OpenCores
URL https://opencores.org/ocsvn/c16/c16/trunk

Subversion Repositories c16

[/] [c16/] [trunk/] [vhdl/] [input_output.vhd] - Diff between revs 2 and 9

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 2 Rev 9
Line 10... Line 10...
 
 
use work.cpu_pack.ALL;
use work.cpu_pack.ALL;
 
 
entity input_output is
entity input_output is
    PORT (      CLK_I                   : in std_logic;
    PORT (      CLK_I                   : in std_logic;
                        T2                              : in std_logic;
                        ADR_I                   : in  std_logic_vector( 7 downto 0);
 
                        CYC_I                   : in  std_logic;
 
                        STB_I                   : in  std_logic;
 
                        ACK_O                   : out std_logic;
 
 
 
                        RST_O                   : out STD_LOGIC;
 
 
                        SWITCH                  : in  STD_LOGIC_VECTOR (9 downto 0);
                        SWITCH                  : in  STD_LOGIC_VECTOR (9 downto 0);
 
 
                        HALT                    : in  STD_LOGIC;
                        HALT                    : in  STD_LOGIC;
                        SER_IN                  : in  STD_LOGIC;
                        SER_IN                  : in  STD_LOGIC;
                        SER_OUT                 : out STD_LOGIC;
                        SER_OUT                 : out STD_LOGIC;
Line 25... Line 31...
                        TEMP_CE                 : out STD_LOGIC;
                        TEMP_CE                 : out STD_LOGIC;
                        TEMP_SCLK               : out STD_LOGIC;
                        TEMP_SCLK               : out STD_LOGIC;
 
 
                    LED                         : out STD_LOGIC_VECTOR (7 downto 0);
                    LED                         : out STD_LOGIC_VECTOR (7 downto 0);
 
 
                        CLR                             : out STD_LOGIC;
 
 
 
                        -- input/output
                        -- input/output
                        IO_RD    : in  std_logic;
                        IO       : in  std_logic;
                        IO_WR    : in  std_logic;
                        WE_I     : in  std_logic;
                        IO_ADR   : in  std_logic_vector( 7 downto 0);
 
                        IO_RDAT  : out std_logic_vector( 7 downto 0);
                        IO_RDAT  : out std_logic_vector( 7 downto 0);
                        IO_WDAT  : in  std_logic_vector( 7 downto 0);
                        IO_WDAT  : in  std_logic_vector( 7 downto 0);
                    INT      : out STD_LOGIC
                    INT      : out STD_LOGIC
        );
        );
end input_output;
end input_output;
 
 
architecture Behavioral of input_output is
architecture Behavioral of input_output is
 
 
        COMPONENT temperature
        COMPONENT temperature
        PORT(   CLK_I     : IN std_logic;
        PORT(   CLK_I     : IN std_logic;
                        T2        : IN std_logic;
                        RST_I     : IN std_logic;
                        CLR       : IN std_logic;
 
                        TEMP_SPO  : IN std_logic;
                        TEMP_SPO  : IN std_logic;
                        DATA_OUT  : OUT std_logic_vector(7 downto 0);
                        DATA_OUT  : OUT std_logic_vector(7 downto 0);
                        TEMP_SPI  : OUT std_logic;
                        TEMP_SPI  : OUT std_logic;
                        TEMP_CE   : OUT std_logic;
                        TEMP_CE   : OUT std_logic;
                        TEMP_SCLK : OUT std_logic
                        TEMP_SCLK : OUT std_logic
                );
                );
        END COMPONENT;
        END COMPONENT;
 
 
        COMPONENT uart_baudgen
        COMPONENT uart_baudgen
        PORT(   CLK_I     : IN std_logic;
        PORT(   CLK_I     : IN std_logic;
                        T2        : IN std_logic;
                        RST_I     : IN std_logic;
                        CLR       : IN std_logic;
 
                        RD        : IN std_logic;
                        RD        : IN std_logic;
                        WR        : IN std_logic;
                        WR        : IN std_logic;
                        TX_DATA   : IN std_logic_vector(7 downto 0);
                        TX_DATA   : IN std_logic_vector(7 downto 0);
                        RX_SERIN  : IN std_logic;
                        RX_SERIN  : IN std_logic;
                        TX_SEROUT : OUT std_logic;
                        TX_SEROUT : OUT std_logic;
Line 66... Line 67...
                        RX_READY  : OUT std_logic;
                        RX_READY  : OUT std_logic;
                        TX_BUSY   : OUT std_logic
                        TX_BUSY   : OUT std_logic
                );
                );
        END COMPONENT;
        END COMPONENT;
 
 
        signal L_IO_ADR        : std_logic_vector(7 downto 0);
 
        signal IO_RD_SERIAL    : std_logic;
        signal IO_RD_SERIAL    : std_logic;
        signal IO_WR_SERIAL    : std_logic;
        signal IO_WR_SERIAL    : std_logic;
        signal RX_READY        : std_logic;
        signal RX_READY        : std_logic;
        signal TX_BUSY         : std_logic;
        signal TX_BUSY         : std_logic;
        signal RX_DATA         : std_logic_vector(7 downto 0);
        signal RX_DATA         : std_logic_vector(7 downto 0);
        signal TEMP_DO         : std_logic_vector(7 downto 0);
        signal TEMP_DO         : std_logic_vector(7 downto 0);
 
 
        signal FLAG            : std_logic;
        signal SERDAT          : std_logic;
 
 
        signal LCLR            : std_logic;
        signal LCLR            : std_logic;
        signal C1_N, C2_N      : std_logic;             -- switch debounce, active low
        signal C1_N, C2_N      : std_logic;             -- switch debounce, active low
 
 
        signal RX_INT_ENABLED  : std_logic;
        signal RX_INT_ENABLED  : std_logic;
        signal TX_INT_ENABLED  : std_logic;
        signal TX_INT_ENABLED  : std_logic;
        signal TIM_INT_ENABLED : std_logic;
        signal TIM_INT_ENABLED : std_logic;
        signal TIMER_INT       : std_logic;
        signal TIMER_INT       : std_logic;
        signal TIMER           : std_logic_vector(14 downto 0);
        signal TIMER           : std_logic_vector(15 downto 0);
        signal CLK_COUNT       : std_logic_vector(15 downto 0);
        signal CLK_COUNT       : std_logic_vector(16 downto 0);
 
 
        signal CLK_COUNT_EN    : std_logic;
        signal CLK_COUNT_EN    : std_logic;
        signal CLK_HALT_MSK    : std_logic;
        signal CLK_HALT_MSK    : std_logic;
        signal CLK_HALT_VAL    : std_logic;
        signal CLK_HALT_VAL    : std_logic;
 
 
begin
begin
 
 
        tempr: temperature
        tempr: temperature
        PORT MAP(       CLK_I     => CLK_I,
        PORT MAP(       CLK_I     => CLK_I,
                                T2        => T2,
                                RST_I     => LCLR,
                                CLR       => LCLR,
 
                                DATA_OUT  => TEMP_DO,
                                DATA_OUT  => TEMP_DO,
                                TEMP_SPI  => TEMP_SPI,
                                TEMP_SPI  => TEMP_SPI,
                                TEMP_SPO  => TEMP_SPO,
                                TEMP_SPO  => TEMP_SPO,
                                TEMP_CE   => TEMP_CE,
                                TEMP_CE   => TEMP_CE,
                                TEMP_SCLK => TEMP_SCLK
                                TEMP_SCLK => TEMP_SCLK
        );
        );
 
 
        uart: uart_baudgen
        uart: uart_baudgen
        PORT MAP(       CLK_I     => CLK_I,
        PORT MAP(       CLK_I     => CLK_I,
                                T2        => T2,
                                RST_I     => LCLR,
                                CLR       => LCLR,
 
                                RD        => IO_RD_SERIAL,
                                RD        => IO_RD_SERIAL,
                                WR        => IO_WR_SERIAL,
                                WR        => IO_WR_SERIAL,
                                TX_DATA   => IO_WDAT,
                                TX_DATA   => IO_WDAT,
                                TX_SEROUT => SER_OUT,
                                TX_SEROUT => SER_OUT,
                                RX_SERIN  => SER_IN,
                                RX_SERIN  => SER_IN,
                                RX_DATA   => RX_DATA,
                                RX_DATA   => RX_DATA,
                                RX_READY  => RX_READY,
                                RX_READY  => RX_READY,
                                TX_BUSY   => TX_BUSY
                                TX_BUSY   => TX_BUSY
        );
        );
 
 
        CLR     <= LCLR;
        RST_O   <= LCLR;
        INT     <=     (RX_INT_ENABLED  and     RX_READY)
        INT     <=     (RX_INT_ENABLED  and     RX_READY)
                                or (TX_INT_ENABLED  and not TX_BUSY)
                                or (TX_INT_ENABLED  and not TX_BUSY)
                                or (TIM_INT_ENABLED and     TIMER_INT);
                                or (TIM_INT_ENABLED and     TIMER_INT);
 
 
 
        SERDAT       <= (IO and CYC_I) when (ADR_I = X"00") else '0';
 
        IO_RD_SERIAL <= SERDAT and not WE_I;
 
        IO_WR_SERIAL <= SERDAT and WE_I;
 
        ACK_O        <= STB_I;
 
 
        -- IO read process
        -- IO read process
        --
        --
        process(L_IO_ADR, IO_RD, IO_WR, RX_DATA, TEMP_DO, SWITCH,
        process(ADR_I, RX_DATA, TIM_INT_ENABLED, TIMER_INT, TX_INT_ENABLED, TX_BUSY,
                        TIM_INT_ENABLED, TIMER_INT, TX_INT_ENABLED, TX_BUSY,
                        RX_INT_ENABLED,  RX_READY, TEMP_DO, SWITCH, CLK_COUNT)
                        RX_INT_ENABLED, RX_READY)
 
        begin
        begin
                IO_RD_SERIAL <= '0';
                case ADR_I is
                IO_WR_SERIAL <= '0';
 
                case L_IO_ADR is
 
                        when X"00"      =>      IO_RDAT      <= RX_DATA;
                        when X"00"      =>      IO_RDAT      <= RX_DATA;
                                                        IO_RD_SERIAL <= IO_RD;
 
                                                        IO_WR_SERIAL <= IO_WR;
 
                        when X"01"      =>      IO_RDAT <= '0'
                        when X"01"      =>      IO_RDAT <= '0'
                                                                         & (TIM_INT_ENABLED and  TIMER_INT)
                                                                         & (TIM_INT_ENABLED and  TIMER_INT)
                                                                         & (TX_INT_ENABLED  and not TX_BUSY)
                                                                         & (TX_INT_ENABLED  and not TX_BUSY)
                                                                         & (RX_INT_ENABLED  and RX_READY)
                                                                         & (RX_INT_ENABLED  and RX_READY)
                                                                         & '0'
                                                                         & '0'
                                                                         & TIMER_INT
                                                                         & TIMER_INT
                                                                         & TX_BUSY
                                                                         & TX_BUSY
                                                                         & RX_READY;
                                                                         & RX_READY;
                        when X"02"      => IO_RDAT  <= TEMP_DO;
                        when X"02"      => IO_RDAT  <= TEMP_DO;
                        when X"03"      => IO_RDAT  <= SWITCH(7 downto 0);
                        when X"03"      => IO_RDAT  <= SWITCH(7 downto 0);
                        when X"05"      => IO_RDAT  <= CLK_COUNT(7 downto 0);
                        when X"05"      => IO_RDAT  <= CLK_COUNT(8 downto 1);
                        when others     => IO_RDAT  <= CLK_COUNT(15 downto 8);
                        when others     => IO_RDAT  <= CLK_COUNT(16 downto 9);
                end case;
                end case;
        end process;
        end process;
 
 
        -- IO write and timer process
        -- IO write and timer process
        --
        --
        process(CLK_I)
        process(CLK_I)
        begin
        begin
                if (rising_edge(CLK_I)) then
                if (rising_edge(CLK_I)) then
                        if (T2 = '1') then
 
                                L_IO_ADR <= IO_ADR;
 
                                if (LCLR = '1') then
                                if (LCLR = '1') then
                                        LED             <= X"00";
                                        LED             <= X"00";
                                        RX_INT_ENABLED  <= '0';
                                        RX_INT_ENABLED  <= '0';
                                        TX_INT_ENABLED  <= '0';
                                        TX_INT_ENABLED  <= '0';
                                        TIM_INT_ENABLED <= '0';
                                        TIM_INT_ENABLED <= '0';
                                        TIMER_INT       <= '0';
                                        TIMER_INT       <= '0';
                                        TIMER           <= "000" & X"000";
                                TIMER           <= X"0000";
                                else
                                else
                                        if (IO_WR = '1') then
                                if (IO = '1' and CYC_I = '1' and WE_I = '1') then
                                                case L_IO_ADR is
                                        case ADR_I is
                                                        when X"00"  =>  -- handled by uart
                                                        when X"00"  =>  -- handled by uart
                                                        when X"01"  =>  -- handled by uart
                                                        when X"01"  =>  -- handled by uart
                                                        when X"02"  => LED <= IO_WDAT;
                                                        when X"02"  => LED <= IO_WDAT;
                                                        when X"03"  =>  RX_INT_ENABLED  <= IO_WDAT(0);
                                                        when X"03"  =>  RX_INT_ENABLED  <= IO_WDAT(0);
                                                                                        TX_INT_ENABLED  <= IO_WDAT(1);
                                                                                        TX_INT_ENABLED  <= IO_WDAT(1);
                                                                                        TIM_INT_ENABLED <= IO_WDAT(2);
                                                                                        TIM_INT_ENABLED <= IO_WDAT(2);
                                                        when X"04"  =>  TIMER_INT       <= '0';
                                                        when X"04"  =>  TIMER_INT       <= '0';
                                                        when X"05"  =>  CLK_COUNT_EN    <= '1';
                                                        when X"05"  =>  CLK_COUNT_EN    <= '1';
                                                                        CLK_COUNT       <= X"0000";
                                                                CLK_COUNT       <= '0' & X"0000";
                                                                                        CLK_HALT_VAL    <= IO_WDAT(0);
                                                                                        CLK_HALT_VAL    <= IO_WDAT(0);
                                                                                        CLK_HALT_MSK    <= IO_WDAT(1);
                                                                                        CLK_HALT_MSK    <= IO_WDAT(1);
                                                        when X"06"  =>  CLK_COUNT_EN    <= '0';
                                                        when X"06"  =>  CLK_COUNT_EN    <= '0';
                                                        when others =>
                                                        when others =>
                                                end case;
                                                end case;
                                        end if;
                                        end if;
 
 
                                        TIMER <= TIMER + 1;
                                if (TIMER = 39999) then         -- 1 ms at 40 MHz
                                        if (TIMER = 19999) then         -- 1 ms
 
                                                TIMER_INT <= '1';
                                                TIMER_INT <= '1';
                                                TIMER     <= "000" & X"000";
                                        TIMER     <= X"0000";
 
                                else
 
                                        TIMER <= TIMER + 1;
                                        end if;
                                        end if;
 
 
                                        if (CLK_COUNT_EN = '1' and
                                        if (CLK_COUNT_EN = '1' and
                                            (HALT and CLK_HALT_MSK ) = CLK_HALT_VAL) then
                                            (HALT and CLK_HALT_MSK ) = CLK_HALT_VAL) then
                                                CLK_COUNT <= CLK_COUNT + 1;
                                                CLK_COUNT <= CLK_COUNT + 1;
                                        end if;
                                        end if;
                                end if;
                                end if;
                        end if;
                        end if;
                end if;
 
        end process;
        end process;
 
 
        -- reset debounce process
        -- reset debounce process
        --
        --
        process(CLK_I)
        process(CLK_I)
        begin
        begin
                if (rising_edge(CLK_I)) then
                if (rising_edge(CLK_I)) then
                        if (T2 = '1') then
 
                                -- switch debounce
                                -- switch debounce
                                if (SWITCH(8) = '1' or SWITCH(9) = '1') then
                                if (SWITCH(8) = '1' or SWITCH(9) = '1') then
                                        LCLR <= '1';
                                        LCLR <= '1';
                                        C2_N <= '0';
                                        C2_N <= '0';
                                        C1_N <= '0';
                                        C1_N <= '0';
Line 214... Line 209...
                                        LCLR <= not C2_N;
                                        LCLR <= not C2_N;
                                        C2_N   <= C1_N;
                                        C2_N   <= C1_N;
                                        C1_N   <= '1';
                                        C1_N   <= '1';
                                end if;
                                end if;
                        end if;
                        end if;
                end if;
 
        end process;
        end process;
 
 
end Behavioral;
end Behavioral;
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.