VHDL inout Problem

[Pit (Gast)]

Hallo,

ich habe einen CPLD mit 4 Pins (Mini-CPLD) und möchte darüber Lesen und 
Schreiben.

Hier der Code:

entity TEST1 is
  Port 
  ( 
    DATA_INOUT  : inout STD_LOGIC_VECTOR (3 downto 0);
    CLK       : in STD_LOGIC
  );
end TEST1;

architecture Behavioral of TEST1 is

  signal DATA_IN    : STD_LOGIC_VECTOR (3 downto 0);
  signal DATA_OUT  : STD_LOGIC_VECTOR (3 downto 0);
  signal COUNTER    : STD_LOGIC_VECTOR (3 downto 0);
  signal MAX_COUNT  : STD_LOGIC_VECTOR (3 downto 0);

  signal READ_DATA  : STD_LOGIC;

begin

  process (CLK) 
  begin
    if rising_edge(CLK) then
      COUNTER <= STD_LOGIC_VECTOR(unsigned(COUNTER) + 1);
      
      if COUNTER = "0000" then
        READ_DATA <= '0';
        DATA_OUT <= "1010";
        if MAX_COUNT = "1111" then
          MAX_COUNT <= "0000";
        end if;
      else
        READ_DATA <= '1';
        MAX_COUNT <= DATA_IN;
      end if;
    end if;
  end process;

  process(READ_DATA, DATA_OUT)
  begin
    if READ_DATA = '1' then
      DATA_INOUT <= ( others => 'Z' );
      DATA_IN <= DATA_INOUT;
    else
      DATA_INOUT <= DATA_OUT;
    end if;
  end process;

end Behavioral;

Wenn ich das nun hiermit simuliere, dann geht DATA_INOUT auf konstante 
'1001' und DATA_IN bzw. DATA_OUT bleiben chronisch auf 'undefined':

ENTITY tb_TEST1 IS
END tb_TEST1;
 
ARCHITECTURE behavior OF tb_TEST1 IS 
 
    -- Component Declaration for the Unit Under Test (UUT)
 
    COMPONENT TEST1
    PORT(
         DATA_INOUT : INOUT  std_logic_vector(3 downto 0);
         CLK : IN  std_logic
        );
    END COMPONENT;
    

   --Inputs
   signal CLK : std_logic := '0';

  --BiDirs
   signal DATA_INOUT : std_logic_vector(3 downto 0);

   -- Clock period definitions
   constant CLK_period : time := 10 ns;
 
BEGIN
 
  -- Instantiate the Unit Under Test (UUT)
   uut: TEST1 PORT MAP (
          DATA_INOUT => DATA_INOUT,
          CLK => CLK
        );

   -- Clock process definitions
   CLK_process :process
   begin
    CLK <= '0';
    wait for CLK_period/2;
    CLK <= '1';
    wait for CLK_period/2;
   end process;
 

   -- Stimulus process
   stim_proc: process
   begin    
      -- hold reset state for 100 ns.
      wait for 100 ns;  

      wait for CLK_period*10;

      -- insert stimulus here 
    DATA_INOUT <="1001" after 100 ns;
    
      wait;
   end process;

END;

Warum werden DATA_IN bzw. DATA_OUT nicht zugewiesen?

Danke Pit

[P. K. (pek)]

Beim zweiten Prozess hast Du mal sicher eine unvollständige 
Sensitivity-Liste (DATA_INOUT fehlt). Würde das eh concurrent machen, 
etwa in dieser Art:

  DATA_IN     <= DATA_INOUT;
  DATA_INOUT  <= 'Z' when READ_DATA = '1' else DATA_OUT;

[bko (Gast)]

Welchen Wert hat "COUNTER" in deiner Simulation?
Ich meine da fehlt entweder ein Reset oder ein init-wert.

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

bko schrieb:
> Welchen Wert hat "COUNTER" in deiner Simulation?
> Ich meine da fehlt entweder ein Reset oder ein init-wert.
Du meinst richtig. Denn "UUUU"+1 ergibt "UUUU".

Pit schrieb:
> COUNTER <= STD_LOGIC_VECTOR(unsigned(COUNTER) + 1);
Nimm zum zählen doch besser einen integer, dann wird das viel 
übersichtlicher und du kannst auf "normale Zahlen" vergleichen. Oder 
mach ihn wenigstens unsigned, wenn du den (impliziten) Überlauf nach 
16 Takten brauchst. Dann steht da:

  signal COUNTER    : unsigned (3 downto 0) := "0000";

begin
  process (CLK) 
  begin
    if rising_edge(CLK) then
      COUNTER <= COUNTER + 1;
      
      if COUNTER = "0000" then
        READ_DATA <= '0';

oder gar

  signal COUNTER    : integer range 0 to 15 := 0;

begin
  process (CLK) 
  begin
    if rising_edge(CLK) then
      if counter<15 then counter <= counter + 1; -- falls Überlauf interessant
      else               counter <= 0;
      end if;
      
      if COUNTER = 0 then
        READ_DATA <= '0';

> Hier der Code:
Nimm zum Posten von VHDL-Code besser [vhdl] statt [pre]

Und: schreib Signalnamen klein, evtl. mit einem großen 
Anfangsbuchstaben, DENN SONST BEKOMMST DU BALD DIE KRÄTZE ANS AUGE, UND 
DU MUSST JEDES WORT ZWEIMAL LESEN, WEIL DAS GEHIRN DIESE DAUERNDE 
GROSSSCHREIBEREI NICHT GEWÖHNT IST.

[Pit (Gast)]

Erstmal Danke für die Tipps. Ich probiere das auch gleich mal alles aus. 
Aber irgendwie werd ich das Gefühl nicht los, daß ich ein ganz anderes 
Problem habe.

Folgendes ist Zweck der Übung:
Gegeben sind vier Pins, die als inout definiert sind. Innerhalb der 
StateMAchine soll genau einmal von diesen Pins gelesen werden. Der 
gelesene Wert soll gespeichert werden und dann innerhalb der 
StateMAchine im weiteren Verlauf als Konstante verwendet werden.
Nachdem dieser Wert (die Konstante) gelesen wurde, schalten alle Pins 
auf Ausgang, d.h. ab sofort werden über die Pins nur noch Werte 
ausgegeben.

Mein Problem ist, egal was ich mache, entweder lese ich nur 'UUUU' von 
den Pins oder die gewünschte Konstante wechselt den Wert, sobald ich 
Anfange Werte über die Pins auszugeben.

Mein prinzipielles Vorgehen:
-STEP0 (Konstante einlesen):
INOUT <= "ZZZZ"
KONSTANTE <= INOUT

-STEP1 (Konstante verwenden):
if KONSTANTE = "1010" then
  INOUT <= "1111"
else
  INOUT <= "0000"
end if

Naja, wie gesagt da kommt nur Käse dabei raus.

[Eike (Gast)]

Hey,
nur so am Rande, solltest du nicht VOR dem Auslesen der inouts diese auf 
'Z' setzen? (mind. 1 takt vorher?) Wenn mich nicht alles täuscht 
passiert das bei dir alles beim selben Takt, bzw beim READ_DATA'event 
... Ich bin selber nicht so vertraut damit, ich simuliere es mal eben

[Eike (Gast)]

Hmm, scheint auch so zu gehen. Kann mir jemand in einem Satz erklären 
warum?

Bleiben wir aber beim Thema, also bei mir funktioniert es (es tut 
zumindest etwas, ob es das Richtige ist... naja), sofern ich dem counter 
nen Startwert gebe und in der Testbench mit 'H' und 'L' arbeite, 
anstelle von '0' und '1'. Ich meine H/L bedeuten soviel wie externe 
PullUps / Pulldowns, kollidiert also nicht mit einem entgegengesetztem 
internen Zusatnd (wenn inout nicht als Eingang arbeitet). Glaube so war 
das, oder?

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

Pit schrieb:
> Mein Problem ist, egal was ich mache, entweder lese ich nur 'UUUU' von
> den Pins oder die gewünschte Konstante wechselt den Wert, sobald ich
> Anfange Werte über die Pins auszugeben.
Mein Glückwunsch, du hast die Latency entdeckt.
Das hier
        READ_DATA <= '1';
        MAX_COUNT <= DATA_IN;
bedeutet in der Hardware:
Genau mit dem oder gar wegen dem nächsten Takt wird MAX_COUNT 
eingelesen, und ein paar ps später (Signallaufzeit bis zum 
Ausgangstreiber) wird der Eingang hochohmig geschaltet.

Pit schrieb:
> DATA_OUT nicht zugewiesen?
Läuft dein Zähler?
Wird der irgendwann mal "0000"?

Pit schrieb:
> Mein Problem ist, egal was ich mache, entweder lese ich nur 'UUUU' von
> den Pins oder die gewünschte Konstante wechselt den Wert, sobald ich
> Anfange Werte über die Pins auszugeben.
Screenshot möglich?

[Pit (Gast)]

Die gute Nachricht vorab: Es macht was ich will.

>Welchen Wert hat "COUNTER" in deiner Simulation?
und
>Du meinst richtig. Denn "UUUU"+1 ergibt "UUUU".
Ich dacht, es ist egal, ob ich da was initialisiere oder nicht, da ich 
den Wert erst nach der ersten Zuweisung verwende. Falsch gedacht.

>und in der Testbench mit 'H' und 'L' arbeite
Das hilft, da ich nach dem Einlesen nur noch den Ausgangstreiber habe. 
Änderung in der Testbench von

DATA_INOUT <="1001" after 100 ns;

auf

DATA_INOUT <="1001" after 100 ns, "HHHH" after 200 ns;

Fragen bleiben trotzdem. So wie im folgenden habe ich es jetzt und so 
funktioniert es.

process (CLK,...)
  if enable = '1' then
    if busy = '0' then
      if my_constant = 0 then
        my_constant <= to_integer(unsigned(data_in));
      end if;

      busy <= '1';
      data_read = '0';

    else --busy
      --StateMAchine mit verschiedenen data_out -Zuweisungen unter Verwendung von my_constant
      ...
    end if; --busy
  else --enable
    my_constant = 0;
    data_read = '1';

  end if; --enable
end process;

data_in <= data_inout;

process(data_read, data_out, data_inout)
begin
  if data_read = '1' then
    data_inout <= ( others => 'Z' );
  else
    data_inout <= data_out;
  end if;
end process;

Fragen bleiben trotzdem:
1. Wenn ich die Prüfung auf 'my_constant = 0' vor der Zuweisung von 
my_constant weglasse, dann erhalte ich wieder nur Käse für my_constant. 
Warum? Etwa deshalb, weil my_constant fest verdrahtet mit data_in ist? 
Also nicht so wie beim Programmieren, wo nur bei der Zuweisung der Wert 
geändert wird? Ich frage deshalb, weil der Zuweisungspfad ja in jedem 
Fall nur einmal durchlaufen wird.

2. Wenn ich den zweiten Prozess wie folgt ändere, funktioniert das Ganze 
auch (die Zeile 'data_in <= data_inout;' ist jetzt innerhalb des 
Prozesses).

process(data_read, data_out, data_inout)
begin
  if data_read = '1' then
    data_inout <= ( others => 'Z' );
    data_in <= data_inout;
  else
    data_inout <= data_out;
  end if;
end process;

Aber ich erhalte eine Warnung von wegen Latch und so und man sollte das 
vermeiden. Wie relevant ist diese Warnung und was hat das zu bedeuten?

Und natürlich Danke für Eure Hilfe!