Subversion Repositories saturn

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

--  TITRE : serial_rx2

--  DESCRIPTION : 

--        Déserialisateur des données reçues sur rx et remet en forme

--        le signal (retaillage des durée de bit) pour la recopie 

--        La durée d'un bit est égale à tc_divclk+1 pulse de clk_sys    

--        

--        On additionne les tc_divclk+1 échantillons de chaque bit

--        Si la somme est > tc_divclk/2, c'est un '1', sinon, c'est un '0'

--  FICHIER :        serial_rx2.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;

ENTITY serial_rx2 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énéral 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

      tx       : OUT  STD_LOGIC;    -- Re transmission série

      rx       : IN STD_LOGIC;      -- Port de réception série

      -- Interface parallèle

      busy     : OUT STD_LOGIC;     -- Indique qu'une réception est en cours

      val      : OUT STD_LOGIC;     -- Indique que rx_dat contient la dernière donnée reçu

      rx_dat   : OUT  STD_LOGIC_VECTOR (7 DOWNTO 0)  -- Donnée reçue (synchrone de val)

      );

END serial_rx2;

ARCHITECTURE rtl of serial_rx2 is

   SIGNAL rx_r             : STD_LOGIC;   -- Délai pour détecter le front descendant

   SIGNAL sumrx            : STD_LOGIC_VECTOR(nbbit_div-1 DOWNTO 0);   -- Pour additionner N échantillons consécutifs

   SIGNAL cptbit_rx        : STD_LOGIC_VECTOR(3 downto 0);  -- Compteur de bits dans un caractère en réception

   SIGNAL divclk_rx        : STD_LOGIC_VECTOR(nbbit_div-1 downto 0);  -- Diviseur d'horloge pour mesurer un bit en réception

   SIGNAL rx_encours       : STD_LOGIC;                     -- Indique qu'un caractère est en cours de réception

   SIGNAL shifter_rx       : STD_LOGIC_VECTOR(7 downto 0);  -- Registre à décalage de désrialisation

   SIGNAL consol_bit       : STD_LOGIC;                     -- Bit consolidé après sur-échantillonnage

BEGIN

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

   -- Détection du front descendant sur rx

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

   front_rx : PROCESS(clk_sys, rst_n)

   BEGIN

      IF (rst_n = '0') THEN

         rx_r <= '1';

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

         rx_r <= rx;

      END IF;

   END PROCESS;

   -- Si on a compté des '1' plus de la moitié du temps, on considère un '1' sinon un '0'

   consol_bit <= '1' WHEN (('0' & sumrx) + rx) > ("00" & tc_divclk(nbbit_div-1 DOWNTO 1)) ELSE '0';

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

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

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

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

   deser_shaper : PROCESS(clk_sys, rst_n)

   BEGIN

      IF (rst_n = '0') THEN

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

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

         rx_encours <= '0';

         tx <= '1';

         val <= '0';

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

         IF (rx_encours = '0') THEN

         -- Si on est pas déjà en train de sérialiser un car

            val <= '0';    -- On s'assure que l'écriture dans la FIFO de réception ne dure qu'un pulse

            IF (rx = '0' and rx_r = '1') THEN

            -- Sur détection du front descendant (le Start bit)

               cptbit_rx <= (OTHERS => '0');    -- On initialise le compteur de bits

               -- on initialise le diviseur d'horloge à la fin du tc 

               -- on rajoute 1 pour compenser le retard de détection du front descendant

               -- Donc on initialise à 0

               divclk_rx <= (others => '0');

               sumrx <= (others => '0');        -- On init la somme des sur-echantillonnages

               rx_encours <= '1';               -- On indique qu'on est en réception

            END IF;

            tx <= '1';                          -- Idle de la ligne Tx

         ELSE

         -- Si on est en train de recevoir un car

            IF (divclk_rx = tc_divclk) THEN

            -- Si on atteind le terminal count (TC) du diviseur d'horloge

            -- On va traiter un bit de plus

               divclk_rx <= (OTHERS => '0');                -- re init du diviseur d'horloge

               sumrx <= (others => '0');                    -- re init de la somme

               cptbit_rx <= cptbit_rx + 1;                  -- Un bit de plus reçu

               shifter_rx <= consol_bit & shifter_rx(7 downto 1);   -- On considère un nouveau bit LSB first

               IF (baud_lock = '0') THEN

               -- Tant que l'algo d'Autobaudrate n'a pas convergé

                  tx <= '1';                                -- On ne recopie rien

               ELSE

                  tx <= consol_bit;                         -- On recopie le bit consolidé

               END IF;

               IF (cptbit_rx = "1000") then                 -- On est en train de recevoir le 9ème bit (Start + 8 data)

                  val <= '1';                               -- On valide la donnée

                  rx_encours <= '0';                        -- On arrête la réception et on va attendre le prochain start

               ELSIF (cptbit_rx = "0000") AND (consol_bit = '1') THEN

               -- Si on est au premier bit et que c'est pas un '0' (bit de START)

                  rx_encours <= '0';                        -- On arrête la réception

               END IF;

            ELSE

               divclk_rx <= divclk_rx + 1;         -- En cours de réception on mesure la durée d'un bit

               sumrx <= sumrx + rx;                -- On somme les sur-échantillonnages

               val <= '0';                         -- On s'assure que le signal dure 1 pulse

            END IF;

         END IF;

      END IF;

   END PROCESS;

   rx_dat <= shifter_rx;         -- La data reçue correspond au registre à décalage lorsque val = '1'

   busy <= rx_encours;

END rtl;