2017-01-16 2 views
0

Für die Schule machen wir Code für eine ALU. Der Code muss eine Berechnung mit 1, 2 oder 3 Eingängen durchführen und in den Ausgang kopieren, die Berechnung ist abhängig von einer 4-Bit-Zahl.Bitshifting und Rotieren in vhdl

Der Code I haben, wird unten gezeigt, und das Problem ist I haben, dass die SSLSOLSRL und ROR Betreiber nicht gefunden:

final_ex.vhd (34): kann nicht Definition der Bediener bestimmen, "" SLL "" - gefunden 0 mögliche Definitionen

final_ex.vhd (35): kann nicht bestimmen, Definition des Operators "" rol "" - gefunden 0 mögliche Definitionen

final_ex.vhd (36) : kann die Definition der Oper nicht bestimmen tor "" srl "" - gefunden 0 mögliche Definitionen

final_ex.vhd (37): kann nicht bestimmen, Definition des Operators "" ror "" - fand 0 mögliche Definitionen

Mein vdhl ist auf 2008, also kann es nicht versionsbezogen sein. Ich habe versucht, std_logic_vector anstelle von unsigned zu verwenden, ich habe versucht, eine normale 4-Bit-Nummer wie "0101" zu verwenden, aber jedes Mal gibt es den gleichen Fehler. ich versuchte verschiedene Datentypen aber es wird nicht funktionieren.

LIBRARY ieee; 
USE ieee.std_logic_1164.all; 
USE ieee.numeric_std.all; 

ENTITY final_ex IS 
GENERIC(N: INTEGER:= 4); -- length of the inputs and output 
    PORT(
    A, B: IN STD_LOGIC_VECTOR(N-1 DOWNTO 0); 
    functions: IN STD_LOGIC_VECTOR(3 DOWNTO 0); 
    clock, Setflag, Zeroflag: IN STD_LOGIC; 
    C: OUT STD_LOGIC_VECTOR(N-1 DOWNTO 0) 
); 
END ENTITY; 

ARCHITECTURE alu OF final_ex IS 
    SIGNAL a_sig, b_sig: SIGNED(N-1 DOWNTO 0); 
    SIGNAL c_sig: SIGNED(N-1 DOWNTO 0); 
    SIGNAL c_unsig: STD_LOGIC_VECTOR(N-1 DOWNTO 0); 
    SIGNAL carry: INTEGER RANGE 0 TO 1; 
    SIGNAL a_unsig: UNSIGNED(N-1 DOWNTO 0); 

BEGIN 
    a_unsig <= UNSIGNED(A); 
    ---------Logic Unit----------- (with unsigned output for logic, bitwise operators) 
    WITH functions(2 DOWNTO 0) SELECT 
    c_unsig <= A AND B  WHEN "000", 
        A OR B WHEN "001", 
        A XOR B  WHEN "010", 
         NOT A  WHEN "011", 
        a_unsig SLL 1 WHEN "100", 
        a_unsig ROL 1 WHEN "101", 
        a_unsig SRL 1 WHEN "110", 
        a_unsig ROR 1 WHEN OTHERS; 

    ---------- Arithmetic Unic:---------- (signed for calcualtions with integers) 
    a_sig <= SIGNED(A); 
    b_sig <= SIGNED(B); 
    carry <= 1 WHEN Setflag = '1' Else 0; 

    WITH functions(2 DOWNTO 0) SELECT 
    c_sig <=  "0000"   WHEN "000", 
       a_sig   WHEN "001", 
       a_sig + 1 WHEN "010", 
       a_sig - 1 WHEN "011", 
       a_sig + b_sig WHEN "100", 
       a_sig + b_sig + carry WHEN "101", 
       a_sig - b_sig  WHEN "110", 
       a_sig - b_sig - carry WHEN OTHERS; 

    ----------------------------------------------------------------------------- 
    WITH functions(3) SELECT 
     c <= c_unsig WHEN '1', 
       STD_LOGIC_VECTOR(c_sig) WHEN OTHERS; 

END ARCHITECTURE; 

Antwort

2

Wenn Sie genau die Art von c_unsig sehen ist std_logic_vector. Es gibt keine vordefinierten Operatoren "sll", "rol", "srl" und "ror" mit einer Signatur [unsigned, Ganzzahl return std_logic_vector] (wobei im Paket numeral_std -2008 der Typ unsigned der Basistyp UNRESOLVED_UNSIGNED wäre).

Es gibt drei Möglichkeiten, dies zu beheben.

Mit Typumwandlung:

WITH functions(2 DOWNTO 0) SELECT 
    c_unsig <= A AND B  WHEN "000", 
        A OR B WHEN "001", 
        A XOR B  WHEN "010", 
         NOT A  WHEN "011", 
        std_logic_vector(a_unsig SLL 1) WHEN "100", 
        std_logic_vector(a_unsig ROL 1) WHEN "101", 
        std_logic_vector(a_unsig SRL 1) WHEN "110", 
        std_logic_vector(a_unsig ROR 1) WHEN OTHERS; 

Diese stützt sich auf die Signaturen der im Paket numeric_std deklarierten Funktionen.

Ändern der Art von c_unsig:

SIGNAL c_unsig: unsigned(N-1 DOWNTO 0); 
    SIGNAL carry: INTEGER RANGE 0 TO 1; 
    SIGNAL a_unsig: UNSIGNED(N-1 DOWNTO 0); 

BEGIN 
    a_unsig <= UNSIGNED(A); 
    ---------Logic Unit----------- (with unsigned output for logic, bitwise operators) 
    WITH functions(2 DOWNTO 0) SELECT 
    c_unsig <=  unsigned (A AND B) WHEN "000", 
        unsigned (A OR B)  WHEN "001", 
        unsigned (A XOR B)  WHEN "010", 
        unsigned ( NOT A) WHEN "011", 
        a_unsig SLL 1   WHEN "100", 
        a_unsig ROL 1   WHEN "101", 
        a_unsig SRL 1   WHEN "110", 
        a_unsig ROR 1   WHEN OTHERS; 

    ---------- Arithmetic Unic:---------- (signed for calcualtions with integers) 
    a_sig <= SIGNED(A); 
    b_sig <= SIGNED(B); 
    carry <= 1 WHEN Setflag = '1' Else 0; 

    WITH functions(2 DOWNTO 0) SELECT 
    c_sig <=  "0000"   WHEN "000", 
       a_sig   WHEN "001", 
       a_sig + 1 WHEN "010", 
       a_sig - 1 WHEN "011", 
       a_sig + b_sig WHEN "100", 
       a_sig + b_sig + carry WHEN "101", 
       a_sig - b_sig  WHEN "110", 
       a_sig - b_sig - carry WHEN OTHERS; 

    ----------------------------------------------------------------------------- 
    WITH functions(3) SELECT 
     c <= std_logic_vector(c_unsig) WHEN '1', 
       STD_LOGIC_VECTOR(c_sig) WHEN OTHERS; 

END ARCHITECTURE; 

Und dies bringt eine weitere Art Konvertierung.

Ändern die Art des c_unsig und das Hinzufügen von b_unsig:

SIGNAL c_unsig: unsigned(n-1 downto 0); -- STD_LOGIC_VECTOR(N-1 DOWNTO 0); 
    SIGNAL carry: INTEGER RANGE 0 TO 1; 
    SIGNAL a_unsig: UNSIGNED(N-1 DOWNTO 0); 
    signal b_unsig: unsigned(n-1 downto 0); 

BEGIN 
    a_unsig <= UNSIGNED(A); 
    b_unsig <= unsigned(B); 

    ---------Logic Unit----------- (with unsigned output for logic, bitwise operators) 
    WITH functions(2 DOWNTO 0) SELECT 
    c_unsig <=  a_unsig AND b_unsig  WHEN "000", 
        a_unsig OR b_unsig  WHEN "001", 
        a_unsig XOR b_unsig  WHEN "010", 
         NOT a_unsig   WHEN "011", 
        a_unsig SLL 1   WHEN "100", 
        a_unsig ROL 1   WHEN "101", 
        a_unsig SRL 1   WHEN "110", 
        a_unsig ROR 1   WHEN OTHERS; 

    ---------- Arithmetic Unic:---------- (signed for calcualtions with integers) 
    a_sig <= SIGNED(A); 
    b_sig <= SIGNED(B); 
    carry <= 1 WHEN Setflag = '1' Else 0; 

    WITH functions(2 DOWNTO 0) SELECT 
    c_sig <=  "0000"   WHEN "000", 
       a_sig   WHEN "001", 
       a_sig + 1 WHEN "010", 
       a_sig - 1 WHEN "011", 
       a_sig + b_sig WHEN "100", 
       a_sig + b_sig + carry WHEN "101", 
       a_sig - b_sig  WHEN "110", 
       a_sig - b_sig - carry WHEN OTHERS; 

    ----------------------------------------------------------------------------- 
    WITH functions(3) SELECT 
     c <= std_logic_vector(c_unsig) WHEN '1', 
       STD_LOGIC_VECTOR(c_sig) WHEN OTHERS; 

Dies entspricht Ihre Nutzung für signierten Betrieb.

Alle drei Änderungen analysieren und erarbeiten. Ohne eine Testbench zum Generieren von clock und den verschiedenen anderen Eingaben wurde die Überprüfung der Grenzen nicht verifiziert.

Dieser Code ist nicht auf -2008 angewiesen.

VHDL ist eine stark typisierte Sprache und Funktionen Operatoren gemacht, die für Betreiber Überlastung basierend auf Signaturen Angabe beiden Eingangstypen und den Rückgabetyp zu implementieren.

Siehe IEEE Std 1076-2008 4.5.2 Operatorüberladung, 4.5.3 Signaturen, 9.2 Operatoren, 9.3.6 Typkonvertierungen und 12.5 Der Kontext der Überladungsauflösung.