基于FPGA的快速傅里叶变换加速（一）

最新推荐文章于 2024-08-29 11:31:49 发布
最新推荐文章于 2024-08-29 11:31:49 发布
阅读量2.4k 收藏 17
点赞数 3
文章标签： 算法 fpga fft c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lc1852109/article/details/113418432
版权
本文详细介绍了快速傅里叶变换（FFT）的基本原理和C++实现，包括递归方法和位逆序置换。通过分治策略，FFT将计算复杂度降低到O(nlogn)。此外，还提供了64点FFT的C++代码实例，展示了如何进行分层蝶形运算。
摘要由CSDN通过智能技术生成

基于FPGA的快速傅里叶变换加速（一） 基本原理介绍及C++代码实现


基本原理介绍及C++代码实现)

1. FFT的基本原理

1.1 离散傅里叶变换

介绍FFT之前需要首先介绍DFT(Discrete Fourier Transform),即离散傅里叶变换，是傅里叶变换在时域和频域上都呈离散的形式，将信号的时域采样变换为其 DTFT 的频域采样。

1.2 快速傅里叶变换

1.2.1 概念

FFT(Fast Fourier Transform)，是一种高效实现 DFT 的算法，它对傅里叶变换的理论并没有新的发现，但是对于在计算机系统或者说数字系统中应用离散傅立叶变换，可以说是进了一大步。快速数论变换 (NTT) 是快速傅里叶变换（FFT）在数论基础上的实现。

在 1965 年，Cooley 和 Tukey 发表了快速傅里叶变换算法。事实上 FFT 早在这之前就被发现过了，但是在当时现代计算机并未问世，人们没有意识到 FFT 的重要性。一些调查者认为 FFT 是由 Runge 和 König 在 1924 年发现的。但事实上高斯早在 1805 年就发明了这个算法，但一直没有发表。

1.2.2 基本思想

FFT 算法的基本思想是分治。就 DFT 来说，它分治地来求当 的时候 的值。他的分治思想体现在将多项式分为奇次项和偶次项处理。

举个例子，对于一共8项的多项式
源自OI-Wiki
在这里插入图片描述

2 两种C++代码实现

2.1 递归实现

代码实现方面，STL 提供了复数的模板，当然也可以手动实现。两者区别在于，使用 STL 的 complex 可以调用 exp 函数求出Wn。但事实上使用欧拉公式得到的虚数来求 Wn也是等价的。

#include <cmath>
#include <complex>
#define M_PI 3.14159265358979323846
// M_PI是C++自带宏，如果报错则加上上面一行即可

typedef std::complex<double> Comp;  // STL complex

const Comp I(0, 1);  // i
const int MAX_N = 1 << 20;

Comp tmp[MAX_N];

//这里是封装好的DFT函数，需要自行在main函数中调用
void DFT(Comp* f, int n, int rev) 
{  
    // rev=1,DFT; rev=-1,IDFT
    if (n == 1) return;
    for (int i = 0; i < n; ++i) 
        tmp[i] = f[i];
    for (int i = 0; i < n; ++i) 
    {  // 偶数放左边，奇数放右边
        if (i & 1)
            f[n / 2 + i / 2] = tmp[i];
        else
            f[i / 2] = tmp[i];
    }
    Comp* g = f, * h = f + n / 2;
    DFT(g, n / 2, rev), DFT(h, n / 2, rev);  // 递归 DFT
    Comp cur(1, 0), step(cos(2 * M_PI / n), sin(2 * M_PI * rev / n));
    // Comp step=exp(I*(2*M_PI/n*rev)); 
    // 两个 step 定义是等价的
    for (int k = 0; k < n / 2; ++k) 
    {
        tmp[k] = g[k] + cur * h[k];
        tmp[k + n / 2] = g[k] - cur * h[k];
        cur *= step;
    }
    for (int i = 0; i < n; ++i) 
        f[i] = tmp[i];
}

时间复杂度O(n log n)

2.2 分层蝶形运算/位逆序置换(bit-reversal permutation)

这里只贴出可运行的64点FFT变换，在下一篇博客中将会具体解释其原理及matlab验证

#include <stdio.h>
#include<iostream>
#include"math.h"
#include<string.h>
#define pi 3.14159265
double w[32][2];

void Reverse(double x[64][2], double y[64][2])
{
	int m;
	int cnt[6];
	for (int i = 0; i < 64; i++)
	{
		m = i;
		int j = 0;
		for (int k = 0; k < 6; k++)
		{
			cnt[5 - k] = m % 2;
			m = m / 2;
		}
		for (int k = 0; k < 3; k++)
		{
			int q = 0;
			q = cnt[k];
			cnt[k] = cnt[5 - k];
			cnt[5 - k] = q;
		}
		for (int k = 0; k < 6; k++)
		{
			int qq = 1;
			for (int q = k; q > 0; q--)
			{
				qq = 2 * qq;
			}
			j += cnt[k] * (32 / qq);
		}
		y[j][0] = x[i][0];
		y[j][1] = x[i][1];
		//cout << i << "  " << j << endl;
	}
}
void Wcalculate()
{
	//这里是为了满足大作业要求，无法使用三角函数
	w[0][0] = 1;  w[0][1] = -0;
	w[1][0] = 0.995185;  w[1][1] = -0.0980171;
	w[2][0] = 0.980785;  w[2][1] = -0.19509;
	w[3][0] = 0.95694;  w[3][1] = -0.290285;
	w[4][0] = 0.92388;  w[4][1] = -0.382683;
	w[5][0] = 0.881921;  w[5][1] = -0.471397;
	w[6][0] = 0.83147;  w[6][1] = -0.55557;
	w[7][0] = 0.77301;  w[7][1] = -0.634393;
	w[8][0] = 0.707107;  w[8][1] = -0.707107;
	w[9][0] = 0.634393;  w[9][1] = -0.77301;
	w[10][0] = 0.55557;  w[10][1] = -0.83147;
	w[11][0] = 0.471397;  w[11][1] = -0.881921;
	w[12][0] = 0.382683;  w[12][1] = -0.92388;
	w[13][0] = 0.290285;  w[13][1] = -0.95694;
	w[14][0] = 0.19509;  w[14][1] = -0.980785;
	w[15][0] = 0.0980171;  w[15][1] = -0.995185;
	w[16][0] = 0;  w[16][1] = -1;
	w[17][0] = -0.0980171;  w[17][1] = -0.995185;
	w[18][0] = -0.19509;  w[18][1] = -0.980785;
	w[19][0] = -0.290285;  w[19][1] = -0.95694;
	w[20][0] = -0.382683;  w[20][1] = -0.92388;
	w[21][0] = -0.471397;  w[21][1] = -0.881921;
	w[22][0] = -0.55557;  w[22][1] = -0.83147;
	w[23][0] = -0.634393;  w[23][1] = -0.77301;
	w[24][0] = -0.707107;  w[24][1] = -0.707107;
	w[25][0] = -0.77301;  w[25][1] = -0.634393;
	w[26][0] = -0.83147;  w[26][1] = -0.55557;
	w[27][0] = -0.881921;  w[27][1] = -0.471397;
	w[28][0] = -0.92388;  w[28][1] = -0.382683;
	w[29][0] = -0.95694;  w[29][1] = -0.290285;
	w[30][0] = -0.980785;  w[30][1] = -0.19509;
	w[31][0] = -0.995185;  w[31][1] = -0.0980171;
	//实际可将下代码还原即可
	//double w[32][2];
	//for (int i = 0; i < 32; i++)
	//{
		//w[i][0] = (i * pi / 32);
		//w[i][1] = -(i * pi / 32);
		//cout << w[i][0] << "  " << w[i][1] << endl;
	//}
}
char* my_itoa(int d, char str[])			//定义整形-字符型转换函数
{
	int j, len = 0, sign;
	if ((sign = d) < 0)    //记录符号
		d = -d;         //使成为正数
	for (int i = 0; d != 0; i++)
	{
		str[i] = d % 10 + '0';    //取下一个数字
		d = d / 10;
		if (d == 0)
		{
			str[i + 1] = '\0';
		}
	}
	for (int i = 0; str[i] != '\0'; i++)
		len = i;//
	len++;
	int i;
	for (j = len - 1, i = 0; j > i; j--, i++)        //生成的数字是逆序的，所以要交换
	{
		int t = str[j];
		str[j] = str[i];
		str[i] = t;
	}
	return str;
}
int main()
{
	printf("Final work test\n");
	double input[64][2];
	double middle[64][2];
	for (int i = 0; i < 64; i++)
	{
		//cout << "请输入实部" << endl;	//可以通过手动输入
		//cin >> middle[i][0];
		input[i][0] = 1.0; //pow(2, 16)*		//或者在此初始化
		input[i][1] = 0.0;
		//cout << input[i][0] << endl;
		//input[i][0] = i;
	}
	//也可以在这里进行全部数据的初始化
	//input[0][0] = 0.0; input[1][0] = 12.0; input[2][0] = 25.0; input[3][0] = 37.0; input[4][0] = 49.0; input[5][0] = 60.0; input[6][0] = 71.0; input[7][0] = 81.0;
	//input[8][0] = 90.0; input[9][0] = 99.0; input[10][0] = 106.0; input[11][0] = 113.0; input[12][0] = 118.0; input[13][0] = 122.0; input[14][0] = 125.0; input[15][0] = 126.0;
	//input[16][0] = 126.0; input[17][0] = 126.0; input[18][0] = 123.0; input[19][0] = 120.0; input[20][0] = 115.0; input[21][0] = 109.0; input[22][0] = 103.0; input[23][0] = 95.0;
	//input[24][0] = 86.0; input[25][0] = 76.0; input[26][0] = 66.0; input[27][0] = 55.0; input[28][0] = 43.0; input[29][0] = 31.0; input[30][0] = 18.0; input[31][0] = 6.0;
	//input[32][0] = -6.0; input[33][0] = -18.0; input[34][0] = -31.0; input[35][0] = -43.0; input[36][0] = -55.0; input[37][0] = -66.0; input[38][0] = -76.0; input[39][0] = -86.0;
	//input[40][0] = -95.0; input[41][0] = -103.0; input[42][0] = -109.0; input[43][0] = -115.0; input[44][0] = -120.0; input[45][0] = -123.0; input[46][0] = -126.0; input[47][0] = -126.0;
	//input[48][0] = -126.0; input[49][0] = -125.0; input[50][0] = -122.0; input[51][0] = -118.0; input[52][0] = -113.0; input[53][0] = -106.0; input[54][0] = -99.0; input[55][0] = -90.0;
	//input[56][0] = -81.0; input[57][0] = -71.0; input[58][0] = -60.0; input[59][0] = -49.0; input[60][0] = -37.0; input[61][0] = -25.0; input[62][0] = -12.0; input[63][0] = 0.0;
	
	Reverse(input, middle);		//逆序
	Wcalculate();					//旋转系数的生成
	//蝶形运算
	for (int N = 0; N < 6; N++)
	{
		for (int i = 0; i < 64;)
		{
			int qq = 1;
			for (int q = N; q > 0; q--)
			{
				qq = qq * 2;
			}
			int m = qq;
			int p = 32 / qq;
			for (int n = 0; n < p; n++, i = i + m)
			{
				for (int j = 0; j < m; j++, i++)
				{
					double q1[2], q2[2];
					q1[0] = middle[i][0];			//切记不可直接变换
					q1[1] = middle[i][1];
					q2[0] = middle[i + m][0];
					q2[1] = middle[i + m][1];
					middle[i][0] = q1[0] + q2[0] * w[j * p][0] - q2[1] * w[j * p][1];
					middle[i][1] = q1[1] + q2[0] * w[j * p][1] + q2[1] * w[j * p][0];
					middle[i + m][0] = q1[0] - (q2[0] * w[j * p][0] - q2[1] * w[j * p][1]);
					middle[i + m][1] = q1[1] - (q2[0] * w[j * p][1] + q2[1] * w[j * p][0]);
				}
			}
		}
	}
	for (int i = 0; i < 64; i++)
	{
		if (middle[i][1] < 0)
		{
			char m[80] = "\0", n[80] = "\0";
			my_itoa(middle[i][0], m);
			my_itoa(middle[i][1], n);
			printf(m);
			printf("  -  ");
			printf(n);
			printf("j\n");
		}
		else
		{
			char m[80] = "\0", n[80] = "\0";
			my_itoa(middle[i][0], m);
			my_itoa(middle[i][1], n);
			printf(m);
			printf("  +  ");
			printf(n);
			printf("j\n");
		}
	}
	system("pause");
	return 0;
}

本文结束，详情可见下篇博客

生如昭诩
关注
FFT(快速傅里叶变换)的FPGA实现
07-04
文档中包括FFT的算法推导，FFT算法的量化以及FPGA的实现
基于FPGA的有限域NTT算法设计与实现.pdf
07-13
基于FPGA的有限域NTT算法设计与实现.pdf
基于FPGA的FFT算法硬件实现
最新发布
weixin_33240461的博客
08-29 1172
本文还有配套的精品资源，点击获取 简介：本项目着重于在FPGA上用Verilog语言实现快速傅里叶变换（FFT）算法。FFT算法广泛应用于信号处理、图像处理和通信等众多领域，是计算离散傅里叶变换（DFT）的一种高效方式。项目中，旋转因子是自行设计的，而乘法器和数据存储则利用了预设的IP核。代码编写完毕并通过了仿真测试，准备下载到FPGA中进行实际运行。此外，项目还包含了详细...
FPGA：实现快速傅里叶变换（FFT）算法
热门推荐
m0_46830519的博客
06-30 2万+
FFT怎么玩
基于FPGA的快速傅里叶变换加速（二）
lc1852109的博客
01-30 1987
基于FPGA的快速傅里叶变换加速（二） 蝶形运算模块介绍及matlab代码实现1. 基二FFT的基本原理1.1 快速傅里叶变换1.2 常用FFT算法1.2.1 时域抽取（1） 实现过程（2）运算规律及编程思想原位计算旋转因子距离码位颠倒1.2.2 频域抽取（1） 运算规律比较（2）运算量比较2. Matlab实现本文结束，详情可见下篇博客 蝶形运算模块介绍及matlab代码实现) 1. 基二FFT的基本原理 1.1 快速傅里叶变换 简单形式离散傅立叶变换（DFT）和逆离散傅立叶变换（IDFT）所需的复杂乘法
基于FPGA的快速傅里叶变换加速（三）
lc1852109的博客
01-31 2618
基于FPGA的快速傅里叶变换加速（三） 硬件加速介绍及部分verilog代码实现1. 硬件加速1.1 FPGA1.1.1 FPGA介绍概念：基本结构：工作原理：1.1.2 开发板开发板类型开发板介绍1.2 加速理念1.2.1 硬件加速1.2.2 FFT中的加速（一）并行运算（二）模块化调用各模块分层复数加法模块超前进位加法器复数乘法模块16位流水线乘法器主模块（三）CORDIC算法2. Verilog代码实现2.1 流程介绍算法流程图2.2 实现方法2.3 代码实现总结 硬件加速介绍及部分verilog代码
关于FFT提速
weixin_30535843的博客
06-22 506
前面的文章，我们对用硬件实现FFT做了简单介绍。前面文章我们使用的是控制器方式实现FFT，也就是说将一组数据放入FFT模块的RAM中，计算一次蝶形计算，完成后从RAM中读出数据继续计算。 以2048点为例的话，这个FFT计算周期是2048*11*DT，DT为计算一次蝶形运算的时间，按照上述算法，整个FFT时间为2ms左右。这个速度按照控制器的方式，是可以接受的。在不需要实时性的某些场合可...
基于FPGA的傅里叶变换光谱仪光谱复原技术.pdf
07-13
基于FPGA的傅里叶变换光谱仪光谱复原技术的研究，是一种利用硬件编程技术，特别是FPGA（现场可编程门阵列）来实现快速傅里叶变换（FFT）的光谱复原方法。傅里叶变换光谱仪是一种利用干涉图来获取物体光谱信息的光谱...
STM32单片机FPGA毕设电路原理论文报告基于硬件加速的快速傅里叶变换
03-19
STM32单片机FPGA毕设电路原理论文报告基于硬件加速的快速傅里叶变换本资源系百度网盘分享地址
基于硬件加速的快速傅里叶变换.pdf
11-25
《基于硬件加速的快速傅里叶变换》这篇论文主要探讨了如何在单片机系统中利用FPGA（Field-Programmable Gate Array，现场可编程门阵列）硬件加速技术来提升快速傅里叶变换（Fast Fourier Transform, FFT）的计算速度...
参考资料-基于硬件加速的快速傅里叶变换.zip
01-22
在“参考资料-基于硬件加速的快速傅里叶变换.pdf”中，我们可以期待找到以下关键知识点： 1. **快速傅里叶变换（FFT）原理**：FFT是DFT的一种分治算法，通过将大问题分解为小问题来降低计算复杂度。典型地，N点DFT...
大整数乘法器的FPGA设计与实现
03-15
大整数乘法是公钥加密中最为核心的计算环节，实现运算快速的大数乘法单元是RSA, ElGamal，全同态等密码体制中急需解决的问题之一。针对全同态加密(FHE)应用需求，该文提出一种基于Schönhage-Strassen算法(SSA)的768 kbit大整数乘法器硬件架构。采用并行架构实现了其关键模块64K点有限域快速数论变换(NTT)的运算，并主要采用加法和移位操作以保证并行处理的最大化，有效提高了处理速度。该大整数乘法器在.Stratix-V FPGA上进行了硬件验证，通过与CPU上使用数论库(NTL)和GMP库实现的大整数乘法运算结果对比，验证了该文设计方法的正确性和有效性。实验结果表明，该方法实现的大整数乘法器运算时间比CPU平台上的运算大约有8倍的加速。
基于fpga快速傅里叶变换（FFT）的IP核设计（含程序）
12-10
快速傅立叶变换(FFT)作为时域和频域转换的基本运算，是数字谱分析的必要前提。传统的FFT使用软件或DSP实现，高速处理时实时性较难满足。FPGA是直接由硬件实现的，其内部结构规则简单，通常可以容纳很多相同的运算单元，因此FPGA在作指定运算时，速度会远远高于通用的DSP芯片。FFT运算结构相对比较简单和固定，适于用FPGA进行硬件实现，并且能兼顾速度及灵活性。本文介绍了一种通用的可以在FPGA上实现32点FFT变换的方法。
一种基于FPGA的互相关函数加速器设计.pdf
07-13
- 频域算法：基于FFT（快速傅里叶变换）和IFFT（逆快速傅里叶变换）来求解相关系数，计算量同样较大且可能难以满足实时处理的需求。 4. FPGA在互相关函数加速器设计中的应用： - 随着集成电路制造和FPGA技术的进步...
采用FPGA实现FFT算法
HackEle的博客
04-27 2526
关注、星标公众号，精彩内容每日送达来源：网络素材　随着数字技术的快速发展，数字信号处理已深入到各个学科领域。在数字信号处理中，许多算法如相关、滤波、谱估计、卷积等都可通过转化为离散傅立叶变换(DFT)实现，从而为离散信号分析从理论上提供了变换工具。但DFT计算量大，实现困难。快速傅立叶(FFT)的提出，大大减少了计算量，从根本上改变了傅立叶变换的地位，成为数字信号处理中的技术之一，广泛应用于雷达、...
基于FPGA的FFT变换和反变换实现,使用IP核设计,包含testbench
fpga/matlab/simulink算法仿真工程
04-02 1607
Nr=2，N=2则N点DFT的计算可分解为N=2×N/2，即两个N/2点DFT计算的组合，而N/2点DFT的计算又可分解为N/2=2×N/4，即两个N/4点DFT计算的组合。分裂基算法(RSFFT) 1984年由P．杜哈美尔和H．赫尔曼等导出的一种比库利图基算法更加有效的改进算法，其基本思想是在变换式的偶部采用基2算法，在变换式的奇部采用基4算法。优点是具有相对简单的结构，非常适用于实对称数据，对长度N=2能获得最少的运算量(乘法和加法），所以是选用固定基算法中的一种最佳折衷算法。FFT变换实部和虚部。
如何用FPGA实现FFT算法？
HackEle的博客
10-11 1251
点击蓝字关注我们关注、星标公众号，精彩内容每日送达 来源：网络素材　引言　　DFT（Discrete Fourier Transformation）是数字信号分析与处理如图形、语音及图像等领域的重要变换工具，直接计算DFT的计算量与变换区间长度N的平方成正比。当N较大时，因计算量太大，直接用DFT算法进行谱分析和信号的实时处理是不切实际的。快速傅立叶变换（Fast Fourier Transfor...
基于fpga的快速傅里叶变换
06-30
基于FPGA（可编程逻辑门阵列）的快速傅里叶变换（FFT）是一种高效实现FFT算法的方法。FFT是一种重要的数学运算，用于将时域信号转换为频域信号，并广泛应用于信号处理、图像处理、通信等领域。 使用FPGA实现FFT的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

生如昭诩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值