Frage zur VHDL Syntax - unsigned(std_logic_vector)

[hmmm (Gast)]

Hallo,

ich steh grade etwas aufm Schlauch. Ich will einen std_logic_vector mit 
einem generic integer vergleichen. Ich hab jetzt aber grad ein anderes 
Problem

...
generic(foo : integer := 8);
...

signal footo : std_logic_vector(3 downto 0);
signal foodownto : std_logic_vector(0 to 3);

...
-- hier kommen einige Zuweisungen zu den beiden Variablen, angenommen es steht jetzt in beiden "1000" drin, also: (könnte aber auch innerhalb von eines prozesses sein, ist also variabl und keine feste, concorrent zuweisung
footo <= "1000";
foodownto <= "1000";


-- und später prüfe ich dann sowas, innerhalb eines prozesses
if unsigned(footo) = foo then
-- do something
end if;
if unsigned(foodownto) = foo then
-- do something
end if;

werden dann beide if anweisungen ausgeführt? also sind beide if 
auswertungen true, obwohl der eine downto und der andere to deklariert 
wurden? Danke für die Hilfe

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

hmmm schrieb:
> werden dann beide if anweisungen ausgeführt?
Keine wird ausgeführt, weil du einen unsigned-Vektor mit einem Integer 
vergleichst. Das geht nicht.

Mit der numeric_std ginge es so:

if to_integer(unsigned(foodownto)) = foo then ...

Und dann wird es spannend: wird auch der "to-Vektor" "richtig" 
umgerechnet?
Da hilft ein Blick in die numeric_std:
http://www.csee.umbc.edu/portal/help/VHDL/packages/numeric_std.vhd
Dort findet sich dann sowas:

library ieee;
use ieee.STD_LOGIC_1164.all;

Package numeric_std is
  --================================================================
  -- Numeric array type definitions
  --================================================================
 
  type UNSIGNED is array ( NATURAL range <> ) of STD_LOGIC;

Und das sieht genau so aus wie die definition des std_logic_vectors:

    type std_logic_vector is array ( natural range <>) of std_logic;

Das heißt also, dass der Cast zum unsigend() nichts am Vektor ändert.

Nächster Schritt: was passiert beim to_integer()?
Wieder in der numeric_std nachgeschaut:

function TO_INTEGER(ARG: UNSIGNED) return NATURAL is
:
variable XARG:UNSIGNED(ARG_LEFT downto 0); 
variable RESULT: NATURAL:= 0;
variable w : INTEGER:= 1;  -- weight factor
begin
  :
  :
  for i in XARG'reverse_range loop
    if XARG (i) = '1' then
      RESULT:= RESULT + w;
      end if;
    if (i /= XARG'left) then w := w + w;
      end if;
    end loop;
  return RESULT;
  end TO_INTEGER;

Nach genauem hinsehen erkennt man, dass hier mit 'reverse_range stur die 
Bits des Vektors "von hinten her" angeschaut werden. Und eben nicht 
explizit das footo(3) oder das foodownto(3).

Fazit: beide Vergleiche werden auf die selbe Art reagieren...

[hmmm (Gast)]

Ahh verdammt...

Gut, danke mal für die Hinweise.^^
Interessant ist dann nur folgendes:
hab mir mal einen sehr übersichtlichen "Test" geschrieben

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity test is
end entity test;

architecture RTL of test is
  signal a : std_logic_vector(0 to 3) := "0000";
  constant b : integer := 8;
begin
  
  a <= "1000" after 1 ns;
  
  test : process(a) is
  begin
    report "here";
    if unsigned(a) = b then
      report "if";
    else
      report "elsee";
    end if;
  end process test;
  
end architecture RTL;

und modelsim git mir aus

run 2 ns
# ** Note: here
#    Time: 0 ns  Iteration: 0  Instance: /test
# ** Note: elsee
#    Time: 0 ns  Iteration: 0  Instance: /test
# ** Note: here
#    Time: 1 ns  Iteration: 0  Instance: /test
# ** Note: if
#    Time: 1 ns  Iteration: 0  Instance: /test

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

hmmm schrieb:
> und modelsim git mir aus
Ja, passt doch...
Erst ist der Wert ungleich, und dann nach 1 ns gleich.

Aber wie gesagt: du hast Glück, dass der "=" Operator passend für den 
Vergleich eines unsigend Vektors mit einem positiven(!) Integer 
überladen, und zudem die Zahl 8 genau so ein Integer ist:

  :
     -- Id: C.29
  function "=" ( L: UNSIGNED; R: NATURAL) return BOOLEAN;
     -- Result subtype: BOOLEAN
     -- Result: Computes "L = R" where L is an UNSIGNED vector and
     --         R is a non-negative INTEGER.
  :

> test : process(a) is
Dir ist klar, dass diese Sensitivliste nicht vollständig ist?