Subversion Repositories saturn

--============================================================================= 
--  TITRE : STORE_FRAMETXDMA
--  DESCRIPTION : 
--        Stocke une trame émise par le PIC dans un buffer tournant
--        On écrit le nombre d 'octets au début de la zone 
--  FICHIER :        store_frametxdma.vhd 
--=============================================================================
--  CREATION 
--  DATE	      AUTEUR	PROJET	REVISION 
--  10/04/2014	DRA	   SATURN	V1.0 
--=============================================================================
--  HISTORIQUE  DES  MODIFICATIONS :
--  DATE	      AUTEUR	PROJET	REVISION 
--=============================================================================
 
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
 
LIBRARY work;
USE work.package_saturn.ALL;
 
ENTITY store_frametxdma IS
   PORT (
      clk_sys        : IN  STD_LOGIC;                    -- Horloge système
      rst_n          : IN  STD_LOGIC;                    -- Reset général système
      store_enable   : IN  STD_LOGIC;                    -- Autorise le stockage des trames incidentes
      -- Interface de réception des trames Rx
      data_store     : IN  STD_LOGIC_VECTOR(7 DOWNTO 0); -- Données à stocker.  
      val_store      : IN  STD_LOGIC;                    -- Validant du bus data_store(signal write)
      sof_store      : IN  STD_LOGIC;                    -- Indique und début de trame (nouvelle trame). Synchrone du 1er octet envoyé
      eof_store      : IN  STD_LOGIC;                    -- Indique que la trame est finie (plus de données à envoyer)
 
      -- Interface de restitution des trames enregistrées
      frame_dispo    : OUT STD_LOGIC;                    -- Indique qu'il y'a au moins une trame dispo à émettre
      frame_data     : OUT STD_LOGIC_VECTOR(31 DOWNTO 0);-- Données à émettre (lue comme une FIFO en FWFT)
      frame_rd       : IN  STD_LOGIC;                    -- Signal de lecture d'une donnée
      overflow       : OUT STD_LOGIC;                    -- Indique que le pointeur d'écriture a rattraper celui de lecture
      timestamp      : IN  STD_LOGIC_VECTOR(7 DOWNTO 0)  -- Pour timestamper la récetion des trames 
   );
END store_frametxdma;
 
ARCHITECTURE rtl of store_frametxdma is
   CONSTANT nbbit_add8 : integer := 12;                  -- Nombre de bit du bus d'adresse du buffer
   CONSTANT vecnull    : STD_LOGIC_VECTOR(31 DOWNTO 0) := x"00000000";
 
   SIGNAL cpt_adwr : STD_LOGIC_VECTOR(nbbit_add8-1 DOWNTO 0);  -- Compteur et pointeur d'écriture
   SIGNAL cpt_adrd : STD_LOGIC_VECTOR(nbbit_add8-2-1 DOWNTO 0);-- Compteur de lecture
   SIGNAL old_adwr : STD_LOGIC_VECTOR(nbbit_add8-2-1 DOWNTO 0);-- 1er empalcement libre dans la mémoire
   SIGNAL adread   : STD_LOGIC_VECTOR(nbbit_add8-2-1 DOWNTO 0);-- Pointeur de lecture
   SIGNAL cpt_byte : STD_LOGIC_VECTOR(7 DOWNTO 0);             -- Compteur d'octet dans une trame
   SIGNAL data_wr  : STD_LOGIC_VECTOR(7 DOWNTO 0);             -- Donnée à écrire dans la DPRAM
   SIGNAL wr_dpram : STD_LOGIC;                                -- Signal d'écriture dans la DPRAM
   SIGNAL wea      : STD_LOGIC_VECTOR(0 DOWNTO 0);
 
   TYPE fsm_write_type IS (idlewr_st, write_payload_st, store_cpt_st, clr_msbsize_st, gest_over_st); -- Machine d'état d'écriture d'une trame
   SIGNAL fsm_write : fsm_write_type;
 
   -- DPRAM de stockage
   COMPONENT dpram_storerx
      PORT (
         clka  : IN STD_LOGIC;
         wea   : IN STD_LOGIC_VECTOR(0 DOWNTO 0);
         addra : IN STD_LOGIC_VECTOR(nbbit_add8-1 DOWNTO 0);
         dina  : IN STD_LOGIC_VECTOR(7 DOWNTO 0);
         douta : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);
         clkb  : IN STD_LOGIC;
         web   : IN STD_LOGIC_VECTOR(0 DOWNTO 0);
         addrb : IN STD_LOGIC_VECTOR(nbbit_add8-2-1 DOWNTO 0);
         dinb  : IN STD_LOGIC_VECTOR(31 DOWNTO 0);
         doutb : OUT STD_LOGIC_VECTOR(31 DOWNTO 0)
      );
   END COMPONENT;
 
BEGIN
 
   --------------------------------------------
   -- Gestion du compteur d'adresse de la DPRAM en lecture
   --------------------------------------------
   cptr : PROCESS(clk_sys, rst_n)
   BEGIN
      IF (rst_n = '0') THEN
         cpt_adrd <= (others => '0');
         frame_dispo <= '0';
      ELSIF (clk_sys'EVENT and clk_sys = '1') THEN
         IF (frame_rd = '1') THEN
         -- A chaque donéne lue
            cpt_adrd <= cpt_adrd + 1;
         END IF;
         IF (cpt_adrd /= old_adwr) THEN
         -- Si le pointeur en lecture est différent du pointeur en écriture, on indique qu'il 
         -- y'a des données à traiter
            frame_dispo <= '1';
         ELSE
            frame_dispo <= '0';
         END IF;
      END IF;
   END PROCESS;
   -- Permet d'avoir un fonctionnement style FWFT avec un seul cycle entre le rd et la donnée
   adread <= cpt_adrd WHEN (frame_rd = '0') ELSE cpt_adrd+1;
 
   --------------------------------------------
   -- Machine d'état d'écriture du flux
   --------------------------------------------
   wr_fsm : PROCESS(clk_sys, rst_n)
      VARIABLE temp : STD_LOGIC_VECTOR(nbbit_add8-1 DOWNTO 0);
   BEGIN
      IF (rst_n = '0') THEN
         fsm_write <= idlewr_st;
         cpt_adwr <= (others => '0');
         old_adwr <= (others => '0');
         cpt_byte <= (others => '0');
         overflow <= '0';
         wr_dpram <= '0';
      ELSIF (clk_sys'EVENT and clk_sys = '1') THEN
         CASE fsm_write IS
            WHEN idlewr_st =>
            -- Etat d'attente d'un SOF
               overflow <= '0';
               IF (val_store = '1' AND sof_store = '1' AND store_enable = '1') THEN
               -- Sur SOF et que le store est autorisé
                  cpt_adwr <= (old_adwr + 1) & "00";  -- On réserve un espace pour stocker la longueur
                  data_wr <= data_store;              -- On va écrire la première donnée
                  wr_dpram <= '1';                    -- On va écrire
                  cpt_byte <= x"01";                  -- On a 1 octet utile
                  fsm_write <= write_payload_st;
               ELSE
                  wr_dpram <= '0';
               END IF;
 
            WHEN write_payload_st =>
            -- Etat d'attente du EOF
               IF (wr_dpram = '1') AND ((cpt_adwr(nbbit_add8-1 DOWNTO 2) = cpt_adrd-4) OR 
                                        (cpt_adwr(nbbit_add8-1 DOWNTO 2) = cpt_adrd-3)) THEN
               -- On a un overflow si on écrit et que le pointeur wr a rattrapé le pointeur rd
               -- On teste par rapprot à 2 valeurs du pointeurs de lecture car sinon, le fonctionnement
               -- en FWFT peut faire qu'on loupe une valeur
                  overflow <= '1';
                  wr_dpram <= '0';
                  IF (eof_store = '1') THEN
                  -- Si c'est également le dernier mot de la trame
                     fsm_write <= idlewr_st;
                  ELSE
                  -- Si c'est pas le derneir, on va attendre la fin de la trame
                     fsm_write <= gest_over_st;
                  END IF;
               ELSE
                  IF (val_store = '1') THEN
                  -- A cqhaue nouvelle donnée
                     cpt_adwr <= cpt_adwr + 1;     -- On va l'écrire à l'adresse suivante
                     cpt_byte <= cpt_byte + 1;     -- On la compte
                     data_wr <= data_store;        -- On l'écrit telle quelle
                     wr_dpram <= '1';
                     IF (eof_store = '1') THEN
                     -- Si c'était la dernière de la trame
                        fsm_write <= store_cpt_st;
                     END IF;
                  ELSE
                     wr_dpram <= '0';
                  END IF;
               END IF;
 
            WHEN store_cpt_st =>
            -- Etat de stockage du nombre d'octets dans le LSB 1er mot de 32 bits 
               cpt_adwr <= old_adwr & "00";     -- On va stocker le nombre d'octets utiles dans les LSB du au début
               data_wr <= cpt_byte;             -- On garde toutes les données écrites
               temp := cpt_adwr;                -- On arrondit le nouveau pointeur d'écriture au multiple de 4 supérieur
               old_adwr <= temp(nbbit_add8-1 DOWNTO 2) + 1;
               wr_dpram <= '1';
               fsm_write<= clr_msbsize_st;
 
            WHEN clr_msbsize_st =>
            -- Etat de fabrication des MSB du 1er mot de 32 bits
            -- La première zone mémoire du bloc contient:
            -- LSB : Taille du bloc
            -- LSB+1 : 0
            -- LSB+2 : 0
            -- MSB : Timestamp
               cpt_adwr(1 DOWNTO 0) <= cpt_adwr(1 DOWNTO 0) + 1;
               IF (cpt_adwr(1 DOWNTO 0) = "10") THEN
               -- On va écrire le time stamp dans les 8 MSB de la 1ère zone
                  data_wr <= timestamp;
                  fsm_write <= idlewr_st;
               ELSE
               -- On cleare les LSB+1 et LSB+2
                  data_wr <= x"00";
               END IF;
 
            WHEN gest_over_st =>
               overflow <= '0';
               wr_dpram <= '0';
               IF (eof_store = '1') THEN
               -- On attend le signal de fin trame pour recommencer à traiter
                  fsm_write <= idlewr_st;
               END IF;
 
            WHEN OTHERS =>
               fsm_write <= idlewr_st;
         END CASE;
      END IF;
   END PROCESS;
 
   wea(0) <= wr_dpram;
   store : dpram_storerx
      PORT MAP (
         clka => clk_sys,
         wea => wea,
         addra => cpt_adwr,
         dina => data_wr,
         douta => OPEN,
         clkb => clk_sys,
         web => vecnull(0 DOWNTO 0),
         addrb => adread,
         dinb => vecnull,
         doutb => frame_data
      );
END rtl;