Numeric_Std

Die gerne noch verwendeten Quasi-Industrie-Standards der Synopsys-Lib sind schon geraume Zeit obsolete.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

Statt dessen sollte die Numeric_Std Library verwendet werden. Diese ist herstellerunabhängig und über IEEE 1076.3 genormt.

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

Auf keinen Fall dürfen aber frei nach dem Motto "Viel hilft viel!" einfach alle Libs genommen werden. Denn dann existieren ein paar Typdefinitionen und Umwandlungen doppelt, und der Synthesizer hat die Qual der Wahl, die er aber in Form einer Fehlermeldung gern an den Bediener zurückgibt.


Hier eine kurze Übersicht, wie die Datentypen signed und unsigned zwischen integer und std_logic_vector sitzen.

Cast vs. Konvertierung:
Von std_logic_vector nach signed/unsigned und zurück wird "nur" gecastet mit singed(), unsigned() und std_logic_vector().

Von signed/unsigned nach integer und zurück wird konvertiert, das ist leicht zu erkennen an dem Prefix "to_" bei to_signed(), to_unsigned() und to_integer().


Umwandlung von real nach std_logic_vector und zurück:
Natürlich kann man einen Vektor nicht so einfach in eine Fließkommazahl umwandeln. Um aber irgendeine Berechnung mit der ieee.math_real.all durchführen zu können und das Ergebnis dann einem integer und anschliessend einem Vektor übergeben zu können, gibt es die Konvertierungsfunktionen real() und integer().

realzahl <= real(to_integer(unsigned(vektor))) / 32768.0;

vektor <= std_logic_vector(to_unsigned(integer(realzahl * 512.0),vektor'length));

Diese Wandlungen werden z.B. bei der Tabellenberechnung für die DDFS und bei der Berechnung der Vektorbreite verwendet.



Übrigens:
Ein beliebter Fehler ist es, dem Synthesizer undefinierte Typen mit einem Cast "beizubiegen". Der richtig Ansatz dafür wäre aber ein Qualifier.

Mit der numeric_std lassen sich schöne Dinge anstellen, die den Code fast unlesbar machen

Hier einige akademische und praktische Beispiele, wie ein 16-Bit Integer in einzelne Nibble zerlegt werden kann:

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

entity Vectors is
    Port ( vin : in  STD_LOGIC_VECTOR (15 downto 0);
           sel : in  STD_LOGIC_VECTOR (3 downto 0);
           voutA : out  STD_LOGIC_VECTOR (3 downto 0);
           voutB : out  STD_LOGIC_VECTOR (3 downto 0);
           voutC : out  STD_LOGIC_VECTOR (3 downto 0);
           voutD : out  STD_LOGIC_VECTOR (3 downto 0));
end Vectors;

architecture Behavioral of Vectors is
signal s : std_logic_vector(1 downto 0);
signal i : integer range 0 to 2**16-1;
signal h : integer range 0 to 3;
begin
   i <= to_integer(unsigned(vin));
   s <= sel(1) & sel(3);
   h <= to_integer(unsigned(s));          

   with s select
   voutA <= std_logic_vector(to_unsigned(i,16)(3  downto  0)) when "00", 
            std_logic_vector(to_unsigned(i,16)(7  downto  4)) when "01", 
            std_logic_vector(to_unsigned(i,16)(11 downto  8)) when "10", 
            std_logic_vector(to_unsigned(i,16)(15 downto 12)) when others;
            
   with s select
   voutB <= std_logic_vector(to_unsigned(i     ,4)) when "00", 
            std_logic_vector(to_unsigned(i/16  ,4)) when "01", 
            std_logic_vector(to_unsigned(i/256 ,4)) when "10", 
            std_logic_vector(to_unsigned(i/1024,4)) when others;
            
   voutC <= std_logic_vector(to_unsigned(i,16)(h*4+3 downto h*4));

   -- leider noch nicht synthetisierbar
   voutD <= std_logic_vector(to_unsigned(i/(2**(h*4)),4)); 
end Behavioral;

Zuerst wird vorbereitend der Eingangsvektor vin in einen Integer i umgewandelt. Im echten Leben wäre i z.B. ein Zähler oder ein Rechenwert. Der Auswahlvektor s wird aus einzelnen Bits eines Eingangssignals zusammengesetzt. Über s wird dann jeweils ein Nibble von i auf voutA..C abgebildet.

Wie im RTL-Schaltplan zu sehen ist, werden alle drei gültigen Beschreibungen identisch implementiert:

Alle drei Beschreibungen erzeugen die selbe Hardware

voutD simuliert zwar schön, kann aber von der Synthese nicht abgebildet werden, Xilinx ISE meldet:
Operator <DIVIDE> must have constant operands or first operand must be power of 2
Die Fehlermeldung ist nicht ganz einsichtig, denn 2**(h*4) ist eine Zweierpotenz


Soll aus einem Integer ein einzelnes Bit herausgelöst werden, können diese Beschreibungen verwendet werden:

   signal bit9 : STD_LOGIC;
   signal bit8 : STD_LOGIC;

   -- ein einzelnes Bit aus einem Integer herausholen
   bit8 <= to_unsigned(i,9)(8);
   
   -- to_unsigned(i,1) gibt einen Vektor (0 downto 0) zurück
   -- daraus wird dann das Bit 0 verwendet
   bit9 <= to_unsigned(i/2**9,1)(0);

Wie gerne möchte man in VDHL für einen Vektorvergleich einfach wie bei einer Vektor-Zuweisung

signal vec: std_logic_vector(3 downto 0);
vec <= (others => '0');

den (others => '0') Konstrukt verwenden und schreiben:

erg  <= '1' when vec = (others => '1') else '0';

Aber dann hagelt es bei Verwendung der genormten numeric_std nur Fehlermeldungen
Warum denn?
Und wie kann ich den Vektor trotzdem mit so einem generischen Vergleich machen?

Der einfache Grund warum dieser Vergleich nicht funktioniert, ist, dass keine definierte Wortbreite für den Vergleichsektor da ist. Und damit ist die Länge von

(others => '1')

erst mal unbekannt. Der Synthesizer stellt sich also doof und meckert:
"Ich kann den linken Vektor nicht mit einem Vektor unbekannter Breite vergleichen!"

Also muß ihm das gesagt werden. So geht es mit manueller Bereichsangabe:

erg  <= '1' when vec = (3 downto 0 => '1') else '0';

Und so wird automatisch der Bereich des Vektors verwendet:

erg  <= '1' when vec = (vec'range => '1') else '0';

Natürlich gilt das vorherige auch für if-Abfragen und i.A. für Vergleiche.

if vec = (3 downto 0=>'0') then..
if vec = (vec'range =>'0') then..

Ein Vergleich mit einem Zahlenwert muß bei Verwendung der numeric_std ein wenig konvertiert und gecastet werden. Hier wird einfach die Wortbreite ('length) des Vektors angegeben:

if vec = std_logic_vector(to_unsigned(5,vec'length)) then...