Subversion Repositories gpib_controller

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

--This file is part of fpga_gpib_controller.

--

-- Fpga_gpib_controller is free software: you can redistribute it and/or modify

-- it under the terms of the GNU General Public License as published by

-- the Free Software Foundation, either version 3 of the License, or

-- (at your option) any later version.

--

-- Fpga_gpib_controller 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 General Public License for more details.

-- You should have received a copy of the GNU General Public License

-- along with Fpga_gpib_controller.  If not, see <http://www.gnu.org/licenses/>.

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

-- Author: Andrzej Paluch

--

-- Create Date:   16:22:23 02/04/2012

-- Design Name:   

-- Module Name:   RegsGpibFasade_test.vhd

-- Project Name:  proto1

-- Target Device:  

-- Tool versions:  

-- Description:   

-- 

-- VHDL Test Bench Created by ISE for module: RegsGpibFasade

-- 

-- Dependencies:

-- 

-- Revision:

-- Revision 0.01 - File Created

-- Additional Comments:

--

-- Notes: 

-- This testbench has been automatically generated using types std_logic and

-- std_logic_vector for the ports of the unit under test.  Xilinx recommends

-- that these types always be used for the top-level I/O of a design in order

-- to guarantee that the testbench will bind correctly to the post-implementation 

-- simulation model.

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

LIBRARY ieee;

USE ieee.std_logic_1164.ALL;

-- Uncomment the following library declaration if using

-- arithmetic functions with Signed or Unsigned values

--USE ieee.numeric_std.ALL;

use work.wrapperComponents.ALL;

ENTITY RegsGpibFasade_communication_test IS

END RegsGpibFasade_communication_test;

ARCHITECTURE behavior OF RegsGpibFasade_communication_test IS

        component gpibCableEmulator is port (

                -- interface signals

                DIO_1 : in std_logic_vector (7 downto 0);

                output_valid_1 : in std_logic;

                DIO_2 : in std_logic_vector (7 downto 0);

                output_valid_2 : in std_logic;

                DIO : out std_logic_vector (7 downto 0);

                -- attention

                ATN_1 : in std_logic;

                ATN_2 : in std_logic;

                ATN : out std_logic;

                -- data valid

                DAV_1 : in std_logic;

                DAV_2 : in std_logic;

                DAV : out std_logic;

                -- not ready for data

                NRFD_1 : in std_logic;

                NRFD_2 : in std_logic;

                NRFD : out std_logic;

                -- no data accepted

                NDAC_1 : in std_logic;

                NDAC_2 : in std_logic;

                NDAC : out std_logic;

                -- end or identify

                EOI_1 : in std_logic;

                EOI_2 : in std_logic;

                EOI : out std_logic;

                -- service request

                SRQ_1 : in std_logic;

                SRQ_2 : in std_logic;

                SRQ : out std_logic;

                -- interface clear

                IFC_1 : in std_logic;

                IFC_2 : in std_logic;

                IFC : out std_logic;

                -- remote enable

                REN_1 : in std_logic;

                REN_2 : in std_logic;

                REN : out std_logic

        );

        end component;

   --Inputs

   signal reset : std_logic := '0';

   signal clk : std_logic := '0';

   signal DI : std_logic_vector(7 downto 0) := (others => '0');

   signal ATN_in : std_logic := '0';

   signal DAV_in : std_logic := '0';

   signal NRFD_in : std_logic := '0';

   signal NDAC_in : std_logic := '0';

   signal EOI_in : std_logic := '0';

   signal SRQ_in : std_logic := '0';

   signal IFC_in : std_logic := '0';

   signal REN_in : std_logic := '0';

   signal data_in : std_logic_vector(15 downto 0) := (others => '0');

   signal reg_addr : std_logic_vector(14 downto 0) := (others => '0');

   signal strobe_read : std_logic := '0';

   signal strobe_write : std_logic := '0';

        --Outputs

   signal DO : std_logic_vector(7 downto 0);

   signal output_valid : std_logic;

   signal ATN_out : std_logic;

   signal DAV_out : std_logic;

   signal NRFD_out : std_logic;

   signal NDAC_out : std_logic;

   signal EOI_out : std_logic;

   signal SRQ_out : std_logic;

   signal IFC_out : std_logic;

   signal REN_out : std_logic;

   signal data_out : std_logic_vector(15 downto 0);

   signal interrupt_line : std_logic;

   signal debug1 : std_logic;

   --Inputs

   signal data_in_1 : std_logic_vector(15 downto 0) := (others => '0');

   signal reg_addr_1 : std_logic_vector(14 downto 0) := (others => '0');

   signal strobe_read_1 : std_logic := '0';

   signal strobe_write_1 : std_logic := '0';

        --Outputs

   signal DO_1 : std_logic_vector(7 downto 0);

   signal output_valid_1 : std_logic;

   signal ATN_out_1 : std_logic;

   signal DAV_out_1 : std_logic;

   signal NRFD_out_1 : std_logic;

   signal NDAC_out_1 : std_logic;

   signal EOI_out_1 : std_logic;

   signal SRQ_out_1 : std_logic;

   signal IFC_out_1 : std_logic;

   signal REN_out_1 : std_logic;

   signal data_out_1 : std_logic_vector(15 downto 0);

   signal interrupt_line_1 : std_logic;

        -- Clock period definitions

        constant clk_period : time := 10 ns;

BEGIN

        -- Instantiate the Unit Under Test (UUT)

        uut: RegsGpibFasade PORT MAP (

                reset => reset,

                clk => clk,

                DI => DI,

                DO => DO,

                output_valid => output_valid,

                ATN_in => ATN_in,

                ATN_out => ATN_out,

                DAV_in => DAV_in,

                DAV_out => DAV_out,

                NRFD_in => NRFD_in,

                NRFD_out => NRFD_out,

                NDAC_in => NDAC_in,

                NDAC_out => NDAC_out,

                EOI_in => EOI_in,

                EOI_out => EOI_out,

                SRQ_in => SRQ_in,

                SRQ_out => SRQ_out,

                IFC_in => IFC_in,

                IFC_out => IFC_out,

                REN_in => REN_in,

                REN_out => REN_out,

                data_in => data_in,

                data_out => data_out,

                reg_addr => reg_addr,

                strobe_read => strobe_read,

                strobe_write => strobe_write,

                interrupt_line => interrupt_line,

                debug1 => debug1

        );

        -- Instantiate the Unit Under Test (UUT)

        uut_1: RegsGpibFasade PORT MAP (

                reset => reset,

                clk => clk,

                DI => DI,

                DO => DO_1,

                output_valid => output_valid_1,

                ATN_in => ATN_in,

                ATN_out => ATN_out_1,

                DAV_in => DAV_in,

                DAV_out => DAV_out_1,

                NRFD_in => NRFD_in,

                NRFD_out => NRFD_out_1,

                NDAC_in => NDAC_in,

                NDAC_out => NDAC_out_1,

                EOI_in => EOI_in,

                EOI_out => EOI_out_1,

                SRQ_in => SRQ_in,

                SRQ_out => SRQ_out_1,

                IFC_in => IFC_in,

                IFC_out => IFC_out_1,

                REN_in => REN_in,

                REN_out => REN_out_1,

                data_in => data_in_1,

                data_out => data_out_1,

                reg_addr => reg_addr_1,

                strobe_read => strobe_read_1,

                strobe_write => strobe_write_1,

                interrupt_line => interrupt_line_1,

                debug1 => open

        );

        gce: gpibCableEmulator port map (

                -- interface signals

                DIO_1 => DO,

                output_valid_1 => output_valid,

                DIO_2 => DO_1,

                output_valid_2 => output_valid_1,

                DIO => DI,

                -- attention

                ATN_1 => ATN_out,

                ATN_2 => ATN_out_1,

                ATN => ATN_in,

                -- data valid

                DAV_1 => DAV_out,

                DAV_2 => DAV_out_1,

                DAV => DAV_in,

                -- not ready for data

                NRFD_1 => NRFD_out,

                NRFD_2 => NRFD_out_1,

                NRFD => NRFD_in,

                -- no data accepted

                NDAC_1 => NDAC_out,

                NDAC_2 => NDAC_out_1,

                NDAC => NDAC_in,

                -- end or identify

                EOI_1 => EOI_out,

                EOI_2 => EOI_out_1,

                EOI => EOI_in,

                -- service request

                SRQ_1 => SRQ_out,

                SRQ_2 => SRQ_out_1,

                SRQ => SRQ_in,

                -- interface clear

                IFC_1 => IFC_out,

                IFC_2 => IFC_out_1,

                IFC => IFC_in,

                -- remote enable

                REN_1 => REN_out,

                REN_2 => REN_out_1,

                REN => REN_in

        );

   -- Clock process definitions

   clk_process :process

   begin

                clk <= '0';

                wait for clk_period/2;

                clk <= '1';

                wait for clk_period/2;

   end process;

   -- Stimulus process

        stim_proc: process begin

                -- hold reset state for 10 clock cycles

                reset <= '1';

                wait for clk_period*10;

                reset <= '0';

                wait for clk_period*10;

                -- set address of GPIB1

                reg_addr_1 <= "000000000000001";

                data_in_1 <= X"0002";

                wait for clk_period*2;

                strobe_write_1 <= '1';

                wait for clk_period*2;

                strobe_write_1 <= '0';

                wait for clk_period*2;

                -- set rsc

                reg_addr <= "000000000000111";

                data_in <= X"0040";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait for clk_period*20;

                -- set sic

                reg_addr <= "000000000000111";

                data_in <= X"00c0";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait for clk_period*20;

                -- reset sic

                reg_addr <= "000000000000111";

                data_in <= X"0040";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait until IFC_in = '0';

                -- address GPIB1 to listen

                reg_addr <= "000000000001101";

                data_in <= X"0022";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait for clk_period*5;

                -- address GPIB0 to talk

                reg_addr <= "000000000001101";

                data_in <= X"0041";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait for clk_period*5;

                -- go to standby

                reg_addr <= "000000000000111";

                data_in <= X"0240";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait until ATN_in = '0';

                reg_addr <= "000000000000111";

                data_in <= X"0040";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait for clk_period*5;

                -- set eof

                reg_addr <= "000000000001010";

                data_in <= X"0006";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait for clk_period*5;

                -- writes data to GPIB1

                reg_addr <= "000000000001101";

                data_in <= X"0007";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait for clk_period*15;

                -- take control

                reg_addr <= "000000000000111";

                data_in <= X"0840";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait for clk_period*150;

                -- reset buffer

                reg_addr <= "000000000001010";

                data_in <= X"000a";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait for clk_period*10;

                -- address GPIB0 to listen

                reg_addr <= "000000000001101";

                data_in <= X"0021";

                wait for clk_period*2;

                strobe_write <= '1';

                wait for clk_period*2;

                strobe_write <= '0';

                wait for clk_period*5;

                wait;

        end process;

END;