www.mikrocontroller.net

Forum: FPGA, VHDL & Co. Daten von FLASH in 2 BRAM schreiben


Autor: Igor (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich habe wie schon in einem anderem Thread beschrieben einen Flash 
controller geschrieben der auch soweit funktioniert. Ich möchte jetzt 
die Daten von Flash in 2 BRAM schreiben, und zwar soll er in den 1.BRAM 
schreiben während er den 2. BRAM ausließt und dann wieder umgekehrt 
schreibt er in den 2 BRAM und ließt den 1 BRAM aus. (Beim ersten 
durchlauf ließt er logischer weiße nichts aus da noch keine daten 
geschrieben wurden)

Ich habe ein ZUSTANDSAUTOMATEN den ich für das Auslesen von FLASH und 
gleichzeitig für das schreiben in den ersten BRAM verwende und ein 
zweiten ZUSTANDSAUTOMATEN der den BRAM ausließt.

Zudem eine Schalter der die Enable Signal für die BRAMs  umschaltet.

So leider habe ich irgendwo ein Fehler und bitte euch daher vielleicht 
mal mir ein Tipp zu geben.


Laut Simulation sollten die Schreibe und lesen Zugriffe passen.

P.s Wie kann ich in der Simulation die Daten vom FLASH simulieren?


----------------------------------------------------------------------------------
-- Company: 
-- Engineer: 
-- 
-- Create Date:    17:15:57 12/21/2009 
-- Design Name: 
-- Module Name:    FLASH_CONTROLLER - Behavioral 
-- Project Name: 
-- Target Devices: 
-- Tool versions: 
-- Description: 
--
-- Dependencies: 
--
-- Revision: 
-- Revision 0.01 - File Created
-- Additional Comments: 
--
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity FLASH_CONTROLLER is
    Port (           
          ----------------------- NUR FÜR SIMULATION----------------------------------
          ----------------------- KANN ENTFERNT WERDEN--------------------------------
          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_V          : out std_logic;
          ADD_EN         : out std_logic;
          
          BRAM_WR_RD_ENABLE                                : 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):="11111111111111";
          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);   
          
          
          
          
          
          ----------------------------------------------------------------------------
          
          -------------------------STUER-UND DATENSIGNALE----------------------------
  
          BRAM_ADD_EN      : out std_logic;
          BRAM_WEAEN      : out std_logic_vector(0 downto 0);
          BADD          : out std_logic_VECTOR(13 downto 0):="00000000000000";
          
          --READ_BRAM_CLK                              : in std_logic;
          FLASH_ENABLE                          : in   std_logic;                   -- ENABLE SIGNAL FÜR ZUSTANDSAUTOMATEN,WANN DARF DER AUTOMAT LOSLAUFEN WANN SOLL ER SCHLAFEN
          FLASH_RESET                            : in  STD_LOGIC;                   -- FLASH RESET VON MASTER RESET
          FLASH_CLK                             : in  STD_LOGIC;                  -- 40 MHZ TAKT 25 ns
          FLASH_ADD                            : out std_logic_vector (23 downto 0);    -- FLASH ADDRESSEN
          FLASH_RP                              : out  std_logic;                    -- CHIP RESET,DIENT ZUR BESCHÜTZUNG DER DATEN WENN GESCHRIEBEN WIRD(DA ABER NUR GELSEN WIRD KANN AUF 1 GESETZT WERDEN)  
          FLASH_CE                              : out std_logic;                   -- CHIP ENABLE
          FLASH_OE                              : out std_logic;                    -- OUT ENABLE
          FLASH_DATA                            : in STD_LOGIC_vector (7 downto 0);      -- DATEN DIE IM FLASH EINGEBRANNT WURDEN (MIT IMPACT)
          AUSGABE_DATEN_BRAM                      : out std_logic_vector (11 downto 0);   
          DATAOUT                              : out std_logic_vector (11 downto 0));   -- EINGEBRANNTE DATEN WERDEN HIER AUSGELESEN(DA 12 BIT BREITE DATEN;WIRD 2 BYTE ZUSSAMENGGESCHRIEBEN)
          
          ----------------------------------------------------------------------------
end FLASH_CONTROLLER;

architecture Behavioral of FLASH_CONTROLLER is

COMPONENT SINGLE_RAM_1
  port (
        clka: IN std_logic;
        rsta: IN std_logic;
        wea: IN std_logic_VECTOR(0 downto 0);
        addra: IN std_logic_VECTOR(13 downto 0);
        dina: IN std_logic_VECTOR(11 downto 0);
        douta: OUT std_logic_VECTOR(11 downto 0));
End component;

COMPONENT SINGLE_RAM_2
  port (
        clka: IN std_logic;
        rsta: IN std_logic;
        wea: IN std_logic_VECTOR(0 downto 0);
        addra: IN std_logic_VECTOR(13 downto 0);
        dina: IN std_logic_VECTOR(11 downto 0);
        douta: OUT std_logic_VECTOR(11 downto 0));
End component;
---------------------------------------------
-- HIFSSIGNAL FÜR FLASH AUSLESEN
Signal A                                  : std_logic;
Signal CE,OE,RP                             : std_logic;
Signal ADD                                : std_logic_vector(23 downto 0):="000000000000000000000000";
Signal DATA_ENABLE_HI,DATA_ENABLE_LOW              : std_logic;
Signal DA_HI                              : std_logic_vector(7 downto 0);
Signal DA_LOW                              : std_logic_vector (7 downto 0);
Signal BYTE_SCHREIBEN                        : std_logic;
Signal ADD_COUNT_ENABLE,ADD_VOLL,ADD_ZERO            : std_logic;
-----------------------------------------------------------------------------------------
-- HILFSSIGNAL FÜR SCHREIBEN AUF BRAM
Signal BRAM_WRITE_ADD_COUNT_ENABLE                        : std_logic;
Signal BRAM_WRTIE_ADD                                : std_logic_VECTOR(13 downto 0):="11111111111111";  
Signal BRAM_WRITE_ENABLE                              : std_logic;
Signal BRAM_WEA                                    : std_logic_vector(0 downto 0);
Signal BRAM_WRITE_OR_READ_ENABLE                         : std_logic:='0';
Signal WRITE_OR_READ_COUNTER                            : integer range 0 to 2:=0;


-- HILFSSIGNAL FÜR LESEN DER BRAM


Signal BRAM_READ_ADD_COUNT_ENABLE                         : std_logic;
Signal BRAM_READ_ADD_COUNT_VOLL                          : std_logic:='0';
Signal BRAM_READ_ADD                                  : std_logic_VECTOR(13 downto 0):="00000000000000";
Signal BRAM_READ_ADD_ZERO                              : std_logic;  

Signal BRAM_CLOCK_1                                  : std_logic;  
Signal BRAM_ADD_1                                    : std_logic_VECTOR(13 downto 0);
Signal BRAM_IN_DATA_1                                : std_logic_vector  (11 downto 0);
Signal BRAM_OUT_DATA_1                                : std_logic_vector  (11 downto 0);
Signal BRAM_WRITE_ENABLE_1                              : std_logic_vector (0 downto 0);

Signal BRAM_CLOCK_2                                  : std_logic;  
Signal BRAM_ADD_2                                    : std_logic_VECTOR(13 downto 0);
Signal BRAM_IN_DATA_2                                : std_logic_vector  (11 downto 0);  
Signal BRAM_OUT_DATA_2                                : std_logic_vector  (11 downto 0);
Signal BRAM_WRITE_ENABLE_2                              : std_logic_vector (0 downto 0);

Signal DATA_FROM_FLASH                                : std_logic_vector (11 downto 0); 

-----------------------------------------------------------------------------------------------

-------------------------------- ZUSTANDSAUTOMAT_FLASH_BRAM_SCHRREIBEN ----------------------------------------------
type STATE_TYPE_WRITE is (Grundzustand,Add_Zahlen,Warten_01,Warten_02,Warten_03,Warten_0,Warten_1,Warten_2,Lesen_0,Anlegen_1,Lesen_1,Anlegen_2,Lesen_2,Anlegen_3,Lesen_3,Anlegen_4,Lesen_4,Anlegen_5,Lesen_5,Anlegen_6,Lesen_6,Anlegen_7,Lesen_7,Schlafen); 
Signal naechster_zustand: STATE_TYPE_WRITE;
Signal aktueller_zustand: STATE_TYPE_WRITE:=Schlafen;

-----------------------------------------------------------------------------------------------

-------------------------------- ZUSTANDSAUTOMAT_BRAM_LESEN ----------------------------------------------
type STATE_TYPE_READ is (Sleep,BRAM_1_AUSLESEN,WARTEN_LESEN_1,ADD_ANLEGEN_LESEN,WARTEN_AUF_SCHREIBEN); 
Signal naechster_zustand_lesen: STATE_TYPE_READ;
Signal aktueller_zustand_lesen: STATE_TYPE_READ:=Sleep;
  
-----------------------------------------------------------------------------------------------

begin


  DATAOUT <=  DATA_FROM_FLASH; 


  FLASH_LESEN_BRAM_SCHRIEBEN_ZUSTAND_WEITERGEBEN:process (FLASH_CLK,FLASH_RESET)
    begin
      if FLASH_RESET = '1' then
        aktueller_zustand<=Schlafen;--Grundzustand;
      elsif rising_edge(Flash_CLK) then
        aktueller_zustand <= naechster_zustand;
      end if;
  end process FLASH_LESEN_BRAM_SCHRIEBEN_ZUSTAND_WEITERGEBEN;
  ---------------------------------------------
  
  Zustandsautomat_Write:process (aktueller_zustand,ADD_VOLL,FLASH_ENABLE) 
  begin
  case aktueller_zustand is
    -----------------------------------------------------------
    when Schlafen       =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';  
                                    
                    ADD_COUNT_ENABLE   <= '0';       --  DIESER ZUSTAND LÄßT DEN SPEICHER NICHT AUSLESEN
                    ADD_ZERO       <= '0';       -- BIS DAS ENABLE SINGAL VOM EINGANG KOMMT, DANN
                    BYTE_SCHREIBEN    <= '0';      -- STARTET DER AUTOMAT LOS DEN FLASH SPEICHER AUSZU-
                    DATA_ENABLE_HI    <= '0';      -- LESEN
                    DATA_ENABLE_LOW  <= '0';      --
                    CE            <=  '0';      --
                    OE            <=  '0';      --
                    RP            <=  '0';      --        
                    if FLASH_ENABLE = '0' then      --
                    naechster_zustand <= Schlafen;  --  
                    else                    --
                    naechster_zustand <=Grundzustand;--
                    end if;                  --
    -----------------------------------------------------------
    when Grundzustand =>          
                    ADD_COUNT_ENABLE   <= '0';       --  HIER STARTET DER ZUSTANDSAUTOMAT WENN ER ZUM ERSTEN MAL 
                    ADD_ZERO       <= '1';        -- GESTARTET WIRD ODER WENN DIE FLASH ADDRESSE VOLL GELAUFEN
                    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
                    if ADD_VOLL='1' then          -- IST. HIER WIRD DIE FALSH ADDRESSE WIEDER AUF NULL ZURÜCK-
                      BYTE_SCHREIBEN    <= '1';      -- GESETZT ODER FÄNGT MIT DER NULL AN.
                    else                    -- AUßERDEM WIRD HIER DURCH BYTE SCHREIBEN DATEN AUSGE-
                      BYTE_SCHREIBEN    <= '0';      -- GEBEN WENN 
                    end if;                  --
                    DATA_ENABLE_HI    <= '0';      -- 
                    DATA_ENABLE_LOW  <= '0';      --
                    CE            <=  '1';      --
                    OE            <=  '1';      --
                    RP            <=  '1';      --  
                    naechster_zustand <= Warten_0;  --
    -----------------------------------------------------------                                      --  
    
    -----------------------------------------------------------
    
    when Warten_0   =>     BRAM_WRITE_ADD_COUNT_ENABLE <='0';       
                    BRAM_WRITE_ENABLE        <= '0';
                    if ADD_VOLL='1' then
                      BRAM_WRITE_ADD_COUNT_ENABLE <='1';
                    else
                      BRAM_WRITE_ADD_COUNT_ENABLE <='0';
                    end if;
                    ADD_COUNT_ENABLE   <= '0';       
                    ADD_ZERO       <= '0';         
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Warten_1;
        
    when Warten_1    =>    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '1'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Warten_2;
    
    when Warten_2    =>    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Lesen_0;
    
    -------------------------------------------------------------
    -------------------------------------------------------------
    when Add_Zahlen =>    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
                    ADD_COUNT_ENABLE   <= '1';       -- DIESER ZUSTAND ZÄHLT DIE ADDRESSE WEITER DA DIE FLASH    
                    ADD_ZERO       <= '0';       -- ADDRESSE NOCH NICHT VOLLGELAUFEN IST. BENÖTIGT WIRD 
                    BYTE_SCHREIBEN    <= '1';      -- DIESER ZUSTAND UM DEN CACHE SPEICHER VOM FALSH NEU ZU
                    DATA_ENABLE_HI    <= '0';      -- LADEN
                    DATA_ENABLE_LOW  <= '0';      --
                    CE            <=  '1';      --
                    OE            <=  '1';      --
                    RP            <=  '1';      --
                    naechster_zustand <= Warten_01;  --  
    
    
    
    when Warten_01    =>    BRAM_WRITE_ADD_COUNT_ENABLE <='1';                     
                    BRAM_WRITE_ENABLE      <= '0';
                    --BRAM_TAKT_20MHZ  <= '0';
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Warten_02;
    
    when Warten_02    =>    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '1';
                    --BRAM_TAKT_20MHZ  <= '0';
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Warten_03;  
    
    when Warten_03    =>    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    --BRAM_TAKT_20MHZ  <= '0';
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    naechster_zustand <= Lesen_0;
    ------------------------------------------------------------
    
    
    
    
    
    when Lesen_0      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
    
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '1';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    if ADD_VOLL = '1' then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Anlegen_1;
                    end if;
                    
      
    when Anlegen_1       =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
                    ADD_COUNT_ENABLE   <= '1'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    naechster_zustand <= Lesen_1;
                    
    
    when Lesen_1      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
    
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '1';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    if ADD_VOLL = '1' then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Anlegen_2;
                    end if;
                      
    when Anlegen_2      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    --BRAM_TAKT_20MHZ  <= '1';
                    ADD_COUNT_ENABLE   <= '1'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '1';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    naechster_zustand <= Lesen_2;
                    
    when Lesen_2      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='1';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '1';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    if ADD_VOLL = '1' then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Anlegen_3;
                    end if;
                    
      
    when Anlegen_3       =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '1';
                    
                    ADD_COUNT_ENABLE       <= '1'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    naechster_zustand <= Lesen_3;
                    
    
    when Lesen_3      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
                    ADD_COUNT_ENABLE       <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '1';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    if ADD_VOLL = '1' then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Anlegen_4;
                    end if;
                      
    when Anlegen_4      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
    
                    ADD_COUNT_ENABLE   <= '1'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '1';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    naechster_zustand <= Lesen_4;
                    
    when Lesen_4      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='1';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
    
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '1';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    if ADD_VOLL = '1' then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Anlegen_5;
                    end if;
                    
      
    when Anlegen_5       =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '1';
                    
                    ADD_COUNT_ENABLE   <= '1'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    naechster_zustand <= Lesen_5;
                    
    
    when Lesen_5      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
                    ADD_COUNT_ENABLE       <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '1';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    if ADD_VOLL = '1' then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Anlegen_6;
                    end if;
                      
    when Anlegen_6      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
                    ADD_COUNT_ENABLE   <= '1'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '1';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    naechster_zustand <= Lesen_6;
                    
    when Lesen_6      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='1';                     
                    BRAM_WRITE_ENABLE        <= '0';
                    
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '1';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    if ADD_VOLL = '1' then
                    naechster_zustand <= Grundzustand;  
                    else
                    naechster_zustand <= Anlegen_7;
                    end if;
                    
      
    when Anlegen_7       =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE        <= '1';
                    
                    ADD_COUNT_ENABLE   <= '1'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '0';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';          
                    naechster_zustand <= Lesen_7;
                    
    
    when Lesen_7      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     
                    BRAM_WRITE_ENABLE  <= '0';
                    
                    ADD_COUNT_ENABLE   <= '0'; 
                    ADD_ZERO       <= '0'; 
                    BYTE_SCHREIBEN    <= '0';
                    DATA_ENABLE_HI    <= '0';
                    DATA_ENABLE_LOW  <= '1';
                    CE            <=  '0';
                    OE            <=  '0';
                    RP            <=  '1';
                    if FLASH_ENABLE = '1' then
                      if ADD_VOLL = '1' then
                      naechster_zustand <= Grundzustand;  
                      else
                      naechster_zustand <= Add_Zahlen;
                      end if;
                    else
                      naechster_zustand <= schlafen;
                    end if;
        
    end case;
  end process Zustandsautomat_Write;
  -------------------------------------------------  
  FLASH_ADDRESSEN_AUSLESEN: process (FLASH_CLK)
  begin
        
    if falling_edge(FLASH_CLK) then
      if ADD_COUNT_ENABLE = '1' then
        ADD<=ADD+1;
      elsif ADD_ZERO = '1' then
        ADD <= "000000000000000000000000";
      else
        ADD <= ADD;
      end if;
    end if;
  end process FLASH_ADDRESSEN_AUSLESEN;
  -------------------------------------------------  
  TEST: process (FLASH_CLK) 
  begin
    if rising_edge(FLASH_CLK) then
      if ADD = "000000000100000110011101"  then
        ADD_VOLL<='1';
      else 
        ADD_VOLL<='0';
      end if;
    end if;
  end process TEST;
  -------------------------------------------------
  FLASH_DATEN_EINLESEN_HI_BITS: process (FLASH_CLK)
  begin
    if falling_edge(FLASH_CLK) then
      if DATA_ENABLE_HI = '1' then
        DA_HI<=FLASH_DATA;
      else
        DA_HI<=DA_HI;
      end if;
    end if;
  end process FLASH_DATEN_EINLESEN_HI_BITS;
  -------------------------------------------------
  FLASH_DATEN_EINLESEN_LOW_BITS: process (FLASH_CLK)
  begin
    if falling_edge(FLASH_CLK) then
      if DATA_ENABLE_LOW = '1' then
        DA_LOW<=FLASH_DATA;
      else
        DA_LOW<=DA_LOW;
      end if;
    end if;
  end process FLASH_DATEN_EINLESEN_LOW_BITS;
  -------------------------------------------------
  BYTE_ZUSAMENSETZEN: process (FLASH_CLK)
  begin
    if falling_edge (FLASH_CLK) then
      if BYTE_SCHREIBEN  = '1' then
        DATA_FROM_FLASH <= DA_HI(3 downto 0) & DA_LOW; 
      end if;
    
    end if;
  end process BYTE_ZUSAMENSETZEN;
  
  -----------------------------------------------------
  
  
  -- BRAM ADD COUNTER UND WRITE ENABLE -----------------------

  BRAM_WRITE_ADD_ZAHLEN:process (FLASH_CLK)
  begin
    if falling_edge (FLASH_CLK) then
       if BRAM_WRITE_ADD_COUNT_ENABLE = '1' then
        BRAM_WRTIE_ADD <=BRAM_WRTIE_ADD+1;
      elsif ADD_ZERO = '1' then
        BRAM_WRTIE_ADD    <= "11111111111111";
      else
        BRAM_WRTIE_ADD <=BRAM_WRTIE_ADD;
      end if;
    end if;
  end process BRAM_WRITE_ADD_ZAHLEN;
  
  BRAM_WRITE_ENABLE_ANLEGEN:process (FLASH_CLK)
  begin
    if falling_edge (FLASH_CLK) then
       if BRAM_WRITE_ENABLE = '1' then
        BRAM_WEA <="1";
      else
        BRAM_WEA <="0";
      end if;
    end if;
  end process BRAM_WRITE_ENABLE_ANLEGEN;





  ----------------------------------------------------------------------

  ----------------------------------------------------------------------
  ----------------------------------------------------------------------
  FLASHDATEN_INS_RAM_UEBERNEHMEN_COUNTER: process (ADD_VOLL)
  begin
    if ADD_VOLL ='1' then
      WRITE_OR_READ_COUNTER <= WRITE_OR_READ_COUNTER + 1;
    elsif WRITE_OR_READ_COUNTER > 1 then
      WRITE_OR_READ_COUNTER <= 0;  
    else
      WRITE_OR_READ_COUNTER <= 1;
    end if;
  end process FLASHDATEN_INS_RAM_UEBERNEHMEN_COUNTER;


  BRAM_WRITE_OR_READ_ENABLE <= '1' when WRITE_OR_READ_COUNTER = 1 else-- überflüssig, ist gleich sezten
                      '0' when WRITE_OR_READ_COUNTER = 0 else
                      '1';
  -----------------------------------------------------------------------                  




  ----------------------------- UMSCHLATER FÜR BRAM's------------------------------------
  ---------------------------------------------------------------------------------------------------------------
  BRAM_CLOCK_1       <= FLASH_CLK;
                
  BRAM_ADD_1         <= BRAM_WRTIE_ADD      when BRAM_WRITE_OR_READ_ENABLE = '1' else       
                  BRAM_READ_ADD      when BRAM_WRITE_OR_READ_ENABLE = '0' ;
  
  BRAM_WRITE_ENABLE_1   <= BRAM_WEA          when BRAM_WRITE_OR_READ_ENABLE = '1' else   
                  "0"            when BRAM_WRITE_OR_READ_ENABLE = '0' else
                  "0";
  
  BRAM_IN_DATA_1     <= DATA_FROM_FLASH;    
  ---------------------------------------------------------------------------------                              
  BRAM_CLOCK_2       <= FLASH_CLK;
                  
  
  BRAM_ADD_2         <= BRAM_READ_ADD      when BRAM_WRITE_OR_READ_ENABLE = '1' else       
                  BRAM_WRTIE_ADD      when BRAM_WRITE_OR_READ_ENABLE = '0' ;
  
  BRAM_WRITE_ENABLE_2   <= "0"            when BRAM_WRITE_OR_READ_ENABLE = '1' else   
                  BRAM_WEA          when BRAM_WRITE_OR_READ_ENABLE = '0' else
                  "0";
  
  BRAM_IN_DATA_2     <= DATA_FROM_FLASH;              
  
  -----------------------------------------------------------------------------------
    
  AUSGABE_DATEN_BRAM  <=  BRAM_OUT_DATA_1     when BRAM_WRITE_OR_READ_ENABLE = '1' else   
                  BRAM_OUT_DATA_2     when BRAM_WRITE_OR_READ_ENABLE = '0';  
  ---------------------------------------------------------------------------------






---------------------------------------------------------------------------------------------------------------
----------------------------------ZUSTANDSAUTOMAT FÜR BRAM LESEN-----------------------------------------------
---------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------

  BRAM_LESEN_ZUSTAND_WEITERGEBEN:process (FLASH_CLK,FLASH_RESET)
    begin
      if FLASH_RESET = '1' then
        aktueller_zustand_lesen<=Sleep;
      elsif rising_edge(FLASH_CLK) then
        aktueller_zustand_lesen <= naechster_zustand_lesen;
        
      end if;
  end process BRAM_LESEN_ZUSTAND_WEITERGEBEN;  
  

  Zustandsautomat_Read:process (aktueller_zustand_lesen,BRAM_READ_ADD_COUNT_VOLL,ADD_VOLL,FLASH_ENABLE) 
  begin
  case aktueller_zustand_lesen is
    -----------------------------------------------------------
    when Sleep                =>  BRAM_READ_ADD_COUNT_ENABLE    <= '0';  
                          BRAM_READ_ADD_ZERO         <= '1';  
                          if FLASH_ENABLE = '1' then      
                            naechster_zustand_lesen <= ADD_ANLEGEN_LESEN;
                          else
                            naechster_zustand_lesen <= Sleep;  
                          end if;
                          
    when ADD_ANLEGEN_LESEN      =>  BRAM_READ_ADD_COUNT_ENABLE    <= '0';  
                          BRAM_READ_ADD_ZERO         <= '1';  
                          naechster_zustand_lesen <= WARTEN_LESEN_1;  
                    

    when BRAM_1_AUSLESEN         =>  BRAM_READ_ADD_COUNT_ENABLE    <= '1';  
                          BRAM_READ_ADD_ZERO         <= '0';  
                        
                          if BRAM_READ_ADD_COUNT_VOLL = '1' then
                            naechster_zustand_lesen <= WARTEN_AUF_SCHREIBEN;  
                          else
                            naechster_zustand_lesen <=WARTEN_LESEN_1;
                          end if;
    
    when WARTEN_LESEN_1         =>  BRAM_READ_ADD_COUNT_ENABLE      <= '0';  
                          BRAM_READ_ADD_ZERO           <= '0';  
                          naechster_zustand_lesen       <= BRAM_1_AUSLESEN;  
                    
    
    
    when WARTEN_AUF_SCHREIBEN     =>  BRAM_READ_ADD_COUNT_ENABLE    <= '0';  
                          BRAM_READ_ADD_ZERO         <= '0';  
                          if ADD_VOLL = '1' then 
                            naechster_zustand_lesen <= Sleep;  
                          else
                            naechster_zustand_lesen <=WARTEN_AUF_SCHREIBEN;
                          end if;                
      
  end case;
  end process Zustandsautomat_Read;
  
  
  RAM_READ_ADD_ZAHLEN:process (FLASH_CLK)
  begin
    if falling_edge (FLASH_CLK) then
       if BRAM_READ_ADD_COUNT_ENABLE = '1' then
        BRAM_READ_ADD <= BRAM_READ_ADD+1;
      elsif BRAM_READ_ADD_ZERO = '1' then
        BRAM_READ_ADD <= "00000000000000";
      elsif ADD_VOLL ='1' then
        BRAM_READ_ADD <= "00000000000000";
      else
        
        BRAM_READ_ADD <= BRAM_READ_ADD;  
      end if;
    end if;
  end process RAM_READ_ADD_ZAHLEN;
  
  RAM_READ_ADD_VOLL:process (FLASH_CLK)
  begin
    if rising_edge (FLASH_CLK) then
      if BRAM_READ_ADD > "10000011001101" then
        BRAM_READ_ADD_COUNT_VOLL <= '1';
      else
        BRAM_READ_ADD_COUNT_VOLL <= '0';
      end if;
    end if;
  end process RAM_READ_ADD_VOLL;
  
  -----------------------------------------------------------------------------------------------------------
  -----------------------------------------------------------------------------------------------------------
    
  --------------NUR FÜR SIMULATION---------------------
  -----------------------------------------------------
  DATA_EN_H      <= DATA_ENABLE_HI; 
  DATA_EN_L      <= DATA_ENABLE_LOW; 
  DA_H          <= DA_HI;
  DA_L          <= DA_LOW;      
  BYTE_SR        <= BYTE_SCHREIBEN;    
  ADD_ZE           <= ADD_ZERO;
  ADD_V          <= ADD_VOLL;
  ADD_EN        <= ADD_COUNT_ENABLE;     
  BRAM_ADD_EN      <=  BRAM_WRITE_ADD_COUNT_ENABLE;
  BRAM_WEAEN      <= BRAM_WEA;
  BADD          <= BRAM_WRTIE_ADD;
  
  BRAM_WR_RD_ENABLE  <= BRAM_WRITE_OR_READ_ENABLE;
  
  
  BRAM_R_ADD_COUNT_ENABLE   <=  BRAM_READ_ADD_COUNT_ENABLE;                
  BRAM_R_ADD_COUNT_VOLL    <=  BRAM_READ_ADD_COUNT_VOLL  ;                                    
  BRAM_R_ADD            <=  BRAM_READ_ADD;                                
  BRAM_R_ADD_ZERO        <=  BRAM_READ_ADD_ZERO;                        
  
  BRAM_CLK_1            <=  BRAM_CLOCK_1  ;                                
  BRAM_A_1              <=  BRAM_ADD_1;                
  BRAM_IN_DA_1          <=  BRAM_IN_DATA_1;                                  
  BRAM_OUT_DA_1          <=  BRAM_OUT_DATA_1;                
  BRAM_WR_ENABLE_1        <=  BRAM_WRITE_ENABLE_1;                  

  BRAM_CLK_2            <=  BRAM_CLOCK_2;                
  BRAM_A_2              <=  BRAM_ADD_2  ;                
  BRAM_IN_DA_2          <=  BRAM_IN_DATA_2;                
  BRAM_OUT_DA_2          <=  BRAM_OUT_DATA_2;                
  BRAM_WR_ENABLE_2           <=  BRAM_WRITE_ENABLE_2;                

  DA_FROM_FLASH          <= DATA_FROM_FLASH  ;
  
  --------------------------------------------------------
    
  ------------------------------------------------------
  ---------------------HILFSSIGNALE---------------------
  --DATA_FROM_FLASH <= DATAOUT  ;  
  FLASH_RP <= RP;
  FLASH_CE  <= CE;
  FLASH_OE  <= OE;
  FLASH_ADD <=ADD;
  
  -------------------------------------------------

  
  --------------PORT MAPPING ----------------
  
  RAM_EINLESEN_1:SINGLE_RAM_1
   
  PORT MAP (  clka  => BRAM_CLOCK_1,
          rsta  => FLASH_RESET,
          addra => BRAM_ADD_1,
          wea   => BRAM_WRITE_ENABLE_1,
          dina  => BRAM_IN_DATA_1,
          douta => BRAM_OUT_DATA_1);


  RAM_EINLESEN_2:SINGLE_RAM_2
   
  PORT MAP (  clka  => BRAM_CLOCK_2,
          rsta  => FLASH_RESET,
          addra => BRAM_ADD_2,
          wea   => BRAM_WRITE_ENABLE_2,
          dina  => BRAM_IN_DATA_2,
          douta => BRAM_OUT_DATA_2);
end Behavioral;



Autor: D. I. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Für das was du vorhast scheint mir der Automat deutlich übertrieben zu 
sein.

Autor: Igor (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
So ich denke ich habe den Fehler gefunden weiß nur noch nicht wieso der 
kommt. Wenn ein Trigger signal kommt (hier FLASH_ENABLE) dann startet 
der Automat den Flash zu lesen und in den Bram zu schreiben. Wenn das 
Zweite trigger Signal wieder kommt dann soll das ganze wieder loslaufen 
nur das er in das Zweite Bram schreibt. Beim dritten trigger Signal 
wieder anders rum usw.

Dafür habe ich ein Counter der zwischen 0 und 1 gesetzt wird wenn die 
Flash Add voll gelaufen ist (ADD_VOLL)...

Hier der Code dazu

FLASHDATEN_INS_RAM_UEBERNEHMEN_COUNTER: process (ADD_VOLL)
  begin
    if ADD_VOLL='1' then
      WRITE_OR_READ_COUNTER <= WRITE_OR_READ_COUNTER + 1;
    elsif WRITE_OR_READ_COUNTER > 1 then
      WRITE_OR_READ_COUNTER <= 0;  
    else
      WRITE_OR_READ_COUNTER <= 1;
    end if;
  end process FLASHDATEN_INS_RAM_UEBERNEHMEN_COUNTER;


  BRAM_WRITE_OR_READ_ENABLE <= '1' when WRITE_OR_READ_COUNTER = 1 else
                      '0' when WRITE_OR_READ_COUNTER = 0 else
                      '1';



BRAM_WRITE_OR_READ_ENABLE  benutze ich dann als umschalter, aber das 
funktioniert nicht . Wieso ?


Gruß

Igor

Autor: Igor (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bzw. gibt es eine bessere alternative wie ich auf ein Trigger Signal 
reagiere.

Also ich bekomme ein Trigger Signal damit muss mein zweites Signal auf 1 
gehen bis wieder ein Trigger Signal kommt dann muss mein zweites Signal 
auf 0 gehen und immer hin und her switchen abhängig von Trigger Signal.


Ich habs über ein Counter gemacht, gibt es dazu eine bessere 
Alternative?



Gruß



Igor

Autor: Igor (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hat sich erledigt, hab ein anderen Weg gefunden!


Gruß


Igor

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [vhdl]VHDL-Code[/vhdl]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.