Lothar Miller - Code-Schnipsel

Qualifier

nospam@example.com (Lothar Miller) — Thu, 10 Nov 2011 13:16:56 +0100

Es gestaltet sich in VHDL oft nicht so einfach, dem Synthesizer etwas Glasklares zu vermitteln. Nehmen wir mal diese einfache Aufgabe: Eine Konstante x"1234" soll an einen Vektor (std_logic_vector oder unsigned) zugewiesen werden. Weil die Länge des Vektors noch nicht feststeht, soll vorher ein resize() durchgeführt werden.
Wenn man das jetzt einfach so hinschreibt:

slv <= std_logic_vector(resize(x"1234", slv'length));

Dann erlebt man ein blaues Wunder. Obwohl eigentlich auf Anhieb erkennbar ist, was hier passieren soll, zickt der Compiler herum und meldet sowas wie:

Expression in type conversion to std_logic_vector has 2 possible definitions in this scope, for example, SIGNED and UNSIGNED.

Was ist passiert?
resize() kann signed oder unsigned für diese Konstante zurückliefern. Weil der Synthesizer selber aber nicht entscheiden kann, welcher Datentyp gemeint ist, weiß er auch nicht, ob die resize() Funktion die Konstante als signed oder unsigned zu betrachten hat.
Dies kann ihm mit einem Qualifier gesagt werden: unsigned' sagt, dass der folgende Wert als unsigned zu betrachten ist.

slv <= std_logic_vector(unsigned'(resize(x"1234", slv'length)));

Das hilft dem Synthesizer aus der Klemme, denn jetzt weiß er was das Ziel ist und er verwendet die gewünschte Implementierung der Funktion.

Hier mal eine kleine Aufstellung, was geht und was nicht:

signal slv  :  std_logic_vector (15 downto 0);
signal uv   :  unsigned (15 downto 0);


slv <= std_logic_vector(resize(x"1234", slv'length));
--> Expression in type conversion to std_logic_vector has 2 possible definitions in this scope, for example, SIGNED and UNSIGNED.

slv <= std_logic_vector(unsigned'(resize(x"1234", slv'length)));
--> ok, das Ergebnis von resize ist ein unsigned Vektor

slv <= std_logic_vector(resize(unsigned(x"1234"), slv'length));
--> Expression in type conversion to unsigned has 7 possible definitions in this scope, for example, std_ulogic_vector and std_logic_vector.

slv <= std_logic_vector(resize(unsigned'(x"1234"), slv'length));
--> ok, die Konstante x"1234" ist ein unsigned Wert

uv <= resize(unsigned(x"1234"), uv'length);
--> Expression in type conversion to unsigned has 7 possible definitions in this scope, for example, std_ulogic_vector and std_logic_vector.

uv <= resize(unsigned'(x"1234"), uv'length);
--> ok, die Konstante x"1234" ist ein unsigned Wert

uv <= resize(x"1234", uv'length);
--> ok, der Typ von uv wird für resize verwendet

Bis zu einer Vektorlänge von 31 Bit geht es auch so:

slv <= std_logic_vector(to_unsigned(16#1234#, slv'length));

Hello World!

nospam@example.com (Lothar Miller) — Fri, 23 Sep 2011 11:59:39 +0200

Eine blinkende LED ist das "Hello World!" der Hardware.

Man kann daran erkennen, dass die Versorgung funktioniert, die Logik arbeitet und anhand der Blinkfrequenz einen Zähler beurteilen. Also schon einiges, was so eine einzelne Funzel einem sagen kann

Leider funktioniert diese einfache Variante eines Blinklichts nur in der Simulation:

library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
 
entity BlinkLED is 
    Port (led : buffer  STD_LOGIC := '0'); 
end BlinkLED; 
 
architecture Behavioral of BlinkLED is 
begin 
   led <= not led after 500 ms;    -- LED alle 500 ms toggeln 
end Behavioral;

Warum geht das nicht? Es gibt keine "einstellbaren Verzögerungsglieder" (ähnlich wie Monoflops oder RC-Glieder...) im FPGA. Alles, was mit Zeiten zu tun hat, muss in einem FPGA als Zähler aufgebaut werden, der einen Takt mitzählen und beim Erreichen eines passenden Endwertes eine Reaktion auslöst.
Also brauchen wir einen Takt und einen Zähler. In der Regel ist am FPGA ein Quarz mit z.B. 50MHz angeschlossen. Für eine halbe Sekunde müssen also 25 Millionen Takte gezählt werden. Das ergibt eine Registerkette mit 25 Bits (mit diesen 25 Bit wären maximal 2^25=33554432 Zählschritte möglich).
Und diese 25 Register werden mit einem festen Wert 24999999 verglichen. Warum 24999999 und nicht 25000000?
Weil 0...24999999 schon 25000000 Schritte sind. Einfacher wird es vielleicht mit kleineren Zahlen: ein Zähler, der 5 Schritte abzählen muß, braucht die Zahlen 0, 1, 2, 3 und 4.

Also zusammengefasst:
Ein Takt geht auf einen Zähler, der mit einem festen Wert verglichen wird, bei dessen Erreichen zurückgesetzt wird und gleichzeitig eine Aktion auslöst: die LED wird getoggelt.

Hier ist der VHDL-Quellcode für so ein Blinklicht:

library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.NUMERIC_STD.ALL; 
 
entity BlinkLED is 
    Port ( clk : in  STD_LOGIC; 
           led : out  STD_LOGIC); 
end BlinkLED; 
 
architecture Behavioral of BlinkLED is 

signal c : integer range 0 to 24999999 := 0; -- 0,5s bei 50MHz fosc
signal x : std_logic:= '0';  

begin 
   process begin  
      wait until rising_edge(clk); -- warten bis zum nächsten Takt 
      if (c<24999999) then         -- 0…24999999 = 25000000 Takte = 1/2 Sekunde bei 50MHz 
          c <= c+1;                -- wenn kleiner: weiterzählen 
      else                         -- wenn Zählerende erreicht: 
          c <= 0;                  -- Zähler zurücksetzen 
          x <= not x;              -- und Signal x togglen 
      end if; 
   end process; 
   led <= x;                       -- Signal x an LED ausgeben 
end Behavioral;

Zur Funktionsweise:
mit einem Zähler werden 25 Millionen Takte eines 50 MHz Taktes abgezählt (also 0..24999999). Wenn der Zählerendwert erreicht wurde, wird der Zähler zurückgesetzt und gleichzeitig ein lokales Signal x getoggelt. Dieses Signal wird dann an den led Ausgang gegeben.

Das lokale Signal x brauchen wir, weil der Port led als out deklariert ist, und daher entsprechend den VHDL Richtlinien nicht lesbar ist.
Und um den Schlauen zuvorzukommen: Nein, es ist keine gute Idee, den Port led als buffer oder inout zu deklarieren, nur damit er zurückgelesen werden und so ein lokales Signal gespart werden kann. Das ist eher ein Kündigungsgrund oder sollte wenigstens einen strengen Verweis in der Personalakte nach sich ziehen...
Als kleiner Lichtblick: ab VHDL 2008 können auch out Ports wieder zurückgelesen werden, diese Ports verhalten sich dann ähnlich wie buffer. So ist es dann möglich, z.B. einen Zähler direkt auf einen out Port zu erzeugen.

Und hier die kompakte Stimuli-"Testbench":

library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.NUMERIC_STD.ALL;  
  
entity tb_BlinkLED is 
                                   -- leere Entity --> Testbench
end tb_BlinkLED; 
  
architecture behavior of tb_BlinkLED is
   component BlinkLED 
   port( clk : IN  std_logic; 
         led : OUT  std_logic ); 
   end component; 
    
   signal clk : std_logic := '0';  -- lokale Signale der Testbench
   signal led : std_logic;         -- werden an den Prüfling angeschlossen

begin
   uut: BlinkLED                   -- der Prüfling wird verdrahtet
   port map ( clk => clk, 
              led => led ); 
 
   clk <= not clk after 10 ns;     -- einen 50MHz Takt erzeugen
end;

Wer dieses Blinklicht zum ersten Mal mit ISE realisieren will, der kann sich die Schritt-für-Schritt Anleitung HIER mal ansehen.

Für alle, die noch nicht genug haben kommt hier der Binärzähler auf 8 LEDs.

library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.NUMERIC_STD.ALL; 
 
entity BinaryLED is 
    Port ( clk  : in  STD_LOGIC; 
           leds : out STD_LOGIC_VECTOR(7 downto 0)); 
end BinaryLED; 
 
architecture Behavioral of BinaryLED is 

signal c : integer range 0 to 12499999 := 0; -- 0,25s bei 50MHz fosc
signal x : unsigned (7 downto 0) := (others=>'0');  

begin 
   process begin  
      wait until rising_edge(clk); -- warten bis zum nächsten Takt 
      if (c<12499999 ) then        -- 0..12499999 = 12500000 Takte = 1/4 Sekunde bei 50MHz 
          c <= c+1;                -- wenn kleiner: c weiterzählen 
      else                         -- wenn Zählerende erreicht: 
          c <= 0;                  -- Zähler c zurücksetzen 
          x <= x+1;                -- und Zähler x hochzählen 
      end if; 
   end process; 
   leds <= std_logic_vector(x);    -- Signal x an LEDs ausgeben 
end Behavioral;

Im Großen und Ganzen ist das Beispiel gleich wie das obere. Nur wird hier statt der einzelnen LED ein unsigned-Vektor hochgezählt. Das Hochzählen von Vektoren hat den Vorteil, dass der Überlauf von 11111111bin = 255dez nach 00000000bin = 0dez automatisch passiert.

Ich hätte den Zähler x natürlich wie den Zähler c auch als integer machen können, dann hätte der Code (für eine fehlerfreie Simulation) aber so aussehen müssen:

library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.NUMERIC_STD.ALL; 
 
entity BinaryLED is 
    Port ( clk  : in  STD_LOGIC; 
           leds : out STD_LOGIC_VECTOR(7 downto 0)); 
end BinaryLED; 
 
architecture Behavioral of BinaryLED is 

signal c : integer range 0 to 12499999 := 0; -- 0,25s bei 50MHz fosc
signal x : integer range 0 to 255 := 0;  

begin 
   process begin  
      wait until rising_edge(clk); -- warten bis zum nächsten Takt 
      if (c<12499999 ) then        -- 0..12499999 = 12500000 Takte 
          c <= c+1;                -- wenn kleiner: c weiterzählen 
      else                         -- wenn Zählerende erreicht: 
          c <= 0;                  -- Zähler c zurücksetzen 
          if (x<255) then          -- ist Zähler x schon "oben" angekommen
             x <= x+1;             -- nein: Zähler x hochzählen 
          else
             x <= 0;               -- ja: zurücksetzen
          end if;
      end if; 
   end process; 
   -- Signal konvertieren und casten und an LEDs ausgeben 
   leds <= std_logic_vector(to_unsigned(x,8)); 
end Behavioral;

Der nächste logische Schritt ist dann, die Erzeugung des Fortschaltimpulses in einem eigenen Prozess zu erzeugen.

library IEEE; 
use IEEE.STD_LOGIC_1164.ALL; 
use IEEE.NUMERIC_STD.ALL; 
 
entity BinaryLED is 
    Port ( clk  : in  STD_LOGIC; 
           leds : out STD_LOGIC_VECTOR(7 downto 0)); 
end BinaryLED; 
 
architecture Behavioral of BinaryLED is 

signal c : integer range 0 to 12499999 := 0; -- 0,25s bei 50MHz fosc
signal t : std_logic := '0';
signal x : integer range 0 to 255 := 0;  

begin 
   process begin  
      wait until rising_edge(clk); -- warten bis zum nächsten Takt 
      if (c<12499999 ) then        -- 1/4 Sekunde bei 50MHz 
          c <= c+1;                -- wenn kleiner: c weiterzählen 
          t <= '0';                
      else                         -- wenn Zählerende erreicht: 
          c <= 0;                  -- Zähler c zurücksetzen 
          t <= '1';                -- Flag für Tick setzen
      end if; 
   end process; 

   process begin  
      wait until rising_edge(clk); -- warten bis zum nächsten Takt 
      if (t='1') then              -- sind schon wieder 0,25 sec vorbei?
          if (x<255) then          -- ist Zähler x schon "oben" angekommen
             x <= x+1;             -- nein: Zähler x hochzählen 
          else
             x <= 0;               -- ja: zurücksetzen
          end if;
      end if; 
   end process; 

   -- Signal konvertieren und casten und an LEDs ausgeben 
   leds <= std_logic_vector(to_unsigned(x,8)); 
end Behavioral;

Wie man klar sieht, gibt es in diesem Design nur und genau einen einzigen Takt clk. Das ist der Quarzoszillator, der aussen am FPGA angeschlossen ist. Mit diesem Takt läuft das ganze Design. Für Anfänger gilt:
Der Takt ist wie der Highlander: es kann nur einen geben.

Breite eines Vektors berechnen (log2)

nospam@example.com (Lothar Miller) — Mon, 26 Apr 2010 10:29:54 +0200

Manchmal möchte man, dass sich die Wortbreite von Vektoren eines VHDL-Moduls z.B. über ein Generic einstellen lassen. Natürlich kann man das Ganze händisch machen:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity CalcBW is
    Generic ( COUNT_MAX : natural  := 100;
              COUNT_WIDTH : natural := 7     -- 7 Bits sind nötig.
             );
    Port ( clk   : in  STD_LOGIC;
           count : out STD_LOGIC_VECTOR (31 downto 0) := (others=>'0')
          );
end CalcBW;

architecture Behavioral of CalcBW is
signal   cnt  : unsigned (COUNT_WIDTH-1 downto 0) := (others=>'0');
begin
  process begin
     wait until rising_edge(clk);
     if (cnt < COUNT_MAX) then  cnt <= cnt+1;
     else                       cnt <= (others=>'0'); 
     end if;
  end process;
  count(cnt'range) <= std_logic_vector(cnt);
end Behavioral;

Wesentlich eleganter ist aber, wenn hier z.B. nur der Zählerendwert übergeben und daraus in dem VHDL-Modul die nötige Vektorbreite berechnet wird. Das kann z.B. so gemacht werden:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
USE ieee.math_real.log2;
USE ieee.math_real.ceil;

entity CalcBW is
    Generic ( COUNT_MAX : natural := 100
             );
    Port ( clk   : in  STD_LOGIC;
           clear : in  STD_LOGIC;
           count : out STD_LOGIC_VECTOR (31 downto 0) := (others=>'0')
          );
end CalcBW;

architecture Behavioral of CalcBW is
constant COUNT_WIDTH : integer := INTEGER(CEIL(LOG2(REAL(COUNT_MAX+1))));
signal   cnt  : unsigned (COUNT_WIDTH-1 downto 0) := (others=>'0');
begin
  process begin
     wait until rising_edge(clk);
     if (cnt < COUNT_MAX) then  cnt <= cnt+1;
     else                       cnt <= (others=>'0'); 
     end if;
  end process;
  count(cnt'range) <= std_logic_vector(cnt);
end Behavioral;

Mit den in der MATH_REAL Bibliothek enthaltenen Funktionen LOG2 wird zuerst die tatsächliche Bitzahl ausgerechnet und mit CEIL auf das nächste Bit aufgerundet. So erhält man z.B. für die Werte 100 und 126 die nötigen 7 Bits, für einen Wert von 129 dann 8 Bits.

Lauflicht

nospam@example.com (Lothar Miller) — Thu, 01 Oct 2009 20:29:00 +0200

Hier das klassische Lauflicht in verschiedenen Variationen. Als Voraussetzung wird ein 10MHz-Takt verwendet, der jeweils auf die entsprechende Lauflichtgeschwindigkeit angepasst wird. Die Ausgabe erfolgt 8-kanalig z.B. auf LEDs.
Wir haben also folgenden Header mit Entity und Takterzeugung:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Clockdivider is
    Generic ( fclk     : integer := 10000000;
              frequenz : integer := 3);
    Port ( clk : in  STD_LOGIC;
           clken : out  STD_LOGIC);
end Clockdivider;

architecture Behavioral of Clockdivider is
signal clkdiv : integer range 0 to fclk/frequenz := 0;
begin
   process begin
      wait until rising_edge(clk);
      if (clkdiv < fclk/frequenz) then
         clkdiv <= clkdiv+1;
         clken  <= '0';
      else
         clkdiv <= 0;
         clken  <= '1';
      end if;
   end process;
end Behavioral;

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Lauflicht is
    Port ( clk : in  STD_LOGIC;
           leds : out  STD_LOGIC_VECTOR (7 downto 0));
end Lauflicht;

architecture Behavioral of Lauflicht is
  component Clockdivider is
    Generic ( fclk     : integer;
              frequenz : integer);
    Port    ( clk : in  STD_LOGIC;
              clken : out  STD_LOGIC);
  end component;
  signal clken  : std_logic;
  :
  :
begin
   clocken: Clockdivider GENERIC MAP( fclk => 10000000, frequenz => 3)
                         PORT MAP   ( clk => clk , clken => clken );
:
:
:   
end Behavioral;

Darin eingefügt wird jeweils an den Punkten (Signale bzw. Code) eines der folgenden Module:

1. Schieberegister, von links nach rechts

   signal sr : std_logic_vector (7 downto 0) := "10000000";
   :
   :
   process begin
      wait until rising_edge(clk);
      if (clken='1') then
         if (sr="00000001") then
            sr <= "10000000";
         else
            sr <= '0' & sr(7 downto 1);
         end if;
      end if;
   end process;
   leds <= sr;

Hier wird der Vektor sr auf einen Randwert (00000001) verglichen, und beim Erreichen dieses Wertes der Startwert (10000000) geladen.
Einiges eleganter ist die folgende Version. Hier wird einfach das hinten herausfallende Bit vorne wieder eingeschoben:

   :
   process begin
      wait until rising_edge(clk);
      if (clken='1') then
         sr <= sr(0) & sr(7 downto 1);
      end if;
   end process;
   leds <= sr;

2. Schieberegister, von rechts nach links

   signal sr : std_logic_vector (7 downto 0) := "00000001";
   :
   process begin
      wait until rising_edge(clk);
      if (clken='1') then
         sr <= sr(6 downto 0) & sr(7);
      end if;
   end process;
   leds <= sr;

3. Schieberegister, hin und her (einfacher Knight-Rider)

   signal sr : std_logic_vector (7 downto 0) := "00000001";
   signal dir : std_logic := '0';
   : 
   : 
   process begin
      wait until rising_edge(clk);
      if (clken='1') then
         if (dir='0') then
            if (sr="01000000") then  dir <= not dir; end if;
            sr <= sr(6 downto 0) & '0';
         else
            if (sr="00000010") then  dir <= not dir; end if;
            sr <= '0' & sr(7 downto 1);
         end if;
      end if;
   end process;
   leds <= sr;

4. LUT, konfigurierbar

   signal cnt : integer range 0 to 7 := 0;
   :
   : 
   process begin
      wait until rising_edge(clk);
      if (clken='1') then
         if (cnt<7) then cnt <= cnt+1;
         else            cnt <= 0;
         end if;
      end if;
      case cnt is
         when 0 =>    leds <= "10000000"; -- Lauflichtmuster hier ablegen
         when 1 =>    leds <= "00100000";
         when 2 =>    leds <= "00001000";
         when 3 =>    leds <= "00000010";
         when 4 =>    leds <= "00000001";
         when 5 =>    leds <= "00000100";
         when 6 =>    leds <= "00010000";
         when others=>leds <= "01000000";
      end case;
   end process;

Hier gibt es auch die Alternative, diese Zuweisung Concurrent zu schreiben:

   process begin
      wait until rising_edge(clk);
      if (clken='1') then
         if (cnt<7) then cnt <= cnt+1;
         else            cnt <= 0;
         end if;
      end if;
   end process;
   
   leds <= "10000000" when cnt = 0 else
           "00100000" when cnt = 1 else
           "00001000" when cnt = 2 else
           "00000010" when cnt = 3 else
           "00000001" when cnt = 4 else
           "00000100" when cnt = 5 else
           "00010000" when cnt = 6 else
           "01000000";

Damit wird eine Registerstufe am Ausgang gespart. Das selbe wäre erreicht, wenn im vorherigen Code die case-Anweisung in einen eigenen kombinatorischen Prozess ausgelagert würde. Der Synthesizer erkennt hier in beiden Beschreibungen ein ROM und fügt dieses in den RTL-Plan ein. Natürlich könnte das ROM auch direkt beschrieben werden, wie im Beispiel 5.

5. ROM, konfigurierbar

   signal cnt : integer range 0 to 7 := 0;
   : 
   : 
   process
     type Rom is array (0 to 7) of std_logic_vector(7 downto 0); 
     constant ledarray : Rom := ("10000000",
                                 "00100000",
                                 "00001000",
                                 "00000010",
                                 "00000001",
                                 "00000100",
                                 "00010000",
                                 "01000000");
   begin
      wait until rising_edge(clk);
      if (clken='1') then
         if (cnt<7) then
            cnt <= cnt+1;
         else
            cnt <= 0;
         end if;
      end if;
      leds <= ledarray(cnt);
   end process;

Und last but not least, der Traum aller Pontiac Trans Am Fahrer
6. ROM, der echte Knight-Rider (mit nachleuchtenden LEDs)

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity Lauflicht is
    Port ( clk : in  STD_LOGIC;
           leds : out  STD_LOGIC_VECTOR (7 downto 0));
end Lauflicht;

architecture Behavioral of Lauflicht is
  constant fclk    : integer := 50000;
  signal clkdiv    : integer range 0 to fclk/2000 := 0;-- PWM Frequenz: 2000 Hz / 16 Schritte = 125 Hz
  signal nextled   : integer range 0 to 5000/3 := 0;   -- Weiterschalten mit 3Hz
  signal idx       : integer range 0 to 13 := 0;       -- Index
  signal pwmcnt    : integer range 0 to 15 := 0;       -- PWM Zähler
  signal ledbright : std_logic_vector( 7 downto 0); -- die hellen LEDs
  signal leddimmed : std_logic_vector( 7 downto 0); -- die etwas dunkler nachleuchtenden LEDs
  signal ledglow   : std_logic_vector( 7 downto 0); -- die gerade noch so nachleuchtenden LEDs
  
begin
   
   process
     type Rom is array (0 to 13) of std_logic_vector(7 downto 0); 
     constant ledarray : Rom := ("10000000",
                                 "01000000",
                                 "00100000",
                                 "00010000",
                                 "00001000",
                                 "00000100",
                                 "00000010",
                                 "00000001",
                                 "00000010",
                                 "00000100",
                                 "00001000",
                                 "00010000",
                                 "00100000",
                                 "01000000");
   begin
      wait until rising_edge(clk);
      if (clkdiv<fclk/5000) then  -- Taktteiler 
         clkdiv<=clkdiv+1;
      else
         clkdiv<=0;
         if (nextled<5000/3) then -- Bitmuster verwalten
            nextled <= nextled+1;
         else
            nextled <= 0;
            if (idx<13) then idx<=idx+1;
            else             idx<=0;
            end if;
            ledglow   <= leddimmed;
            leddimmed <= ledbright;
            ledbright <= ledarray(idx);
         end if;
         if (pwmcnt<15) then      -- PWM für gedimmte LEDs
            pwmcnt <= pwmcnt+1;
         else
            pwmcnt <= 0;
         end if;
      end if;
   end process;
      
   leds <= ledbright or leddimmed or ledglow when pwmcnt < 4 else
           ledbright or leddimmed            when pwmcnt < 8 else
           ledbright;
           
end Behavioral;

Das Nachleuchten wird mit einer 4 Bit (16 Stufen) PWM mit 125 Hz realisiert. Abhängig von den LEDs sollten die "Nachleuchtwerte" 4 und 8 noch angepasst werden.

Finde das MSB

nospam@example.com (Lothar Miller) — Sun, 02 Aug 2009 14:30:00 +0200

Öfter mal sucht man nach dem führenden Bit (aka. MSB bzw. LSB).
Hier sind einige Vorgehensweisen, dieses Bit zu finden, und dazu eine Performancebewertung.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity MSB is
    Port ( data : in  STD_LOGIC_VECTOR (31 downto 0);
           msb1 : out  STD_LOGIC_VECTOR (4 downto 0);
           msb2 : out  STD_LOGIC_VECTOR (4 downto 0);
           msb3 : out  STD_LOGIC_VECTOR (4 downto 0);
           msb4 : out  STD_LOGIC_VECTOR (4 downto 0));
end MSB;

architecture Behavioral of MSB is
signal msbint1 : integer range 0 to 31;
signal msbint2 : integer range 0 to 31;
signal msbint3 : integer range 0 to 31;
signal msbint4 : integer range 0 to 31;
begin

-- Beispiel 1
  msbint1 <= 31 when data(31)='1' else
             30 when data(30)='1' else
             29 when data(29)='1' else
             28 when data(28)='1' else
             27 when data(27)='1' else
             26 when data(26)='1' else
             25 when data(25)='1' else
             24 when data(24)='1' else
             23 when data(23)='1' else
             22 when data(22)='1' else
             21 when data(21)='1' else
             20 when data(20)='1' else
             19 when data(19)='1' else
             18 when data(18)='1' else
             17 when data(17)='1' else
             16 when data(16)='1' else
             15 when data(15)='1' else
             14 when data(14)='1' else
             13 when data(13)='1' else
             12 when data(12)='1' else
             11 when data(11)='1' else
             10 when data(10)='1' else
              9 when data( 9)='1' else
              8 when data( 8)='1' else
              7 when data( 7)='1' else
              6 when data( 6)='1' else
              5 when data( 5)='1' else
              4 when data( 4)='1' else
              3 when data( 3)='1' else
              2 when data( 2)='1' else
              1 when data( 1)='1' else
              0;
   msb1 <= std_logic_vector(to_unsigned(msbint1,msb1'length));
   
-- Beispiel 2
   process (data) 
   variable foundbit : std_logic;
   begin
      foundbit := '0';
      msbint2 <= 0;
      for i in 31 downto 0 loop
         if (data(i)='1' and foundbit='0') then 
            msbint2  <= i;
            foundbit := '1';
         end if;
      end loop;
   end process;
   msb2 <= std_logic_vector(to_unsigned(msbint2,msb2'length));

-- Beispiel 3
   process (data) 
   begin
      msbint3 <= 0;
      for i in 31 downto 0 loop
         if (data(i)='1') then 
            msbint3 <= i;
            exit;
         end if;
      end loop;
   end process;
   msb3 <= std_logic_vector(to_unsigned(msbint3,msb3'length));

-- Beispiel 4
   process (data) 
   variable i : integer range 0 to 31;
   begin
      i := 31;
      while (data(i)='0') loop 
         i := i-1;
      end loop;
      msbint4 <= i;
   end process;
   msb4 <= std_logic_vector(to_unsigned(msbint4,msb4'length));
  
end Behavioral;

Hier das Syntheseergebnis:

Beispiel	Slices	LUT	Time
1	23	40	19,263ns
2	51	87	24,339ns
3	23	40	19,263ns
4	28	47	18,821ns

Das aufwendig beschriebene Beispiel 1 (concurrent) gibt wie das Beispiel 3 (for-Schleife mit exit) die kompakteste Logik ab.

Am schnellsten wird dagegen die while-Scheife im Beispiel 4 umgesetzt.

Das Ergebnis für das Beispiel 2 ist suboptimal, weil die for-Schleife weiter durchlaufen wird, auch wenn eine '1' gefunden wurde.

Vektor (0 downto 0)

nospam@example.com (Lothar Miller) — Wed, 24 Jun 2009 08:15:00 +0200

Was tun, wenn ein std_logic_vector den Bereich (0 downto 0) hat, und dessen Elemente auf andere Signale abgebildet werden müssen?

Die Lösung ist ganz einfach: es wird nur das 0. Element des Vektors verwendet

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity VectAssign is
    Port ( dins  : in  STD_LOGIC;
           dos   : out STD_LOGIC;
           dinv  : in  STD_LOGIC_VECTOR (0 downto 0);
           dov   : out STD_LOGIC_VECTOR (0 downto 0));
end VectAssign ;

architecture Behavioral of VectAssign is
begin
   dov(0) <= not dinv(0) and     dins;
   dos    <=     dinv(0) and not dins;
end Behavioral;

Aus dieser Beschreibung macht die Synthese dann folgendes:

Ergebnis: ANDs mit einem invertiertem Eingang