Subversion Repositories saturn

--============================================================================= 

--  TITRE : SWITCH

--  DESCRIPTION : 

--        - Gère la réception et la transmission d'une ligne série

--                       - Copie du port Rx sur le port Tx avec remise en forme du signal

--        - Gestion du switch entre les sources Tx

--        - Buffurise les données reçues pendant la transmission                

--  FICHIER :        switch.vhd 

--=============================================================================

--  CREATION 

--  DATE        AUTEUR  PROJET  REVISION 

--  29/02/2012  DRA     CONCERTO        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;

-- Uncomment the following library declaration if instantiating

-- any Xilinx primitives in this code.

--library UNISIM;

--use UNISIM.VComponents.all;

ENTITY switch IS

   GENERIC (

      nbbit_div : INTEGER := 10);   -- Nombre de bits pour coder le diviseur d'horloge 

   PORT (

      -- Ports système

      clk_sys  : IN  STD_LOGIC;  -- Clock système

      rst_n    : IN  STD_LOGIC;  -- Reset génrél système

      baud_lock: IN  STD_LOGIC;  -- Indique que le baudrate est calé

      -- Interface série

      tc_divclk: IN  STD_LOGIC_VECTOR (nbbit_div-1 DOWNTO 0); -- Diviseur de l'horloge système pour le baudrate

      rx       : IN  STD_LOGIC;  -- Réception série    

      tx       : OUT  STD_LOGIC; -- Transmission série

      -- Interface avec la mémoire de transmission

      tx_dat   : IN  STD_LOGIC_VECTOR (7 DOWNTO 0);  -- Prochaine donnée à transmettre

      tx_empty : IN  STD_LOGIC;  -- Mémoire de transmission vide

      tx_rd    : OUT  STD_LOGIC; -- Lecture de la donnée suivante à transmettre

      -- Interface avec la mémoire de réception

      rx_dat   : OUT  STD_LOGIC_VECTOR (7 DOWNTO 0);  -- Donnée en cours de réception

      rx_val   : OUT  STD_LOGIC; -- Signal d'écriture dans la méoire de réception

      -- Gestion de la recopie

      sw_ena   : IN  STD_LOGIC;  -- Autorisation du changement d'émetteur

      copy_ena : IN  STD_LOGIC  -- Autorisation de recopie d'un port sur l'autre

      );

END switch;

ARCHITECTURE rtl of switch is

   SIGNAL data_deser       : STD_LOGIC_VECTOR(7 downto 0);  -- Donnée reçue déserialisée

   SIGNAL tx_copy          : STD_LOGIC;                     -- Valeur d'un bit à retransmettre pour la recopie

   SIGNAL rx_wr_buf        : STD_LOGIC;                     -- Pulse d'écriture d'un nouveau caractère reçu

   SIGNAL rx_encours       : STD_LOGIC;                     -- Indique qu'une réception est en cours

   SIGNAL ser_rdy          : STD_LOGIC;                     -- Le sérialisateur est prêt à traiter un nouveau car

   SIGNAL tx_ser           : STD_LOGIC;                     -- Sortie du sérialisateur

   SIGNAL sel_ser          : STD_LOGIC;                     -- Sélection de la source série pour le Tx (recopie ou sérialisateur)

   SIGNAL sel_par          : STD_LOGIC;                     -- Sélection de la source parallèle pour le sérialisateur (FIFO de copy ou transmission)

   SIGNAL datatx_mux_c     : STD_LOGIC_VECTOR(7 downto 0);  -- Source parallèle pour le sérialisateur (FIFO de copy ou transmission)

   SIGNAL fifocopy_dout    : STD_LOGIC_VECTOR(7 downto 0);  -- Donnée en sortie de la FIFO de recopie

   SIGNAL start_ser_c      : STD_LOGIC;                     -- Déclenche la sérialisation du mot présent sur datatx_mux_c

   SIGNAL cop_read_c       : STD_LOGIC;                     -- Lit un car dans la FIFO de recopie

   SIGNAL tx_read_c        : STD_LOGIC;                     -- Lit un car dans la mémoire de transmission

   SIGNAL cop_empty        : STD_LOGIC;                     -- FIFO de recopie vide

   SIGNAL cop_clr          : STD_LOGIC;                     -- Purge de la FIFO de recopie

   SIGNAL req_cop_c        : STD_LOGIC;                     -- Indique qu'il y'a ou qu'il va y'avoir un caractère dans la FIFO de recopie

   SIGNAL tempo            : STD_LOGIC_VECTOR(nbbit_div-1 downto 0); -- Tempo de 1 bit

   -- Machine d'état de gestion du module

   TYPE switch_state IS (idle_st, txreq_st, wait1bit_st, txproc_st, copproc_st);

   SIGNAL fsm_switch       : switch_state;

   -- Composant de serialisation

   COMPONENT serial_tx

        GENERIC (

      nbbit_div : INTEGER := 10);

   PORT(

                clk_sys     : IN std_logic;

                rst_n       : IN std_logic;

                tc_divclk   : IN std_logic_vector(nbbit_div-1 downto 0);

                start_ser   : IN std_logic;

                tx_dat      : IN std_logic_vector(7 downto 0);

                tx          : OUT std_logic;

                ser_rdy     : OUT std_logic

                );

        END COMPONENT;

   -- Composant de déserialisation

        COMPONENT serial_rx

        GENERIC (

      nbbit_div : INTEGER := 10);

        PORT(

                clk_sys     : IN std_logic;

                rst_n       : IN std_logic;

      baud_lock   : IN  STD_LOGIC;

                tc_divclk   : IN std_logic_vector(nbbit_div-1 downto 0);

                rx          : IN std_logic;

                tx          : OUT std_logic;

      busy        : OUT STD_LOGIC;

                val         : OUT std_logic;

                rx_dat      : OUT std_logic_vector(7 downto 0)

                );

        END COMPONENT;

   -- FIFO de stockage des données reçues qui ne peuvent pas être recopiées

   -- La FIFO est en FWFT

   COMPONENT fifo_copy

   PORT (

      clk      : IN STD_LOGIC;

      srst     : IN STD_LOGIC;

      din      : IN STD_LOGIC_VECTOR(7 DOWNTO 0);

      wr_en    : IN STD_LOGIC;

      rd_en    : IN STD_LOGIC;

      dout     : OUT STD_LOGIC_VECTOR(7 DOWNTO 0);

      full     : OUT STD_LOGIC;

      overflow : OUT STD_LOGIC;

      empty    : OUT STD_LOGIC

      );

   END COMPONENT;

BEGIN

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

   -- Déserialisateur des données reçues sur rx 

   -- et remise en forme (retaillage des durée de bit) pour la recopie

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

   inst_serial_rx: serial_rx

   GENERIC MAP (

      nbbit_div => nbbit_div)

   PORT MAP(

                clk_sys => clk_sys,

                rst_n => rst_n,

      baud_lock => baud_lock,

                tc_divclk => tc_divclk,

                tx => tx_copy,

                rx => rx,

      busy => rx_encours,

                val => rx_wr_buf,

                rx_dat => data_deser

        );

   rx_dat <= data_deser;

   rx_val <= rx_wr_buf;

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

   -- Sérialise sur 10 bits une donnée 8 bits en entrée 

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

   inst_serial_tx: serial_tx

   GENERIC MAP (

      nbbit_div => nbbit_div)

   PORT MAP(

                clk_sys => clk_sys,

                rst_n => rst_n,

                tc_divclk => tc_divclk,

                tx => tx_ser,

                ser_rdy => ser_rdy,

                start_ser => start_ser_c,

                tx_dat => datatx_mux_c

        );

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

   -- Machine d'état de gestion de la source de tx

   --   Soit on recopie le rx

   --   Soit on émet des données reçues et stockées dans la FIFO rx

   --   Soit on émet une trame (FIFO externe au module)

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

   -- Indique qu'il y'a des données (cop_empty) ou qu'il va y'en avoir (rx_encours et rx_wr_buf et

   -- copy_ena) dans la FIFO de recopie

   req_cop_c <= NOT(cop_empty) OR ((rx_encours OR rx_wr_buf) AND copy_ena);

   man_fsm : PROCESS(clk_sys, rst_n)

   BEGIN

      IF (rst_n = '0') THEN

         fsm_switch <= idle_st;

         sel_ser <= '0';

         sel_par <= '1';

         cop_clr <= '1';

         tempo   <= (OTHERS => '0');

      ELSIF (clk_sys'EVENT and clk_sys = '1') THEN

         CASE fsm_switch IS

            WHEN idle_st =>

            -- Dans cet état, la FIO Tx et la FIFO copy sont forcément vides

                              IF (rx_encours = '0') THEN -- Le nouvel état de copy_ena n'est pris en compte que sur une frontière octet

                  sel_ser <= copy_ena;    -- Si la copie n'est pas autorisée, tx est de base sur le sérialisateur

               END IF;

               sel_par <= '1';

               cop_clr <= '1';         -- Par défaut, la FIFO de recopie doit être vide

               IF (tx_empty = '0') THEN

               -- S'il y'a des données à transmettre dans la FIFO externe

                  fsm_switch <= txreq_st;

               END IF;

            WHEN txreq_st =>

            -- Etat d'attente que les conditions soient favorables pour changer la source du tx

               IF ((sw_ena = '1' AND rx_encours = '0') OR

                    (copy_ena = '0')) THEN

               -- Si la recopie est interdite, on change quand on veut

               -- Sinon, il faut attendre d'être entre 2 trames (sw_ena) et qu'on est pas déjà en train de recopier le car suivant

                  sel_ser <= '0';            -- Le tx est sur le sérialisateur

                  sel_par <= '0';            -- Les données du sérialisateur viennent de la FIFO externe

                  cop_clr <= not(copy_ena);  -- Si la recopie est interdite on purge la FIFO de recopie

                  tempo   <= (OTHERS => '0');

                  fsm_switch <= wait1bit_st;

               END IF;

            WHEN wait1bit_st =>

            -- Etat d'attente de 1 bit pour assurer que le STOP bit recopié fait au moins un bit

               IF (tempo = tc_divclk) THEN

                  fsm_switch <= txproc_st;

               ELSE

                  tempo <= tempo + 1;

               END IF;

            WHEN txproc_st =>

            -- Etat d'émission des données de la FIFO externe

               IF ((tx_empty = '1') AND (req_cop_c = '1')) THEN

               -- S'il n'y a plus rien à émettre dans la FIFO externe et qu'il y'a des données dans la FIFO de recopie

                  sel_ser <= '0';            -- Le tx est sur le sérialisateur

                  sel_par <= '1';            -- Les données du sérialisateur viennent de la FIFO de recopie

                  cop_clr <= not(copy_ena);

                  fsm_switch <= copproc_st;

               ELSIF ((tx_empty = '1') AND (ser_rdy = '1') AND (req_cop_c = '0')) THEN

               -- Si n'y a plus rien à émettre dans aucune FIFO et que l'émission du dernier car est finie

                  sel_ser <= copy_ena;       -- Le tx est branché sur le rx si la recopie est autorisée

                  sel_par <= '1';

                  cop_clr <= '1';

                  fsm_switch <= idle_st;

               END IF;

            WHEN copproc_st =>

            -- Etat d'émission des données de la FIFO de recopie

               IF ((tx_empty = '0') AND (req_cop_c = '0')) THEN

               -- S'il n'y a plus rien à émettre dans la FIFO de recopie et qu'il y'a des données dans la FIFO externe

                  sel_ser <= '0';            -- Le tx est sur le sérialisateur

                  sel_par <= '0';            -- Les données du sérialisateur viennent de la FIFO externe

                  cop_clr <= not(copy_ena);

                  fsm_switch <= txproc_st;

               ELSIF ((tx_empty = '1') AND (ser_rdy = '1') AND (req_cop_c = '0') AND

                      (sw_ena = '1' OR copy_ena = '0')) THEN

               -- Si n'y a plus rien à émettre dans aucune FIFO et que l'émission du dernier car est finie

               -- et que soit on est pas au milieu d'une trame (sw_ena = 1) ou bien que la copy n'est pas 

               -- autorisé (dans ce cas on peut switcher quand on veut)

                  sel_ser <= copy_ena;       -- Le tx est branché sur le rx si la recopie est autorisée

                  sel_par <= '1';

                  cop_clr <= '1';

                  fsm_switch <= idle_st;

               END IF;

            WHEN OTHERS =>

               fsm_switch <= idle_st;

         END CASE;

      END IF;

   END PROCESS;

   -- On lit un mot dans la FIFO de recopie chaque fois que le sérialisateur est prêt et qu'on est dans le bon état

   cop_read_c <= ser_rdy AND NOT(cop_empty) WHEN (fsm_switch = copproc_st) ELSE '0';

   -- On lit un mot dans la FIFO externe chaque fois que le sérialisateur est prêt et qu'on est dans le bon état

   tx_read_c <= ser_rdy AND NOT(tx_empty) WHEN (fsm_switch = txproc_st) ELSE '0';

   tx_rd <= tx_read_c;

   -- A cahque mot lu dans une des FIFO, on active le sérialisateur

   start_ser_c <= cop_read_c OR tx_read_c;

   -- L'entrée du sérialisateur dépend du signal de sélection

   datatx_mux_c <= tx_dat WHEN (sel_par = '0') ELSE fifocopy_dout;

   -- La sortie tx dépend du signal de sélection. Il n'y a pas de problème de glitch car sel_ser ne 

   -- change qu'entre 2 caractère et donc la ligne est IDLE à ce moment là

   tx <= tx_ser WHEN (sel_ser = '0') ELSE tx_copy;

   inst_fifo_copy : fifo_copy

   PORT MAP (

      clk => clk_sys,

      srst => cop_clr,

      din => data_deser,

      wr_en => rx_wr_buf,

      rd_en => cop_read_c,

      dout => fifocopy_dout,

      full => OPEN,

      overflow => OPEN,

      empty => cop_empty

   );

END rtl;