Subversion Repositories uart_block

--! Data receiver
--! http://www.fpga4fun.com/SerialInterface.html
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
 
--! Use CPU Definitions package
use work.pkgDefinitions.all;
 
entity serial_receiver is
    Port ( 
			  rst : in STD_LOGIC;
			  baudClk : in  STD_LOGIC;
			  baudOverSampleClk : in  STD_LOGIC;
           serial_in : in  STD_LOGIC;
           data_ready : out  STD_LOGIC;
           data_byte : out  STD_LOGIC_VECTOR ((nBits-1) downto 0));
end serial_receiver;
 
architecture Behavioral of serial_receiver is
signal current_s,next_s: rxStates; 
signal filterRx : rxFilterStates; 
signal syncDetected : std_logic;
 
begin
	-- First we need to oversample(4x baud rate) out serial channel to syncronize with the PC
	process (rst, baudOverSampleClk, serial_in, current_s)
	begin
		if rst = '1' then
			filterRx <= s0;			
			syncDetected <= '0';
		elsif rising_edge(baudOverSampleClk) then
			case filterRx is
				when s0 =>
					syncDetected <= '0';
					-- Spike down detected, verify if it's valid for at least 3 cycles
					-- We shoose a little bit on the end to enforce the baud clk to sample 
					-- the data at the right time... iE we're going to start sampling when
					-- the stop has been detected and we already for some of the first bit
					-- signal
					if serial_in = '0' then
						filterRx <= s1;						
					else
						filterRx <= s0;						
					end if;
 
				when s1 =>
					syncDetected <= '0';
					if serial_in = '0' then
						filterRx <= s2;
						syncDetected <= '0';
					else
						filterRx <= s0;
					end if;
 
				when s2 =>
					syncDetected <= '0';
					if serial_in = '0' then
						filterRx <= s3;
						syncDetected <= '0';
					else
						filterRx <= s0;
					end if;
 
				when s3 =>					
					-- Real Beginning of start bit detected 
					if serial_in = '0' then
						filterRx <= s3;
						syncDetected <= '1';					
					end if; 
 
					-- Reset out sync detector when finished to receive a byte
					if current_s = rx_stop then
						filterRx <= s0;						
					end if;
			end case;
		end if;
	end process;
 
	-- Next state logic for rx Receiver (On this case our reset is the syncDetected signal
	process (syncDetected, baudClk, serial_in) 
	begin
		if syncDetected = '0' then
			current_s <= rx_idle;			
		elsif rising_edge(baudClk) then
			current_s <= next_s;
		end if;
	end process;
 
	-- Process to handle the serial receive
	process (current_s, serial_in) 
	variable byteReceived : STD_LOGIC_VECTOR ((nBits-1) downto 0);
	begin
		case current_s is
			when rx_idle =>
				data_ready <= '0';
				byteReceived := (others => 'Z');
				next_s <=  bit0;
 
			when bit0 =>
				data_ready <= '0';
				byteReceived(0) := serial_in;
				next_s <=  bit1;
 
			when bit1 =>
				data_ready <= '0';
				byteReceived(1) := serial_in;
				next_s <=  bit2;
 
			when bit2 =>
				data_ready <= '0';
				byteReceived(2) := serial_in;
				next_s <=  bit3;
 
			when bit3 =>
				data_ready <= '0';
				byteReceived(3) := serial_in;
				next_s <=  bit4;
 
			when bit4 =>
				data_ready <= '0';
				byteReceived(4) := serial_in;
				next_s <=  bit5;
 
			when bit5 =>
				data_ready <= '0';
				byteReceived(5) := serial_in;
				next_s <=  bit6;
 
			when bit6 =>
				data_ready <= '0';
				byteReceived(6) := serial_in;
				next_s <=  bit7;
 
			when bit7 =>
				data_ready <= '0';
				byteReceived(7) := serial_in;
				data_byte <= byteReceived;
				next_s <=  rx_stop;
 
			when rx_stop =>
				data_ready <= '1';								
				next_s <=  rx_stop;			
		end case; 
 
	end process;
 
end Behavioral;