谁会？

serene

下面引用由snowyd在 2004/05/29 11:40am 发表的内容：
乘法器以我们的想法怎么都不溢出，但这样加法就会溢出，所以输入蝶形单元的数据必须先除二或四,运算后直接进入下一级依次下去
，因为这里有个累加过程！！！！
拿sin函数说，基次波，变换后可以达到32。

呵呵，我好象越解释越乱了。
相乘数据/2 －－见data_scaling注释
乘积的绝对值的最大值为00xxxxxx xxxxxxxx，
在data_scaling这个process中进行了除以4运算，绝对值的最大值也是00xxxxxx xxxxxxxx，
这样加减运算后，绝对值的最大值为0yyyyyyy yyyyyyyy，
再进行左移1位，成为yyyyyyyy yyyyyyy0，所以实际上不会溢出。

serene

下面引用由snowyd在 2004/05/29 12:24pm 发表的内容：
现在看来我想把fft做成最顶层相当于一个控制器，发送控制其它各部分！！！
这部分要改，数据的输入直接进入ram！！

为了保证运算速度，ram一定要用的，需要2个，而且是双口的。

snowyd

今天将rom的地址产生编完了，64点有点复杂，或是我的思想太笨，有400多行！！
脖子都抬不起来了，昨完毕业设计我的眼睛也得换了！
我现在想最顶层是什么样！还有ram地址生成，还有一个很重要的问题就是时序问题！！
我打算将fft改成最顶层，做所有部件的
控制单元和相应信号产生单元！蝶形运算我正在改！！

serene

看看这个双口RAM能不能综合，若能也仿真一下有没有问题。
entity dual_port_ram is
      generic(
             data_width     : integer := 16;
             ram_length     : integer := 64);
      port   (
             data_in        : in  std_logic_vector(data_width-1 downto 0);   -- Input Data
             data_out1      : out std_logic_vector(data_width-1 downto 0);   -- Output Data1
             data_out2      : out std_logic_vector(data_width-1 downto 0);   -- Output Data2
             clk            : in std_logic;                                  -- Input Clock
             en             : in std_logic;                                  -- Ram Enable
             we             : in std_logic;                                  -- Write Enable...Active Low
             address1       : in std_logic_vector(6 downto 0);               -- Ram Address1
             address2       : in std_logic_vector(6 downto 0)                -- Ram Address2
             );
end dual_port_ram;

architecture rtl of dual_port_ram is
type mem_array is array (ram_length -1 downto 0) of std_logic_vector(data_width-1 downto 0);-- Defining memory array
signal mem : mem_array;           
begin
ram_proc : process(clk)
begin
   if rising_edge(clk) then
      if en = '1' then
         if we = '0' then
            mem(To_Integer(unsigned(address1))) <= data_in;
         end if;
      end if;
   end if;
end process ram_proc;
data_out1 <= mem(To_Integer(unsigned(address1)));
data_out2 <= mem(To_Integer(unsigned(address2)));
end rtl;

serene

[这个贴子最后由serene在 2004/06/19 05:47pm 第 1 次编辑]

component butterfly, 其原理与stg1_butterfly一样，只是采用复数乘法。
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity butterfly is
      generic(
             data_width     : integer := 16;                                        -- No of Data bits
             tw_fact_width  : integer := 16);                                       -- No of Twiddle Factor bits
      port   (
             reset          : in std_logic;                                         -- Reset
             clk            : in std_logic;                                         -- Input Clock
             data_rd        : in std_logic;                                         -- New Sample Read (This is the sampling clk Active High)
             data1_r_in     : in  std_logic_vector(data_width-1 downto 0);          -- Input Data1 Real
             data1_i_in     : in  std_logic_vector(data_width-1 downto 0);          -- Input Data1 Imag
             data2_r_in     : in  std_logic_vector(data_width-1 downto 0);          -- Input Data2 Real
             data2_i_in     : in  std_logic_vector(data_width-1 downto 0);          -- Input Data2 Real
             tf1_r          : in  std_logic_vector(tw_fact_width-1 downto 0);       -- Twiddle Factor1 Real Data
             tf1_i          : in  std_logic_vector(tw_fact_width-1 downto 0);       -- Twiddle Factor1 Imag Data
             data1_r_out    : out std_logic_vector(data_width-1 downto 0);          -- Output Data1 Real
             data1_i_out    : out std_logic_vector(data_width-1 downto 0);          -- Output Data1 Imag
             data2_r_out    : out std_logic_vector(data_width-1 downto 0);          -- Output Data2 Real
             data2_i_out    : out std_logic_vector(data_width-1 downto 0)           -- Output Data2 Imag
             );
end butterfly;

architecture rtl of butterfly is

component complex_mult is
      generic(
             data1_width     : integer := 16;                                       -- Size of Data1 (bits)
             data2_width     : integer := 16);                                      -- Size of Data2 (bits)
      port   (
             data_rd        : in std_logic;                                         -- New Sample Read (This is the sampling clk Active High)
             data1_real     : in  std_logic_vector(data1_width-1 downto 0);         -- Data1 Real Value
             data1_imag     : in  std_logic_vector(data1_width-1 downto 0);         -- Data1 Imag Value
             data2_real     : in  std_logic_vector(data2_width-1 downto 0);         -- Data2 Real Value
             data2_imag     : in  std_logic_vector(data2_width-1 downto 0);         -- Data2 Imag Value
             data_out_real  : out std_logic_vector(data1_width-1 downto 0);         -- Output Data Real Value
             data_out_imag  : out std_logic_vector(data1_width-1 downto 0)          -- Output Data Imag Value
             );
end component;

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

signal last_data_rd                : std_logic;                                     -- Used to sample new data
signal data1_r_in_div4             : std_logic_vector(data_width-1 downto 0);       -- Real part of data1 divided by four
signal data1_i_in_div4             : std_logic_vector(data_width-1 downto 0);       -- Imag part of data1 divided by four
signal data2_r_in_div2             : std_logic_vector(data_width-1 downto 0);       -- Real part of data2 divided by two
signal data2_i_in_div2             : std_logic_vector(data_width-1 downto 0);       -- Imag part of data2 divided by two
signal tf1_r_div2                  : std_logic_vector(tw_fact_width-1 downto 0);    -- Real part of twiddle factor divided by two
signal tf1_i_div2                  : std_logic_vector(tw_fact_width-1 downto 0);    -- Imag part of twiddle factor divided by two
signal Mult_TF_Xn2_R_Out           : std_logic_vector((data_width-1) downto 0);     -- Real value output from complex multiplication
signal Mult_TF_Xn2_I_Out           : std_logic_vector((data_width-1) downto 0);     -- Imag value output from complex multiplication
signal Butt_Data1_Out_R_signed     : signed (data_width-1 downto 0);                -- Data1 real result from butterfly
signal Butt_Data1_Out_I_signed     : signed (data_width-1 downto 0);                -- Data1 imag result from butterfly
signal Butt_Data2_Out_R_signed     : signed (data_width-1 downto 0);                 -- Data2 real result from butterfly
signal Butt_Data2_Out_I_signed     : signed (data_width-1 downto 0);                -- Data2 imag result from butterfly

begin

butterfly_calcs: process(data1_r_in_div4, data1_i_in_div4, Mult_TF_Xn2_R_Out, Mult_TF_Xn2_I_Out)
-- Update butterfly outputs
begin
  Butt_Data1_Out_R_signed <= signed(data1_r_in_div4) + signed(Mult_TF_Xn2_R_Out);
  Butt_Data1_Out_I_signed <= signed(data1_i_in_div4) + signed(Mult_TF_Xn2_I_Out);
  Butt_Data2_Out_R_signed <= signed(data1_r_in_div4) - signed(Mult_TF_Xn2_R_Out);
  Butt_Data2_Out_I_signed <= signed(data1_i_in_div4) - signed(Mult_TF_Xn2_I_Out);
end process butterfly_calcs;

data_scaling: process(reset, clk)
begin
  if reset = '0' then
     tf1_r_div2 <= (others => '0');
     tf1_i_div2 <= (others => '0');
     data1_r_in_div4 <= (others => '0');
     data1_i_in_div4 <= (others => '0');
     data2_r_in_div2 <= (others => '0');
     data2_i_in_div2 <= (others => '0');
  elsif Rising_Edge(clk) then  
     if tf1_r(tw_fact_width-1) = '0' then
        tf1_r_div2 <= '0' & tf1_r(tw_fact_width-1 downto 1);
     else
        tf1_r_div2 <= '1' & tf1_r(tw_fact_width-1 downto 1);
     end if;
     if tf1_i(tw_fact_width-1) = '0' then
        tf1_i_div2 <= '0' & tf1_i(tw_fact_width-1 downto 1);
     else
        tf1_i_div2 <= '1' & tf1_i(tw_fact_width-1 downto 1);
     end if;
     if data2_r_in(data_width-1) = '0' then
        data2_r_in_div2 <= '0' & data2_r_in(data_width-1 downto 1);
     else
        data2_r_in_div2 <= '1' & data2_r_in(data_width-1 downto 1);
     end if;
     if data2_i_in(data_width-1) = '0' then
        data2_i_in_div2 <= '0' & data2_i_in(data_width-1 downto 1);
     else
        data2_i_in_div2 <= '1' & data2_i_in(data_width-1 downto 1);
     end if;
     if data1_r_in(data_width-1) = '0' then
        data1_r_in_div4 <= "00" & data1_r_in(data_width-1 downto 2);
     else
        data1_r_in_div4 <= "11" & data1_r_in(data_width-1 downto 2);
     end if;
     if data1_i_in(data_width-1) = '0' then
        data1_i_in_div4 <= "00" & data1_i_in(data_width-1 downto 2);
     else
        data1_i_in_div4 <= "11" & data1_i_in(data_width-1 downto 2);
     end if;
  end if;
end process data_scaling;

-- Output the results which are divided by 2 for scaling
data1_r_out <= std_logic_vector(Butt_Data1_Out_R_signed(data_width-2 downto 0)) & '0';
data1_i_out <= std_logic_vector(Butt_Data1_Out_I_signed(data_width-2 downto 0)) & '0';
data2_r_out <= std_logic_vector(Butt_Data2_Out_R_signed(data_width-2 downto 0)) & '0';
data2_i_out <= std_logic_vector(Butt_Data2_Out_I_signed(data_width-2 downto 0)) & '0';

TF1_X1_Mult: complex_mult
        generic map (data1_width        => tw_fact_width,
                     data2_width        => data_width
                    )
                port map(
                        data_rd         => data_rd,
                        data1_real      => tf1_r_div2,
                        data1_imag      => tf1_i_div2,
                        data2_real      => data2_r_in_div2,
                        data2_imag      => data2_i_in_div2,
                        data_out_real   => Mult_TF_Xn2_R_Out,
                        data_out_imag   => Mult_TF_Xn2_I_Out
                        );
end rtl;

serene

component已经都写全了，晚上来写fft的architecture和testbench！
就是不知道综合会不会有问题，请斑竹们帮帮忙，给看一下吧。

snowyd

我已经研究过了
在蝶形单元不用对数据处理直接在蝶形单元运算就行,不用进行除4运算.
是理论推导的,在数据进入前归一化后除以64这样,在FFT运算过程中怎么的也都不会
有溢处!
在我的毕业论文中已经介绍了!!!
在过去的一周的时间里,我大部分时间用来整理论文和翻译资料,虽然
我没有做完,但论文必须要整理,
所以心理也很矛盾,没能完成FFT,里面的关键问题没有说清,连我自己都觉得
论文没什么价值!

snowyd

蝶形块想用一个用于旋转因子复数的乘法器，再加上一个加法和一个减法器！！
还没实现，更谈不上验证仿真！！！
关于蝶形计数，级数计数单元我弄出来了同样没有验证仿真！！！
时序部分用于控制蝶形运算的没有弄明白！！！

旋转因子乘法器中应该有实数四个乘法器,和两个加/减法器!
还有控制单元用mealy状态机可不可以
!!
还有我的最顶层用蝶形单元!

spark

www.opencores.org 上有个fft的core是cfft，我觉得写的简单清楚，模块很少，比较好看懂，而且不用乘法器和rom，任意点数。

serene

下面引用由snowyd在 2004/06/19 05:58pm 发表的内容：
我已经研究过了
在蝶形单元不用对数据处理直接在蝶形单元运算就行,不用进行除4运算.
是理论推导的,在数据进入前归一化后除以64这样,在FFT运算过程中怎么的也都不会
有溢处!
...

蝶形单元对数据处理不完全是看会不会溢出，同时也是为了每一个stage的butterfly的数据保持同样的格式。从而使你的代码简洁明了。
我以前看过别人的fft设计，都有涉及数据处理的。在数据进入前归一化后除以64，会使得有效数据位减少。你再仔细想想。