谁会？

serene

[这个贴子最后由serene在 2004/05/26 00:04am 第 2 次编辑]

stg1_butterfly.vhd大致应该是这样的：
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity stg1_butterfly is
      generic(
             data_width     : integer := 16;                                             -- 前面已经有注释
             int_data_width : integer := 16;                                             
             tw_fact_width  : integer := 16);                                            
      port   (
             reset          : in std_logic;                                             
             clk            : in std_logic;                                             
             data_rd        : in std_logic;                                             
             data1_r_in     : in  std_logic_vector(data_width-1 downto 0);               
             data1_i_in     : in  std_logic_vector(data_width-1 downto 0);               
             data2_r_in     : in  std_logic_vector(data_width-1 downto 0);               
             data2_i_in     : in  std_logic_vector(data_width-1 downto 0);               
             tf1_r          : in  std_logic_vector(tw_fact_width-1 downto 0);            
             data1_r_out    : out std_logic_vector(int_data_width-1 downto 0);           
             data1_i_out    : out std_logic_vector(int_data_width-1 downto 0);           
             data2_r_out    : out std_logic_vector(int_data_width-1 downto 0);           
             data2_i_out    : out std_logic_vector(int_data_width-1 downto 0)            
             );
end stg1_butterfly;

architecture rtl of stg1_butterfly is
component Multiplier
generic(
             multiplier_width      : integer := 16;
             data_width            : integer := 16);
        port (
             load        : in std_logic;
             mult1_data  : in std_logic_vector(data_width-1 downto 0);
             mult2_data  : in std_logic_vector(multiplier_width-1 downto 0);
             product     : out std_logic_vector(multiplier_width+data_width-2 downto (multiplier_width-1)) -- 乘积输出
       );   
end component;
---------------------------------------------------------------------------
signal last_data_rd                : std_logic;                                    -- 用于读取数据
signal data1_r_in_div4             : std_logic_vector(data_width-1 downto 0);      -- （data1/4）的实部
signal data1_i_in_div4             : std_logic_vector(data_width-1 downto 0);      -- （data1/4）的虚部
signal Butt_Data1_Out_R_signed     : signed (data_width-1 downto 0);               -- butterfly的data1实部输出
signal Butt_Data1_Out_I_signed     : signed (data_width-1 downto 0);               -- butterfly的data1虚部输出
signal Butt_Data2_Out_R_signed     : signed (data_width-1 downto 0);               -- butterfly的data2实部输出
signal Butt_Data2_Out_I_signed     : signed (data_width-1 downto 0);               -- butterfly的data2虚部输出
signal Mult_A_C_Out                : std_logic_vector(data_width-1 downto 0);      -- 乘法器输出（实部）
signal Mult_A_D_Out                : std_logic_vector(data_width-1 downto 0);      -- 乘法器输出（虚部）

begin

stg1_butterfly_calcs:
process(data1_r_in_div4, data1_i_in_div4, Mult_A_C_Out, Mult_A_D_Out)
-- 该进程用于butterfly的输出，其值＝原输出/4。
begin
  Butt_Data1_Out_R_signed <= signed(data1_r_in_div4) + signed(Mult_A_C_Out);
  Butt_Data1_Out_I_signed <= signed(data1_i_in_div4) + signed(Mult_A_D_Out);
  Butt_Data2_Out_R_signed <= signed(data1_r_in_div4) - signed(Mult_A_C_Out);
  Butt_Data2_Out_I_signed <= signed(data1_i_in_div4) - signed(Mult_A_D_Out);
end process stg1_butterfly_calcs;

data_scaling:
process(reset, clk)
-- 该进程用于比例变换，为防乘法器溢出，相乘数据/2，乘积即为原来的1/4，所以对data1_in进行变换，存于data1_in_div4。
begin
  if reset = '0' then
     data1_r_in_div4 <= (others => '0');
     data1_i_in_div4 <= (others => '0');
  elsif Rising_Edge(clk) then  
     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;

-- 输出＝原输出值/2，这里实际需要对Butt_Data值乘2。
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';
--butterfly乘积实部计算
A_C_Mult: Multiplier
generic map (
                  multiplier_width => data_width,
                  data_width       => tw_fact_width
                  )
         port map (
                  load             => data_rd,
                  mult1_data       => tf1_r,
                  mult2_data       => data2_r_in,
                  product          => Mult_A_C_Out
                  );
--butterfly乘积虚部计算
A_D_Mult: Multiplier
generic map (
                  multiplier_width => data_width,
                  data_width       => tw_fact_width
                  )
         port map (
                  load             => data_rd,
                  mult1_data       => tf1_r,
                  mult2_data       => data2_i_in,
                  product          => Mult_A_D_Out
                  );
end rtl;

serene

下面引用由snowyd在 2004/05/25 06:01pm 发表的内容：
你的New Sample Read(上升沿)是指，有上升沿时就读数据？

现在再想想，好象上升沿不是太合理，就用高电平吧。前面的注释我已修改。

snowyd

fft这样做可以吗？entity fft is
      generic(
             coeff_width : integer := 16;
             data_width  : integer := 16;
             fft_length  : integer := 64);
      port   (
             RESET       : in  std_logic;                               -- 复位，假设低有效
             clk         : in  std_logic;                               -- 输入时钟
             START       : in  std_logic;                               -- 开始变换信号
             DATA_RD     : in  std_logic;                               -- New Sample Read (上升沿)
             DR          : in  std_logic_vector(Data_width-1 downto 0); -- 实部输入
             DI          : in  std_logic_vector(Data_width-1 downto 0); -- 虚部输入
             ADDRESS     : in  std_logic_vector(6 downto 0);            -- 输出矩阵地址
             XK_R        : out std_logic_vector(Data_width-1 downto 0); -- 实部输出
             XK_I        : out std_logic_vector(Data_width-1 downto 0); -- 虚部输出
             RES_VALID   : out std_logic                                -- 输出有效指示
             );
end fft;
architecture FFT of fft  is
  component fft
      port (
        clk      : in  std_logic;
        RESET    : in std_logic;
        DR15     : in std_logic;
        DR14     : in std_logic;
        DR13     : in std_logic;
        DR12     : in std_logic;
        DR11     : in std_logic;
        DR10     : in std_logic;
        DR9     : in std_logic;
        DR8     : in std_logic;
        DR7     : in std_logic;
        DR6     : in std_logic;
        DR5     : in std_logic;
        DR4     : in std_logic;
        DR3     : in std_logic;
        DR2     : in std_logic;
        DR1     : in std_logic;
        DR0     : in std_logic;
        DI15     : in std_logic;
        DI14     : in std_logic;
        DI13     : in std_logic;
        DI12     : in std_logic;
        DI11     : in std_logic;
        DI10     : in std_logic;
        DI9     : in std_logic;
        DI8     : in std_logic;
        DI7     : in std_logic;
        DI6     : in std_logic;
        DI5     : in std_logic;
        DI4     : in std_logic;
        DI3     : in std_logic;
        DI2     : in std_logic;
        DI1     : in std_logic;
        DI0     : in std_logic;
        START   : in std_logic;
        RES_VALID  : out std_logic;
        XK_R15  : out std_logic;
        XK_R14  : out std_logic;
        XK_R13  : out std_logic;
        XK_R12  : out std_logic;
        XK_R11  : out std_logic;
        XK_R10  : out std_logic;
        XK_R9  : out std_logic;
        XK_R8  : out std_logic;
        XK_R7  : out std_logic;
        XK_R6  : out std_logic;
        XK_R5 : out std_logic;
        XK_R4  : out std_logic;
        XK_R3  : out std_logic;
        XK_R2  : out std_logic;
        XK_R1  : out std_logic;
        XK_R0  : out std_logic;
        XK_I15  : out std_logic;
        XK_I14  : out std_logic;
        XK_I13  : out std_logic;
        XK_I12  : out std_logic;
        XK_I11  : out std_logic;
        XK_I10  : out std_logic;
        XK_I9  : out std_logic;
        XK_I8  : out std_logic;
        XK_I7  : out std_logic;
        XK_I6  : out std_logic;
        XK_I5  : out std_logic;
        XK_I4  : out std_logic;
        XK_I3  : out std_logic;
        XK_I2  : out std_logic;
        XK_I1  : out std_logic;
        XK_I0  : out std_logic      
) ;
         end component;
begin
  FFT64: fft
    port map (
        RS    => RS ,
        DR15    => DR(15) ,
        DR14    => DR(14) ,
        DR13    => DR(13) ,
        DR12    => DR(12) ,
        DR11    => DR(11) ,
        DR10    => DR(10) ,
        DR9     => DR(9) ,
        DR8     => DR(8) ,
        DR7     => DR(7) ,
        DR6     => DR(6) ,
        DR5     => DR(5) ,
        DR4     => DR(4) ,
        DR3     => DR(3) ,
        DR2     => DR(2) ,
        DR1     => DR(1) ,
        DR0     => DR(0) ,
        DI15    => DI(15) ,
        DI14    => DI(14) ,
        DI13    => DI(13) ,
        DI12    => DI(12) ,
        DI11    => DI(11) ,
        DI10    => DI(10) ,
        DI9     => DI(9) ,
        DI8     => DI(8) ,
        DI7     => DI(7) ,
        DI6     => DI(6) ,
        DI5     => DI(5) ,
        DI4     => DI(4) ,
        DI3     => DI(3) ,
        DI2     => DI(2) ,
        DI1     => DI(1) ,
        DI0     => DI(0) ,
        START   => START ,
        clk     => clk ,
        RES_VALID   =>RES_VALID,   
        XK_R15   => XK_R(15) ,
        XK_R14   => XK_R(14) ,
        XK_R13   => XK_R(13) ,
        XK_R12   => XK_R(12) ,
        XK_R11   => XK_R(11) ,
        XK_R10   => XK_R(10) ,
        XK_R9    => XK_R(9) ,
        XK_R8    => XK_R(8) ,
        XK_R7    => XK_R(7) ,
        XK_R6    => XK_R(6) ,
        XK_R5    => XK_R(5) ,
        XK_R4    => XK_R(4) ,
        XK_R3    => XK_R(3) ,
        XK_R2    => XK_R(2) ,
        XK_R1    => XK_R(1) ,
        XK_R0    => XK_R(0) ,
        XK_I15   => XK_I(15) ,
        XK_I14   => XK_I(14) ,
        XK_I13   => XK_I(13) ,
        XK_I12   => XK_I(12) ,
        XK_I11   => XK_I(11) ,
        XK_I10   => XK_I(10) ,
        XK_I9    => XK_I(9) ,
        XK_I8    => XK_I(8) ,
        XK_I7    => XK_I(7) ,
        XK_I6    => XK_I(6) ,
        XK_I5    => XK_I(5) ,
        XK_I4    => XK_I(4) ,
        XK_I3    => XK_I(3) ,
        XK_I2    => XK_I(2) ,
        XK_I1    => XK_I(1) ,
        XK_I0    => XK_I(0));
end FFT;

serene

对于乘法器的说明：
一般来说用纯小数或纯整数乘法比较容易确定小数点的位置，不易搞错。
这里采用x.xxxxxxx xxxxxxxx格式的两数相乘，乘积为：
yy.yyyyyy yyyyyyyy (yyyyyyyy yyyyyyyy)格式，对该值左移1位，成为：
y.yyyyyyy yyyyyyyy格式。这样做是为了计算上小数点不易搞错。

serene

前面的stg1_butterfly要用到乘法器，这个还比较简单，multiplier.vhd可以是：
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity multiplier is
  generic(multiplier_width       : natural;
          data_width             : natural);
  port(
          load         : in std_logic;                                                  -- 输入数据ready
          mult1_data   : in std_logic_vector(multiplier_width-1 downto 0);              -- Data1
          mult2_data   : in std_logic_vector(data_width-1 downto 0);                    -- Data2
          product      : out std_logic_vector(multiplier_width+data_width-2 downto (multiplier_width-1))   -- 乘积输出
);
end multiplier;
architecture rtl of multiplier is
signal t_product       : std_logic_vector(multiplier_width+data_width-1 downto 0);      -- 乘积
begin
  process (load, mult1_data, mult2_data)
  begin
    if load = '1' then
      t_product <= std_logic_vector(signed(mult1_data) * signed(mult2_data));
    end if;  
  end process;
product <= t_product(multiplier_width+data_width-2 downto (multiplier_width-1));
end rtl;

serene

[这个贴子最后由serene在 2004/05/26 10:08am 第 1 次编辑]

建议先将stg1_butterfly编译仿真一下看看，验证一下正确与否。
对于butterfly这个component，由于旋转因子含有虚部，所以要用复数乘法来替代前面的multiplier。其乘数有实部、虚部，乘积也含有实部、虚部。复数乘法器可以调用multiplier来实现。

serene

下面引用由snowyd在 2004/05/26 09:23am 发表的内容：
fft这样做可以吗？entity fft is
      generic(
             coeff_width = 16;
             data_width  = 16;
...

感觉上，数组还是用std_logic_vector比较好，看起来简洁明了，行数也会少很多。
如果你的project就是这个FFT，不是其它应用调用FFT模块，也可以不写fft component，直接在architecture里写好了，因为已经是最顶层了。

serene

[这个贴子最后由serene在 2004/05/27 00:27am 第 2 次编辑]

fft的architecture建议这样考虑：
architecture fft_architecture of fft is
--component dual_port_ram 前面已经有描述
--component stg1_butterfly 前面已经有描述
--component butterfly 前面已经有描述
-------------------------------------------------------------------------
--constant subtype type 等
--signal 定义
begin
--旋转因子实部、虚部赋值
-- process－data_average: 输入数据存入Ram1和Ram2前计算其平均值，该值用作stg1_butterfly的数据输入

-- process－reverse_address: 新数据到达后指示bit reversal，bit reversal结束后指示可以取新数据

-- process－reverse_bits:reverse存储地址，使数据写入正确的 Ram1和Ram2地址

-- process－选择Ram1和Ram2中的实部或虚部copy到FFT array

-- process－将Ram1和Ram2中的实部和虚部数据copy到FFT array

-- process－计算完成、结果有效指示

-- 结果输出到data_out

-- Component例化：
-- Ram1
-- Ram2
-- Stage1-6 Butterfly，这里的内容会很长。
end;

snowyd

现在我已经将旋转因子装到rom里面！
还有我打算输入数据全部变换成0和1之间的定点小数，这样跟旋转因子一样了1！
还有蝶形图我打算就用第二个，第一个省掉1！
处理上第一级把虚部等于0！！！！
还有对于fft作为最顶层
时！你说的思想，我不能完全明白？

serene

是啊，从程序上看，两个蝶形图可以合并的，但不清楚会不会多占资源。
从数学角度看，每个stage有32个butterflies，共有6个stage，很费资源的，估计编译都要化一定时间的。
对于fft作为最顶层，是你的peoject决定的，如果你的peoject就是这个FFT，那就不必做fft component了；如果是其它的功能中需要调用FFT，那么就做成component，因为那个功能才是最顶层，这样比较明了。
呵呵，做出来后，一定要告诉我结果啊，如所耗的资源、能达到的Fmax等。
另外，我觉得好象曾看到的你的有些回帖找不到了，郁闷。