用于ARM上的FFT与IFFT源代码（C语言，不依赖特定平台）

发布时间：2020-12-13 22:41:52 所属栏目：百科来源：网络整理

导读：http://blog.csdn.net/piaojun_pj/article/details/5911914 代码在2011年全国电子大赛结束后（2011年9月3日）发布，多个版本，注释详细。 [cpp] view plain copy /******************************************************************************* **程序

http://blog.csdn.net/piaojun_pj/article/details/5911914

代码在2011年全国电子大赛结束后（2011年9月3日）发布，多个版本，注释详细。

[cpp] 
   view plain 
   copy 
    
   
 /*******************************************************************************
 **程序名称：快速傅里叶变换(FFT)
**程序描述：本程序实现快速傅里叶变换
**程序作者：宋元瑞
**最后修改：2011年4月5日
*******************************************************************************/
 #include<stdio.h>
 #include<math.h>
 
 #definePI3.141592653589//圆周率，12位小数
 #defineN8//傅里叶变换的点数
 #defineM3//蝶形运算的级数，N=2^M
 typedefdoubleElemType;//原始数据序列的数据类型,可以在这里设置
 
typedefstruct//定义复数结构体
 {
 ElemTypereal,imag;
 }complex;
 complexdata[N];//定义存储单元，原始数据与负数结果均使用之
 ElemTyperesult[N];//存储FFT后复数结果的模
//变址
 voidChangeSeat(complex*DataInput)
 {
 intnextValue,nextM,i,k,j=0;
 complextemp;
 nextValue=N/2;//变址运算，即把自然顺序变成倒位序，采用雷德算法
 nextM=N-1;
for(i=0;i<nextM;i++)
if(i<j)//如果i<j,即进行变址
 temp=DataInput[j];
 DataInput[j]=DataInput[i];
 DataInput[i]=temp;
 }
 k=nextValue;//求j的下一个倒位序
while(k<=j)//如果k<=j,表示j的最高位为1
 j=j-k;//把最高位变成0
 k=k/2;//k/2，比较次高位，依次类推，逐个比较，直到某个位为0
 j=j+k;//把0改为1
 }
/*
//变址
voidChangeSeat(complex*DataInput)
{
complexTemp[N];
inti,n,New_seat;
for(i=0;i<N;i++)
Temp[i].real=DataInput[i].real;
Temp[i].imag=DataInput[i].imag;
}
for(i=0;i<N;i++)
{
New_seat=0;
for(n=0;n<M;n++)
New_seat=New_seat|(((i>>n)&0x01)<<(M-n-1));
}
DataInput[New_seat].real=Temp[i].real;
DataInput[New_seat].imag=Temp[i].imag;
*/
//复数乘法
 complexXX_complex(complexa,complexb)
 complextemp;
 temp.real=a.real*b.real-a.imag*b.imag;
 temp.imag=b.imag*a.real+a.imag*b.real;
returntemp;
//FFT
voidFFT(void)
 intL=0,B=0,J=0,K=0;
intstep=0;
 ElemTypeP=0,T=0;
 complexW,Temp_XX;
//ElemTypeTempResult[N];
 ChangeSeat(data);
for(L=1;L<=M;L++)
 B=1<<(L-1);//B=2^(L-1)
for(J=0;J<=B-1;J++)
 P=(1<<(M-L))*J;//P=2^(M-L)*J
 step=1<<L;//2^L
for(K=J;K<=N-1;K=K+step)
 W.real=cos(2*PI*P/N);
 W.imag=-sin(2*PI*P/N);
 Temp_XX=XX_complex(data[K+B],W);
 data[K+B].real=data[K].real-Temp_XX.real;
 data[K+B].imag=data[K].imag-Temp_XX.imag;
 data[K].real=data[K].real+Temp_XX.real;
 data[K].imag=data[K].imag+Temp_XX.imag;
voidIFFT(void)
intstep=0;
 ElemTypeP=0,T=0;
 complexW,Temp_XX;
//ElemTypeTempResult[N];
 ChangeSeat(data);
for(L=1;L<=M;L++)
 B=1<<(L-1);//B=2^(L-1)
for(J=0;J<=B-1;J++)
 P=(1<<(M-L))*J;//P=2^(M-L)*J
 step=1<<L;//2^L
for(K=J;K<=N-1;K=K+step)
 W.real=cos(2*PI*P/N);
 W.imag=sin(2*PI*P/N);//逆运算，这里跟FFT符号相反
 Temp_XX=XX_complex(data[K+B],W);
 data[K+B].real=data[K].real-Temp_XX.real;
 data[K+B].imag=data[K].imag-Temp_XX.imag;
 data[K].real=data[K].real+Temp_XX.real;
 data[K].imag=data[K].imag+Temp_XX.imag;
intmain(intargc,char*argv[])
inti=0;
for(i=0;i<N;i++)//制造输入序列
 data[i].real=sin(2*PI*i/N);
 printf("%lf",data[i]);
 printf("nn");
 FFT();//进行FFT计算
for(i=0;i<N;i++)
 {printf("%lf",sqrt(data[i].real*data[i].real+data[i].imag*data[i].imag));}
 IFFT();//进行FFT计算
 printf("nn");
for(i=0;i<N;i++)
 {printf("%lf",data[i].real/N);}
 printf("n");
/*for(i=0;i<N;i++)
{printf("%lf",data[i].imag/N);}
printf("n");*/
/*for(i=0;i<N;i++)
return0;
 }

copy 
    
   

**程序版本：V6.5
**最后修改：2011年5月16日
#definePI3.14159265358979323846264338327950288419716939937510//圆周率，50位小数
#definePI26.28318530717958647692528676655900576839433879875021
#defineN1024//傅里叶变换的点数
#defineM10//蝶形运算的级数，N=2^M
#defineNpart2512//创建正弦函数表时取PI的1/2
#defineNpart4256//创建正弦函数表时取PI的1/4
#defineFFT_RESULT(x)(sqrt(data[x].real*data[x].real+data[x].imag*data[x].imag))
#defineIFFT_RESULT(x)(data[x].real/N)
floatElemType;
//定义复数结构体
ElemTypereal,imag;
}complex;
complexdata[N];//定义存储单元，原始数据与负数结果均使用之
ElemTypeSIN_TABLE[Npart4+1];
//产生模拟原始数据输入
voidInputData(inti;
data[i].real=sin(2*PI*i/N);//正弦波
data[i].imag=0;
//创建正弦函数表
voidCREATE_SIN_TABLE(for(i=0;i<=Npart4;i++)
SIN_TABLE[i]=sin(PI*i/Npart2);//SIN_TABLE[i]=sin(PI2*i/N);
ElemTypeSin_find(ElemTypex)
inti=(int)(N*x);
i=i>>1;
if(i>Npart4)//注意：i已经转化为0~N之间的整数了！
{//不会超过N/2
i=Npart2-i;//i=i-2*(i-Npart4);
returnSIN_TABLE[i];
ElemTypeCos_find(ElemTypex)
if(i<Npart4)//i=Npart4-i;
returnSIN_TABLE[Npart4-i];
else//i>Npart4&&i<N/2
//i=i-Npart4;
return-SIN_TABLE[i-Npart4];
//变址
voidChangeSeat(complex*DataInput)
nextValue=N/2;//变址运算，即把自然顺序变成倒位序，采用雷德算法
nextM=N-1;
for(i=0;i<nextM;i++)
temp=DataInput[j];
DataInput[j]=DataInput[i];
DataInput[i]=temp;
k=nextValue;//求j的下一个倒位序
j=j-k;//把最高位变成0
k=k/2;//k/2，比较次高位，依次类推，逐个比较，直到某个位为0
j=j+k;//把0改为1
//复数乘法
/*complexXX_complex(complexa,complexb)
complextemp;
temp.real=a.real*b.real-a.imag*b.imag;
temp.imag=b.imag*a.real+a.imag*b.real;
returntemp;
}*/
//FFT运算函数
intstep=0,KB=0;
//ElemTypeP=0;
ElemTypeangle;
ChangeSeat(data);//CREATE_SIN_TABLE();
B=step>>1;for(J=0;J<B;J++)
//P=(1<<(M-L))*J;//P=2^(M-L)*J
angle=(double)J/B;//这里还可以优化
W.imag=-Sin_find(angle);//用C++该函数课声明为inline
W.real=Cos_find(angle);//用C++该函数课声明为inline
//W.real=cos(angle*PI);
//W.imag=-sin(angle*PI);
for(K=J;K<N;K=K+step)
KB=K+B;
//Temp_XX=XX_complex(data[KB],W);
//用下面两行直接计算复数乘法，省去函数调用开销
Temp_XX.real=data[KB].real*W.real-data[KB].imag*W.imag;
Temp_XX.imag=W.imag*data[KB].real+data[KB].imag*W.real;
data[KB].real=data[K].real-Temp_XX.real;
data[KB].imag=data[K].imag-Temp_XX.imag;
//IFFT运算函数
W.imag=Sin_find(angle); W.real=Cos_find(angle);//W.real=cos(angle*PI);
//W.imag=-sin(angle*PI);
for(K=J;K<N;K=K+step)
KB=K+B;
//用下面两行直接计算复数乘法，省去函数调用开销
Temp_XX.real=data[KB].real*W.real-data[KB].imag*W.imag;
Temp_XX.imag=W.imag*data[KB].real+data[KB].imag*W.real;
data[KB].real=data[K].real-Temp_XX.real;
data[KB].imag=data[K].imag-Temp_XX.imag;
//主函数
CREATE_SIN_TABLE();//创建正弦函数表,这句只需在程序开始时执行一次
InputData();//输入原始数据，此处用公式模拟；实际应用时为AD采样数据
{printf("%f",FFT_RESULT(i));}/**/
//进行IFFT计算
copy
1. **性能提升：修正了FFT的bug,变量重新命名,并将N_FFT改为动态值
2. **程序版本：V6.6
3. #include<stdlib.h>
4. #include<math.h>
5. //#defineOUTPRINTprintf
6. //#defineDEL/##/
7. #defineRESULT(x)sqrt(data_of_N_FFT[x].real*data_of_N_FFT[x].real+data_of_N_FFT[x].imag*data_of_N_FFT[x].imag)
8. #definePI3.14159265358979323846264338327950288419716939937510//圆周率，50位小数
9. #definePI26.28318530717958647692528676655900576839433879875021
10. intN_FFT=0;//傅里叶变换的点数
11. intM_of_N_FFT=0;//蝶形运算的级数，N=2^M
12. intNpart2_of_N_FFT=0;//创建正弦函数表时取PI的1/2
13. intNpart4_of_N_FFT=0;//创建正弦函数表时取PI的1/4
14. }complex_of_N_FFT,*ptr_complex_of_N_FFT;
15. ptr_complex_of_N_FFTdata_of_N_FFT=NULL;//开辟存储单元，原始数据与负数结果均使用之
16. ElemType*SIN_TABLE_of_N_FFT=NULL;
17. for(i=0;i<N_FFT;i++) data_of_N_FFT[i].real=sin(2*PI*i/N_FFT); data_of_N_FFT[i].imag=0;
18. printf("%f",data_of_N_FFT[i].real);
19. for(i=0;i<=Npart4_of_N_FFT;i++)
20. SIN_TABLE_of_N_FFT[i]=sin(PI*i/Npart2_of_N_FFT); ElemTypeSin_find(ElemTypex)
21. int)(N_FFT*x);
22. i=i>>1;
23. if(i>Npart4_of_N_FFT)//注意：i已经转化为0~N之间的整数了！
24. i=Npart2_of_N_FFT-i;returnSIN_TABLE_of_N_FFT[i];
25. ElemTypeCos_find(ElemTypex)
26. if(i<Npart4_of_N_FFT)returnSIN_TABLE_of_N_FFT[Npart4_of_N_FFT-i];
27. return-SIN_TABLE_of_N_FFT[i-Npart4_of_N_FFT];
28. voidChangeSeat(complex_of_N_FFT*DataInput)
29. complex_of_N_FFTtemp;
30. nextValue=N_FFT/2; nextM=N_FFT-1;
31. complex_of_N_FFTW,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> ChangeSeat(data_of_N_FFT);for(L=1;L<=M_of_N_FFT;L++)
32. for(K=J;K<N_FFT;K=K+step)
33. Temp_XX.real=data_of_N_FFT[KB].real*W.real-data_of_N_FFT[KB].imag*W.imag;
34. Temp_XX.imag=W.imag*data_of_N_FFT[KB].real+data_of_N_FFT[KB].imag*W.real;
35. data_of_N_FFT[KB].real=data_of_N_FFT[K].real-Temp_XX.real;
36. data_of_N_FFT[KB].imag=data_of_N_FFT[K].imag-Temp_XX.imag;
37. data_of_N_FFT[K].real=data_of_N_FFT[K].real+Temp_XX.real;
38. data_of_N_FFT[K].imag=data_of_N_FFT[K].imag+Temp_XX.imag;
39. //IFFT运算函数
40. //ElemTypeP=0;
41. ElemTypeangle;
42. complex_of_N_FFTW,108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> ChangeSeat(data_of_N_FFT);//CREATE_SIN_TABLE();
43. for(L=1;L<=M_of_N_FFT;L++)
44. B=step>>1;for(J=0;J<B;J++)
45. //P=(1<<(M-L))*J;//P=2^(M-L)*J
46. angle=(//这里还可以优化
47. W.imag=Sin_find(angle);//初始化FFT程序
48. //N_FFT是FFT的点数，必须是2的次方
49. voidInit_FFT(intN_of_FFT)
50. inti=0;
51. inttemp_N_FFT=1;
52. N_FFT=N_of_FFT;//傅里叶变换的点数，必须是2的次方
53. M_of_N_FFT=0;//蝶形运算的级数，N=2^M
54. for(i=0;temp_N_FFT<N_FFT;i++)
55. temp_N_FFT=2*temp_N_FFT;
56. M_of_N_FFT++;
57. printf("n%dn",M_of_N_FFT);
58. Npart2_of_N_FFT=N_FFT/2;//创建正弦函数表时取PI的1/2
59. Npart4_of_N_FFT=N_FFT/4;//创建正弦函数表时取PI的1/4
60. //ptr_complex_of_N_FFTdata_of_N_FFT=NULL;//开辟存储单元，原始数据与负数结果均使用之
61. data_of_N_FFT=(ptr_complex_of_N_FFT)malloc(N_FFT*sizeof(complex_of_N_FFT));
62. //ptr_complex_of_N_FFTSIN_TABLE_of_N_FFT=NULL;
63. SIN_TABLE_of_N_FFT=(ElemType*)malloc((Npart4_of_N_FFT+1)*sizeof(ElemType));
64. CREATE_SIN_TABLE();//结束FFT运算，释放相关内存
65. voidClose_FFT(if(data_of_N_FFT!=NULL)
66. free(data_of_N_FFT);//释放内存
67. data_of_N_FFT=NULL;
68. if(SIN_TABLE_of_N_FFT!=NULL)
69. free(SIN_TABLE_of_N_FFT);//释放内存
70. SIN_TABLE_of_N_FFT=NULL;
71. Init_FFT(1024);//初始化各项参数，此函数只需执行一次
72. //输入原始数据
73. for(i=0;i<N_FFT;i++)
74. printf("%f",RESULT(i));
75. IFFT();//进行IFFT计算
76. for(i=0;i<N_FFT;i++)
77. Close_FFT();
  copy
  1. **模块描述：本程序实现快速傅里叶变换
  2. **性能提升：已达到网上同类程序最高速度
  3. **模块版本：V6.0
  4. **模块作者：宋元瑞
  5. **最后修改：2011年5月6日
  6. **程序说明：
  7. FFT运算输入参数source_Data(i)是一个N大小的数组（注意是小括号）
  8. FFT运算输出结果result_Data(i)是一个N大小的数组（注意是小括号）
  9. **调用举例：
  10. intmain(intargc,char*argv[])
  11. inti=0;
  12. ///以下为FFT运算的调用方式
  13. FFT_prepare();//为FFT做好准备，此函数只需程序开始时执行一次即可，切勿写在循环中
  14. while(1)
  15. for(i=0;i<N_FFT;i++)//输入原始数据
  16. {source_Data(i)=sin(2*PI*i/N_FFT);}//注意inputData后面是小括号
  17. FFT();//进行FFT计算
  18. //输出结果：XXX=result_Data(i);
  19. return0;
  20. #ifndefSYRFFT_H
  21. //#pragmaonce
  22. //#include<stdio.h>
  23. #defineFFT_prepare()CREATE_SIN_TABLE();//创建正弦函数表
  24. #definesource_Data(i)data_FFT[i].imag//接收输入数据的数组，大小为N
  25. #defineresult_Data(i)sqrt(data_FFT[i].real*data_FFT[i].real+data_FFT[i].imag*data_FFT[i].imag)//FFT结果
  26. #defineN_FFT1024//傅里叶变换的点数
  27. #defineM_of_N_FFT10//蝶形运算的级数，N=2^M
  28. #defineNpart2_of_N_FFT512//创建正弦函数表时取PI的1/2
  29. #defineNpart4_of_N_FFT256//创建正弦函数表时取PI的1/4
  30. }complex_of_N_FFT;
  31. complex_of_N_FFTdata_FFT[N_FFT];//存放要进行FFT运输的数据，运算结果也存放这里
  32. ElemTypeSIN_TABLE[Npart4_of_N_FFT+1];
  33. /*
  34. voidInputData(void)
  35. inti;
  36. for(i=0;i<N_FFT;i++)//制造输入序列
  37. source_Data(i)=sin(2*PI*i/N_FFT);//模拟输入正弦波
  38. //data_FFT[i].imag=sin(2*PI*i/N);//正弦波
  39. //printf("%f",data_FFT[i].imag);
  40. SIN_TABLE[i]=sin(PI*i/Npart2_of_N_FFT);int)(N_FFT*x);
  41. returnSIN_TABLE[Npart4_of_N_FFT-i];
  42. return-SIN_TABLE[i-Npart4_of_N_FFT];
  43. //变址前data_FFT[i].imag存储了输入数据，变址后data_FFT[i].real存储了输入数据
  44. inti,New_seat;
  45. New_seat=0;
  46. for(n=0;n<M_of_N_FFT;n++)
  47. New_seat=New_seat|(((i>>n)&0x01)<<(M_of_N_FFT-n-1));
  48. DataInput[New_seat].real=DataInput[i].imag;
  49. DataInput[i].imag=0;
  50. complex_of_N_FFTXX_complex(complex_of_N_FFTa,complex_of_N_FFTb)
  51. complex_of_N_FFTtemp;
  52. ChangeSeat(data_FFT);//Temp_XX=XX_complex(data_FFT[KB],108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> Temp_XX.real=data_FFT[KB].real*W.real-data_FFT[KB].imag*W.imag;
  53. Temp_XX.imag=W.imag*data_FFT[KB].real+data_FFT[KB].imag*W.real;
  54. data_FFT[KB].real=data_FFT[K].real-Temp_XX.real;
  55. data_FFT[KB].imag=data_FFT[K].imag-Temp_XX.imag;
  56. data_FFT[K].real=data_FFT[K].real+Temp_XX.real;
  57. data_FFT[K].imag=data_FFT[K].imag+Temp_XX.imag;
  58. #defineSYRFFT_H
  59. #endif
  copy
  1. **程序作者：宋元瑞
  2. **最后修改：2011年5月6日
  3. *******************************************************************************/
  4. #include"syrFFT_H.h"//包含FFT运算头文件
  5. //以下3句为FFT运算的调用函数
  6. FFT_prepare();//为FFT做好准备，此函数只需程序开始时执行一次即可，切勿写在循环中
  7. //while(1)
  8. //模拟输入
  9. {source_Data(i)=sin(2*PI*i/N_FFT);}//注意inputData后面是小括号
  10. FFT();
  11. //输出结果
  12. copy
    
    #ifndefFFT_H
    #include<stdlib.h>
    
    //创建正弦函数表
    
    for(i=0;i<=Npart4_of_N_FFT;i++)
    
    SIN_TABLE_of_N_FFT[i]=sin(PI*i/Npart2_of_N_FFT);//SIN_TABLE[i]=sin(PI2*i/N);
    
    {//不会超过N/2
    
    i=Npart2_of_N_FFT-i;//i=i-2*(i-Npart4);
    
    returnSIN_TABLE_of_N_FFT[i];
    
    //i=Npart4-i;
    
    returnSIN_TABLE_of_N_FFT[Npart4_of_N_FFT-i];
    
    //i>Npart4&&i<N/2
    
    //i=i-Npart4;
    
    return-SIN_TABLE_of_N_FFT[i-Npart4_of_N_FFT];
    
    voidChangeSeat(complex_of_N_FFT*DataInput)
    
    complex_of_N_FFTtemp;
    
    nextValue=N_FFT/2; nextM=N_FFT-1;
    
    complextemp;
    
    temp.real=a.real*b.real-a.imag*b.imag;
    
    temp.imag=b.imag*a.real+a.imag*b.real;
    
    returntemp;
    
    }*/
    
    //FFT运算函数
    
    W.imag=-Sin_find(angle);for(K=J;K<N_FFT;K=K+step)
    
    Temp_XX.real=data_of_N_FFT[KB].real*W.real-data_of_N_FFT[KB].imag*W.imag;
    
    Temp_XX.imag=W.imag*data_of_N_FFT[KB].real+data_of_N_FFT[KB].imag*W.real;
    
    data_of_N_FFT[KB].real=data_of_N_FFT[K].real-Temp_XX.real;
    
    data_of_N_FFT[KB].imag=data_of_N_FFT[K].imag-Temp_XX.imag;
    
    data_of_N_FFT[K].real=data_of_N_FFT[K].real+Temp_XX.real;
    
    data_of_N_FFT[K].imag=data_of_N_FFT[K].imag+Temp_XX.imag;
    
    //printf("n%dn",M_of_N_FFT);
    
    //结束FFT运算，释放相关内存
    
    if(data_of_N_FFT!=NULL)
    
    free(data_of_N_FFT); data_of_N_FFT=NULL;
    
    if(SIN_TABLE_of_N_FFT!=NULL)
    
    free(SIN_TABLE_of_N_FFT); SIN_TABLE_of_N_FFT=NULL;
    
    #defineFFT_H
    
    #endif
    
    copy
    
    **性能提升：修正了FFT的bug
    #include"jxust_fft6_6.h"
    
    //产生模拟原始数据输入,在实际应用时替换为AD采样数据
    
    //输入采样数据
    
    //主函数，示例如何调用FFT运算
    
    char*argv[])
    
    Init_FFT(1024);//①初始化各项参数，此函数只需执行一次;参数为FFT的点数，必须为2的次方
    
    InputData();//②输入原始数据,此处在实际应用时替换为AD采样数据
    
    FFT();//③进行FFT计算
    
    //for(i=0;i<N_FFT;i++)//④输出FFT频谱结果sqrt(data_of_N_FFT[i].real*data_of_N_FFT[i].real+data_of_N_FFT[i].imag*data_of_N_FFT[i].imag)
    
    //{printf("%f",RESULT(i));}
    
    //for(i=0;i<N_FFT;i++)//(可选步骤)⑤输出IFFT结果，滤波时会用到；暂时不用
    
    Close_FFT();//结束FFT运算，释放相关内存;此函数在彻底结束FFT运算后调用，
    
    return0;
    
    }
    
    copy
    
    #ifndefSYRFFT_6_55_H
    #defineFFT_RESULT(x)(sqrt(data_of_N_FFT[x].real*data_of_N_FFT[x].real+data_of_N_FFT[x].imag*data_of_N_FFT[x].imag))
    
    #defineIFFT_RESULT(x)(data_of_N_FFT[x].real/N_FFT)
    
    #defineN_FFT1024//傅里叶变换的点数
    
    #defineM_of_N_FFT10//蝶形运算的级数，N=2^M
    
    #defineNpart2_of_N_FFT512//创建正弦函数表时取PI的1/2
    
    #defineNpart4_of_N_FFT256//创建正弦函数表时取PI的1/4
    
    }complex_of_N_FFT,*ptr_complex_of_N_FFT;
    
    complex_of_N_FFTdata_of_N_FFT[N_FFT]; ElemTypeSIN_TABLE_of_N_FFT[Npart4_of_N_FFT+1];
    
    int)(N_FFT*x); i=i>>1;//i=i/2;
    
    if(i>Npart4_of_N_FFT)
    
    //根据FFT相关公式，sin()参数不会超过PI，即i不会超过N/2
    
    if(i<Npart4_of_N_FFT)
    
    else//初始化FFT程序
    
    voidInit_FFT()
    
    #defineSYRFFT_6_55_H
    
    #endif
    
    copy
    
    **程序版本：V6.55
    **最后修改：2011年5月22日
    
    #include"syrFFT_6_55.h"
    
    inti;
    
    //制造输入序列
    
    data_of_N_FFT[i].real=sin(2*PI*i/N_FFT);//输入采样数据
    
    data_of_N_FFT[i].imag=0;
    
    //主函数，示例如何调用FFT运算
    
    Init_FFT();//①初始化各项参数，此函数只需执行一次;修改FFT的点数去头文件的宏定义处修改
    
    //③进行FFT计算
    
    //for(i=0;i<N_FFT;i++)//④输出FFT频谱结果sqrt(data_of_N_FFT[i].real*data_of_N_FFT[i].real+data_of_N_FFT[i].imag*data_of_N_FFT[i].imag)
    
    //for(i=0;i<N_FFT;i++)//(可选步骤)⑤输出IFFT结果，滤波时会用到；暂时不用
    
    //结束FFT运算，此版本此句无用，可不写
    
    }
    
    （编辑：李大同）
    
    【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!