verilog实现8点FFT运算

已于 2022-03-17 16:19:31 修改
阅读量3.9k 收藏 55
点赞数 7
文章标签： 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结果对比：
在这里插入图片描述
在这里插入图片描述

历久弥坚
关注
  • 7
    点赞
  • 踩
  • 55
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
FFT蝶形算法的verilog实现专题——64点FFT 蝶形算法完整展开
gzy0506的博客
11-06 8448
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;
FFT蝶形算法的verilog实现专题——FFT的matlab到verilog转化过程——第1部分
gzy0506的博客
11-13 8536
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 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实现1024点FFT算法
一个热爱通信的硬件算法工程师
05-06 810
verilog实现1024点FFT算法
基于System Verilog的8点FFT实现
qq_40268672的博客
07-22 2191
我们采用system verilog实现一个8点的基于蝶形运算单元的FFT变换，如下图，是蝶形运算单元的示意图。 然后，由于FFT涉及复数运算，因此，我们编写如下复数类型以及运算符的一个包: `timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: // // Create Date: 2021
基于Verilog的FFT模块实现
FPGA/MATLAB学习教程/源码/项目合作开发
02-11 4150
/* -- 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 ( ...
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.给出算法结构...
verilog中实现FFT的代码（需要请自取）
weixin_47032674的博客
01-18 1万+
verilog中实现FFT的代码（需要请自取） 1.FFT（Fast Fourier Transform），快速傅立叶变换，是一种 DFT（离散傅里叶变换）的高效算法。在以时频变换分析为基础的数字处理方法中，有着不可替代的作用。 2.FFT原理介绍 3.重要特性 4.FFT的设计 设计说明 为了利用仿真简单的说明 FFT 的变换过程，数据点数取较小的值 8。 如果数据是串行输入，需要先进行缓存，所以设计时数据输入方式为并行。 数据输入分为实部和虚部共 2 部分，所以计算结果也分为实部和虚部。 设计采
基-2 16点fft的verilog实现
juniorofMFC的博客
04-25 9366
本文是采用输入8位数据，输出8位数据的16点fft实现，旋转因子采用8位rom存储，分为cos和sin2个rom存储；输入数据以及每一级的输出数据采用8位的ram进行存储，分为实部和虚部进行存储。采用顺序输入，那么输出则为倒序。生成rom，可先在matlab中，计算出cos和sin的值，然后写入coe文件，再由ip核生成，具体过程自行百度，懒得百度的话，可以发我的邮箱来获得具体的程序。因为本文采用...
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通常会使用蝶形结构，该...
基于verilog编程实现的2048点FFT实现不使用IP核，
04-29
标题中的“基于verilog编程实现的2048点FFT实现不使用IP核”表明了这是一个使用硬件描述语言Verilog实现的项目，目标是设计一个2048点的快速傅里叶变换（FFT）算法，而且这个实现不依赖于现成的 Intellectual ...
yolo-fastest.zip
07-28
yolo-fastest
mysql安装配置教程.pdf
最新发布
07-28
MySQL的安装配置教程可以细分为以下几个步骤，这里以Windows系统为例进行说明： 一、下载MySQL 1.访问MySQL官网： 1.前往MySQL的官方网站（https://www.mysql.com/）下载MySQL Community Server。 2.选择下载版本： 1.在官网的Downloads页面，选择“MySQL Community (GPL) Downloads”下的“MySQL Installer for Windows”。 2.跳过注册步骤，直接下载MySQL安装包。 二、安装MySQL 1.运行安装包： 1.找到下载好的MySQL安装包文件，双击运行。 2.选择安装类型： 1.在安装向导中，选择安装类型（通常建议选择“Custom”进行自定义安装）。 2.选择操作系统的位数（如64位），并勾选“Enable the Select Features...”等选项（如果提示缺少运行库，需要先安装相应的VC_redist）。 3.设置安装路径： 1.选择MySQL的安装路径和数据存储路径，建议将MySQL安装在非系统盘（如D盘）以避免潜在的问题。 4.设置密码：
基于transformers+pytorch实现非结构化商业文本信息中隐私信息识别python源码（比赛获奖项目）.zip
07-28
基于transformers+pytorch实现非结构化商业文本信息中隐私信息识别python源码（比赛获奖项目）.zip CCF大数据与计算智能大赛-非结构化商业文本信息中隐私信息识别方案 bert base + flat + crf + fgm + swa + pu learning策略 + clue数据集 = test1单模0.906 词向量：https://github.com/Embedding/Chinese-Word-Vectors SGNS(Mixed-large 综合) loss mask相关代码为pu learning策略的实现 主要模块版本 python 3.6.9 torch 1.1.0 transformers 3.0.2 pytorchcrf 1.2.0 torchcontrib 0.0.2 主要功能点 使用BERT base作为基础模型 采用flat结构进行命名实体识别 使用CRF层进行序列标注 采用对抗训练(FGM)和平滑权重平均(SWA)策略提高模型泛化能力 使用PU learning策略处理标注不全的数据 利用clue数据集进行训练
（verilog）基于MIPS指令集的单周期CPU设计
07-28
相关代码及Vivado项目工程文件
verilog实现64点fft算法
05-12
Verilog是一种硬件描述语言，可用于数字电路设计。64点FFT算法是一种快速傅里叶变换算法，用于将时域信号转换为频域信号。在Verilog中实现64点FFT算法需要以下步骤： 1. 设计输入输出接口 根据算法需求设计模块的输入输出接口，包括输入数据和输出数据的宽度和信号类型等。在FFT算法中，输入为时域信号，输出为频域信号。 2. 编写蝶形运算模块 蝶形运算是FFT算法的基础操作，使用Verilog实现蝶形运算模块。蝶形运算模块的输入为两个复数，输出为两个新的复数，其中，计算公式如下： W = exp(-j*2*pi/n) //旋转因子 Xp = X1 + W * X2 Xq = X1 - W * X2 其中X1和X2为输入的复数，Xp和Xq为输出的复数，n为蝶形运算的总数，W为旋转因子。 3. 编写FFT模块 将蝶形运算模块连接起来，编写FFT模块。FFT模块将输入的时域信号分成两个大小为n/2的时域信号，并对它们进行FFT计算，在蝶形运算模块中进行计算，再将计算结果相加得到FFT的输出结果。 4. 仿真调试 使用仿真工具对设计的模块进行仿真调试，对仿真结果进行验证和调整，确保设计的模块在硬件实现中工作正常。 5. 合成 将完成调试的模块进行综合并生成对应的硬件电路，进一步验证模块在硬件实现中的正确性。 总之，通过以上步骤，便可实现用Verilog实现64点FFT算法。
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值