Subversion Repositories iqcorrection

library ieee;

use ieee.std_logic_1164.all;

use ieee.math_real.all;

use ieee.numeric_std.all;

use std.textio.all;

use ieee.std_logic_textio.all;

entity IQGainPhaseCorrection_testbench is

end entity;

--The read architecture reads I and Q samples from a text file.

--The values were created by the MATLAB reference model for the design.

architecture IQGainPhaseCorrection_testbench_read of IQGainPhaseCorrection_testbench is

--declare the DUT as a component.

component IQGainPhaseCorrection is

        generic(width :natural);

        port(

        clk                             :in std_logic;

        x1                              :in signed(width-1 downto 0);

        y1                              :in signed(width-1 downto 0);

        gain_error              :out signed(width-1 downto 0);

        gain_lock               :out bit;

        phase_error             :out signed(width-1 downto 0);

        phase_lock              :out bit;

        corrected_x1    :out signed(width-1 downto 0);

        corrected_y1    :out signed(width-1 downto 0)

        );

end component;

--tell the testbench which architecture we're using.

--for DUT: IQGainPhaseCorrection use entity IQGainPhaseCorrection_entity(IQGainPhaseCorrection_arch_integer);

--provide signals to run the DUT.

signal clk_tb                   : std_logic := '0';

signal clk_tb_delayed   : std_logic     := '0';

signal x1_tb                    : signed(31 downto 0);

signal y1_tb                    : signed(31 downto 0);

signal gain_error_tb    : signed(31 downto 0);

signal gain_lock_tb             : bit;

signal phase_error_tb   : signed(31 downto 0);

signal phase_lock_tb    : bit;

signal corrected_x1_tb  : signed(31 downto 0);

signal corrected_y1_tb  : signed(31 downto 0);

begin

        --connect the testbench signal to the component

        DUT:IQGainPhaseCorrection

        generic map(

        width => 32

        )

        port map(

        clk => clk_tb_delayed,

        x1 => x1_tb,

        y1 => y1_tb,

        gain_error => gain_error_tb,

        gain_lock => gain_lock_tb,

        phase_error => phase_error_tb,

        phase_lock => phase_lock_tb,

        corrected_x1 => corrected_x1_tb,

        corrected_y1 => corrected_y1_tb

        );

--Read I and Q from a text file created by MATLAB.

--type file_type is file of element_type;

--

--the read and endfile operations are implicitly declared as

--

--procedure read ( file f : file_type;  value : out element_type );

--function endfile ( file f : file_type ) return boolean;

READ_I_Q_SAMPLES: process (clk_tb) is

--read input data into process using the readline technique

file I_data : text open READ_MODE is "I_data_octave";

file Q_data : text open READ_MODE is "Q_data_octave";

variable incoming : line;

variable local_x1 : real;

variable local_y1 : real;

variable int_x1 : integer;

variable returned_x1 : signed(31 downto 0);  --need to parameterize this 

variable int_y1 : integer;

variable returned_y1 : signed(31 downto 0);  --need to parameterize this

begin

        if (clk_tb'event and clk_tb = '1') then

                if (not endfile(I_data) and not endfile(Q_data)) then

                        readline(I_data, incoming);  --read in the first line.

                        read(incoming, local_x1);  --get the real value from the first line

                        report "Reading " & real'image(local_x1) & " from I_data.";

                        local_x1 := local_x1/(1.11); --model AGC

                        report "AGC applied. Result: " & real'image(local_x1) & ".";

                        int_x1 := integer(trunc(local_x1*((2.0**31.0)-1.0)));  --scaled

                        report "Converted real I_data to the integer " & integer'image(int_x1) & ".";

                        returned_x1 := (to_signed(int_x1, 32));

                        x1_tb <= returned_x1;

                        readline(Q_data, incoming);  --read in the first line.

                        read(incoming, local_y1);  --get the real value from the first line

                        report "Reading " & real'image(local_y1) & " from Q_data.";

                        local_y1 := local_y1/(1.11); --model AGC

                        report "AGC applied. Result: " & real'image(local_y1) & ".";

                        int_y1 := integer(trunc(local_y1*((2.0**31.0)-1.0)));  --scaled

                        report "Converted real Q_data to the integer " & integer'image(int_y1) & ".";

                        returned_y1 := (to_signed(int_y1, 32));

                        y1_tb <= returned_y1;

                else

                        file_close(I_data);

                        file_close(Q_data);

                end if;

        end if;

end process READ_I_Q_SAMPLES;

COMPARE_RESULTS : process (clk_tb) is

--compare process output with data file using the readline technique

file phase_error : text open READ_MODE is "phase_error_estimate_octave";

file gain_error : text open READ_MODE is "gain_error_estimate_octave";

variable incoming : line;

variable filter_delay : natural := 0;

variable local_phase_error : real;

variable int_phase_error : integer;

variable octave_phase_error : signed(31 downto 0);

variable local_gain_error : real;

variable int_gain_error : integer;

variable octave_gain_error : signed(31 downto 0);

begin

        if (clk_tb'event and clk_tb = '1') then

                if filter_delay > 3 then

                        if (not endfile(phase_error) and not endfile(gain_error)) then

                                --read in a result and compare with testbench result

                                readline(phase_error, incoming);  --read in the first line.

                                read(incoming, local_phase_error);  --get the real value from the first line

                                report "Phase error from model: " & real'image(local_phase_error) & ".";

                                int_phase_error := integer(trunc(local_phase_error*((2.0**31.0)-1.0)));  --scaled

                                report "Converted real phase_error to the integer " & integer'image(int_phase_error) & ".";

                                octave_phase_error := (to_signed(int_phase_error, 32));

                                --does the phase error from the block match octave_phase_error?

                                readline(gain_error, incoming);  --read in the first line.

                                read(incoming, local_gain_error);  --get the real value from the first line

                                report "Gain error from model: " & real'image(local_gain_error) & ".";

                                int_gain_error := integer(trunc(local_gain_error*((2.0**31.0)-1.0)));  --scaled

                                report "Converted real gain_error to the integer " & integer'image(int_gain_error) & ".";

                                octave_gain_error := (to_signed(int_gain_error, 32));

                                --does the gain error from the block match octave_gain_error?

                        else

--                              file_close(phase_error);

--                              file_close(gain_error);

                        end if;

                else

                        filter_delay := filter_delay + 1;

                end if;

        end if;

end process COMPARE_RESULTS;

DRIVE_CLOCK:process

begin

        wait for 50 ns;

        clk_tb <= not clk_tb;

        clk_tb_delayed <= not clk_tb_delayed after 1 ns;

end process;

end IQGainPhaseCorrection_testbench_read;