VHDL - Kombinatorische Logik und Signal aus dem Prozess aktuallisieren

[Artata (Gast)]

Ich stehe gerade auf dem Schlauch. Und zwar habe ich hier eine 
vereinfachte Version eines Adressendecoder der mit bei Schreibzugriffen 
die Adresse und den Datensatz in zwei Temp-Registern ablegen soll:
AD_TEMP_ADDR_OUT
AD_TEMP_DATA_OUT

Werden Daten über die Serielle Schnittstelle empfangen, werden diese an 
den Adressendecoder weiter geleitet. Ähnlich wie bei SPI kommt erst die 
Adresse, die dann als paralleles Signal an den Adressendecoder 
ausgegeben wird und dann die Daten. Der Adressendecoder soll diese, bei 
Schreibzugriffen, in Temp-Registern zwischen lagern und einen Interrupt 
generieren. Die Sache ist, so wie es jetzt ist, werden die Interrupts 
bereits bei Änderung der Adresse generiert. Somit erhalte ich beim 
Auslesen der Temp Register einen Datensatz bestehend aus der richtigen 
Adresse aber einem vorher geschriebenen Wert. Da ich zum Umrechnen der 
Adresse auf die Änderung dieser reagieren muss, fällt mir gerade nichts 
ein, wie ich Interrupt generieren soll, erst wenn die Daten ebenfalls 
geschrieben wurden. Mir fällt da so eine Art onChange Funktion :)

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
use IEEE.numeric_std.all;

entity address_decoder is
port (
  -- RAM CLOCK
  AD_CLK_SERIALBUS_IN          : in  STD_LOGIC;  -- clock from SERIALBUS

  -- Address from SERIALBUS/uC to RAm
  AD_REGADDR_SERIALBUS_IN        : in  STD_LOGIC_VECTOR(15 downto 0);  -- reg address from SERIALBUS Interface
  AD_REGADDR_RAM8_OUT        : out  STD_LOGIC_VECTOR(15 downto 0);   -- reg address to RAM8

  
  -- Data from SERIALBUS/uC to RAM
  AD_REGDATA_SERIALBUS_IN        : in    STD_LOGIC_VECTOR(15 downto 0);  -- data from SERIALBUS
  AD_REGDATA_RAM8_OUT        : out  STD_LOGIC_VECTOR(7 downto 0);  -- data to ram8

  -- Data from RAM to SERIALBUS/uC
  AD_REGDATA_SERIALBUS_OUT        : out  STD_LOGIC_VECTOR(15 downto 0);  -- data to SERIALBUS   
  AD_REGDATA_RAM8_IN        : in   STD_LOGIC_VECTOR(7 downto 0);  -- data from ram8 

  -- Read/Write
  AD_RW_SERIALBUS_IN          : in  STD_LOGIC;  -- read/write Signal from SERIALBUS
  AD_RW_RAM8_OUT          : out  STD_LOGIC;  -- read/write to RAM8
  
  -- RAM CLK
  AD_CLK_RAM8_OUT          : out   STD_LOGIC;  -- clock to 8Bit  RAM
  AD_CLK_RAM16_OUT        : out  STD_LOGIC;  -- clock to 16Bit RAM

  -- RAM ENABLE
  AD_ENABLE_RAM8          : out  STD_LOGIC;  -- anable signal (HIGH: enabled)
  AD_ENABLE_RAM16          : out  STD_LOGIC;

  -- internal connections to uC interface to signalize SERIALBUS writes from host
  AD_TEMP_INTERRUPT_OUT      : out  STD_LOGIC;            -- will be set if new data is available
  AD_TEMP_ADDR_OUT        : out  STD_LOGIC_VECTOR(15 downto 0);  -- stores the register address
  AD_TEMP_DATA_OUT        : out  STD_LOGIC_VECTOR(15 downto 0);  -- stores the data 
  AD_TEMP_CLEAR_IN        : in  STD_LOGIC;            -- signal to clear Tempdata

  -- Asynchronous reset input
  RESET              : in  STD_LOGIC
);
end address_decoder;

architecture address_decoder_arch of address_decoder is
begin

process (RESET, AD_REGADDR_SERIALBUS_IN, AD_REGDATA_SERIALBUS_IN, AD_RW_SERIALBUS_IN, AD_REGDATA_RAM8_IN, AD_TEMP_CLEAR_IN)

constant READ_ONLY    : STD_LOGIC := '1';
constant WRITE       : STD_LOGIC := '0';
constant ENABLED    : STD_LOGIC := '1';
constant DISABLED     : STD_LOGIC := '0';

BEGIN
  if rising_edge(RESET) then

    AD_REGADDR_RAM8_OUT   <= (others => '1');
    AD_REGDATA_RAM8_OUT   <= (others => '0');

    AD_REGDATA_SERIALBUS_OUT    <= (others => '0');

    -- clear temporary signals on reset
    AD_TEMP_ADDR_OUT     <= (others => '0');
    AD_TEMP_DATA_OUT     <= (others => '0');
    AD_TEMP_INTERRUPT_OUT  <= DISABLED;

    --// For Loop To Initialize all Registers to 0 on power on
  end if;

  if AD_TEMP_CLEAR_IN = ENABLED then
    AD_TEMP_INTERRUPT_OUT <= DISABLED; -- reset interrupt out signal
  end if;
  

  -- Decode Address comming from SERIALBUS Interface to RAM
  ----------------------------------------------------------------------------
  -- 8BIT RAM
  -- Used 682 Bytes within 2 Block RAMs: 342 Bytes are left
  ----------------------------------------------------------------------------
  if (AD_REGADDR_SERIALBUS_IN >= x"1000" and AD_REGADDR_SERIALBUS_IN <= x"1FFF") then
      
      AD_ENABLE_RAM8   <= ENABLED;
      AD_ENABLE_RAM16 <= DISABLED;

      --sig_flag_ram16 <= '0';
      if 
      -- ##### CFP NVR 
      (AD_REGADDR_SERIALBUS_IN >= x"1000" and AD_REGADDR_SERIALBUS_IN <= x"1198") then
        AD_REGADDR_RAM8_OUT <= (AD_REGADDR_SERIALBUS_IN - x"1000");
      -- disable writing to this address space (Read: HIGH; Write: LOW). Signal shall stay HIGH!
        AD_RW_RAM8_OUT      <= READ_ONLY;       -- Writes by SERIALBUS are restricted
      -- forward data from SERIALBUS to ram 
        AD_REGDATA_RAM8_OUT <= AD_REGDATA_SERIALBUS_IN(7 downto 0);
      -- forward data from ram to SERIALBUS
        AD_REGDATA_SERIALBUS_OUT <= (x"00" & AD_REGDATA_RAM8_IN);
      elsif
      -- ##### Vendor NVR 1 
      (AD_REGADDR_SERIALBUS_IN >= x"1420" and AD_REGADDR_SERIALBUS_IN <= x"1430") then
        AD_REGADDR_RAM8_OUT <= (AD_REGADDR_SERIALBUS_IN - x"1420" + x"199"); -- +"Offset
        AD_RW_RAM8_OUT     <= READ_ONLY;        -- Writes by SERIALBUS are restricted
        AD_REGDATA_RAM8_OUT <= AD_REGDATA_SERIALBUS_IN(7 downto 0); 
        AD_REGDATA_SERIALBUS_OUT <= (x"00" & AD_REGDATA_RAM8_IN); 
      elsif
      -- ##### User NVR 1 and User NVR 2 
      (AD_REGADDR_SERIALBUS_IN >= x"1800" and AD_REGADDR_SERIALBUS_IN <= x"18FF") then
        AD_REGADDR_RAM8_OUT <= (AD_REGADDR_SERIALBUS_IN - x"1800" +  x"1AA"); -- +Offset: 
        AD_RW_RAM8_OUT     <= AD_RW_SERIALBUS_IN;  -- read/wire is controlled by 
        AD_REGDATA_RAM8_OUT <= AD_REGDATA_SERIALBUS_IN(7 downto 0); 
        AD_REGDATA_SERIALBUS_OUT <= (x"00" & AD_REGDATA_RAM8_IN); --

        if AD_RW_SERIALBUS_IN = WRITE and AD_TEMP_CLEAR_IN = ENABLED then   -- save new data if uC cleared last request
          AD_TEMP_ADDR_OUT    <=   AD_REGADDR_SERIALBUS_IN;       -- contains current register address
          AD_TEMP_DATA_OUT    <=  AD_REGDATA_SERIALBUS_IN;      -- contains current register data
          AD_TEMP_INTERRUPT_OUT   <=  ENABLED;             -- signalize uC "NEW DATA ARRIVED"
        end if;
        
      else
        AD_REGADDR_RAM8_OUT  <= (others => '0');
        AD_RW_RAM8_OUT     <= READ_ONLY;
        AD_REGDATA_RAM8_OUT <= (others => '0');
        AD_REGDATA_SERIALBUS_OUT <= (others => '0'); -- send zeros instead to read from RAM, if an unspecefied address was selected
      end if;
  end if;  
end process;

-- Forward Clock Signal to both RAMs
AD_CLK_RAM8_OUT   <= AD_CLK_SERIALBUS_IN;  -- clock to RAM8

end address_decoder_arch;

Wie kann ich diesen Teil so umschreiben, dass Interrupt erst bei 
Änderung von Daten kommt, damit Adresse und Daten korrelieren?

if AD_RW_SERIALBUS_IN = WRITE and AD_TEMP_CLEAR_IN = ENABLED then   -- save new data if uC cleared last request
          AD_TEMP_ADDR_OUT    <=   AD_REGADDR_SERIALBUS_IN;       -- contains current register address
          AD_TEMP_DATA_OUT    <=  AD_REGDATA_SERIALBUS_IN;      -- contains current register data
          AD_TEMP_INTERRUPT_OUT   <=  ENABLED;             -- signalize uC "NEW DATA ARRIVED"
        end if;

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

Artata schrieb:
> if rising_edge(RESET) then
Hoppala. Das kann lustig werden. Ich glaube nicht, dass das wie 
gewünscht funktioniert. Und falls doch, dann glaube ich, dass ich den 
Trick dabei nicht verstanden habe...

  if rising_edge(RESET) then
    :
  end if;

  if AD_TEMP_CLEAR_IN = ENABLED then
    :
  end if;

  if (AD_REGADDR_SERIALBUS_IN >= x"1000" and AD_REGADDR_SERIALBUS_IN <= x"1FFF") then
    :
  end if;

In welchem Buch/welcher Vorlesung hast du sowas gelernt?

Artata schrieb:
> Wie kann ich diesen Teil so umschreiben, dass Interrupt erst bei
> Änderung von Daten kommt, damit Adresse und Daten korrelieren?
Um Änderungen erkennen zu können brauchst du ein "Vorher" und ein 
"Jetzt". Also irgendwas, das mit "Zeit" und "Merken" zu tun hat. 
Zeitliche Abläufe und speichernde Werte werden in VHDL über getaktete 
Register beschrieben.

[Artata (Gast)]

>Ich glaube nicht, dass das wie gewünscht funktioniert.
Meinst du, weil ich mix Betrieb habe und rising_edge benutze?

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

Artata schrieb:
> Meinst du, weil ich mix Betrieb habe und rising_edge benutze?
Ja, auch.
Und im Besonderen, weil ein Reset normalerweise nicht an die 
Takteingänge von Flipflops gehört...

[Weltbester FPGA-Pongo (Gast)]

Lothar Miller schrieb:
> Und im Besonderen, weil ein Reset normalerweise nicht an die
> Takteingänge von Flipflops gehört...
Niemals gehört ein Reset an den Tekteingang. Der Reset gehört bei einem 
modernden FPGA in die Kiste und Deckel zu. FPGAs brauchen nur in 
Ausnahmefällen einen Reset.