verilog实现8点FFT运算

已于 2022-03-17 16:19:31 修改
阅读量3.8k 收藏 52
点赞数 6
文章标签： verilog fpga
于 2021-07-19 22:07:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43623428/article/details/118915463
版权

IP核设定

使用复数乘法IP核，参数设定如下：
在这里插入图片描述
在这里插入图片描述

verilog代码以及testbench

fft_8.v

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2021/07/16 11:15:56
// Design Name: 
// Module Name: fft_8
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module fft_8(
	// input ena
input clk, 
input reset,

// input data
input din_ena,
input signed [9:0] din_re0,
input signed [9:0] din_im0,
input signed [9:0] din_re1,
input signed [9:0] din_im1,
input signed [9:0] din_re2,
input signed [9:0] din_im2,
input signed [9:0] din_re3,
input signed [9:0] din_im3,
input signed [9:0] din_re4,
input signed [9:0] din_im4,
input signed [9:0] din_re5,
input signed [9:0] din_im5,
input signed [9:0] din_re6,
input signed [9:0] din_im6,
input signed [9:0] din_re7,
input signed [9:0] din_im7,


// output data
output dout_ena,
output signed [12:0] dout_re0,
output signed [12:0] dout_im0,
output signed [12:0] dout_re1,
output signed [12:0] dout_im1,
output signed [12:0] dout_re2,
output signed [12:0] dout_im2,
output signed [12:0] dout_re3,
output signed [12:0] dout_im3,
output signed [12:0] dout_re4,
output signed [12:0] dout_im4,
output signed [12:0] dout_re5,
output signed [12:0] dout_im5,
output signed [12:0] dout_re6,
output signed [12:0] dout_im6,
output signed [12:0] dout_re7,
output signed [12:0] dout_im7

    );
    
    //  FFT_1
    reg fft1_ena;
        reg signed [10:0] fft1_re0;
    reg signed [10:0] fft1_im0;
    		reg signed [10:0] fft1_re1;
    reg signed [10:0] fft1_im1;
        reg signed [10:0] fft1_re2;
    reg signed [10:0] fft1_im2;
        reg signed [10:0] fft1_re3;
    reg signed [10:0] fft1_im3;
        reg signed [10:0] fft1_re4;
    reg signed [10:0] fft1_im4;
        reg signed [10:0] fft1_re5;
    reg signed [10:0] fft1_im5;
        reg signed [10:0] fft1_re6;
    reg signed [10:0] fft1_im6;
        reg signed [10:0] fft1_re7;
    reg signed [10:0] fft1_im7;

always @ (posedge clk)
		if(!reset)
			// reset the device
			begin
				fft1_ena <=0;
				fft1_re0 <=0;
				fft1_im0 <=0;
				fft1_re1 <=0;
				fft1_im1 <=0;
				fft1_re2 <=0;
				fft1_im2 <=0;
				fft1_re3 <=0;
				fft1_im3 <=0;
				fft1_re4 <=0;
				fft1_im4 <=0;
				fft1_re5 <=0;
				fft1_im5 <=0;
				fft1_re6 <=0;
				fft1_im6 <=0;
				fft1_re7 <=0;
				fft1_im7 <=0;
			end
		else if(din_ena)
			begin
				fft1_ena <= 1;
				fft1_re0 <= din_re0 + din_re4;
				fft1_im0 <= din_im0 + din_im4;
				fft1_re1 <= din_re0 - din_re4;
				fft1_im1 <= din_im0 - din_im4;
				fft1_re2 <= din_re2 + din_re6;
				fft1_im2 <= din_im2 + din_im6;
				fft1_re3 <= din_re2 - din_re6;
				fft1_im3 <= din_im2 - din_im6;
				fft1_re4 <= din_re1 + din_re5;
				fft1_im4 <= din_im1 + din_im5;
				fft1_re5 <= din_re1 - din_re5;
				fft1_im5 <= din_im1 - din_im5;
				fft1_re6 <= din_re3 + din_re7;
				fft1_im6 <= din_im3 + din_im7;
				fft1_re7 <= din_re3 - din_re7;
				fft1_im7 <= din_im3 - din_im7;
			end
    else
    	fft1_ena <= 0;
    
    //FFT_2
    wire fft2_ena1_d0;
    wire signed [9:0] fft2_f1im;
    wire signed [10:0] fft2_im3_d0;
    wire signed [2:0] fft2_b1lim;
    wire signed [9:0] fft2_f1re;
    wire signed [10:0] fft2_re3_d0;
    wire signed [2:0] fft2_b1lre;
    cmpy_0 commul22 (
  .aclk(clk),                              // input wire aclk
  .s_axis_a_tvalid(fft1_ena),        // input wire s_axis_a_tvalid
  .s_axis_a_tdata({4'd0,fft1_im3,1'd0,4'd0,fft1_re3,1'd0}),          // input wire [31 : 0] s_axis_a_tdata
  .s_axis_b_tvalid(1'b1),        // input wire s_axis_b_tvalid
  .s_axis_b_tdata({8'b11111111,8'b10000000,8'd0,8'b00000000}),          // input wire [31 : 0] s_axis_b_tdata
  .m_axis_dout_tvalid(fft2_ena1_d0),  // output wire m_axis_dout_tvalid
  .m_axis_dout_tdata({fft2_f1im,fft2_im3_d0,fft2_b1lim,fft2_f1re,fft2_re3_d0,fft2_b1lre})    // output wire [47 : 0] m_axis_dout_tdata
);

    wire fft2_ena2_d0;
    wire signed [9:0] fft2_f2im;
    wire signed [10:0] fft2_im7_d0;
    wire signed [2:0] fft2_b2lim;
    wire signed [9:0] fft2_f2re;
    wire signed [10:0] fft2_re7_d0;
    wire signed [2:0] fft2_b2lre;
    cmpy_0 commul24 (
  .aclk(clk),                              // input wire aclk
  .s_axis_a_tvalid(fft1_ena),        // input wire s_axis_a_tvalid
  .s_axis_a_tdata({4'd0,fft1_im7,1'd0,4'd0,fft1_re7,1'd0}),          // input wire [31 : 0] s_axis_a_tdata
  .s_axis_b_tvalid(1'b1),        // input wire s_axis_b_tvalid
  .s_axis_b_tdata({8'b11111111,8'b10000000,8'd0,8'b00000000}),          // input wire [31 : 0] s_axis_b_tdata
  .m_axis_dout_tvalid(fft2_ena2_d0),  // output wire m_axis_dout_tvalid
  .m_axis_dout_tdata({fft2_f2im,fft2_im7_d0,fft2_b2lim,fft2_f2re,fft2_re7_d0,fft2_b2lre})    // output wire [47 : 0] m_axis_dout_tdata
);
    
        reg fft2_ena;
        reg signed [11:0] fft2_re0;
    reg signed [11:0] fft2_im0;
    		reg signed [11:0] fft2_re1;
    reg signed [11:0] fft2_im1;
        reg signed [11:0] fft2_re2;
    reg signed [11:0] fft2_im2;
        reg signed [11:0] fft2_re3;
    reg signed [11:0] fft2_im3;
        reg signed [11:0] fft2_re4;
    reg signed [11:0] fft2_im4;
        reg signed [11:0] fft2_re5;
    reg signed [11:0] fft2_im5;
        reg signed [11:0] fft2_re6;
    reg signed [11:0] fft2_im6;
        reg signed [11:0] fft2_re7;
    reg signed [11:0] fft2_im7;
    
always @ (posedge clk)
		if(!reset)
			begin
				fft2_ena <= 0;
				fft2_re0 <= 0;
				fft2_im0 <= 0;
				fft2_re1 <= 0;
				fft2_im1 <= 0;
				fft2_re2 <= 0;
				fft2_im2 <= 0;
				fft2_re3 <= 0;
				fft2_im3 <= 0;
				fft2_re4 <= 0;
				fft2_im4 <= 0;
				fft2_re5 <= 0;
				fft2_im5 <= 0;
				fft2_re6 <= 0;
				fft2_im6 <= 0;
				fft2_re7 <= 0;
				fft2_im7 <= 0;
			end
		else if(fft2_ena2_d0&&fft2_ena1_d0)
			begin
				fft2_ena <=1;
				fft2_re0 <= fft1_re0 + fft1_re2;
				fft2_im0 <= fft1_im0 + fft1_im2;
				fft2_re2 <= fft1_re0 - fft1_re2;
				fft2_im2 <= fft1_im0 - fft1_im2;
				
				fft2_re1 <= fft1_re1 + fft2_re3_d0;
				fft2_im1 <= fft1_im1 + fft2_im3_d0;
				fft2_re3 <= fft1_re1 - fft2_re3_d0;
				fft2_im3 <= fft1_im1 - fft2_im3_d0;
				
				fft2_re4 <= fft1_re4 + fft1_re6;
				fft2_im4 <= fft1_im4 + fft1_im6;
				fft2_re6 <= fft1_re4 - fft1_re6;
				fft2_im6 <= fft1_im4 - fft1_im6;
				
				fft2_re5 <= fft1_re5 + fft2_re7_d0;
				fft2_im5 <= fft1_im5 + fft2_im7_d0;
				fft2_re7 <= fft1_re5 - fft2_re7_d0;
				fft2_im7 <= fft1_im5 - fft2_im7_d0;
			end
		else
			fft2_ena <= 0;
		
    // FFT_3
    wire fft3_ena1_d0;
    wire signed [5:0] fft3_f1im;
    wire signed [11:0] fft3_im5_d0;
    wire signed [5:0] fft3_b1lim;
    wire signed [5:0] fft3_f1re;
    wire signed [11:0] fft3_re5_d0;
    wire signed [5:0] fft3_b1lre;
    cmpy_0 commul32 (
  .aclk(clk),                              // input wire aclk
  .s_axis_a_tvalid(fft2_ena),        // input wire s_axis_a_tvalid
  .s_axis_a_tdata({4'd0,fft2_im5,4'd0,fft2_re5}),          // input wire [31 : 0] s_axis_a_tdata
  .s_axis_b_tvalid(1'b1),        // input wire s_axis_b_tvalid
  .s_axis_b_tdata({4'd0,12'b101001011000,4'd0,12'b010110101000}),          // input wire [31 : 0] s_axis_b_tdata
  .m_axis_dout_tvalid(fft3_ena1_d0),  // output wire m_axis_dout_tvalid
  .m_axis_dout_tdata({fft3_f1im,fft3_im5_d0,fft3_b1lim,fft3_f1re,fft3_re5_d0,fft3_b1lre})    // output wire [47 : 0] m_axis_dout_tdata
);
		wire fft3_ena2_d0;
    wire signed [5:0] fft3_f2im;
    wire signed [11:0] fft3_im6_d0;
    wire signed [5:0] fft3_b2lim;
    wire signed [5:0] fft3_f2re;
    wire signed [11:0] fft3_re6_d0;
    wire signed [5:0] fft3_b2lre;
    cmpy_0 commul33 (
  .aclk(clk),                              // input wire aclk
  .s_axis_a_tvalid(fft2_ena),        // input wire s_axis_a_tvalid
  .s_axis_a_tdata({4'd0,fft2_im6,4'd0,fft2_re6}),          // input wire [31 : 0] s_axis_a_tdata
  .s_axis_b_tvalid(1'b1),        // input wire s_axis_b_tvalid
  .s_axis_b_tdata({4'd0,12'b100000000000,4'd0,12'b000000000000}),          // input wire [31 : 0] s_axis_b_tdata
  .m_axis_dout_tvalid(fft3_ena2_d0),  // output wire m_axis_dout_tvalid
  .m_axis_dout_tdata({fft3_f2im,fft3_im6_d0,fft3_b2lim,fft3_f2re,fft3_re6_d0,fft3_b2lre})    // output wire [47 : 0] m_axis_dout_tdata
);
		wire fft3_ena3_d0;
    wire signed [5:0] fft3_f3im;
    wire signed [11:0] fft3_im7_d0;
    wire signed [5:0] fft3_b3lim;
    wire signed [5:0] fft3_f3re;
    wire signed [11:0] fft3_re7_d0;
    wire signed [5:0] fft3_b3lre;
    cmpy_0 commul34 (
  .aclk(clk),                              // input wire aclk
  .s_axis_a_tvalid(fft2_ena),        // input wire s_axis_a_tvalid
  .s_axis_a_tdata({4'd0,fft2_im7,4'd0,fft2_re7}),          // input wire [31 : 0] s_axis_a_tdata
  .s_axis_b_tvalid(1'b1),        // input wire s_axis_b_tvalid
  .s_axis_b_tdata({4'd0,12'b101001011000,4'd0,12'b101001011000}),          // input wire [31 : 0] s_axis_b_tdata
  .m_axis_dout_tvalid(fft3_ena3_d0),  // output wire m_axis_dout_tvalid
  .m_axis_dout_tdata({fft3_f3im,fft3_im7_d0,fft3_b3lim,fft3_f3re,fft3_re7_d0,fft3_b3lre})    // output wire [47 : 0] m_axis_dout_tdata
);
        reg fft3_ena;
        reg signed [12:0] fft3_re0;
    reg signed [12:0] fft3_im0;
    		reg signed [12:0] fft3_re1;
    reg signed [12:0] fft3_im1;
        reg signed [12:0] fft3_re2;
    reg signed [12:0] fft3_im2;
        reg signed [12:0] fft3_re3;
    reg signed [12:0] fft3_im3;
        reg signed [12:0] fft3_re4;
    reg signed [12:0] fft3_im4;
        reg signed [12:0] fft3_re5;
    reg signed [12:0] fft3_im5;
        reg signed [12:0] fft3_re6;
    reg signed [12:0] fft3_im6;
        reg signed [12:0] fft3_re7;
    reg signed [12:0] fft3_im7;
always @ (posedge clk)
		if(!reset)
			begin
				fft3_ena <= 0;
				fft3_re0 <= 0;
				fft3_im0 <= 0;
				fft3_re1 <= 0;
				fft3_im1 <= 0;
				fft3_re2 <= 0;
				fft3_im2 <= 0;
				fft3_re3 <= 0;
				fft3_im3 <= 0;
				fft3_re4 <= 0;
				fft3_im4 <= 0;
				fft3_re5 <= 0;
				fft3_im5 <= 0;
				fft3_re6 <= 0;
				fft3_im6 <= 0;
				fft3_re7 <= 0;
				fft3_im7 <= 0;
			end
			else if(fft3_ena1_d0&&fft3_ena2_d0&&fft3_ena3_d0)
				begin
					fft3_ena <=1'b1;
					fft3_re0 <= fft2_re0 + fft2_re4;
					fft3_im0 <= fft2_im0 + fft2_im4;
					fft3_re4 <= fft2_re0 - fft2_re4;
					fft3_im4 <= fft2_im0 - fft2_im4;
					
					fft3_re1 <= fft2_re1 + fft3_re5_d0;
					fft3_im1 <= fft2_im1 + fft3_im5_d0;
					fft3_re5 <= fft2_re1 - fft3_re5_d0;
					fft3_im5 <= fft2_im1 - fft3_im5_d0;
					
					fft3_re2 <= fft2_re2 + fft3_re6_d0;
					fft3_im2 <= fft2_im2 + fft3_im6_d0;
					fft3_re6 <= fft2_re2 - fft3_re6_d0;
					fft3_im6 <= fft2_im2 - fft3_im6_d0;
					
					fft3_re3 <= fft2_re3 + fft3_re7_d0;
					fft3_im3 <= fft2_im3 + fft3_im7_d0;
					fft3_re7 <= fft2_re3 - fft3_re7_d0;
					fft3_im7 <= fft2_im3 - fft3_im7_d0;
				end
			else
				fft3_ena <= 0;
assign dout_ena = fft3_ena;
assign dout_re0 = fft3_re0;
assign dout_im0 = fft3_im0;
assign dout_re1 = fft3_re1;
assign dout_im1 = fft3_im1;
assign dout_re2 = fft3_re2;
assign dout_im2 = fft3_im2;
assign dout_re3 = fft3_re3;
assign dout_im3 = fft3_im3;
assign dout_re4 = fft3_re4;
assign dout_im4 = fft3_im4;
assign dout_re5 = fft3_re5;
assign dout_im5 = fft3_im5;
assign dout_re6 = fft3_re6;
assign dout_im6 = fft3_im6;
assign dout_re7 = fft3_re7;
assign dout_im7 = fft3_im7;
endmodule

fft_8_tb.v

`timescale 1ns / 1ps
//
// Company: 
// Engineer: 
// 
// Create Date: 2021/07/16 17:56:18
// Design Name: 
// Module Name: fft_8_tb
// Project Name: 
// Target Devices: 
// Tool Versions: 
// Description: 
// 
// Dependencies: 
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
//


module fft_8_tb(

    );
    reg aclk;
    reg rst;
    reg din_ena;
    wire dout_ena;
    reg [9:0] din_re0;
    reg [9:0] din_im0;
    reg [9:0] din_re1;
    reg [9:0] din_im1;
    reg [9:0] din_re2;
    reg [9:0] din_im2;
    reg [9:0] din_re3;
    reg [9:0] din_im3;
    reg [9:0] din_re4;
    reg [9:0] din_im4;
    reg [9:0] din_re5;
    reg [9:0] din_im5;
    reg [9:0] din_re6;
    reg [9:0] din_im6;
    reg [9:0] din_re7;
    reg [9:0] din_im7;
    wire [12:0] dout_re0;
    wire [12:0] dout_im0;
    wire [12:0] dout_re1;
    wire [12:0] dout_im1;
    wire [12:0] dout_re2;
    wire [12:0] dout_im2;
    wire [12:0] dout_re3;
    wire [12:0] dout_im3;
    wire [12:0] dout_re4;
    wire [12:0] dout_im4;
    wire [12:0] dout_re5;
    wire [12:0] dout_im5;
    wire [12:0] dout_re6;
    wire [12:0] dout_im6;
    wire [12:0] dout_re7;
    wire [12:0] dout_im7;
    
    initial
    begin
        #0 aclk = 0;
            rst = 0;
        #10
            rst = 1;
            din_ena = 1;
            din_re0 = 10'b0000000000;
            din_im0 = 10'b0000000000;
            din_re1 = 10'b0000000000;
            din_im1 = 10'b0000000000;
            din_re2 = 10'b0010000000;
            din_im2 = 10'b0000000000;
            din_re3 = 10'b0000000000;
            din_im3 = 10'b0000000000;
            din_re4 = 10'b0100000000;
            din_im4 = 10'b0000000000;
            din_re5 = 10'b0000000000;
            din_im5 = 10'b0000000000;
            din_re6 = 10'b0000000000;
            din_im6 = 10'b0000000000;
            din_re7 = 10'b0000000000;
            din_im7 = 10'b0000000000;
        forever 
         #5 aclk =~aclk;
    end
    
    fft_8 fft81(
        .clk(aclk),
        .reset(rst),
        .din_ena(din_ena),
        .din_re0(din_re0),
        .din_im0(din_im0),
        .din_re1(din_re1),
        .din_im1(din_im1),
        .din_re2(din_re2),
        .din_im2(din_im2),
        .din_re3(din_re3),
        .din_im3(din_im3),
        .din_re4(din_re4),
        .din_im4(din_im4),
        .din_re5(din_re5),
        .din_im5(din_im5),
        .din_re6(din_re6),
        .din_im6(din_im6),
        .din_re7(din_re7),
        .din_im7(din_im7),
        
        .dout_ena(dout_ena),
        .dout_re0(dout_re0),
        .dout_im0(dout_im0),
        .dout_re1(dout_re1),
        .dout_im1(dout_im1),
        .dout_re2(dout_re2),
        .dout_im2(dout_im2),
        .dout_re3(dout_re3),
        .dout_im3(dout_im3),
        .dout_re4(dout_re4),
        .dout_im4(dout_im4),
        .dout_re5(dout_re5),
        .dout_im5(dout_im5),
        .dout_re6(dout_re6),
        .dout_im6(dout_im6),
        .dout_re7(dout_re7),
        .dout_im7(dout_im7)
    );
endmodule

输出结果dout中的数的构成是：
共13位其中5位整数，8位小数。
模拟结果在波形图里应该如下设置：
在这里插入图片描述
在这里插入图片描述
输出结果如下：
在这里插入图片描述
可以看到会有一些误差存在，因为在使用ip核进行计算的时候，直接对小数乘法部分进行了截断处理，会造成误差。
和matlab结果对比：
在这里插入图片描述
在这里插入图片描述

历久弥坚
关注
  • 6
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
fft，verilog
05-19
这个是利用IP内核写的fft，建议私人不要下载（不过里面还有其他可参考的文件），youIP核的人可以下载参考
verilog实现1024点FFT算法
一个热爱通信的硬件算法工程师
05-06 752
verilog实现1024点FFT算法
使用Verilog实现FFT （付完整注释 可直接运行的源码 ！）
qq_26584021的博客
07-18 3398
Verilog FFT 设计 实现了通用的Butterfly和四点的FFT/IFFT，代码也配有非常完整的注释，方便理解。非常适合入门verilog练手。😝本工程使用iverlog和modelsim通过了仿真，
m基于FPGA的256点FFT傅里叶变换verilog实现,含testbench,不使用IP核
fpga/matlab/simulink算法仿真工程
07-25 1531
FFT是一种高效的计算傅里叶变换的算法，可以降低傅里叶变换的计算复杂度。对于长度为$N=2^m$的信号序列，其中$m$是整数，快速傅里叶变换可以通过分治法和蝶形运算来实现。对于256点FFT，信号序列长度$N=256$，可以使用快速傅里叶变换算法高效地计算。基于FPGA的256点FFT傅里叶变换Verilog实现是一个重要的信号处理技术，在数字信号处理、通信系统和图像处理等领域有广泛的应用。因为FFT模块需要大量的计算和存储资源，如何在有限的FPGA资源约束下完成256点FFT的实现是一个挑战。
64点FFT的verilog 实现
热门推荐
清爽帅气的博客
03-21 1万+
目录 1.工作说明 2.系数计算 3.数据选取 4.变量说明 5.仿真结果 1)波形 2)Transcript 6.Matlab 验证 1.工作说明 1.采用硬件RTL代码实现串行64点FFT算法 具体实现方法不做硬性要求，可以自行定义 FFT输入I/Q数据为8bits有符号数，输出I/Q数据20bits。数据存储模块可以用verilog二维数组建模 2.FFT基本公式如下 3.给出算法结构...
FFT蝶形算法的verilog实现专题——FFT的matlab到verilog转化过程——第1部分
gzy0506的博客
11-13 8516
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 FFT蝶形算法的verilog实现专题——FFT的matlab到verilog转化过程——第1部分 功能需求 算法方案要点 verilog 模块的接口： 因为FFT是流水线模式的，即进来64个点，出去64个点 进来的顺序为： x(0),x(1),…x(63) 顺序输入，出去的点为X(0),X(32),X(16),X(48)…倒序输出。 具体问题具体分析： 从我们的具体需求分析，输入13个复数，后面53个都是0，可以对第一阶段运算进行简化
Verilog实现8点FFT与128点FFT
09-05
标题中的“Verilog实现8点FFT与128点FFT”指的是使用硬件描述语言Verilog设计并实现快速傅里叶变换（FFT）算法，分别针对8个数据点和128个数据点的情况。FFT是一种在数字信号处理领域广泛应用的算法，它能够将一个...
基于verilog的2048点fft实现
05-26
本项目“基于verilog的2048点fft实现”着重讨论了如何在FPGA（Field-Programmable Gate Array）上利用硬件描述语言Verilog实现2048点的FFT运算。 FPGA是一种可编程逻辑器件，它的优点在于能够根据设计需求灵活配置...
verilog流水线256点fft算法
07-17
在本项目中，"verilog流水线256点fft算法"是指利用Verilog实现的一种256点快速傅里叶变换（FFT）算法，并采用了流水线技术进行优化。流水线技术是数字系统设计中的一个重要概念，它通过将计算过程分成多个阶段，每个...
64点FFT Verilog实现
03-21
本项目将深入探讨如何使用Verilog实现64点的FFT。 FFT算法是一种高效的计算离散傅里叶变换（DFT）的方法，它的主要思想是将大问题分解为小问题，通过复用计算结果来减少运算量。64点的FFT通常会使用蝶形结构，该...
FFT的verilog实现详解
01-21
FFT算法在FPGA上的verilog实现 详解 Implementation of Fast Fourier Transform (FFT) on FPGA using Verilog HDL
基于verilog编程实现的2048点FFT实现不使用IP核，
04-29
标题中的“基于verilog编程实现的2048点FFT实现不使用IP核”表明了这是一个使用硬件描述语言Verilog实现的项目，目标是设计一个2048点的快速傅里叶变换（FFT）算法，而且这个实现不依赖于现成的 Intellectual ...
基于verilog的四级流水线实现并行fft16(可计算小数和负数)
qq_62229083的博客
04-05 2020
本人第一次写csdn,其中如果有写的不正确或者不恰当的地方还请多多批评指正，在下不胜感激。
2020-11-08
m0_37753944的博客
11-08 723
FFT 设计 设计说明 为了利用仿真简单的说明 FFT 的变换过程，数据点数取较小的值 8。 如果数据是串行输入，需要先进行缓存，所以设计时数据输入方式为并行。 数据输入分为实部和虚部共 2 部分，所以计算结果也分为实部和虚部。 设计采用流水结构，暂不考虑资源消耗的问题。 为了使设计结构更加简单，这里做一步妥协，乘法计算直接使用乘号。如果 FFT 设计应用于实际，一定要将乘法结构换成可以流水的乘法器，或使用官方提供的效率较高的乘法器 IP。 蝶形单元设计 蝶形单元为定点运算，需要对旋转...
基于Verilog HDL的FFT算法硬件实现（8点，三级流水线，DIT-FFT）
小张爱学习哦的博客
02-13 3801
三级流水，8点fft算法verilog实现
基于Verilog的FFT模块实现
FPGA/MATLAB学习教程/源码/项目合作开发
02-11 4135
/* -- Arish Alreja: ECE 4902 Special Problems Spring 2006 -- School of Electrical & Computer Engineering -- Georgia Institute of Technology -- Atlanta, GA 30332 -- -- 64 point FFT Processor -- -- Top level FFT module */ module fft ( ...
FFT蝶形算法的verilog实现专题——64点FFT 蝶形算法完整展开
gzy0506的博客
11-06 8437
FFT蝶形算法的verilog实现专题——64点FFT 蝶形算法完整展开 针对上一篇博文继续分解 因为64点FFT进行分组后，每组还是有16个数据，这需要对每组的16个数据在进行分组，这样才能达到最小运算单位4点FFT。 同样的，将A(n),B(n),C(n),D(n)按照上面的分组规则再次分组，A(n)又分出了4个数据组,依此类推，直接用matlab程序来展示(程序段3) close all; clear all; clc; %%%%%%%%%%%stage1 N = 64; n = 0:N/4-1;
互联网生态峰会PPT模板
最新发布
07-13
【作品名称】：互联网生态峰会PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
verilog实现64点fft算法
05-12
在Verilog中实现64点FFT算法需要以下步骤： 1. 设计输入输出接口 根据算法需求设计模块的输入输出接口，包括输入数据和输出数据的宽度和信号类型等。在FFT算法中，输入为时域信号，输出为频域信号。 2. 编写蝶形...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值