VHDL

[davidvajda.de]

1. Block
2. Signal

Blöcke: Zähler, Multiplexer, Dekoder, ...

Blöcke werden über Signale miteinander verbunden

1. Konventionen
   1. Namensregeln
   2. Kommentare
   3. Zuweisungen
2. Typologie
3. Vektoren
4. Aufbau der Schaltungsbeschreibung
   1. Header mit Bibliothek und Packageeinbindungen
   2. Entity für Schnittstellendefinition
   3. Architecture für Funktionsbeschreibung
5. Nebenläufige oder sequentielle Umgebungen
   1. Nebenläufig
   2. Sequentiell
6. Anweisungen
   1. Einfache Verknüpfungen
   2. Arithmetische Operatoren
   3. with/select
   4. when/else
   5. if/then
   6. case/is

1. Konventionen
   1. Namensregeln
      
      • Zwischen Gross und Kleinschreibung wird in VHDL nicht unterschieden
      • ... das übliche
   2. Kommentare
      • Komentare werden durch doppelten Bindestrich eingeleitet --
   3. Zuweisungen
      • Zuweisungen
        • Signal an ein anderes Signal
        • konstanter Wert an Signal
      • Zeichenkombination <=
      • Von rechts nach links
      Beispiel:

      Code: Alles auswählen

      Y <= S;
      Y <= A or B;
      -- Falsch A => Y; -- Falsch
      

2. Typologie
   • VHDL ist streng typgebundene Sprache
   Es genügt:
   • boolean
   • bit
   • std_logic
   1. Typ: boolean
      1. Wertevorrat: true, false
      2. Verwendung: logische Abfragen (if)
   2. Typ: bit
      1. Wertevorrat: 0, 1
      2. Verwendung: Entwurf
   3. Typ: std_logic:
      1. Wertevorrat: 0, 1, Z, -, L, H, X, W
      2. Entwurf und Simulation
   Deklartion:

   Code: Alles auswählen

   signale <signalname>: typ;
   
   signal x0, x1, x2, x3: bit;
   signal EN: std_logic;
   signal on_of: boolean;
   

   Bei Verknüpfungen müssen einzelne Signale vom selben Typ sein
   

   Code: Alles auswählen

   0: starke 0
   1: starke 1
   Z: hochohmig
   -: don't care
   U: unbekannt
   X: konflikt
   L: Schwache 0
   H: Schwache 1
   W: Schwaches X
   

3. Vektoren
   1. Deklaration

      Code: Alles auswählen

      signal <signalname>: typ (<lower> to <upper>);
      signal <signalname>: typ (<upper> downto <lower>);
      
      signal x: bit_vector(0 to 7);
      signal a: std_logic_vector(2 to 4);
      signal r: bit_vector(3 downto 0);
      

   2. Zuweisungen

      Code: Alles auswählen

      c <= a or b;
      c <= ('1', '0', '0', '0');
      c <= "1000";
      

4. Aufbau der Schaltungsbeschreibung
   1. Header mit Bibliothek und Packageeinbindungen
   2. Entity für Schnittstellendefinition
   3. Architecture für Funktionsbeschreibung
   1. Header
      • Definitionen die für Schaltungsbeschreibung gelten sollen

      Code: Alles auswählen

      library ieee;
      use ieee.std_logic_1164.all
      use ieee.std_logic_unsigned.all
      

   2. Entity
      
      1. Eingang
      2. Ausgang
      3. Bidirektional
      1. Eingang: in
      2. Ausgang: out
      3. Bidirektional: inout

      Code: Alles auswählen

      entity <blockname> is
      port
      (
          <signalnamen>: <richtung> <typ>;
          <signalnamen>: <richtung> <typ>;
          <signalnamen>: <richtung> <typ>
      );
      end;
      

      Code: Alles auswählen

      entity multiplexer is
      port
      (
          a0, a1, a2, a3: in bit;
          b0, b1, b2, b3: in bit;
          s:              in bit;
          y0, y1, y2, y3: out bit;
      );
      end;
      

      Code: Alles auswählen

      entity counter is
      port
      (
          clk: in bit;
          rst: in bit;
          q: out bit_vector (3 downto 0)
      );
      end;
      

   3. Die Funktion - Architecture

      Code: Alles auswählen

      architecture <beschreibungsname> of <blockname> is
      -- locale signale 
      begin 
      -- functionsbeschreibung
      end;
      

      Code: Alles auswählen

        
      architecture mymux of multiplexer is 
          signal a, b, y: bit_vector (0 to 3);
      begin 
          a <= (a0, a1, a2, a3);
          b <= (b0, b1, b2, b3);
          
          y <= a when (s='0') else b;
          
          y0 <= y(0);
          y1 <= y(1);
          y2 <= y(2);
          y3 <= y(3);
      end mymux
      

   4. Nebenläufige oder sequentielle Umgebungen
      1. Nebenläufige
         
         
         • In C werden alle Anweisungen hintereinander abgearbeitet
         • Anweisungen in VHDL in der Regel nebenläufig, d.h. parallel
         • Befindet man sich in einer nebenläufigen oder Sequentiellen Umgebung?
         Aus:

         Code: Alles auswählen

         architecture verhalten of multiplexer is 
             signal a, b, y: bit_vector (0 to 3);
         begin 
             a <= (a0, a1, a2, a3);
             b <= (b0, b1, b2, b3);
             
             y <= a when (s='0') else b;
             
             y0 <= y(0);
             y1 <= y(1);
             y2 <= y(2);
             y3 <= y(3);
         end verhalten
         

         Wird:
         

         Code: Alles auswählen

         architecture mymux of multiplexer is 
             signal a, b, y: bit_vector (0 to 3);
         begin 
             a <= (a0, a1, a2, a3);
             b <= (b0, b1, b2, b3);
             
             y <= a when (s='0') else b;
             
             y0 <= y(0);
             y1 <= y(1);
             y2 <= y(2);
             y3 <= y(3);
         end mymux
         

      2. Die erste umgebung ist nebenläufig
      3. Squentielle Umgebung
         1. Prozess

            Code: Alles auswählen

            process <empfindlichkeitsliste>
            -- lokale signale   
            begin 
            -- sequentielle umgebung
            end process;
            

            • Ist eine Sequentielle Umgebung abgearbeitet, startet die Ausführung von vorne
            • Eine parallele Umgebung kann mehrere sequentielle enthalten, die parallel ausgeführt werden
            • Empfindlichkeitsliste: Alle signale die sich potentiell ändern können

            Code: Alles auswählen

            architecture verhalten of counter is
                signal qint: std_logic_vector ( 3 downto 0);
            begin 
                process (reset, clk)
                begin 
                    if (reset='0') then 
                        quint <= x"0";
                    elseif (clk='1') and clk'event
                    then 
                        qint <= qint+1;
                    end if;
                end process;
                
                q<=qint;
            end;
            

            Variablen im Prozess

            Code: Alles auswählen

            process ..
                variable V std_logic_vector (3 downto 0);
            begin 
                V := ...
            end;
            

5. Anweisungen
   1. Einfache Verknüpfungen
      • not
      • and
      • or
      • nand
      • nor
      • xor
      • not
   2. Arithmetische Operatoren
      • Addition +
      • Subtraktion -
      • gleich =
      • ungleich /=
      • kleiner <
      • kleiner gleich <=
      • groesser >
      • groesser gleich >=
   3. with/select
      • nebenläufig

        Code: Alles auswählen

        with <auswahlsignal> select 
        ergebnis <= <Verknüpfung_1> when <auswahlwert_1>,
                    <Verknüpfung_2> when <auswahlwert_2>,
                    <Verknüpfung_n> when others;
        

   4. when/else
      • nebenläufig

        Code: Alles auswählen

        <ergebnis> <=   <Verknüpfung_1> when <Bedingung_1>, 
                        else <Verknüpfung_2> when <Bedingung_2>, 
                        else <Vernüpfung_n>;
        

   5. if/then
      • sequentiell

      Code: Alles auswählen

      if <Bedingung_1>        then <Sequentielle Anweisungen 1>;
      elseif <Bedingung_2>    then <Sequentielle Anweisungen 2>;
      elseif <Bedingung_3>    then <Sequentielle Anweisungen 3>;
      else                         <Sequentielle Anweisungen n>;
      end if;
      

      Bedingung muss vom Typ Boolean sein
   6. case/is
      • wie with/select nur in sequentiell

      Code: Alles auswählen

      case <testsignal> is
          when <Wert_1> => <Sequentielle Anweisungen 1>;
          when <Wert_2> => <Sequentielle Anweisungen 2>;
          when <Wert_3> => <Sequentielle Anweisungen 3>;
          when others   => <Sequentielle Anweisungen n>; 
      end case;