Re: VHDL

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
   • 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:

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

4. Typologie
   • VHDL ist streng typgebundene Sprache
   Es genügt:

   • boolean
     

   • bit
     

   • std_logic
     

   1. Typ:

      boolean\verb
      

      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:

   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
   

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

5. Vektoren
   1. Deklaration

      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

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

6. 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

      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
         

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

      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;
      

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

   3. Die Funktion - Architecture

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

      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:

         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:

         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

            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

            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

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

7. 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

        with <auswahlsignal> select
        ergebnis <= <Verkn"upfung_1> when <auswahlwert_1>,
                    <Verkn"upfung_2> when <auswahlwert_2>,
                    <Verkn"upfung_n> when others;
        

   4. when/else
      

      • nebenläufig

        <ergebnis> <=   <Verkn"upfung_1> when <Bedingung_1>,
                        else <Verkn"upfung_2> when <Bedingung_2>,
                        else <Vern"upfung_n>;
        

   5. if/then
      

      • sequentiell

        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

        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;