Subversion Repositories saturn

--============================================================================= 
--  TITRE : CON_LAYER2_TX
--  DESCRIPTION : 
--       Encapsule la trame applicative dans une trame Layer2
--       Ajoute les fanions de début et de fin, effectue le byte stuffing 
--       et calcule le CRC
--  FICHIER :        layer2_tx.vhd 
--=============================================================================
--  CREATION 
--  DATE	      AUTEUR	PROJET	REVISION 
--  10/04/2014	DRA	   SATURN	V1.0 
--=============================================================================
--  HISTORIQUE  DES  MODIFICATIONS :
--  DATE	      AUTEUR	PROJET	REVISION 
--  27/04/15   DRA      SATURN   V1.1
--    Suppression du test de FIFO vide dans l'état waitendsend_st. Ce temps
--    permettait de laisser un blanc sur la ligne pour laisser le temps 
--    à un noeud d'insérer sa réponse, mais la stratégie de priorité à l'anneau
--    fait que ce n'est plus utile
--=============================================================================
 
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
 
entity con_layer2_tx is
   PORT (
      -- Ports système
      clk_sys  : IN  STD_LOGIC;                    -- Clock système
      rst_n    : IN  STD_LOGIC;                    -- Reset général système
      stuf_phys: IN  STD_LOGIC;                    -- Ordre d'émission de caractères 7F sur la ligne
      acq_stuf : OUT STD_LOGIC;                    -- Indique que le stuff est fini
 
      -- Interfaces vers le module d'interface du PIC
      dat_in   : IN  STD_LOGIC_VECTOR(7 DOWNTO 0); -- Flux de données applicatives à émettre
                                                   -- La première donnée du flux qui suit le sof est l'@ de destination
      val_in   : IN  STD_LOGIC;                    -- validant du bus dat_in
      sof      : IN  STD_LOGIC;                    -- Indique le début d'une trame à émettre (non synchrone de la 1ère donnée)
      eof      : IN STD_LOGIC;                     -- Indique le dernier octet de la trame à émettre
      datin_free: OUT  STD_LOGIC;                  -- Indique que le module layer2_tx est prêt à recevoir 1 octet suivant
 
      -- Interfaces vers les FIFO de transmissions
      dat_out  : OUT  STD_LOGIC_VECTOR(7 downto 0);-- Flux de données Layer2 à stocker dans les FIFO Tx
      val_out  : OUT  STD_LOGIC;                   -- Validant du bus dat_out
      clr_fifo : IN   STD_LOGIC;                   -- Signal de reset des FIFO Tx
      progfull1: IN   STD_LOGIC;                   -- Indique la FIFO Tx1 est presque pleine
      progfull2: IN   STD_LOGIC;                   -- Indique la FIFO Tx2 est presque pleine
      full1    : IN   STD_LOGIC;                   -- Indique la FIFO Tx1 est pleine
      empty1   : IN   STD_LOGIC;                   -- Indique la FIFO Tx1 est vide
      full2    : IN   STD_LOGIC;                   -- Indique la FIFO Tx2 est pleine
      empty2   : IN   STD_LOGIC                    -- Indique la FIFO Tx2 est vide
      );
end con_layer2_tx;
 
architecture  rtl of con_layer2_tx is
   SIGNAL   crc      : STD_LOGIC_VECTOR(15 downto 0); -- Valeur dynamique du crc
   SIGNAL   val_crc  : STD_LOGIC;                     -- Validant du CCRC
   SIGNAL   init_crc : STD_LOGIC;                     -- Initialise le calcul du CRC
   SIGNAL   dat_crc  : STD_LOGIC_VECTOR(7 DOWNTO 0);  -- Donnée à prendre en compte pour le calcul du CRC
   SIGNAL   last_char: STD_LOGIC;                     -- Pour mémoriser le eof au cas ou il y'ait du stuffing sur le dernier char
   SIGNAL   cpt_stuf : STD_LOGIC_VECTOR(9 DOWNTO 0);  -- Pour compter les octets de stuff de ligne envoyés
   SIGNAL   acq_stuf_buf : STD_LOGIC;                 -- Pour indiquer la focntion de stuff en cours
   SIGNAL   empty1_r1, empty1_r2: STD_LOGIC;          -- Pour changer empty1 d'horloge
   SIGNAL   empty2_r1, empty2_r2: STD_LOGIC;          -- Pour changer empty2 d'horloge
 
   -- Machine d'état de gestion du module
   TYPE layer2_tx_type IS (idle_st, addest_st, data_st, fifo_full_st, stuf5E_st, stuf5D_st, 
                           waitcrc_st, crc1_st, stufcrc1_st, crc2_st, stufcrc2_st, fanionfin_st, waitendsend_st, stuf_st, wait_stuf_st);
   SIGNAL fsm_layer2_tx       : layer2_tx_type;
 
   -- Module de calcul du CRC16
	COMPONENT crc16
   GENERIC (
      poly : STD_LOGIC_VECTOR(15 downto 0) := x"1021"
      );
	PORT(
		clk_sys  : IN std_logic;
		rst_n    : IN std_logic;
		data     : IN std_logic_vector(7 downto 0);
		val      : IN std_logic;
		init     : IN std_logic;          
		crc      : OUT std_logic_vector(15 downto 0)
		);
	END COMPONENT;
 
BEGIN
   acq_stuf <= acq_stuf_buf;
   --------------------------------------------
   -- Machine d'état de génération du flux et d'écriture dans la FIFO Tx
   --       Les FIFO Tx font 512 octet mais leur 'prog_full' est calé à 495 octets
   --       En testant le prog_full, on a donc toujours au moins 15 octets de libre
   --       On ne teste donc le prog_full que quand on écrit des donées utiles de la trame
   --       Lorsqu'on écrit l'entête ou le CRC ou du stuffing, il n 'y a pas besoin de tester
   --       le niveau de remplissage
   --------------------------------------------
   -- La donnée entrante est prise en compte que si on est dans l'état data_st ou addest_st
   -- Autrement dit, le module est dipos pour une nouvelle donnée dans ces cas là
   datin_free <= '1' WHEN (fsm_layer2_tx = data_st OR fsm_layer2_tx = addest_st) ELSE '0';
   man_fsm : PROCESS(clk_sys, rst_n)
   BEGIN
      IF (rst_n = '0') THEN
         fsm_layer2_tx <= idle_st;
         init_crc <= '1';
         val_crc <= '0';
         val_out <= '0';
         last_char <= '0';
         acq_stuf_buf <= '0';
         empty1_r1 <= '0';
         empty1_r2 <= '0';
         empty2_r1 <= '0';
         empty2_r2 <= '0';
         dat_out <= (others => '0');
         dat_crc <= (others => '0');
 
      ELSIF (clk_sys'EVENT and clk_sys = '1') THEN
         empty1_r1 <= empty1;       -- Changement d'horloge de empty1
         empty1_r2 <= empty1_r1;
         empty2_r1 <= empty2;       -- Changement d'horloge de empty2
         empty2_r2 <= empty2_r1;
         CASE fsm_layer2_tx IS
            WHEN idle_st =>
            -- Etat d'attente du signal sof ou d'un ordre de de stuf de la ligne physique
               IF (stuf_phys = '1' AND acq_stuf_buf = '0') THEN
               -- Si on reçoit un ordre de stuf de la ligne physique et que ce n'est pas l'ordre précédent pas encore effacé
                  dat_out <= x"7E";             -- On n'envoie que des fanions 
                  init_crc <= '0';              -- On annule le reset du CRC
                  val_crc <= '0';               -- L'octet qu'on va sortir ne compte pas dans le calcul du crc
                  val_out <= '1';               -- On l'écrit dans la FIFO
                  cpt_stuf <= (OTHERS => '0');
                  fsm_layer2_tx <= stuf_st;     -- On va générer cpt_stuf fanions sur la ligne
               ELSIF (sof = '1' AND full1 = '0' AND full2 = '0' AND clr_fifo = '0') THEN
               -- Si on commence une trame et que le processus de clr est terminé
               -- Lors d'un reset de fifo, le flag full reste actif durant quelques cycle après 
               -- le relachement du clr_fifo
                  dat_out <= x"7E";             -- On envoie le fanion de début 
                  init_crc <= '0';              -- On annule le reset du CRC
                  val_crc <= '0';               -- L'octet qu'on va sortir ne compte pas dans le calcul du crc
                  val_out <= '1';               -- On l'écrit dans la FIFO
                  fsm_layer2_tx <= addest_st;   -- On va générer l'octet de commande
               ELSE
               -- Si pas de début de trame
                  init_crc <= '1';              -- On initialise le CRC
                  val_crc <= '0';               -- On fait rien
                  val_out <= '0';
               END IF;
               acq_stuf_buf <= '0';
 
            WHEN addest_st =>
               IF (val_in = '1') THEN
               -- La première donnée de la trmae est l'@ destination. Elle ne peut pas être stuffée car 7E et 7D sont interdites
                  val_out <= '1';            -- Quelle que soit la donnée on la prend en compte dans le calcul du CRC
                  val_crc <= '1';            -- Elle compte dans le calcul du CRC
                  dat_out <= dat_in;         -- On la fournit à la FIFO
                  dat_crc <= dat_in;         -- On la forunit au CRC
                  fsm_layer2_tx <= data_st;  -- On va traiter l'octet suivant
               ELSE
               -- Tant qu'on recoit pas de donnée
                  val_out <= '0';            -- Rien dans le FIFO
                  val_crc <= '0';            -- CRC inchangé
               END IF;
 
            WHEN data_st =>
            -- On attend une donnée disponible sur le bus d'entrée
               IF (val_in = '1') THEN
               -- Si il y'a une donnée sur le bus
                  val_crc <= '1';            -- Quelle que soit la donnée on la prend en compte dans le calcul du CRC
                  dat_crc <= dat_in;         
                  val_out <= '1';            -- Quelle que soit la donnée on va écrire quelque chose dans la FIFO
                  IF (dat_in = x"7E") THEN
                     dat_out <= x"7D";          -- Si c'est un 7E il doit être remplacé par la séquence 7D 5E
                     last_char <= eof;          -- On mémorise s'il s'agit du dernier char de la trame
                     fsm_layer2_tx <= stuf5E_st;-- On va insérer le code 5E dans le flux
                  ELSIF (dat_in = x"7D") THEN
                     dat_out <= x"7D";          -- Si c'est un 7D il doit être remplacé par la séquence 7D 5D
                     last_char <= eof;          -- On mémorise s'il s'agit du dernier char de la trame
                     fsm_layer2_tx <= stuf5D_st;-- On va insérer le code 5D dans le flux
                  ELSE                          
                  -- Si c'est une donnée normale
                     dat_out <= dat_in;         -- On la met dans le flux
                     IF (eof = '1') THEN        -- Si c'est la dernière donnée de la trame
                        fsm_layer2_tx <= waitcrc_st;  -- On va attendre que le CRC soit prêt
                     ELSIF (progfull1 = '1' OR progfull2 = '1') THEN
                     -- Si une des 2 FIFO en écriture est presque pleine
                        fsm_layer2_tx <= fifo_full_st;   -- On va attendre
                     END IF;
                  END IF;
               ELSE
               -- Si il n'y a pas de nouvelle donnée sur le bus
                  val_crc <= '0';               -- On fait rien
                  val_out <= '0';
               END IF;
 
            WHEN fifo_full_st =>
            -- Etat d'attente qu'il y'ait de la place dans les FIFO en écriture
               val_crc <= '0';               -- On fait rien
               val_out <= '0';
               IF (progfull1 = '0' AND progfull2 = '0') THEN
               -- On attend que les 2 FIFO ne soient plus pleines
                  fsm_layer2_tx <= data_st;
               END IF;
 
 
            WHEN stuf5E_st =>
            -- Etat d'insertion du char 5E dans le flux
               dat_out <= x"5E";
               val_crc <= '0';                  -- Le CRC ne doit pa sêtre mis à jour avec l'octet de bourrage
               val_out <= '1';                  -- On l'écrit dans la FIFO
               IF (last_char = '1') THEN        -- Si c'était le dernier octet, on va insérer le CRC 
                  fsm_layer2_tx <= crc1_st;
               ELSE
                  fsm_layer2_tx <= data_st;
               END IF;
 
            WHEN stuf5D_st =>
            -- Etat d'insertion du char 5D dans le flux
               dat_out <= x"5D";                
               val_crc <= '0';                  -- Le CRC ne doit pa sêtre mis à jour avec l'octet de bourrage
               val_out <= '1';                  -- On l'écrit dans la FIFO
               IF (last_char = '1') THEN        -- Si c'était le dernier octet, on va insérer le CRC
                  fsm_layer2_tx <= crc1_st;
               ELSE
                  fsm_layer2_tx <= data_st;
               END IF;
 
            WHEN waitcrc_st =>
            -- On attend un cycle que le CRC soit à jour avec la dernière donnée
               val_crc <= '0';
               val_out <= '0';
               fsm_layer2_tx <= crc1_st;        -- On va traiter les 8 MSB du CRC
 
            WHEN crc1_st =>
            -- Etat de traitement des 8 MSB du CRC
               val_crc <= '0';                  -- On doit pas modifier le CRC
               val_out <= '1';                  -- On va écrire une donnée en FIFO
               IF (crc(15 downto 8) = x"7E" OR crc(15 downto 8) = x"7D") THEN
               -- Si les 8 MSB sont une donnée à stuffer
                  dat_out <= x"7D";             -- On écrit le code de stuffing
                  fsm_layer2_tx <= stufcrc1_st; -- On va traiter le stuf
               ELSE
               -- Si les 8 MSB ne sont pas à stuffer
                  dat_out <= crc(15 downto 8);  -- On les met tel quel dans le flux
                  fsm_layer2_tx <= crc2_st;     -- On va traiter les 8 LSB du CRC
               END IF;
 
            WHEN stufcrc1_st =>
            -- Etat de gestion du stuffing des 8 MSB du CRC
               val_crc <= '0';
               val_out <= '1';
               IF (crc(15 downto 8) = x"7E") THEN
               -- Selon la valeur à stuffer
                  dat_out <= x"5E";             -- On envoie le bon code
               ELSE
                  dat_out <= x"5D";
               END IF;
               fsm_layer2_tx <= crc2_st;        -- On va traiter les 8 LSB du CRC 
 
            WHEN crc2_st =>
            -- Etat de traitement des 8 LSB du CRC
               val_crc <= '0';
               val_out <= '1';
               IF (crc(7 downto 0) = x"7E" OR crc(7 downto 0) = x"7D") THEN
               -- Si les 8 LSB sont une donnée à stuffer
                  dat_out <= x"7D";
                  fsm_layer2_tx <= stufcrc2_st;
               ELSE
               -- Si les 8 MSB ne sont pas à stuffer
                  dat_out <= crc(7 downto 0);
                  fsm_layer2_tx <= fanionfin_st;   -- On va insérer le fanion de fin dans le flux
               END IF;
 
            WHEN stufcrc2_st =>
            -- Etat de gestion du stuffing des 8 LSB du CRC
               val_crc <= '0';
               val_out <= '1';
               IF (crc(7 downto 0) = x"7E") THEN
                  dat_out <= x"5E";
               ELSE
                  dat_out <= x"5D";
               END IF;
               fsm_layer2_tx <= fanionfin_st;
 
            WHEN fanionfin_st =>
            -- On envoie le fanion de fin
               dat_out <= x"7E";
               val_crc <= '0';
               init_crc <= '1';
               val_out <= '1';
               fsm_layer2_tx <= waitendsend_st; -- On va attendre la fin des transmission
 
            WHEN waitendsend_st =>
               -- Etat d'annulation de l'émission
               val_out <= '0';
               fsm_layer2_tx <= idle_st;
 
            WHEN stuf_st =>
            -- Envoie cpt_stuf fanion sur la ligne
               IF (cpt_stuf = CONV_STD_LOGIC_VECTOR(800, cpt_stuf'LENGTH)) THEN
               -- Si on a émis tous les fanions
                  fsm_layer2_tx <= wait_stuf_st;
                  val_out <= '0';      -- On n'écrit plus rien dans la FIFO
               ELSE
               -- Tant qu'il faut émettre
                  IF (progfull1 = '1' OR progfull2 = '1') THEN
                  -- Si une des 2 FIFO Tx est pleine
                     val_out <= '0';      -- On attend sans ecrire
                  ELSE
                     val_out <= '1';      -- Chaque octet écrit est décompté
                     cpt_stuf <= cpt_stuf + 1;
                  END IF;
               END IF;
 
            WHEN wait_stuf_st =>
            -- Etat d'attente que les mots de stuff soit tous partis
               IF (empty1_r2 = '1' AND empty2_r2 = '1') THEN
               -- Si les 2 FIFO Tx sont vides
                  acq_stuf_buf <= '1'; -- On signale que l'opération est finie
                  fsm_layer2_tx <= idle_st;
               END IF;
 
            WHEN OTHERS =>
               fsm_layer2_tx <= idle_st;
 
         END CASE;
      END IF;
   END PROCESS;
 
   --------------------------------------------
   -- Calcul du crc16
   --------------------------------------------
	inst_crc16: crc16
   GENERIC MAP (
      poly => x"1021"   -- CCITT16
      )
   PORT MAP(
		clk_sys => clk_sys,
		rst_n => rst_n,
		data => dat_crc,         -- Dans le calcul du CRC, on prend en compte le flux déstuffé
		val => val_crc,
		init => init_crc,
		crc => crc
	);
 
end rtl;