VHDL: Volladdierer

[Andi K. (fry12)]

Hallo zusammen!

Ich arbeite gerade ein wenig mit VHDL (bin totaler Anfänger) und benutze 
dazu das Xilinx ISE Webpack. Jetzt habe ich mir gedacht, ich könnte mal 
als kleine Übung einen 2-Bit-Volladdierer bauen und ihn entsprechend in 
Komponenten zerlegen, um die component-Funktion zu testen:

Also ein 2-Bit-Volladdierer bestehend aus zwei 1-Bit-Volladdierern, die 
wiederum jeweils aus zwei 1-Bit-Halbaddierern und einem OR-Gatter 
aufgebaut sind. Allerdings kommt bei der Simulation nur Blödsinn heraus.

Hier mal der Code des 2-Bit-Volladierers:

entity FULLADDER_2BIT is
  port(A, B  : in std_logic_vector(1 downto 0);
      C_IN  : in std_logic;
      S     : out std_logic_vector(1 downto 0);
      C_OUT : out std_logic);
end FULLADDER_2BIT;

architecture FULLADDER_2BIT_IDEAL of FULLADDER_2BIT is
  component FULLADDER
    port(A, B, C_IN : in std_logic;
        C_OUT, S   : out std_logic);
  end component;
  
  signal W_CARRY : std_logic;
  
begin
  FA0: FULLADDER port map(A => A(0),
                  B => B(0),
                  C_IN => C_IN,
                  C_OUT => W_CARRY,
                  S => S(0));
                  
  FA1: FULLADDER port map(A => A(1),
                  B => B(1),
                  C_IN => W_CARRY,
                  C_OUT => C_OUT,
                  S => S(1));
  
end FULLADDER_2BIT_IDEAL;

Ich denke es ist recht selbsterklärend, A und B sind die Eingangszahlen 
(jeweils 2 Bit), S die Ausgangszahl. Das interne Signal W_CARRY wird 
benutzt, um den Carry-Ausgang des einen Volladdierers mit dem 
Carry-Eingang des anderen zu verbinden.

Soweit ich das mit dem component verstanden habe, lege ich jetzt eine 
neue VHDL-Datei namens "FULLADDER" an und schreibe dort entsprechend das 
Verhalten eines 1-Bit-Volladdierers rein:

entity FULLADDER is
  port(A, B, C_IN : in std_logic;
      C_OUT, S    : out std_logic);
end FULLADDER;

architecture FULLADDER_IDEAL of FULLADDER is
  component HALFADDER
    port(X0, Y0       : in std_logic;
        CARRY0, SUM0 : out std_logic);
  end component;
  
  signal W_CARRY0, W_CARRY1, W_SUM : std_logic;
  
begin
  HA0: HALFADDER port map(X0 => A, 
                  Y0 => B, 
                  CARRY0 => W_CARRY0, 
                  SUM0 => W_SUM);
                  
  HA1: HALFADDER port map(X0 => W_SUM, 
                  Y0 => C_IN, 
                  CARRY0 => W_CARRY1, 
                  SUM0 => S);
  
  C_OUT <= W_CARRY0 OR W_CARRY1;
  

end FULLADDER_IDEAL;

Nun fehlt noch die VHDL-Datei für einen einzelnen Halbaddierer:

entity HALFADDER is
  port(X0, Y0       : in std_logic;
      CARRY0, SUM0 : out std_logic);
end HALFADDER;

architecture HALFADDER_IDEAL of HALFADDER is

begin
  SUM0   <= X0 XOR Y0;
  CARRY0 <= X0 OR Y0;

end HALFADDER_IDEAL;

Das Problem ist nun: Wenn ich mir eine Testbench erzeugen lasse und 
bspw. für den Eingang A "01" (binär) wähle (alle anderen Eingänge sind 
auf 0), bekomme ich für den Ausgang S "11" und für den Carry-out '1', 
was natürlich nicht stimmen kann. Allerdings habe ich keine Ahnung was 
falsch sein könnte. An alle die bis jetzt durchgehalten haben: Schon mal 
vielen Dank fürs lesen ;-)

Wer kann mir da weiterhelfen?

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

Andi X. schrieb:
> Allerdings habe ich keine Ahnung was falsch sein könnte.
Du hast doch schon die Siluationam laufen, da kannst du doch einfach 
herausfinden, was schief läuft...
Als Tipp: du kannst im ISIM links im Fenster (Strukturbaum) auch interne 
Signale von Submodulen zur Waveform hinzifügen. Dann kannst du ja mal 
kontrollieren, ob jedes Modul das macht, was du von ihm erwartest.

> eine Testbench
Lass doch mal die Testbench sehen und mach einen Screenshot von der 
Waveform...

> Ich arbeite gerade ein wenig mit VHDL (bin totaler Anfänger) und benutze
> dazu das Xilinx ISE Webpack. Jetzt habe ich mir gedacht, ich könnte mal
> als kleine Übung einen 2-Bit-Volladdierer bauen und ihn entsprechend in
> Komponenten zerlegen, um die component-Funktion zu testen
Ist das eine Hausaufgabe, oder tust du dir gern selber weh? Ich wäre 
beim besten Willen niemals auf die Idee gekommen, einen Addierer in 
subatomare Teile zu zerlegen und die dann per händischer Instantiierung 
wieder zu einem Addierer zusammenzufügen. Sowas gibt es doch nur an 
Schulen und in Lehrbüchern...

> um die component-Funktion zu testen
Was ist das?

> Wer kann mir da weiterhelfen?
Ich könnte, aber ich will nicht. Denn 1. ist das sicher etwas ganz 
Einfaches, und 2. lernst du nichts dabei, wenn ich dir diesen einfachen 
Fehler zeige.
Mein Tipp wäre: nimm den '+' Operator, der in VHDL eingebaut ist. Und 
wenn du schon unbedingt Komponenten einsetzen willst, dann bastle dir 
einen Timer, der jede Sekunde ein Clock-Enable ausgibt und binde den als 
Komponente in ein Lauflicht oder sonstwas ein. Dann hast du shcon mal 
was, was du später auch noch verwenden kannst...

[Grobi (Gast)]

> Ich wäre
> beim besten Willen niemals auf die Idee gekommen, einen Addierer in
> subatomare Teile zu zerlegen und die dann per händischer Instantiierung
> wieder zu einem Addierer zusammenzufügen

Ich denke Andi will damit einfach mal üben wie die Definition, 
Deklaration und Instanziierung von Componenten und der Simulator 
funktioniert. Als Übung finde ich das ganz ok.

[Andi K. (fry12)]

Grobi schrieb:
>> Ich wäre
>> beim besten Willen niemals auf die Idee gekommen, einen Addierer in
>> subatomare Teile zu zerlegen und die dann per händischer Instantiierung
>> wieder zu einem Addierer zusammenzufügen
>
> Ich denke Andi will damit einfach mal üben wie die Definition,
> Deklaration und Instanziierung von Componenten und der Simulator
> funktioniert. Als Übung finde ich das ganz ok.

Exakt das ist es! Natürlich könnte ich mir das Numeric-package einbinden 
und zwei Zahlen einfach addieren, aber es geht mir hier nicht um das 
Ergebnis an sich, sondern das ist eine reine Übungssache, um, wie Grobi 
bereits geschrieben hat, Componenten, Simulator etc. zu testen. Wie 
gesagt, ich bin totaler Anfänger in Sachen VHDL und würde nichts lernen, 
wenn ich S <= A + B; eintippen würde ;)

Und nein, es ist weder eine Hausaufgabe noch Prüfungsaufgabe oder 
irgendetwas anderes in diese Richtung, einfach nur eine kleine Übung, 
die ich mir ausgedacht habe, also bitte keine Flames à la "Ich löse doch 
nicht deine Hausaufgaben" ;-)

>Als Tipp: du kannst im ISIM links im Fenster (Strukturbaum) auch interne
>Signale von Submodulen zur Waveform hinzifügen. Dann kannst du ja mal
>kontrollieren, ob jedes Modul das macht, was du von ihm erwartest.
Danke für den Tipp! Das werde ich mir mal anschauen

Okay, also die Testbench hab ich mir vom Webpack automatisch erzeugen 
lassen und habe auf die schnelle ein paar kleine Signalzuweisungen 
reingepackt:

ENTITY FULLADDER_2BIT_TESTBENCH IS
END FULLADDER_2BIT_TESTBENCH;
 
ARCHITECTURE behavior OF FULLADDER_2BIT_TESTBENCH IS 
 
    -- Component Declaration for the Unit Under Test (UUT)
 
    COMPONENT FULLADDER_2BIT
    PORT(
         A : IN  std_logic_vector(1 downto 0);
         B : IN  std_logic_vector(1 downto 0);
         C_IN : IN  std_logic;
         S : OUT  std_logic_vector(1 downto 0);
         C_OUT : OUT  std_logic
        );
    END COMPONENT;
    

   --Inputs
   signal A : std_logic_vector(1 downto 0) := (others => '0');
   signal B : std_logic_vector(1 downto 0) := (others => '0');
   signal C_IN : std_logic := '0';

   --Outputs
   signal S : std_logic_vector(1 downto 0);
   signal C_OUT : std_logic;
   -- No clocks detected in port list. Replace <clock> below with 
   -- appropriate port name 
 
   --constant <clock>_period : time := 10 ns;
 
BEGIN
 
  -- Instantiate the Unit Under Test (UUT)
   uut: FULLADDER_2BIT PORT MAP (
          A => A,
          B => B,
          C_IN => C_IN,
          S => S,
          C_OUT => C_OUT
        );

   -- Clock process definitions
   --<clock>_process :process
   --begin
  --  <clock> <= '0';
  --  wait for <clock>_period/2;
  --  <clock> <= '1';
  --  wait for <clock>_period/2;
   --end process;
 

   -- Stimulus process
   stim_proc: process
   begin    
      -- hold reset state for 100 ns.
      wait for 100 ns;  

      --wait for <clock>_period*10;

      -- insert stimulus here 
    wait for 50 ns;
    A <= "01";
    wait for 50 ns;
    B <= "10";
    C_IN <= '0';
    wait for 50 ns;
    C_IN <= '1';
      wait;
   end process;

END;

Die Bereiche mit clock habe ich auskommentiert, da ich keinen Takt 
verwende (hier soll nichts auf einen FPGA implementiert werden, ich 
schaue nur, dass ich mit der VHDL-Syntax zurechtkomme)

[Fpgakuechle K. (Gast)]

das carry vom halbadder wird mit AND gebildet, nicht mit OR.
MfG,

[Andi K. (fry12)]

Fpga Kuechle schrieb:
> das carry vom halbadder wird mit AND gebildet, nicht mit OR.
> MfG,
Vielen Dank, das war tatsächlich der Fehler! :)

Eine Frage habe ich noch: Wenn ich mir das Schematic anzeigen lasse, 
würde ich zwei Volladdierer, also FA0 und FA1 erwarten, ich bekomme 
allerdings nur das Bild im Anhang angezeigt. Kommentiere ich jedoch 
jeweils einen Volladdierer aus, bekomm ich ihn entsprechend angezeigt, 
also FA0 oder FA1.  Außerdem ist der C_OUT nicht mit dem C_OUT Ausgang 
der entity verbunden. Ist das normal?

Edit:
@Lothar:
>Ich wäre beim besten Willen niemals auf die Idee gekommen, einen Addierer in
>subatomare Teile zu zerlegen und die dann per händischer Instantiierung
>wieder zu einem Addierer zusammenzufügen.
Mal rein aus Interesse, wie macht man so etwas effektiver (also jetzt 
nicht über ein +)? Gibt es eine Möglichkeit die Instantiierungen in 
einer Art Schleife ablaufen zu lassen?

[Fpgakuechle K. (Gast)]

Andi X. schrieb:

> @Lothar:
>>Ich wäre beim besten Willen niemals auf die Idee gekommen, einen Addierer in
>>subatomare Teile zu zerlegen und die dann per händischer Instantiierung
>>wieder zu einem Addierer zusammenzufügen.
> Mal rein aus Interesse, wie macht man so etwas effektiver (also jetzt
> nicht über ein +)? Gibt es eine Möglichkeit die Instantiierungen in
> einer Art Schleife ablaufen zu lassen?

Ja, siehe unvollständiges beispiel:

--Instanziierung der fullader
--dabei Verdrahtung mit std_logic_vector mit Index loopindex

G_16bit_adder: FOR loopindex in 0 TO 15 GENERATE
  i_FULLADDS: FULLADDER port map(
                  A     => A(loopindex),
                  B     => B(loopindex),
                  C_IN  => carries_in(loopindex),
                  C_OUT => carries_out(loopindex),
                  S     => S(loopindex));
               END GENERATE;
  carries_in(15 downto 1) <= carries_out(14 downto 0);

wobei "+"  vorzuziehen ist. In modernen FPGA's kann das auf 
verschiedenene "Hardware-Adder" abgebildet (Syntetisiert/map) werden:
-carry-chain + luts
-dsp-slices

Oder embedded memory als Adder-LookUp-table verwenden (falls alle slices 
belegt sind, aber noch BRAMS frei).

MfG

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

Fpga Kuechle schrieb:
> wobei "+"  vorzuziehen ist. In modernen FPGA's kann das auf
> verschiedenene "Hardware-Adder" abgebildet (Syntetisiert/map) werden
Denn gerade solche alltäglichen Aufgaben sind den FPGA Entwicklern 
natürlich auch bekannt und es wurden zig Mannjahre z.B. allein auf das 
effiziente Design des Carrys verwendet und Patente dafür erteilt (jeder 
Zähler ist ein Addierer). Da muss jede manuelle Implementierung 
zwangsläufig schlechter sein.

[berndl (Gast)]

Lothar Miller schrieb:
> Fpga Kuechle schrieb:
>> wobei "+"  vorzuziehen ist. In modernen FPGA's kann das auf
>> verschiedenene "Hardware-Adder" abgebildet (Syntetisiert/map) werden
> Denn gerade solche alltäglichen Aufgaben sind den FPGA Entwicklern
> natürlich auch bekannt und es wurden zig Mannjahre z.B. allein auf das
> effiziente Design des Carrys verwendet und Patente dafür erteilt (jeder
> Zähler ist ein Addierer). Da muss jede manuelle Implementierung
> zwangsläufig schlechter sein.

Wobei es gar nicht so schlecht ist, wenigstens einmal einen 
'Ripple-Carry' Addierer sowie einen 'Carry-Lookahead' Addierer zu Fuss 
zu bauen und ggf. auch mal die maximalen Taktfrequenzen bzw. den 
Resourcenverbrauch anzuschauen. Das mag fuer FPGAs nicht wirklich viel 
bringen, zum Verstaendnis der Logik aber schon. Sind halt Grundlagen, 
die man im Logic-Design verstanden haben sollte...
Wenn schon jemand 'einfach mal so' in die Materie schnuppern will, dann 
hat das schon einen Sinn. Und dann danach halt so Sachen wie FSMs, ...

[Fpgakuechle K. (Gast)]

berndl schrieb:
> Lothar Miller schrieb:
>> Fpga Kuechle schrieb:
>>> wobei "+"  vorzuziehen ist. In modernen FPGA's kann das auf
>>> verschiedenene "Hardware-Adder" abgebildet (Syntetisiert/map) werden
>> Denn gerade solche alltäglichen Aufgaben sind den FPGA Entwicklern
>> natürlich auch bekannt und es wurden zig Mannjahre z.B. allein auf das
>> effiziente Design des Carrys verwendet und Patente dafür erteilt (jeder
>> Zähler ist ein Addierer). Da muss jede manuelle Implementierung
>> zwangsläufig schlechter sein.
>
> Wobei es gar nicht so schlecht ist, wenigstens einmal einen
> 'Ripple-Carry' Addierer sowie einen 'Carry-Lookahead' Addierer zu Fuss
> zu bauen und ggf. auch mal die maximalen Taktfrequenzen bzw. den
> Resourcenverbrauch anzuschauen. Das mag fuer FPGAs nicht wirklich viel
> bringen, zum Verstaendnis der Logik aber schon. Sind halt Grundlagen,
> die man im Logic-Design verstanden haben sollte...

Nun das schärft den Blick für Varianten eine kombinatorische Schaltung 
aufzubauen. Da aber im FPGA das meiste aus LUT's statt aus NAND-Gatter 
aufgebaut wird und die Routing resourcen nicht so feingranular anpassbar 
sind wie im Full-Custom-Entwurf sind dieBewertungen der verschiedenen 
Adder-Architekturen aus dem Lehrbuch nur bedingt auf FPGA-Realisierungen 
übertragbar. Siehe:
http://forums.xilinx.com/t5/Spartan-Family-FPGAs/About-technology-mapping/m-p/116474/highlight/true#M9040

Als Beispiel sei auf die Xilinx Apps zum Multiplexer design XAPP466 und 
XAPP522 verwiesen. Selbst bei so simplen Strukturen kann man durch 
Optimierung auf FPGA-Logik Vorteile erlangen.

MfG