lpm_ram_dp.vhd

8-1024可变点数FFT/IFFT变换,VHDL语言设计, 仿真通过,可以很容易综合.

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
--use work.LPM_COMPONENTS.all;
use std.textio.all;

entity LPM_RAM_DP is
    generic (
        LPM_WIDTH             : natural;    -- MUST be greater than 0
        LPM_WIDTHAD           : natural;    -- MUST be greater than 0
        LPM_NUMWORDS          : natural := 0;
        LPM_INDATA            : string := "REGISTERED";
        LPM_OUTDATA           : string := "REGISTERED";
        LPM_RDADDRESS_CONTROL : string := "REGISTERED";
        LPM_WRADDRESS_CONTROL : string := "REGISTERED";
        LPM_FILE              : string := "UNUSED";
        LPM_TYPE              : string := "LPM_RAM_DP";
        LPM_HINT              : string := "UNUSED"
     );
     port (
        RDCLOCK     : in std_logic := '0';
        RDCLKEN     : in std_logic := '1';
        RDADDRESS   : in std_logic_vector(LPM_WIDTHAD-1 downto 0);
        RDEN        : in std_logic := '1';
        DATA        : in std_logic_vector(LPM_WIDTH-1 downto 0);
        WRADDRESS   : in std_logic_vector(LPM_WIDTHAD-1 downto 0);
        WREN        : in std_logic;
        WRCLOCK     : in std_logic := '0';
        WRCLKEN     : in std_logic := '1';
        Q           : out std_logic_vector(LPM_WIDTH-1 downto 0)
     );

        function int_to_str( value : integer ) return string is
        variable ivalue,index : integer;
        variable digit : integer;
        variable line_no: string(8 downto 1) := "        ";  
        begin
                ivalue := value;
                index := 1;
                while (ivalue > 0) loop
                        digit := ivalue MOD 10;
                        ivalue := ivalue/10;
                        case digit is
                                when 0 =>
                                        line_no(index) := '0';
                                when 1 =>
                                        line_no(index) := '1';
                                when 2 =>
                                        line_no(index) := '2';
                                when 3 =>
                                        line_no(index) := '3';
                                when 4 =>
                                        line_no(index) := '4';
                                when 5 =>
                                        line_no(index) := '5';
                                when 6 =>
                                        line_no(index) := '6';
                                when 7 =>
                                        line_no(index) := '7';
                                when 8 =>
                                        line_no(index) := '8';
                                when 9 =>
                                        line_no(index) := '9';
                                when others =>
                                        ASSERT FALSE
                                        REPORT "Illegal number!"
                                        SEVERITY ERROR;
                        end case;
                        index := index + 1;
                end loop;
                return line_no;
        end;

        function hex_str_to_int( str : string ) return integer is
        variable len : integer := str'length;
        variable ivalue : integer := 0;
        variable digit : integer;
        begin
                for i in len downto 1 loop
                        case str(i) is
                                when '0' =>
                                        digit := 0;
                                when '1' =>
                                        digit := 1;
                                when '2' =>
                                        digit := 2;
                                when '3' =>
                                        digit := 3;
                                when '4' =>
                                        digit := 4;
                                when '5' =>
                                        digit := 5;
                                when '6' =>
                                        digit := 6;
                                when '7' =>
                                        digit := 7;
                                when '8' =>
                                        digit := 8;
                                when '9' =>
                                        digit := 9;
                                when 'A' =>
                                        digit := 10;
                                when 'a' =>
                                        digit := 10;
                                when 'B' =>
                                        digit := 11;
                                when 'b' =>
                                        digit := 11;
                                when 'C' =>
                                        digit := 12;
                                when 'c' =>
                                        digit := 12;
                                when 'D' =>
                                        digit := 13;
                                when 'd' =>
                                        digit := 13;
                                when 'E' =>
                                        digit := 14;
                                when 'e' =>
                                        digit := 14;
                                when 'F' =>
                                        digit := 15;
                                when 'f' =>
                                        digit := 15;
                                when others =>
                                        ASSERT FALSE
                                        REPORT "Illegal character "&  str(i) & "in Intel Hex File! "
                                        SEVERITY ERROR;
                        end case;
                        ivalue := ivalue * 16 + digit;
                end loop;
                return ivalue;
        end;

        procedure Shrink_line(L : inout LINE; pos : in integer) is
        subtype nstring is string(1 to pos);
        variable stmp : nstring;
        begin
                if pos >= 1 then
                        read(l, stmp);
                end if;
        end;

end LPM_RAM_DP;

architecture LPM_SYN of lpm_ram_dp is

--type lpm_memory is array(lpm_numwords-1 downto 0) of std_logic_vector(lpm_width-1 downto 0);
type lpm_memory is array((2**lpm_widthad)-1 downto 0) of std_logic_vector(lpm_width-1 downto 0);

signal data_tmp, data_reg : std_logic_vector(lpm_width-1 downto 0);
signal q_tmp, q_reg : std_logic_vector(lpm_width-1 downto 0) := (others => '0');
signal rdaddress_tmp, rdaddress_reg : std_logic_vector(lpm_widthad-1 downto 0);
signal wraddress_tmp, wraddress_reg : std_logic_vector(lpm_widthad-1 downto 0);
signal wren_tmp, wren_reg : std_logic;
signal rden_tmp, rden_reg : std_logic;

begin
        sync: process(data, data_reg, rden, rden_reg, rdaddress, rdaddress_reg,
                      wren, wren_reg, wraddress, wraddress_reg, q_tmp, q_reg)
        begin
            if (lpm_rdaddress_control = "REGISTERED") then
                  rdaddress_tmp <= rdaddress_reg;
                  rden_tmp <= rden_reg;
            elsif (lpm_rdaddress_control = "UNREGISTERED") then
                  rdaddress_tmp <= rdaddress;
                  rden_tmp <= rden;
            else
                  ASSERT FALSE
                  REPORT "Illegal LPM_RDADDRESS_CONTROL property value for LPM_RAM_DP!"
                  SEVERITY ERROR;
            end if;
            if (lpm_wraddress_control = "REGISTERED") then
                  wraddress_tmp <= wraddress_reg;
                  wren_tmp <= wren_reg; 
            elsif (lpm_wraddress_control = "UNREGISTERED") then
                  wraddress_tmp <= wraddress;
                  wren_tmp <= wren;
            else
                  ASSERT FALSE
                  REPORT "Illegal LPM_WRADDRESS_CONTROL property value for LPM_RAM_DP!"
                  SEVERITY ERROR;
            end if;
            if (lpm_indata = "REGISTERED") then
                  data_tmp <= data_reg;
            elsif (lpm_indata = "UNREGISTERED") then