Subversion Repositories saturn

--============================================================================= 
--  TITRE : serial_rx
--  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 3 échantillons consécutifs de part et d'autre
--        du milieu du bit à échantilloner. Si la somme est >=2 => bit à 1
--        sinon bit à 0	
--  FICHIER :        serial_rx.vhd 
--=============================================================================
--  CREATION 
--  DATE	AUTEUR	PROJET	REVISION 
--  29/02/2012	DRA	CONCERTO	V1.0 
--  14/01/2013 DRA   Modificiation pour échantillonner 3 fois et rendre plus robuste
--                   en environnement bruité
--=============================================================================
--  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 serial_rx 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
      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;     -- 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_rx;
 
ARCHITECTURE rtl of serial_rx is
   SIGNAL rx_r             : STD_LOGIC_VECTOR(1 DOWNTO 0);   -- Délai pour détecter le front descendant
   SIGNAL sumrx            : STD_LOGIC_VECTOR(1 DOWNTO 0);   -- Pour additionner 3 échantillons consécutifs
   SIGNAL front_des_rx_c   : STD_LOGIC;   -- Un pulse de clk_sys sur front descendant de rx
 
   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 réception
 
BEGIN
   --------------------------------------------
   -- Détection du front descendant sur rx
   --------------------------------------------
   -- rx_r(1) & rx_r(0) & rx représente un registre à décalage du flux rx
   front_rx : PROCESS(clk_sys, rst_n)
   BEGIN
      IF (rst_n = '0') THEN
         rx_r <= (OTHERS => '1');
      ELSIF (clk_sys'EVENT and clk_sys = '1') THEN
         rx_r <= rx_r(0) & rx;
      END IF;
   END PROCESS;
   front_des_rx_c <= NOT(rx_r(0)) AND rx_r(1);  -- Détection du front descendant
   sumrx <= CONV_STD_LOGIC_VECTOR(rx_r(0), 2) + CONV_STD_LOGIC_VECTOR(rx_r(1), 2) +
            CONV_STD_LOGIC_VECTOR(rx, 2); -- On compte les 3 échantillons consécutif
 
   --------------------------------------------
   -- 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 (front_des_rx_c = '1') THEN
            -- Sur détection du front descendant (le Start bit)
               cptbit_rx <= (OTHERS => '0');
               -- on initialise le diviseur d'horloge à la motié de tc pour échantilloner au milieu du bit
               -- on rajoute 2 pour compenser le retard de détection du front descendant
               divclk_rx <= ('0' & tc_divclk(tc_divclk'LEFT downto 1))+2;
               rx_encours <= '1';
            END IF;
            tx <= '1';
         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
               divclk_rx <= (OTHERS => '0');
               cptbit_rx <= cptbit_rx + 1;                  -- Un bit de plus reçu
               -- Si la somme des 3 echantillons est >= 2 (i.e. le MSB est à 1) -> le bit est à 1
               shifter_rx <= sumrx(1) & shifter_rx(7 downto 1);   -- On garde le 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 <= sumrx(1);                           -- On échantillonne rx pour la recopie
               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
               ELSIF (cptbit_rx = "1001") then              -- Au 10 ème bit reçu
               -- Il faut attendre le 10ème bit pour garantir qu'en recopie, le 8ème bit utile (i.e. le 9ème) dure le bon temps
                  rx_encours <= '0';                        -- On arrête la réception
                  val <= '0';                               -- On s'assure que le signal dure 1 pulse
               END IF;
            ELSE
               divclk_rx <= divclk_rx + 1;         -- En cours de réception on mesure la durée d'un bit
               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;