Subversion Repositories auto_baud

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

-- Package of auto_baud components

--

-- Contains the following components:

--

--   auto_baud_with_tracking

--   auto_baud_with_tracking_slv

--

-- the version with the suffix _slv attached to the name provides

-- IO busses of the "std_logic_vector" type instead of "unsigned."

-- In all other ways, these components are identical.

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

package auto_baud_pack is

  component auto_baud_with_tracking

    generic (

      CLOCK_FACTOR    : natural; -- Output is this factor times the baud rate

      FPGA_CLKRATE    : integer; -- FPGA system clock rate

      MIN_BAUDRATE    : integer; -- Minimum expected incoming Baud rate

      DELTA_THRESHOLD : integer  -- Max. number of sys_clks difference allowed between

                                 -- "half_measurement" and "measurement"

    );

    port (

      sys_rst_n    : in  std_logic;

      sys_clk      : in  std_logic;

      -- rate and parity

      rx_parity_i  : in  unsigned(1 downto 0); -- 0=none, 1=even, 2=odd

      -- serial input

      rx_stream_i  : in  std_logic;

      -- Output

      baud_lock_o  : out std_logic;

      baud_clk_o   : out std_logic

    );

  end component;

  component auto_baud_with_tracking_slv

    generic (

      CLOCK_FACTOR    : natural; -- Output is this factor times the baud rate

      FPGA_CLKRATE    : integer; -- FPGA system clock rate

      MIN_BAUDRATE    : integer; -- Minimum expected incoming Baud rate

      DELTA_THRESHOLD : integer  -- Max. number of sys_clks difference allowed between

                                 -- "half_measurement" and "measurement"

    );

    port (

      sys_rst_n    : in  std_logic;

      sys_clk      : in  std_logic;

      -- rate and parity

      rx_parity_i  : in  std_logic_vector(1 downto 0); -- 0=none, 1=even, 2=odd

      -- serial input

      rx_stream_i  : in  std_logic;

      -- Output

      baud_lock_o  : out std_logic;

      baud_clk_o   : out std_logic

    );

  end component;

end auto_baud_pack;

package body auto_baud_pack is

end auto_baud_pack;

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

-- Auto Baud with tracking core

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

--

-- Author: John Clayton

-- Date  : Aug. 20, 2002 Began project

-- Update: Sep.  5, 2002 copied this file from "autobaud.v"

--                       Added tracking functions, and debugged them.

-- Update: Sep. 13, 2002 Added test data.  Module complete, it works well.

-- Update: Nov. 20, 2009 Began translation into VHDL

--

-- Description

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

-- This is a state-machine driven core that measures transition intervals

-- in a particular character arriving via rs232 transmission (i.e. PC serial 

-- port.)  Measurements of time intervals between transitions in the received

-- character are then used to generate a baud rate clock for use in serial

-- communications back and forth with the device that originally transmitted

-- the measured character.  The clock which is generated is in reality a

-- clock enable pulse, one single clock wide, occurring at a rate suitable

-- for use in serial communications.  (This means that it will be generated

-- at 4x or 8x or 16x the actual measured baud rate of the received character.

-- The multiplication factor is called "CLOCK_FACTOR" and is a settable

-- parameter within this module.  The parameter "CLOCK_FACTOR" need not

-- be a power of two, but it should be a number between 2 and 16 inclusive.)

--

-- The particular character which is targeted for measurement and verification

-- in this module is: carriage return (CR) = 0x0d = 13.

-- This particular character was chosen because it is frequently used at the

-- end of a command line, as entered at a keyboard by a human user interacting

-- with a command interpreter.  It is anticipated that the user would press

-- the "enter" key once upon initializing communications with the electronic

-- device, and the resulting carriage return character would be used for 

-- determining BAUD rate, thus allowing the device to respond at the correct

-- rate, and to carry on further communications.  The electronic device using

-- this "auto_baud" module adjusts its baud rate to match the baud rate of

-- the received data.  This works for all baud rates, within certain limits,

-- and for all system clock rates, within certain limits.

--

-- Received serially, and with no parity bit, the carriage return appears as

-- the following waveform:

-- ________    __    ____          _______________

--         |__|d0|__|d2d3|________|stop

--        start   d1      d4d5d6d7

--

-- The waveform is shown with an identical "high" time and "low" time for

-- each bit.  However, actual measurements taken using a logic analyzer

-- on characters received from a PC show that the times are not equal.

-- The "high" times turned out shorter, and the "low" times longer...

-- Therefore, this module attempts to average out this discrepancy by

-- measuring one low time and one high time.

--

-- Since the transition measurements must unavoidably contain small amounts

-- of error, the measurements are made during the beginning 2 bits of

-- the received character, (that is, start bit and data bit zero).

-- Then the measurement is immediately transformed into a baud rate clock,

-- used to verify correct reception of the remaining 8 bits of the character.

-- If the entire character is not received correctly using the generated

-- baud rate, then the measurement is scrapped, and the unit goes into an

-- idle scanning mode waiting for another character to test.

--

-- This effectively filters out characters that the unit is not interested in

-- receiving (anything that is not a carriage return.)  There is a slight

-- possibility that a group of other characters could appear by random

-- chance in a configuration that resembles a carriage return closely enough

-- that the unit might accept the measurement and produce a baud clock too

-- low.  But the probability of this happening is remote enough that the

-- unit is considered highly "robust" in normal use, especially when used

-- for command entry by humans.  It would take a very clever user indeed, to

-- enter the correct series of characters with the correct intercharacter

-- timing needed to possibly "fool" the unit!

--

-- (Also, the baud rate produced falls within certain limits imposed by

--  the hardware of the unit, which prevents the auto_baud unit from mistaking

--  a series of short glitches on the serial data line for a really

--  fast CR character.)

--

-- This method of operation implies that each carriage return character

-- received will produce a correctly generated baud rate clock.  Therefore,

-- each and every carriage return actually causes a new baud rate clock to

-- be produced.  However, updates occur smoothly, and there should be no

-- apparent effect as an old BAUD clock is stopped and a new one started.

-- The transition is done smoothly.

--

-- For users who desire a single measurement at the beginning of a session

-- to produce a steady baud clock during the entire session, there is a

-- slightly smaller module called "auto_baud.v" which performs a single

-- measurement, but which requires a reset pulse in order to begin measuring

-- for a new BAUD rate.

--

-- NOTES:

-- - This module uses a counter to divide down the sys_clk signal to produce the

--   baud_clk_o signal.  Since the frequency of baud_clk_o is nominally

--   CLOCK_FACTOR * rx_baud_rate, where "rx_baud_rate" is the baud rate

--   of the received character, then the higher you make CLOCK_FACTOR, the

--   higher the generated baud_clk_o signal frequency, and hence the lower the

--   resolution of the divider.  Therefore, using a lower value for the

--   CLOCK_FACTOR will allow you to use a lower sys_clk with this module.

-- - The lower the minimum baud rate setting, the larger the counters will be.

--   This is so that the counters can accomodate the large count values needed

--   to divide the system clock into the low Baud rate output.

--

-- - If the percentage error for your highest desired baud rate is greater

--   than a few percent, you might want to use a higher Fsys_clk or else a 

--   lower CLOCK_FACTOR.

--

-- Note: Simply changing the template bits does not reconfigure the

--       module to look for a different character (because a new measurement

--       window might have to be defined for a different character...)

--       The template bits are the exact bits used during verify, against

--       which the incoming character is checked.

--       The LSB of the character is not used for verification, since it is

--       actually used in the measurement.

--

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

use IEEE.MATH_REAL.ALL;

entity auto_baud_with_tracking is

    generic (

      CLOCK_FACTOR    : natural := 16;        -- Output is this factor times the baud rate

      FPGA_CLKRATE    : integer := 25000000;  -- FPGA system clock rate

      MIN_BAUDRATE    : integer := 57600;     -- Minimum expected incoming Baud rate

      DELTA_THRESHOLD : integer := 6          -- Max. number of sys_clks difference allowed between

                                              -- "half_measurement" and "measurement"

    );

    port (

      sys_rst_n    : in  std_logic;

      sys_clk      : in  std_logic;

      -- rate and parity

      rx_parity_i  : in  unsigned(1 downto 0); -- 0=none, 1=even, 2=odd

      -- serial input

      rx_stream_i  : in  std_logic;

      -- Output

      baud_lock_o  : out std_logic;

      baud_clk_o   : out std_logic

    );

end auto_baud_with_tracking;

architecture beh of auto_baud_with_tracking is

-- Constants

constant TEMPLATE_BITS    : unsigned(7 downto 0) := "00001101";  -- Carriage return

constant MAIN_COUNT_WIDTH : integer := integer(ceil(log2(real(FPGA_CLKRATE)/real(MIN_BAUDRATE))));  -- Bit Width of timer.

-- Internal signal declarations

  -- State Machine

type FSM_STATE_TYPE is (IDLE, MEASURE_START_BIT, MEASURE_DATA_BIT, VERIFY);

signal fsm_state        : FSM_STATE_TYPE;

signal baud_lock        : std_logic; -- When high, indicates output can operate.

signal char_mismatch    : std_logic; -- Indicates character did not verify

signal baud_count       : unsigned(MAIN_COUNT_WIDTH-1 downto 0); -- BAUD counter register

signal baud_div         : unsigned(MAIN_COUNT_WIDTH-1 downto 0); -- measurement for running

signal measurement      : unsigned(MAIN_COUNT_WIDTH-1 downto 0); -- measurement for verify

signal half_check       : unsigned(MAIN_COUNT_WIDTH-1 downto 0); -- Half of measurement

signal half_measurement : unsigned(MAIN_COUNT_WIDTH-1 downto 0); -- measurement at end of start bit

signal delta            : unsigned(MAIN_COUNT_WIDTH-1 downto 0); -- Difference value

signal target_bits      : unsigned(8 downto 0); -- Character bits to compare

signal target_bit_count : unsigned(3 downto 0); -- Contains count of bits remaining to check

signal parity           : std_logic; -- The "template bit" for checking the received parity bit.

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

-- Functions

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

  function gen_even_parity(in_a : unsigned) return std_logic is

  variable i : natural;

  variable o : std_logic;

  begin

  o := '0'; -- Default value

  for i in 0 to in_a'length-1 loop

    o := o xor in_a(i);

  end loop;

  return(o);

  end;

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

begin

parity <= '1' when (rx_parity_i="00") else

          gen_even_parity(TEMPLATE_BITS) when (rx_parity_i="01") else

          not gen_even_parity(TEMPLATE_BITS) when (rx_parity_i="10") else

          '1';

-- Form a difference between the measurement and twice the "half-measurement"

-- Take the absolute value.

half_check <= '0' & measurement(MAIN_COUNT_WIDTH-1 downto 1);

delta <= (half_check-half_measurement) when (half_check>half_measurement) else

         (half_measurement-half_check);

-- This is state machine.  It checks the status of the rx_stream_i line

-- and coordinates the measurement of the time interval of the first two

-- bits of the received character, which is the "measurement interval."

-- Following the measurement interval, the state machine enters a new

-- phase of bit verification.  If the measured time interval is accurate

-- enough to measure the remaining 8 or 9 bits of the character correctly, then

-- the measurement is accepted, and the baud rate clock is driven onto

-- the baud_clk_o output pin.  Incidentally, the process of verification

-- effectively filters out characters which are not the desired target

-- character for measurement.  In this case, the target character is the

-- carriage return.

fsm_proc: process(sys_clk, sys_rst_n, parity)

begin

  if (sys_rst_n='0') then

    fsm_state        <= IDLE;   -- asynchronous reset

    baud_clk_o       <= '0';

    baud_lock        <= '0';

    char_mismatch    <= '0';

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

    half_measurement <= (others=>'0'); -- The measurement at the end of the start bit

    measurement      <= (others=>'0'); -- The candidate divider value.

    baud_div         <= (others=>'0'); -- The "running" copy of measurement

    target_bits      <= '1' & parity & TEMPLATE_BITS(7 downto 1);

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

  elsif (sys_clk'event and sys_clk='1') then

    -- Handle the baud clock output generation, if we have achieved "baud_lock"

    if (baud_lock='1') then

      if (baud_count + 2*CLOCK_FACTOR > baud_div) then

        baud_count <= to_unsigned(CLOCK_FACTOR,baud_count'length);

--        baud_count <= baud_count + to_unsigned(CLOCK_FACTOR,baud_count'length) - baud_div; 

          -- (Compromised above for simplicity)

          -- (It could have been baud_count+CLOCK_FACTOR-baud_div)

        baud_clk_o <= '1';

      else

        baud_count   <= baud_count + 2*CLOCK_FACTOR;

        baud_clk_o   <= '0';

      end if;

    end if;

    case (fsm_state) is

      when IDLE =>

        char_mismatch    <= '0';

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

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

        target_bits      <= '1' & parity & TEMPLATE_BITS(7 downto 1);

        if (rx_parity_i=0) then

          target_bit_count <= to_unsigned(8,target_bit_count'length);

        else

          target_bit_count <= to_unsigned(9,target_bit_count'length); -- ODD/EVEN parity means extra bit.

        end if;

        if (rx_stream_i = '0') then

          fsm_state <= MEASURE_START_BIT;

        end if;

      when MEASURE_START_BIT =>

        if (rx_stream_i = '1') then

          half_measurement <= measurement;

          fsm_state        <= MEASURE_DATA_BIT;

        else

          measurement <= measurement+1;

        end if;

      when MEASURE_DATA_BIT =>

        -- The duration of the data bit must not be significantly different

        -- than the duration of the start bit...

        measurement <= measurement+1;

        if (rx_stream_i='0') then  -- Look for the end of the least significant data bit.

          if (delta>DELTA_THRESHOLD) then

            fsm_state <= IDLE;

          else

            fsm_state <= VERIFY;

          end if;

        end if;

      when VERIFY =>  -- Wait for verify operations to finish

        if (target_bit_count=0) then -- At the stop bit, check the status

          if (char_mismatch='0') then

            baud_div  <= measurement; -- Store final verified measurement for running

            baud_lock <= '1';

          end if;

          if (rx_stream_i='1') then -- Only return when there is a chance of making a valid new measurement...

            fsm_state <= IDLE; -- Whether successful, or not, return to IDLE ("autotracking" feature.)

          end if;

        else

          if (half_measurement>=measurement) then -- Initial setting leads to near mid-bit sampling.

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

            target_bits <= '0' & target_bits(target_bits'length-1 downto 1);

            target_bit_count <= target_bit_count-1;

            if (target_bits(0)/=rx_stream_i) then

              char_mismatch <= '1';

            end if;

          else

            half_measurement <= half_measurement+2;

          end if;

        end if;

      --when others => 

      --  fsm_state <= IDLE;

    end case;

  end if;

end process;

baud_lock_o <= baud_lock;

end beh;

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

-- ...A wrapper to allow instantiating this module with

-- busses of type "std_logic_vector" for those who need that.

--

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

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

library work;

use work.auto_baud_pack.all;

entity auto_baud_with_tracking_slv is

    generic (

      CLOCK_FACTOR    : natural := 16;        -- Output is this factor times the baud rate

      FPGA_CLKRATE    : integer := 25000000;  -- FPGA system clock rate

      MIN_BAUDRATE    : integer := 57600;     -- Minimum expected incoming Baud rate

      DELTA_THRESHOLD : integer := 6          -- Max. number of sys_clks difference allowed between

                                              -- "half_measurement" and "measurement"

    );

    port (

      sys_rst_n    : in  std_logic;

      sys_clk      : in  std_logic;

      -- rate and parity

      rx_parity_i  : in  std_logic_vector(1 downto 0); -- 0=none, 1=even, 2=odd

      -- serial input

      rx_stream_i  : in  std_logic;

      -- Output

      baud_lock_o  : out std_logic;

      baud_clk_o   : out std_logic

    );

end auto_baud_with_tracking_slv;

architecture beh of auto_baud_with_tracking_slv is

-- Internal signal declarations

signal rx_parity_u : unsigned(1 downto 0); -- The "template bit" for checking the received parity bit.

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

begin

  -- This module generates a serial BAUD clock automatically.

  -- The unit synchronizes on the carriage return character, so the user

  -- only needs to press the "enter" key for serial communications to start

  -- working, no matter what BAUD rate and clk_i frequency are used!

  auto_baud1 : auto_baud_with_tracking

    generic map(

      CLOCK_FACTOR    => CLOCK_FACTOR,   -- Output is this factor times the baud rate

      FPGA_CLKRATE    => FPGA_CLKRATE,   -- FPGA system clock rate

      MIN_BAUDRATE    => MIN_BAUDRATE,   -- Minimum expected incoming Baud rate

      DELTA_THRESHOLD => DELTA_THRESHOLD -- Max. number of sys_clks difference allowed between

                                         -- "half_measurement" and "measurement"

    )

    port map(

      sys_rst_n    => sys_rst_n,

      sys_clk      => sys_clk,

      -- rate and parity

      rx_parity_i  => rx_parity_u, -- 0=none, 1=even, 2=odd

      -- serial input

      rx_stream_i  => rx_stream_i,

      -- Output

      baud_lock_o  => baud_lock_o,

      baud_clk_o   => baud_clk_o

    );

rx_parity_u <= unsigned(rx_parity_i);

end beh;