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!
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
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 ...
@ 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
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.
@ 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
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)
>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
@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 ...
