Solid Fluid - UART VHDL

>>Firmware>Serial Port in VHDL>VHDL & Schematics
Search:
Test Harness Schematic
Transmitter Schematic
library IEEE;
use IEEE.STD_LOGIC_1164.all;
 
package UART is
 
    component UART_Tx is
    port(
        Reset   : in std_logic;
        SampCk  : in std_logic;
        A0      : in std_logic;
        WEn     : in std_logic;
        Data    : in std_logic_vector(8 downto 0);
        SOut    : out std_logic;
        Busy    : out std_logic
        );
    end component;
 
    component UART_Rx is
    port(
        Reset   : in std_logic;
        SampCk  : in std_logic;
        SIn     : in std_logic;
        A0      : in std_logic;
        REn     : in std_logic;
        Data    : inout std_logic_vector(8 downto 0);
        BAv     : out std_logic;
        DAv     : out std_logic
        );
    end component;
 
end package;
 
library IEEE;
use IEEE.STD_LOGIC_1164.all;
use work.UART_TxController.all;
use work.UART_Components.all;
 
entity UART_Tx is
port(
    Reset   : in std_logic;
    SampCk  : in std_logic;
    A0      : in std_logic;
    WEn     : in std_logic;
    Data    : in std_logic_vector(8 downto 0);
    SOut    : out std_logic;
    Busy    : out std_logic
    );
end entity;
 
architecture UART_Tx_A1 of UART_Tx is
 
constant VCC : std_logic := '1';
constant GND : std_logic := '0';
 
-- Controls for the shift register
signal DEn : std_logic;
signal DWr : std_logic;
signal ShiftRegWEn : std_logic;
 
-- Controls for the Baud rate divisor
signal BEn : std_logic;
signal BWr : std_logic;
signal BaudRateRegWEn : std_logic;
 
-- The transmit data path
signal Shift : std_logic;
signal TxD : std_logic;
signal Output_Ctl : std_logic_vector (1 downto 0);
signal DirtySOut : std_logic;
 
-- Sample counter
signal SampClr : std_logic;
signal SampCnt : std_logic;
signal ZSC : std_logic_vector (8 downto 0);
 
-- Bit Counter
signal BitCnt : std_logic;
signal BitClr : std_logic;
signal ZBC : std_logic_vector (3 downto 0);
 
-- Bit boundary detector
signal BitBndDetA : std_logic_vector (8 downto 0);
signal BitBndDetB : std_logic_vector (8 downto 0);
signal BitBnd : std_logic;
 
-- Stop bit detector
signal StopBitDetA : std_logic_vector (3 downto 0);
signal SBC : std_logic_vector (3 downto 0);
signal Stop : std_logic;
 
begin
 
ShiftRegWEn <= DEn and DWr;
BaudRateRegWEn <= BEn and BWr;
 
CleanupReg : BitPipe
generic map(Length => 1)
port map(
    Ck  => SampCk,
    Clr => VCC,
    D   => DirtySOut,
    Pr  => Reset,
    Q   => SOut
    );
 
StopBitConst : Const
  generic map (
    Value   => 8,
    Width   => 4
  )
  port map(
    Result  => SBC
  );
 
StateMachine : TxController
port map(
    AClr        => Reset,
    BEn         => BEn,
    BWr         => BWr,
    BitBnd      => BitBnd,
    BitClr      => BitClr,
    BitCnt      => BitCnt,
    Ck          => SampCk,
    DEn         => DEn,
    DWr         => DWr,
    Output_Ctl  => Output_Ctl,
    SampClr     => SampClr,
    SampCnt     => SampCnt,
    ShiftData   => Shift,
    Stop        => Stop,
    Busy        => Busy
    );
 
ZeroSampleConst : Const
generic map (
    Value   => 0,
    Width   => 9
    )
port map(
    Result  => ZSC
    );
 
ZeroBitConst : Const
generic map (
    Value   => 0,
    Width   => 4
    )
port map(Result => ZBC);
 
OutputControlMux : Mux4
port map(
    ChanA   => TxD,
    ChanB   => VCC,
    ChanC   => VCC,
    ChanD   => GND,
    Result  => DirtySOut,
    Sel     => Output_Ctl
    );
 
TxShiftReg : GenReg
generic map (Width => 8)
port map(
    AClr    => Reset,
    Ck      => SampCk,
    Cnt     => GND,
    D       => Data(7 downto 0),
    OEn     => GND,
    Q       => open,
    ShEn    => Shift,
    WEn     => ShiftRegWEn,
    SIn     => GND,
    SOut    => TxD
    );
 
BaudRateDivisor : GenReg
generic map (Width => 9)
port map(
    AClr    => Reset,
    Ck      => SampCk,
    Cnt     => GND,
    D       => Data,
    OEn     => VCC,
    Q       => BitBndDetB,
    ShEn    => GND,
    WEn     => BaudRateRegWEn,
    SIn     => GND,
    SOut    => open
    );
 
SampleCounter : GenReg
generic map (Width => 9)
  port map(
    AClr    => Reset,
    Ck      => SampCk,
    Cnt     => SampCnt,
    D       => ZSC,
    OEn     => VCC,
    Q       => BitBndDetA,
    ShEn    => GND,
    WEn     => SampClr,
    SIn     => GND,
    SOut    => open
    );
 
BitCounter : GenReg
generic map (Width => 4)
port map(
    AClr    => Reset,
    Ck      => SampCk,
    Cnt     => BitCnt,
    D       => ZBC,
    OEn     => VCC,
    Q       => StopBitDetA,
    ShEn    => GND,
    WEn     => BitClr,
    SIn     => GND,
    SOut    => open
    );
 
BitBoundDetector : GEQ
generic map (Width => 9)
port map(
    ChanA   => BitBndDetA,
    ChanB   => BitBndDetB,
    Result  => BitBnd
    );
 
BitDetector : GEQ
generic map (Width => 4)
port map(
    ChanA   => StopBitDetA,
    ChanB   => SBC,
    Result  => Stop
    );
 
WriteDemux : DeMux2
port map(
    ChanA   => DWr,
    ChanB   => BWr,
    Sel     => A0,
    Source  => WEn
    );
 
end architecture;
 
library IEEE;
use IEEE.STD_LOGIC_1164.all;
use work.UART_RxController.all;
use work.UART_Components.all;
 
entity UART_Rx is
port(
    Reset   : in std_logic;
    SampCk  : in std_logic;
    SIn     : in std_logic;
    A0      : in std_logic;
    REn     : in std_logic;
    Data    : inout std_logic_vector(8 downto 0);
    BAv     : out std_logic;
    DAv     : out std_logic
    );
end entity;
 
architecture UART_Rx_A1 of UART_Rx is
 
constant VCC : std_logic := '1';
constant GND : std_logic := '0';
 
-- Controls for the shift register
signal DRd : std_logic;
 
-- Controls for the Baud rate divisor
signal BRd : std_logic;
 
-- The multiplexed output buffer
signal Muxed_Data : std_logic_vector(8 downto 0);
 
-- The
 transmit data path
signal Shift : std_logic;
signal RxD: std_logic;
signal Shift_Data : std_logic_vector(7 downto 0) := (others => '0');
signal Shift_Buf_Data : std_logic_vector (8 downto 0);
 
-- Sample
 counter
signal SampClr : std_logic;
signal SampCnt : std_logic;
signal ZSC : std_logic_vector (8 downto 0);
 
-- Bit
 Counter
signal BitCnt : std_logic;
signal BitClr : std_logic;
signal ZBC : std_logic_vector (3 downto 0);
 
-- Bit
 boundary detector
signal BitBndDetA : std_logic_vector (8 downto 0);
signal BitBndDetB : std_logic_vector (8 downto 0);
signal Baud : std_logic_vector (8 downto 0);
signal HalfBaud : std_logic_vector (8 downto 0);
signal BitBnd : std_logic;
 
-- Stop bit detector
signal StopBitDetA : std_logic_vector (3 downto 0);
signal SBC : std_logic_vector (3 downto 0);
signal Stop : std_logic;
 
-- Key detector
signal KeyDetA : std_logic_vector (7 downto 0);
signal KBC : std_logic_vector (7 downto 0);
signal KeyDet : std_logic;
 
-- Baud rate register
signal BdLd : std_logic;
signal BdHalf : std_logic;
 
begin
 
StateMachine : RxController
port map(
    AClr        => Reset,
    Ck          => SampCk,
    DRd         => DRd,
    DAv         => DAv,
    BRd         => BRd,
    BAv         => BAv,
    Start       => RxD,
    Stop        => Stop,
    BitBnd      => BitBnd,
    KeyDet      => KeyDet,
    ShiftData   => Shift,
    SampClr     => SampClr,
    SampCnt     => SampCnt,
    BitClr      => BitClr,
    BitCnt      => BitCnt,
    BdHalf      => BdHalf,
    BdLd        => BdLd
    );
 
MetastableReg : BitPipe
generic map(Length => 2)
port map(
    Ck  => SampCk,
    Clr => VCC,
    D   => SIn,
    Pr  => Reset,
    Q   => RxD
    );
 
ZeroSampleConst : Const
generic map (
    Value   => 0,
    Width   => 9
    )
port map(
    Result  => ZSC
    );
 
StopBitConst : Const
generic map (
    Value   => 8,
    Width   => 4
  )
port map(Result => SBC);
 
ZeroBitConst : Const
generic map (
    Value   => 0,
    Width   => 4
    )
port map(Result => ZBC);
 
SerKeyConst : Const
generic map (
    Value   => SLV2I(x"71"),
    Width   => 8
    )
port map(Result => KBC);
 
Shift_Buf_Data(7 downto 0) <= KeyDetA;
Shift_Buf_Data(8) <= '0';
 
OutputDataMux : BusMux2
generic map(Width => 9)
port map(
    Sel     => A0,
    ChanA   => Shift_Buf_Data,
    ChanB   => Baud,
    Result  => Muxed_Data
    );
 
OutputTriState : TriSt
generic map(Width => 9)
port map(
    En      => REn,
    Dir     => VCC,
    ChanA   => Data,
    ChanB   => Muxed_Data
    );
 
RxShiftReg : GenReg
generic map (Width => 8)
port map(
    AClr    => Reset,
    Ck      => SampCk,
    Cnt     => GND,
    D       => Shift_Data,
    OEn     => VCC,
    Q       => KeyDetA,
    ShEn    => Shift,
    WEn     => GND,
    SIn     => RxD,
    SOut    => open
    );
 
BaudRateDivisor : GenReg
generic map (Width => 9)
port map(
    AClr    => Reset,
    Ck      => SampCk,
    Cnt     => GND,
    D       => BitBndDetA,
    OEn     => VCC,
    Q       => Baud,
    ShEn    => GND,
    WEn     => BdLd,
    SIn     => GND,
    SOut    => open
    );
 
SampleCounter : GenReg
generic map (Width => 9)
  port map(
    AClr    => Reset,
    Ck      => SampCk,
    Cnt     => SampCnt,
    D       => ZSC,
    OEn     => VCC,
    Q       => BitBndDetA,
    ShEn    => GND,
    WEn     => SampClr,
    SIn     => GND,
    SOut    => open
    );
 
BitCounter : GenReg
generic map (Width => 4)
port map(
    AClr    => Reset,
    Ck      => SampCk,
    Cnt     => BitCnt,
    D       => ZBC,
    OEn     => VCC,
    Q       => StopBitDetA,
    ShEn    => GND,
    WEn     => BitClr,
    SIn     => GND,
    SOut    => open
    );
 
KeyDetector : EQ
generic map (Width => 8)
port map(
    ChanA   => KeyDetA,
    ChanB   => KBC,
    Result  => KeyDet
    );
 
BitBoundDetector : GEQ
generic map (Width => 9)
port map(
    ChanA   => BitBndDetA,
    ChanB   => BitBndDetB,
    Result  => BitBnd
    );
 
BitDetector : GEQ
generic map (Width => 4)
port map(
    ChanA   => StopBitDetA,
    ChanB   => SBC,
    Result  => Stop
    );
 
BaudMux : BusMux2
generic map(Width => 9)
port map(
    Sel     => BdHalf,
    ChanA   => Baud,
    ChanB   => HalfBaud,
    Result  => BitBndDetB
    );
 
BaudDivide : Div2
generic map(Width => 9)
port map(
    Operand => Baud,
    Result => HalfBaud
    );
 
ReadDemux : DeMux2
port map(
    ChanA   => DRd,
    ChanB   => BRd,
    Sel     => A0,
    Source  => REn
    );
 
end architecture;
Terms & Conditions
Last modified: SolFlu Mon, 19 Oct 2009 17:58:13 GMT