sequentieller Addierer mit 32Bit Breite

[noeppkes (Gast)]

Hallo,

ich habe folgendes Problem:
Um die Slices zu reduzieren, möchte ich anstatt eines 32BIT Synchron 
Addierers einen 32Bit sequentiellen Addierer einsetzen.
Da ich mit bis zu 120 Mhz Takt und 20 usec. Zeit habe, reicht dies 
locker aus.

Wie würde nun der Aufruf aus meinem Programm heraus aussehen.
Bisher schreibe ich:

iw_i1 kommt alle 20 usec. mit einem neuen 11Bit-Wert
(Das 11. Bit ist das Vorzeichen)
Dieser Wert soll zum bisherigen Wert (mittelwert_i1) aufaddiert werden.


if (bclk and bclk'event = '1') then
...
mittelwert_i1 <= mittelwert_i1 + iw_iw;
...
end if;

Einen Fulladder habe ich im Internet gefunden.
entity FullAdder is
Port ( Cin : in STD_LOGIC;
A : in STD_LOGIC;
B : in STD_LOGIC;
Cout : out STD_LOGIC;
S : out STD_LOGIC);
end FullAdder;
...

Auch einen 4Bit FullAdder.
entity FullAdder is
Port ( Cin : in STD_LOGIC;
A : in STD_LOGIC;
B : in STD_LOGIC;
Cout : out STD_LOGIC;
S : out STD_LOGIC);
end FullAdder;

architecture dataflow of FullAdder is

begin

S <= (A and not B and not Cin) or (A and b and Cin) or
(not A and B and not Cin) or (not A and not B and Cin);
Cout <= (A and Cin) or (B and Cin) or (A and B);

end dataflow;

architecture structural of Adder4 is
signal Carry STD_LOGIC_VECTOR (2 downto 0);

component FullAdder
Port ( Cin : in STD_LOGIC;
A : in STD_LOGIC;
B : in STD_LOGIC;
Cout : out STD_LOGIC;
S : out STD_LOGIC);
end component
begin

U01: FullAdder PORT MAP (C,X(0),Y(0),Carry(0),R(0));
U02: FullAdder PORT MAP (Carray(0),X(1),Y(1),Carry(1),R(1));
U03: FullAdder PORT MAP (Carray(1),X(2),Y(2),Carry(2),R(2));
U04: FullAdder PORT MAP (Carray(2),X(3),Y(3),Carry(4),R(3));

end structural;

Jedoch werden diese über component eingebunden.
Ich will die Addition allerdings auf der Flanke haben.
Muss ich das dann über eine function lösen, wenn ja aber wie ?

Hierzu fehlt mit nun jeglicher Lösungsansatz.
Als 4Bit Addierer würd emir das ganze schon mal reichen.
Ich kann es dann selbst erhöhen.

Kann mir jemand helfen ?

noeppkes

[R.D. (Gast)]

Die Verwaltung für den sequenziellen Ablauf eines 4x8 Addierers ist doch 
10mal größer, als den Adder komplett einzubauen. 32Bit sind doch Krümel!

[Falk B. (falk)]

@  R.D. (Gast)

>Die Verwaltung für den sequenziellen Ablauf eines 4x8 Addierers ist doch
>10mal größer, als den Adder komplett einzubauen. 32Bit sind doch Krümel!

Eben! So ziemlich alle FPGAs sind ja auf solche Sachen direkt 
vorbereitet und mittels Zusatzlogik in den Slices/LEs ist das optimal 
synthetisierbar!

MFG
Falk

[noeppkes (Gast)]

Danke für die antworten,

ich habe allerdings 8 Addierer, die nicht unbedingt parallel laufen 
müssen.
Ich möchte gerne Slices einsparen, da der FPGA schon sehr voll ist und 
ich noch ein wenig was dazupacken muss.

Ein sehr guter Prof. sagte mir, dass ich die Addiere mit 4 * 8Bit 
Addierer aufbauen soll.
Das würde zwar auf die Geschwindigkeit gehen, würde aber Slices sparen.

Daher die Frage.

Ist das wirklich so, dass wenn ich 4 * 8Bit Addierer nehmen, das Design 
grösser wird ?

noeppkes ...

[Falk B. (falk)]

@ noeppkes (Gast)

>ich habe allerdings 8 Addierer, die nicht unbedingt parallel laufen
>müssen.

Dann nimm einen Addierer und einen MUX.

>Ich möchte gerne Slices einsparen, da der FPGA schon sehr voll ist und
>ich noch ein wenig was dazupacken muss.

Der normale Addierer in FPGAs ist nicht mehr optimierbar, weder im 
Ressourcenverbrauch noch Geschwindigkeit (naja, vom Pipelining mal 
abgesehen).

>Ein sehr guter Prof. sagte mir, dass ich die Addiere mit 4 * 8Bit
>Addierer aufbauen soll.
>Das würde zwar auf die Geschwindigkeit gehen, würde aber Slices sparen.

Will ich sehen. Hose runter ;-)

>Ist das wirklich so, dass wenn ich 4 * 8Bit Addierer nehmen, das Design
>grösser wird ?

Ja.

MfG
Falk

[Kuckuck (Gast)]

Also in einem slice stecken FF und die passenden Addierer (Carry-chain),
nutz du das FF als register für die summanden, hasst du den adder gratis
dazu, erst wenn du das FF sparen willst lohnt es sich auch die 
adderlogik zu sparen. Das stammt aus aktueller xilinx erfahrung, 
vielleicht gibt es ja
FPGA Architekturen bei denen der adder nicht gratis in der grundzelle 
steckt.

[Falk B. (falk)]

@ Kuckuck (Gast)

>vielleicht gibt es ja
>FPGA Architekturen bei denen der adder nicht gratis in der grundzelle
>steckt.

In uralten FPGAs vielleicht. Neue haben das alle, weil das eine 
Grundfunktion ist.

MFG
Falk

[Haarspalter (Gast)]

auch Quicklogic (Anti-Fuse FPGA) ? und Atmel (?)

[noeppkes (Gast)]

Hallo Falk,

danke für deine Antwort.

Das mit dem MUX habe ich schon probiert.
Jedoch keinerlei Einsparung bzgl. Slices.

Im Moment schreibe ich einfach:

if (blablabla) then
  a1_gesamt <= a1_gesamt + b1;
  a2_gesamt <= a2_gesamt + b2;
  ...
  a8_gesamt <= a8_gesamt + b8;
end if;

Wie bewege ich den FPGA nun dazu, dass er jeweils den gleichen Addierer 
für die Additionen nimmt.
Das würde doch slices sparen wenn ich nur noch einen 32 Bit Addierer 
habe  oder ?
Ich habe es probiert mit einer State Machine und den Addierer als 
Unterprogramm (function) geschrieben.
Jedoch hat das auch nichts gebracht.

Hier die function und der Aufruf.

   function addition
    (wert1 : STD_LOGIC_VECTOR (11 downto 0);
     wert2 : STD_LOGIC_VECTOR (31 downto 0);
     reset : STD_LOGIC)
     return STD_LOGIC_VECTOR  is
      variable result : STD_LOGIC_VECTOR (31 downto 0);
   begin
     if (reset = '0') then
       result := wert1 + wert2;
     else
       result := ("00000000000000000000000000000000");
     end if;
     return (result);
   end addition;


Der jeweilige Aufruf dazu:
if (blablabla) then
  case state
    when 1 => a1_gesamt <= addition (b1,   a1_gesamt,'0');
    when 2 => a2_gesamt <= addition (b2,   a2_gesamt,'0');
    ...
    when 8 => a8_gesamt <= addition (b8,   a8_gesamt,'0');
    when others =>
  end case;
end if;

noeppkes ...

[noeppkes (Gast)]

Ach ja,

XC2S200 (Der hat gleiche ich keine so gute Ausstattung bzgl 32Bit 
Addierer. !

noeppkes ...

[Falk B. (falk)]

@  noeppkes (Gast)

>Das mit dem MUX habe ich schon probiert.
>Jedoch keinerlei Einsparung bzgl. Slices.

Naja, sooo einfach isses nicht.

>Wie bewege ich den FPGA nun dazu, dass er jeweils den gleichen Addierer
>für die Additionen nimmt.

Du musst deine State-Machine so ändern, dass nur eine Addition drin ist.

>Das würde doch slices sparen wenn ich nur noch einen 32 Bit Addierer
>habe  oder ?

Naja, der 4:1 32 Bit MUX ist auch nicht umsonst. Kann ich jetzt nicht 
sagen. Muss man probieren.

>Ich habe es probiert mit einer State Machine und den Addierer als
>Unterprogramm (function) geschrieben.
>Jedoch hat das auch nichts gebracht.

Unterprogramme in VHDL ist nicht Unterprogramme wie in normalen 
Programmiersprachen. Deren Aufruf erzeugt immer wieder neue Logik.

>XC2S200 (Der hat gleiche ich keine so gute Ausstattung bzgl 32Bit
>Addierer. !

???
Den Satz formulieren wir nochmal neu.

@ Haarspalter (Gast)

>auch Quicklogic (Anti-Fuse FPGA) ? und Atmel (?)

Weiss ich nicht. Wahrscheinlich.

MFG
Falk

[noeppkes (Gast)]

@Falk,

danke für deine Hilfe.
Gerade bzgl. der StateMachine.
Das habe ich verstanden.
Ich werde mal versuchen nur einen Addierer einzusetzen und die Werte zu 
"muxen".

Melde mich noch einmal, sobald ich den "neuen Slice Verbrauch" habe.

noeppkes ...