std_logic_vector und std_ulogic_vector

[Beginner (Gast)]

Hallo,

kann mir jemand erklären:

 wieso es möglich ist, std_ulogic Signale an std_logic zu hängen, ebenso 
wie std_ulogic an Ports von einem std_logic_vector, es aber nicht 
möglich ist, einen std_ulogic_vector an einen std_logic_vector zu 
hängen? Der Unterschied zwischen beiden Typen ist mir klar, ich verstehe 
nur nicht, wieso es bei einem  ganzen vektor nicht geht, wohl aber bei 
signalen.

Gibts es dafür irgendwelche Hintergründe? Ich würde mich auch über 
Literaturhinweise freuen!

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Beginner schrieb:
> Gibts es dafür irgendwelche Hintergründe?
Die std_logic_1164 sieht so aus:

    TYPE std_ulogic IS ( 'U',  -- Uninitialized
                         'X',  -- Forcing  Unknown
                         '0',  -- Forcing  0
                         '1',  -- Forcing  1
                         'Z',  -- High Impedance   
                         'W',  -- Weak     Unknown
                         'L',  -- Weak     0       
                         'H',  -- Weak     1       
                         '-'   -- Don't care
                       );
    -------------------------------------------------------------------    
    -- unconstrained array of std_ulogic for use with the resolution function
    -------------------------------------------------------------------    
    TYPE std_ulogic_vector IS ARRAY ( NATURAL RANGE <> ) OF std_ulogic;
                                    
    -------------------------------------------------------------------    
    -- resolution function
    -------------------------------------------------------------------    
    FUNCTION resolved ( s : std_ulogic_vector ) RETURN std_ulogic;
    
    -------------------------------------------------------------------    
    -- *** industry standard logic type ***
    -------------------------------------------------------------------    
    SUBTYPE std_logic IS resolved std_ulogic;

    -------------------------------------------------------------------    
    -- unconstrained array of std_logic for use in declaring signal arrays
    -------------------------------------------------------------------    
    TYPE std_logic_vector IS ARRAY ( NATURAL RANGE <>) OF std_logic;

Und hier siehst du, dass die Auflösungsfunktion nur für einzelne Bits 
definiert ist.

    FUNCTION resolved ( s : std_ulogic_vector ) RETURN std_ulogic IS
        VARIABLE result : std_ulogic := 'Z';  -- weakest state default
    BEGIN
        -- the test for a single driver is essential otherwise the
        -- loop would return 'X' for a single driver of '-' and that
        -- would conflict with the value of a single driver unresolved
        -- signal.
        IF    (s'LENGTH = 1) THEN    RETURN s(s'LOW);
        ELSE
            FOR i IN s'RANGE LOOP
                result := resolution_table(result, s(i));
            END LOOP;
        END IF;
        RETURN result;
    END resolved;

Deshalb findet der & Operator, der ja nur gleiche Datentypen verknüpfen 
kann für die zu verknüpfenden Vektoren keine Umwandlungsmöglichkeit.

Du müsstest also den & Operator überladen, dass auch deine Kombination 
geht:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity sl_sul is
    Port ( a    : in   STD_LOGIC_VECTOR  (3 downto 0);
           b    : in   STD_LOGIC_VECTOR  (3 downto 0);
           au   : in   STD_ULOGIC_VECTOR (3 downto 0);
           bu   : in   STD_ULOGIC_VECTOR (3 downto 0);
           ab   : out  STD_LOGIC_VECTOR  (7 downto 0);
           abu  : out  STD_LOGIC_VECTOR  (7 downto 0);
           aub  : out  STD_LOGIC_VECTOR  (7 downto 0);
           aubu : out  STD_ULOGIC_VECTOR (7 downto 0));
end sl_sul;

architecture Behavioral of sl_sul is

    FUNCTION "&" ( a : std_ulogic_vector; b : std_logic_vector  ) RETURN std_logic_vector IS
        ALIAS av : std_ulogic_vector ( 1 TO a'LENGTH ) IS a;
        ALIAS bv : std_logic_vector ( 1 TO b'LENGTH ) IS b;
        VARIABLE result : std_logic_vector ( 1 TO a'LENGTH+b'LENGTH );
    BEGIN
        FOR i IN av'RANGE LOOP
          result(i)          := av(i);
        END LOOP;
        FOR i IN av'RANGE LOOP
          result(i+a'LENGTH) := bv(i);
        END LOOP;
        RETURN result;
    END "&";

    FUNCTION "&" ( b : std_logic_vector; a : std_ulogic_vector  ) RETURN std_logic_vector IS
        ALIAS av : std_ulogic_vector ( 1 TO a'LENGTH ) IS a;
        ALIAS bv : std_logic_vector ( 1 TO b'LENGTH ) IS b;
        VARIABLE result : std_logic_vector ( 1 TO a'LENGTH+b'LENGTH );
    BEGIN
        FOR i IN av'RANGE LOOP
          result(i)          := av(i);
        END LOOP;
        FOR i IN av'RANGE LOOP
          result(i+a'LENGTH) := bv(i);
        END LOOP;
        RETURN result;
    END "&";

begin
   ab   <= a  & b;             
   abu  <= a  & bu;  -- jetzt gehts
   aub  <= au & b;   -- jetzt gehts
   aubu <= au & bu;
end Behavioral;

[Beginner (Gast)]

Danke für deine Antwort.

Ich meinte allerdings nicht den &-Operator, sondern die gewöhnlichen 
Zuweisungen:

-- Bestehendes VHDL:
a : out std_logic,
b : out std_logic,
a_vector : out std_ulogic_vector(0 to 31),

-- Generierter VHDL-Code:
mb_gpio_data : out std_logic_vector(0 to 31),

-- Anbindung:
 -- das hier funktioniert:
 Inst_test: test PORT MAP(
  mb_gpio_data(31) => a,
  mb_gpio_data(30) => b,
  mb_gpio_data(0 to 29) => open
  );

 -- das hier funktioniert NICHT, ohne zu casten:
 Inst_test: test PORT MAP(
  mb_gpio_data => a_vector
  );

Du meintest ja, dass die Auflösungsfunktion nur für einzelne Bits 
definiert ist. Gibt es dazu einen bestimmten Hintergund? Was ist hier 
der Unterschied zwischen einzelnen Signalen und Vektoren?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Beginner schrieb:
> Gibt es dazu einen bestimmten Hintergund?
Man macht in VHDL lieber eine explizite und sichtbare Umwandlung, als 
sich auf windige Automatismen zu verlassen.

> Du meintest ja, dass die Auflösungsfunktion nur für einzelne Bits
> definiert ist.
Ich meinte nicht, sondern es ist so. Siehe dazu den Ausschnitt aus 
der std_logic_1164... ;-)

> Was ist hier der Unterschied zwischen einzelnen Signalen und Vektoren?
Die Datentypen!
Nehmen wir mal das hier
   signal onebitvector : std_logic_vector( 0 to 0) := "0";
und das hier
   signal onebitsignal : std_logic := '0';
Hier wird augenscheinlich das selbe gemacht/gemeint/realisiert, aber 
VHDL lässt sowas nicht zu:
   onebitsignal <= onbitvector;
Da muss man schreiben:
   onebitsignal <= onbitvector(0);

[Beginner (Gast)]

Lothar Miller schrieb:
>> Gibt es dazu einen bestimmten Hintergund?
> Man macht in VHDL lieber eine explizite und sichtbare Umwandlung, als
> sich auf windige Automatismen zu verlassen.
Anscheinend ist es ja problemlos möglich sich bei einzelnen Signalen 
hierauf zu verlassen? Mich interessiert eigentlich nur, wieso dies bei 
einzelnen Signalen so implementiert wurde und bei Vektoren nicht! 
Irgendeinen Grund wird es hierfür doch geben? Wenn man dies generell 
nicht tun sollte, wäre es ja auch nicht nur bei einzelnen Signalen 
realisiert worden.

>> Was ist hier der Unterschied zwischen einzelnen Signalen und Vektoren?
> Die Datentypen!
> Nehmen wir mal das hier
>    signal onebitvector : std_logic_vector( 0 to 0) := "0";
> und das hier
>    signal onebitsignal : std_logic := '0';
> Hier wird augenscheinlich das selbe gemacht/gemeint/realisiert, aber
> VHDL lässt sowas nicht zu:
>    onebitsignal <= onbitvector;
> Da muss man schreiben:
>    onebitsignal <= onbitvector(0);
Ich meinte nicht generell der Unterschied! Der ist klar! Ich meinte den 
Unterschied, wieso es eben bei einzelnen Signalen automatisiert gecastet 
wird und bei einem Vektor nicht. Woran hier der Unterschied liegt, dass 
es beim einen gemacht wird und beim anderen nicht.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Beginner schrieb:
> Mich interessiert eigentlich nur, wieso dies bei
> einzelnen Signalen so implementiert wurde
Da ist es quasi ein "Abfallprodukt", weil ja der std_logic ein 
Untertyp des std_ulogic ist.