Frage zur Simulation, 2 CLK sync?

[Igor (Gast)]

Hallo,

ich schon wieder sorry, heute läuft aber auch nichts auf anhieb. In der 
Simulations Bench hab ich Zwei clk leitungen, eine 40 MHZ, eine 20 MHZ 
die ich synchrohn in einer state maschine aus 80 MHZ erstelle.

Die führe ich in meine zweite Statemachine für das Auslesen vom Flash.

Folgendes: in der Simulation aber werden mir dei zwei Clk leitungen 
asynchron dargestellt, sind es aber eigentlich nicht oder sollte es zu 
mindest nicht sein. Wie kann ich sie in der Simulation synchron 
darstellen?

Hier die Bench

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
 
ENTITY FLASH_BRAM_BENCH_16 IS
END FLASH_BRAM_BENCH_16;
 
ARCHITECTURE behavior OF FLASH_BRAM_BENCH_16 IS 
 
    -- Component Declaration for the Unit Under Test (UUT)
 
    COMPONENT FLASH_CONTROLLER
    PORT(
         DA_H : OUT  std_logic_vector(7 downto 0);
         DA_L : OUT  std_logic_vector(7 downto 0);
         DATA_EN_H : OUT  std_logic;
         DATA_EN_L : OUT  std_logic;
         BYTE_SR : OUT  std_logic;
         ADD_ZE : OUT  std_logic;
         ADD_K_VOLL : OUT  std_logic;
         ADD_EN : OUT  std_logic;
         ADD_D_VOLL : OUT  std_logic;
         FL_DURCHLAUF_ADD : OUT  std_logic_vector(14 downto 0);
         FL_ADD_DURCHLAUF_ZERO : OUT  std_logic;
         BRAM_WR_RD_ENABLE : OUT  std_logic;
         BRAM_WR_RD_DISABLE : OUT  std_logic;
         BRAM_R_ADD_COUNT_ENABLE : OUT  std_logic;
         BRAM_R_ADD_COUNT_VOLL : OUT  std_logic;
         BRAM_R_ADD : OUT  std_logic_vector(13 downto 0);
         BRAM_R_ADD_ZERO : OUT  std_logic;
         BRAM_CLK_1 : OUT  std_logic;
         BRAM_A_1 : OUT  std_logic_vector(13 downto 0);
         BRAM_IN_DA_1 : OUT  std_logic_vector(11 downto 0);
         BRAM_OUT_DA_1 : OUT  std_logic_vector(11 downto 0);
         BRAM_WR_ENABLE_1 : OUT  std_logic_vector(0 downto 0);
         BRAM_CLK_2 : OUT  std_logic;
         BRAM_A_2 : OUT  std_logic_vector(13 downto 0);
         BRAM_IN_DA_2 : OUT  std_logic_vector(11 downto 0);
         BRAM_OUT_DA_2 : OUT  std_logic_vector(11 downto 0);
         BRAM_WR_ENABLE_2 : OUT  std_logic_vector(0 downto 0);
         DA_FROM_FLASH : OUT  std_logic_vector(11 downto 0);
         BADD : OUT  std_logic_vector(13 downto 0);
         AUSGABE_AN_DA_WANDLER_CLK : IN  std_logic;
         FLASH_ENABLE : IN  std_logic;
         FLASH_RESET : IN  std_logic;
         FLASH_CLK : IN  std_logic;
         FLASH_ADDRESS : OUT  std_logic_vector(23 downto 0);
         FLASH_RP : OUT  std_logic;
         FLASH_CE : OUT  std_logic;
         FLASH_OE : OUT  std_logic;
         STORED_FLASH_DATA : IN  std_logic_vector(7 downto 0);
         AUSGABE_DATEN_BRAM : OUT  std_logic_vector(11 downto 0);
         AUSGABE_DATEN_FLASH : OUT  std_logic_vector(11 downto 0)
        );
    END COMPONENT;
    

   --Inputs
   signal AUSGABE_AN_DA_WANDLER_CLK : std_logic := '0';
   signal FLASH_ENABLE : std_logic := '0';
   signal FLASH_RESET : std_logic := '0';
   signal FLASH_CLK : std_logic := '0';
   signal STORED_FLASH_DATA : std_logic_vector(7 downto 0) := (others => '0');

   --Outputs
   signal DA_H : std_logic_vector(7 downto 0);
   signal DA_L : std_logic_vector(7 downto 0);
   signal DATA_EN_H : std_logic;
   signal DATA_EN_L : std_logic;
   signal BYTE_SR : std_logic;
   signal ADD_ZE : std_logic;
   signal ADD_K_VOLL : std_logic;
   signal ADD_EN : std_logic;
   signal ADD_D_VOLL : std_logic;
   signal FL_DURCHLAUF_ADD : std_logic_vector(14 downto 0);
   signal FL_ADD_DURCHLAUF_ZERO : std_logic;
   signal BRAM_WR_RD_ENABLE : std_logic;
   signal BRAM_WR_RD_DISABLE : std_logic;
   signal BRAM_R_ADD_COUNT_ENABLE : std_logic;
   signal BRAM_R_ADD_COUNT_VOLL : std_logic;
   signal BRAM_R_ADD : std_logic_vector(13 downto 0);
   signal BRAM_R_ADD_ZERO : std_logic;
   signal BRAM_CLK_1 : std_logic;
   signal BRAM_A_1 : std_logic_vector(13 downto 0);
   signal BRAM_IN_DA_1 : std_logic_vector(11 downto 0);
   signal BRAM_OUT_DA_1 : std_logic_vector(11 downto 0);
   signal BRAM_WR_ENABLE_1 : std_logic_vector(0 downto 0);
   signal BRAM_CLK_2 : std_logic;
   signal BRAM_A_2 : std_logic_vector(13 downto 0);
   signal BRAM_IN_DA_2 : std_logic_vector(11 downto 0);
   signal BRAM_OUT_DA_2 : std_logic_vector(11 downto 0);
   signal BRAM_WR_ENABLE_2 : std_logic_vector(0 downto 0);
   signal DA_FROM_FLASH : std_logic_vector(11 downto 0);
   signal BADD : std_logic_vector(13 downto 0);
   signal FLASH_ADDRESS : std_logic_vector(23 downto 0);
   signal FLASH_RP : std_logic;
   signal FLASH_CE : std_logic;
   signal FLASH_OE : std_logic;
   signal AUSGABE_DATEN_BRAM : std_logic_vector(11 downto 0);
   signal AUSGABE_DATEN_FLASH : std_logic_vector(11 downto 0);

   -- Clock period definitions
   constant AUSGABE_AN_DA_WANDLER_CLK_period : time := 50000 ps; -- DIESE HIER!!
   constant FLASH_CLK_period : time := 25000 ps; -- UND DIESE HIER!!!
 
BEGIN
 
  -- Instantiate the Unit Under Test (UUT)
   uut: FLASH_CONTROLLER PORT MAP (
          DA_H => DA_H,
          DA_L => DA_L,
          DATA_EN_H => DATA_EN_H,
          DATA_EN_L => DATA_EN_L,
          BYTE_SR => BYTE_SR,
          ADD_ZE => ADD_ZE,
          ADD_K_VOLL => ADD_K_VOLL,
          ADD_EN => ADD_EN,
          ADD_D_VOLL => ADD_D_VOLL,
          FL_DURCHLAUF_ADD => FL_DURCHLAUF_ADD,
          FL_ADD_DURCHLAUF_ZERO => FL_ADD_DURCHLAUF_ZERO,
          BRAM_WR_RD_ENABLE => BRAM_WR_RD_ENABLE,
          BRAM_WR_RD_DISABLE => BRAM_WR_RD_DISABLE,
          BRAM_R_ADD_COUNT_ENABLE => BRAM_R_ADD_COUNT_ENABLE,
          BRAM_R_ADD_COUNT_VOLL => BRAM_R_ADD_COUNT_VOLL,
          BRAM_R_ADD => BRAM_R_ADD,
          BRAM_R_ADD_ZERO => BRAM_R_ADD_ZERO,
          BRAM_CLK_1 => BRAM_CLK_1,
          BRAM_A_1 => BRAM_A_1,
          BRAM_IN_DA_1 => BRAM_IN_DA_1,
          BRAM_OUT_DA_1 => BRAM_OUT_DA_1,
          BRAM_WR_ENABLE_1 => BRAM_WR_ENABLE_1,
          BRAM_CLK_2 => BRAM_CLK_2,
          BRAM_A_2 => BRAM_A_2,
          BRAM_IN_DA_2 => BRAM_IN_DA_2,
          BRAM_OUT_DA_2 => BRAM_OUT_DA_2,
          BRAM_WR_ENABLE_2 => BRAM_WR_ENABLE_2,
          DA_FROM_FLASH => DA_FROM_FLASH,
          BADD => BADD,
          AUSGABE_AN_DA_WANDLER_CLK => AUSGABE_AN_DA_WANDLER_CLK,
          FLASH_ENABLE => FLASH_ENABLE,
          FLASH_RESET => FLASH_RESET,
          FLASH_CLK => FLASH_CLK,
          FLASH_ADDRESS => FLASH_ADDRESS,
          FLASH_RP => FLASH_RP,
          FLASH_CE => FLASH_CE,
          FLASH_OE => FLASH_OE,
          STORED_FLASH_DATA => STORED_FLASH_DATA,
          AUSGABE_DATEN_BRAM => AUSGABE_DATEN_BRAM,
          AUSGABE_DATEN_FLASH => AUSGABE_DATEN_FLASH
        );

   -- Clock process definitions
   AUSGABE_AN_DA_WANDLER_CLK_process :process
   begin
    AUSGABE_AN_DA_WANDLER_CLK <= '0';
    wait for AUSGABE_AN_DA_WANDLER_CLK_period/2;
    AUSGABE_AN_DA_WANDLER_CLK <= '1';
    wait for AUSGABE_AN_DA_WANDLER_CLK_period/2;
   end process;
 
   FLASH_CLK_process :process
   begin
    FLASH_CLK <= '0';
    wait for FLASH_CLK_period/2;
    FLASH_CLK <= '1';
    wait for FLASH_CLK_period/2;
   end process;
 

   -- Stimulus process
   stim_proc: process
   begin    
      FLASH_RESET  <= '1';
     FLASH_ENABLE <= '0';
    wait for 500000 ns;
      FLASH_RESET  <= '0';
     FLASH_ENABLE <= '0';
    wait for  500000 ns;
    -----------------
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '1';
    wait for 1000000 ns;
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '0';
    wait for  800000 ns;
    ---------------------
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '1';
    wait for  1000000 ns;
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '0';
    wait for  500000 ns;
    ---------------------
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '1';
    wait for 1000000 ns;
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '0';
    wait for  1000000 ns;
    ---------------------
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '1';
    wait for 1000000 ns;
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '0';
    wait for  500000 ns;
    ---------------------
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '1';
    wait for 1000000 ns;
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '0';
    wait for  500000 ns;
    ---------------------
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '1';
    wait for 1000000 ns;
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '0';
    wait for  500000 ns;
    ---------------------
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '1';
    wait for 1000000 ns;
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '0';
    wait for  500000 ns;
    --------------------
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '1';
    wait for 1000000 ns;
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '0';
    wait for  800000 ns;
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '1';
    wait for  500000 ns;
    --------------------
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '0';
    wait for  800000 ns;
    FLASH_RESET  <= '0';
     FLASH_ENABLE <= '1';
    wait;
   end process;

END;

Gruß

Igor

[Falk B. (falk)]

@  Igor (Gast)

Schon mal was von Netiquette gehört? Oder einfach mal den kurzen 
Text hier im Fenster gelesen?

Lange Quelltexte als ANHANG posten!

>ich schon wieder sorry, heute läuft aber auch nichts auf anhieb.

Das ist meistens so.

>Folgendes: in der Simulation aber werden mir dei zwei Clk leitungen
>asynchron dargestellt, sind es aber eigentlich nicht oder sollte es zu
>mindest nicht sein. Wie kann ich sie in der Simulation synchron
>darstellen?

Was verstehst du unter SYNCHRON? Dass keinerlei Verzögerung zwischen den 
80, 40 und 20 MHz liegt? Das geht nur in der Verhaltenssimulation auf 
VHDL-Ebene. Eine Simulation auf Gatter oder gar P&R Ebene hat immer 
relale Verzögerungen drin. Und die muss man beim Entwurf 
berücksichtigen.

MFG
Falk

[Klaus F. (kfalser)]

Vielleicht meinst Du ja das :

CLK_process :process
   begin
    FLASH_CLK <= '0';
    AUSGABE_AN_DA_WANDLER_CLK <= '0';
    wait for FLASH_CLK_period/2;
    FLASH_CLK <= '1';
    wait for FLASH_CLK_period/2;

    FLASH_CLK <= '0';
    AUSGABE_AN_DA_WANDLER_CLK <= '1';
    wait for FLASH_CLK_period/2;
    FLASH_CLK <= '1';
    wait for FLASH_CLK_period/2;
   end process;

[Igor (Gast)]

Genau das meinte ich, nur das die steigeneden Flanken synchron kommen.



Danke!


Gruß


Igor

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

So ginge es auch:

   FLASH_CLK <= not FLASH_CLK after FLASH_CLK_period/2;
   AUSGABE_AN_DA_WANDLER_CLK <= not AUSGABE_AN_DA_WANDLER_CLK when rising_edge (FLASH_CLK);

Aber mir geben die vielen Takte zu denken...  :-/

[Igor (Gast)]

Hi,


ich benutze nur einen Takt, den zweiten habe ich einfach mit eingebunden 
um ihn in der Siumulation zu sehen, da ich FLASH_CLK fürs Flash auslesen 
benutze diese daten an einem DA wandler übergebe der von der anderen CLK 
betrieben wird und deswegen wollte ich mal sehen wie das mit der 
simulation passt wie die Takte mit den Daten stehen und zu einander.



Gruß


Danke!