Summe, Index und Multiplikation von Std_Logic_Vectoren

[hans (Gast)]

Guten Morgen liebes Forum,

ich bin gerade dabei, ein Desgin zu entwerfen, welches die Summe aus n 
Elementen (12 Bit Std_logic_Vector) berechnet, wobei jedes n-te Element 
mit dem Indexfaktor n multipliziert wird.

Formeltechnisch sieht das ganze so aus:

$$\sum\limits_{n=0}^{N-1} Wert(n) \cdot n$$

Die reine Addition, bzw. die Gesamtsumme aller Vektoren steht soweit. 
Dies habe ich folgendermaßen realisiert:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.numeric_std.all; 


entity summ is
    Port ( data_a : in  STD_LOGIC_VECTOR (11 downto 0);
           data_b : in  STD_LOGIC_VECTOR (11 downto 0);
           clk : in  STD_LOGIC;           
           sum_sub : out  STD_LOGIC_VECTOR (23 downto 0)
          );

end summ;

architecture Behavioral of summe_index is
signal sum :  unsigned (23 downto 0):= (others => '0');      
signal count: unsigned (11 downto 0) := (others => '0');      
signal temp : unsigned (11 downto 0):= (others => '0');  


begin

process(clk)
begin
if rising_edge(clk) then    
  temp <= unsigned(data_a) + unsigned(data_b);
  sum_sub <= std_logic_vector(sum);
end if;

if falling_edge(clk) then
  sum <= sum + temp;
end if;

end process;
end Behavioral;

Dazu habe ich mir eine Testbench geschrieben, die  data_a und data_b 
eine gewissen Anzahl von Signalen in Abhängigkeit des Taktes zuweisen. 
Das Ergebnis geht auf.

Um nun jedes Element mit einem Faktor zu belegen, habe ich mir erst 
einmal Zähler gebaut:

process(clk)
begin
  if rising_edge(clk) then    
    count <= count + 1;    
  end if;
end process;

Nun wollte ich das Ganze so lösen:

process(clk)
begin
if rising_edge(clk) then    
  temp <= unsigned(data_a) * unsigned(count sll 1) + unsigned(data_b) * unsiged ((count sll 1) + 1);
  sum_sub <= std_logic_vector(sum);
end if;

if falling_edge(clk) then
  sum <= sum + temp;
end if;

end process;
end Behavioral;

Nun muss ich natürlich den Wertebereich meiner sum und sum_sub 
erweitern, ich meine es waren dann 36 Bit. Dieses Vorhaben geht jedoch 
leider nicht mehr auf. Es wird zwar ohne Fehler synthetisiert, jedoch 
sehe ich im ISIM nur UNITIALIZED bei sum_sub. Kann es sein, dass es mit 
den Takten nicht ganz hin haut, da ich in der aufsteigender Flanke 
addieren UND multiplizieren möchte?

Wäre über jeden Rat sehr dankbar, wie ich das Problem lösen kann.



Schönen Sonntag,

Hans

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

process(clk) begin
 if rising_edge(clk) then    
   ...
 end if;

 if falling_edge(clk) then
  ...
 end if;
end process;

Was versprichst du dir von dieser "Aufteilung" der Arbeit in fallende 
und steigende Flanken?

Abgesehen von vielen zusätzlichen Registern und einer Halbierung der 
Laufzeiten (mit allen Nachteilen) kommt dabei nichts heraus...

> Kann es sein, dass es mit den Takten nicht ganz hin haut, da ich in
> der aufsteigender Flanke addieren UND multiplizieren möchte?
Nein, trotzdem ist es Murks.

Das Ganze wird problemlos etwa auf diese Art funktionieren:

process(clk) begin
  if rising_edge(clk) then    
    sum <= sum + unsigned(data_a) * unsigned(count sll 1) + unsigned(data_b) * unsiged ((count sll 1) + 1);
    count <= count+1;
  end if;
end process;

Denn mehr Aufgaben hast du nicht:
1. Rechnen und Summieren
2. Index hochzählen

> sehe ich im ISIM nur UNITIALIZED bei sum_sub.
Bei allen Elementen des Vektors, oder nur bei einigen?
Passen die Vektorbreiten zusammen?
Was für Infos und Warnings spuckt die Synthese aus?

[hans (Gast)]

Super, danke Lothar. Es funktioniert.

Lothar Miller schrieb:
> Was versprichst du dir von dieser "Aufteilung" der Arbeit in fallende
> und steigende Flanken?

Ich weiß auch nicht so recht, irgendwie hatte ich gedacht, dass sum <= 
sum + x nicht synthesefähig wäre. Ich hatte es am Anfang mal in dieser 
Richtung ausprobiert, hatte eine Fehlermeldung bekommen mit dem Hinweis, 
dass ich ein Signal zur gleichen Zeit mehrfach beanspruche oder in der 
Art. Ich weiß es nicht mehr so genau.

Lothar Miller schrieb:
> Abgesehen von vielen zusätzlichen Registern und einer Halbierung der
> Laufzeiten (mit allen Nachteilen) kommt dabei nichts heraus...

Zu welchen Nachteilen kann es alles kommen?


Und das Ganze funktioniert mit dem use ieee.numeric_std.all Package auch 
auf einem FPGA? Ich könnte mit den Operatoren + , - , * und / rechnen?


Vielen Dank für die super Hilfe,

Hans

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

hans schrieb:
> Zu welchen Nachteilen kann es alles kommen?
Du hast nur die halbe Zeit für die Rechnung zur Verfügung, weil temp 
mit der steigenden Flanke berechnet, aber mit der fallenden Flanke schon 
gespeichert wird (oder andersrum). Wie gesagt: dein Design muss deshalb 
doppelt so schnell sein...
> Und das Ganze funktioniert mit dem use ieee.numeric_std.all Package auch
> auf einem FPGA?
Ja, tadellos.
> Ich könnte mit den Operatoren + , - , * und / rechnen?
Ja, ja, ja, und jein.
Zum Thema "Division in der Synthese" gibts aktuell deinen 
Beitrag "Division von STD_LOGIC_VECTOR"
Und: Divisionen durch Zweierpotenzen (2,4,8,16...) werden im FPGA durch 
einfaches Umverdrahten erledigt.