Subversion Repositories manchesterwireless

-----------------------------------------------------------------------------
--	Copyright (C) 2009 Sam Green
--
-- This code 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 code 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.
--
-- Decodes manchester encoded data
-- 
-----------------------------------------------------------------------------
 
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
 
use work.globals.all;
 
entity decode is
 
  port (
    clk_i     : in  std_logic;
    rst_i     : in  std_logic;
    nd_i      : in  std_logic;
    encoded_i : in  std_logic_vector(3 downto 0);
    decoded_o : out std_logic_vector(WORD_LENGTH-1 downto 0);
    nd_o      : out std_logic
  );
 
end;
 
architecture behavioral of decode is
 
  type state_type is (reset, pause, one_0, one_1, two_0, two_1);
  signal state, next_state : state_type;
 
  -- *2 comes from each bit in the word is manchester encoded.
  -- +2 comes from protocol transmitting -------_ to initiate
  -- a transmission; +1 from the ------- and +1 from the _
  constant STRING_LENGTH : integer := WORD_LENGTH*2+2;
  -- the range -1 comes from the state machine which will
  -- update index_n while the protocol finishes transmission
  signal index, index_n   : integer range -1 to STRING_LENGTH-1;
  signal str_buffer : std_logic_vector(STRING_LENGTH-3 downto 0);
  signal insert : std_logic_vector(1 downto 0);
  signal nd_o_buff : std_logic;
begin
 
  controller : process(nd_i, rst_i)
  begin
    if rst_i = '1' then
 
      index <= STRING_LENGTH-1;
      state <= reset;
      str_buffer <= (others => '0');
      nd_o_buff <= '0';
 
    elsif rising_edge(nd_i) then
      -- index is initalized at STRING_LENGTH-1
      -- the protocol initializes with two bits
      -- which are trashed, hence we wait until the first
      -- trashed bits have been passed
      -- 
      -- processing stops when the WORD_LENGTH bits have arrived (nd_o_buff = '1')
      if STRING_LENGTH - index >= 3 and nd_o_buff = '0' then
        -- Adding a single/double zero/one?
        if index - index_n = 2 then -- update 2
          str_buffer(index downto index-1) <= insert; -- insert double
        else -- update 1
          str_buffer(index) <= insert(1); -- insert single
        end if;
      end if;
 
      -- finished?
      if index = 0 then
        nd_o_buff <= '1';
        state <= reset;
      else
        index <= index_n;
        state <= next_state;
      end if;
    end if;
  end process;
 
  output_decode: process(state, index, nd_i)
  begin
    case state is  
 
      when one_1 =>
        insert <= "10";
        if (index > -1) then
          index_n <= index - 1;
        else
          index_n <= 0; -- error
        end if;
 
      when one_0 =>
        insert <= "00";
        if (index > -1) then
          index_n <= index - 1;
        else
          index_n <= 0; -- error
        end if;
 
      when two_1 =>
        insert <= "11";
 
        if (index > 0) then
          index_n <= index - 2;
        else
          index_n <= 0; -- error
        end if;        
 
      when two_0 =>
        insert <= "00";
 
        if (index > 0) then
          index_n <= index - 2; 
        else
          index_n <= 0; -- error
        end if;        
 
      when others =>
        insert <= "00";
        index_n <= index;
 
    end case;
  end process;
 
  -- For encoded_i:
  --
  -- 0000 = null
  -- 0001 = single one
  -- 0010 = double one
  -- 0100 = single zero
  -- 1000 = double zero  
 
  next_state_decode: process(state, encoded_i)
  begin
    next_state <= state;
    case(state) is
      when reset =>
 
        next_state <= pause;
 
      when pause =>
 
        next_state <= one_1; -- only if we came from reset. The long
        -- initialization string of ones --------- is considered a 
        -- single one.
 
      when one_0 =>
 
        case(encoded_i) is
          when "0100" => next_state <= one_0; -- remain here until change
          when "0001" => next_state <= one_1; -- because of the protocol, a 
          -- single 0 can only be followed by a single one.        
          when others => next_state <= reset; -- only on error
        end case;
 
      when one_1 =>
 
        case(encoded_i) is
          when "0001" => next_state <= one_1; -- remain here until change                                              
          when "0100" => next_state <= one_0;
          when "1000" => next_state <= two_0;
          when others => next_state <= reset; -- only on error
        end case;
 
      when two_0 =>
 
        case(encoded_i) is
          when "1000" => next_state <= two_0; -- remain here until change
          when "0001" => next_state <= one_1;
          when "0010" => next_state <= two_1;
          when others => next_state <= reset; -- only on error
        end case;
 
      when two_1 =>
 
        case(encoded_i) is
          when "0010" => next_state <= two_1; -- remain here until change
          when "0100" => next_state <= one_0;
          when "1000" => next_state <= two_0;
          when others => next_state <= reset; -- only on error
        end case;
 
      when others =>
        next_state <= reset;  -- only on error
 
    end case;
  end process;
 
  -- decoded!
  rearrange : process(clk_i, rst_i)
  begin
    if rst_i = '1' then
      decoded_o <= (others => '0');
      nd_o <= '0';
    elsif rising_edge(clk_i) then
      if nd_o_buff = '1' then
        for i in 0 to WORD_LENGTH-1 loop
          -- the bits are ror when transmitted, thus the left-most
          -- bit in decoded_buffer (excluding the xmitter protocol bits)
          -- describe the right-most bit in the original data word. 
          -- The following line of code turns 01 to 1 and 10 to 0 and it converts
          -- the big endian decoded_buffer to little endian decoded_o.        
          if str_buffer(str_buffer'left-2*i downto str_buffer'left-1-2*i) = "01" then
            decoded_o(i) <= '1';
          else
            decoded_o(i) <= '0';
          end if;
        end loop;
 
        nd_o <= '1';
      end if;
    end if;
  end process;
 
end;