Subversion Repositories manchesteruart

--*************************************************************************

--*                                                                       *

--* Copyright (C) 2014 William B Hunter - LGPL                            *

--*                                                                       *

--* This source file may be used and distributed without                  *

--* restriction provided that this copyright statement is not             *

--* removed from the file and that any derivative work contains           *

--* the original copyright notice and the associated disclaimer.          *

--*                                                                       *

--* This source file is free software; you can redistribute it            *

--* and/or modify it under the terms of the GNU Lesser General            *

--* Public License as published by the Free Software Foundation;          *

--* either version 2.1 of the License, or (at your option) any            *

--* later version.                                                        *

--*                                                                       *

--* This source is distributed in the hope that it will be                *

--* useful, but WITHout ANY WARRANTY; without even the implied            *

--* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR               *

--* PURPOSE.  See the GNU Lesser General Public License for more          *

--* details.                                                              *

--*                                                                       *

--* You should have received a copy of the GNU Lesser General             *

--* Public License along with this source; if not, download it            *

--* from http://www.opencores.org/lgpl.shtml                              *

--*                                                                       *

--*************************************************************************

--

-- Engineer: William B Hunter

-- Create Date: 08/08/2014

-- Project: Manchester Uart

-- File: encode.vhd

-- Description: This encoder sends out short bursts of 16 bit data words encoded with as manchester data.

--   Because this is not a stream encoder, it has no sync pattern or packet alignment typical of manchester encoders.

--   It therefor uses start and stop bits much like a UART. Both the start and stop bits are always ones. The idle 

--   state is always high, and the ones are a low to high transition in the middle of the bit period, and a zero is a 

--   high to low transition in the middle of the bit period. A high for 3 bit periods is a reset/resync.

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

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

entity encode is

  Port (

    clk16x : in STD_LOGIC;

    srst : in STD_LOGIC;

    tx_data : in STD_LOGIC_VECTOR (15 downto 0);

    tx_stb : in STD_LOGIC;

    txd : out STD_LOGIC;

    or_err : out STD_LOGIC;

    tx_idle : out STD_LOGIC

  );

end encode;

architecture rtl of encode is

  signal shifter : std_logic_vector(15 downto 0);

  signal tick_cnt : integer range 0 to 15 := 0;

  signal bit_cnt : integer range 0 to 15 := 0;

  signal txd_int : std_logic := '1';

  signal err_int : std_logic := '0';

  type txr_state_type is (SM_IDLE, SM_START, SM_SEND, SM_STOP);

  signal txr_state : txr_state_type := SM_IDLE;

begin

  p_transmitter: process(clk16x)

  begin

    if rising_edge(clk16x) then

      if srst = '1' then

         txr_state <= SM_IDLE;

         tick_cnt <= 0;

         bit_cnt <= 0;

      else

        case txr_state is

          --wait for a tx strobe to start a transmission

          when SM_IDLE =>

            tick_cnt <=  0;

            bit_cnt <=  0;

            if tx_stb = '1' then

              txr_state <= SM_START;

              shifter <= tx_data;

            end if;

          --the start is a one, which is 8 ticks low followed by 8 ticks high

          when SM_START =>

            if tick_cnt < 8 then

              txd_int <= '0';

              tick_cnt <= tick_cnt + 1;

            elsif  tick_cnt < 15 then

              txd_int <= '1';

              tick_cnt <= tick_cnt + 1;

            else

              txd_int <= '1';

              tick_cnt <= 0;

              bit_cnt <= 0;

              txr_state <= SM_SEND;

            end if;

          when SM_SEND =>

            --for each bit, a one is 8 ticks low followed by 8 ticks high, and a zero is 8 ticks high followed by 8 ticks low

            if tick_cnt < 8 then

              txd_int <= not shifter(15);

              tick_cnt <= tick_cnt + 1;

            elsif  tick_cnt < 15 then

              txd_int <= shifter(15);

              tick_cnt <= tick_cnt + 1;

            else

              txd_int <= shifter(15);

              tick_cnt <= 0;

              shifter <= shifter(14 downto 0) & '1';

              --at end of this bit check to see if we have more bits or if it's time for the stop bit

              if bit_cnt < 15 then

                bit_cnt <= bit_cnt + 1;

              else

                bit_cnt <=0;

                txr_state <= SM_STOP;

              end if;

            end if;

          when SM_STOP =>

            --stop bits are always ones, which are 8 ticks low followed by 8 ticks high

            if tick_cnt < 8 then

              txd_int <= '0';

              tick_cnt <= tick_cnt + 1;

            elsif  tick_cnt < 15 then

              txd_int <= '1';

              tick_cnt <= tick_cnt + 1;

            else

              txd_int <= '1';

              tick_cnt <= 0;

              txr_state <= SM_IDLE;

            end if;

          --we should never get to the iothers state.

          when others =>

            tick_cnt <= 4;

            bit_cnt <= 0;

            txr_state <= SM_IDLE;

        end case;

      end if; --srst

    end if;  --clk16x

  end process;

  --An overrun error occurs when the transmit strobe is triggered and we are not finished with the previous state.

  -- The error is cleared when the transmitter goes back to idle

  p_or_err: process(clk16x)

  begin

    if rising_edge(clk16x) then

      if srst = '1' then

        err_int <='0';

      elsif tx_stb = '1' and txr_state /= SM_IDLE then

        err_int <= '1';

      elsif txr_state = SM_IDLE then

        err_int <= '0';

      end if;

    end if;

  end process;

  txd <= txd_int;

  or_err <= err_int;

  tx_idle <= '1' when txr_state = SM_IDLE else '0';

end rtl;