特别说明：完整45期数字信号处理教程，原创高性能示波器代码全开源地址：链接

第32章 实数FFT的实现

! ~1 c- ?. D) T- J. V/ Q5 D9 e3 ]

    本章主要讲解实数的浮点和定点Q31，Q15的实现。关于这部分的知识点和函数的计算结果上，官方的文档有一些小错误，在章节中会跟大家详细讲述，还有一个要注意的问题，调用实数FFT函数一定要使用CMSIS-DSP V1.4.4及其以上版本，以前的版本有bug。

    本章节使用的复数FFT函数来自ARM官方库的TransformFunctions部分

    32.1 复数FFT

    32.2 复数FFT-基2算法

    32.3 复数FFT-基4算法

    32.4 总结

  w, C( E" y  }' ~8 z
32.1 实数FFT
32.1.1 描述

    CMSIS DSP库里面包含一个专门用于计算实数序列的FFT库，很多情况下，用户只需要计算实数序列即可。计算同样点数FFT的实数序列要比计算同样点数的虚数序列有速度上的优势。

    快速的rfft算法是基于混合基cfft算法实现的。

    一个N点的实数序列FFT正变换采用下面的步骤实现：

    由上面的框图可以看出，实数序列的FFT是先计算N/2个实数的CFFT，然后再重塑数据进行处理从而获得半个FFT频谱即可（利用了FFT变换后频谱的对称性）。

    一个N点的实数序列FFT逆变换采用下面的步骤实现：

    实数FFT支持浮点，Q31和Q15三种数据类型。

/ q0 v, s' V. p32.2 实数FFT
4 q/ ^) S+ j$ I9 f32.2.1 arm_rfft_fast_f32

函数定义如下：

    void arm_rfft_fast_f32(

      arm_rfft_fast_instance_f32 * S,

      float32_t * p, float32_t * pOut,

      uint8_t ifftFlag)

参数定义：

     [in]  *S          points to an arm_rfft_fast_instance_f32 structure.

     [in]  *p          points to the input buffer.

     [in]  *pOut      points to the output buffer.

     [in]  ifftFlag     RFFT if flag is 0, RIFFT if flag is 1

注意事项：

结构arm_rfft_fast_instance_f32的定义如下（在文件arm_math.h文件）：

      typedef struct

      {

          arm_cfft_instance_f32 Sint;      /**< Internal CFFT structure. */

          uint16_t fftLenRFFT;            /**< length of the real sequence */

      float32_t * pTwiddleRFFT;           /**< Twiddle factors real stage  */

      } arm_rfft_fast_instance_f32 ;

    下面通过在开发板上运行函数arm_rfft_fast_f32和arm_cfft_f32计算幅频响应，然后将相应的频率响应结果在Matlab上面绘制出来。

1. /*
   " f) Y5 [. z( j$ g$ v% w( k: x& y
2. *********************************************************************************************************
   
3. *        函 数 名: arm_rfft_fast_f32_app
   
4. *        功能说明: 调用函数arm_rfft_fast_f32计算1024点实数序列的幅频响应并跟使用函数arm_cfft_f32计算结果做对比
   
5. *        形    参：无
   ' V# X! ^* \1 p& u& T
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   / t* n4 S; b# {, c6 y5 N
8. */
   3 }; ?# v- i7 p* [  f. b
9. static void arm_rfft_fast_f32_app(void)
   0 T  a# H" @3 e7 Y2 U
10. {
    
11. uint16_t i;
    
12. arm_rfft_fast_instance_f32 S;
    3 l# Q; M0 e* K  f* R: f
13. /* 实数序列FFT长度 */
    ; T! I& J, _% \6 `2 ~, g" {
14. fftSize = 1024;
    . e& O( F/ w. B% r) k0 M$ u
15. /* 正变换 */
    
16.     ifftFlag = 0;
    
17. /* 初始化结构体S中的参数 */
    ( q4 w7 ~- R' y) E: o
18.          arm_rfft_fast_init_f32(&S, fftSize);
    
19. /* 按照实部，虚部，实部，虚部..... 的顺序存储数据 */
    7 v) o; |3 p" r8 Z
20. for(i=0; i<1024; i++)
    9 i" ?( O  D! [6 Z, k. n( Q
21. {
    
22. /* 50Hz正弦波，采样率1KHz */
    * G0 U) X- ~- z% u
23. testInput_f32_10khz[i] = 1.2f*arm_sin_f32(2*3.1415926f*50*i/1000)+1;
    
24. }
    
25. /* 1024点实序列快速FFT */
    
26. arm_rfft_fast_f32(&S, testInput_f32_10khz, testOutput_f32_10khz, ifftFlag);
    
27. /* 为了方便跟函数arm_cfft_f32计算的结果做对比，这里求解了1024组模值，实际函数arm_rfft_fast_f32
    
28.    只求解出了512组  
    " o" F7 L6 L$ P2 N
29. */
    ) b6 f4 V6 q% ]  \1 E$ [) M
30.          arm_cmplx_mag_f32(testOutput_f32_10khz, testOutput, fftSize);
    & U$ C5 M3 z5 f2 K& x- Y
31. 
    
32. /* 串口打印求解的模值 */
    1 J4 Y% U) b: l$ f6 Q
33. for(i=0; i<fftSize; i++)
    4 d1 B( x- e# p
34. {
    
35. printf("%f\r\n", testOutput[i]);
    * }7 `& P& F5 U$ |8 X0 h
36. }
    
37. 
    : i" l% V+ T: {4 @
38. printf("****************************分割线***************************************\r\n");
    
39. 
    . Q; \( Y+ s  S- S( q" K* a' r
40. for(i=0; i<1024; i++)
    5 \6 d7 Y1 e$ b  f" q
41. {
    
42. /* 虚部全部置零 */
    7 s6 `1 \" p- R8 N: m
43. testInput_f32_10khz[i*2+1] = 0;
    
44. /* 50Hz正弦波，采样率1KHz ,作为实部 */
    
45. testInput_f32_10khz[i*2] = 1.2f*arm_sin_f32(2*3.1415926f*50*i/1000)+1;
    5 z0 s0 M/ B; v4 ]/ N# j  q' J
46. }
    
47. arm_cfft_f32(&arm_cfft_sR_f32_len1024, testInput_f32_10khz, ifftFlag, doBitReverse);
    9 g8 ~. k$ k$ A6 {" i
48. /* 求解模值  */
    ; i0 l0 o: e1 q
49.          arm_cmplx_mag_f32(testInput_f32_10khz, testOutput, fftSize);
    * T* f& Z. b5 s# }' B  H8 H
50. 
    5 S1 g" F$ Q7 X8 A& o3 A2 L. k
51. /* 串口打印求解的模值 */
    / C% a' s6 G' B' o5 ?5 n: e
52. for(i=0; i<fftSize; i++)
    
53. {
    3 V6 ?4 \& t% e! K+ H" A
54. printf("%f\r\n", testOutput[i]);
    ) A, R6 q4 }3 j  {
55. }
    ) R7 q  f# ^2 K: e
56. }

复制代码

运行如上函数可以通过串口打印出函数arm_rfft_fast_f32和arm_cfft_f32计算的幅频模值，下面通过Matlab绘制波形来对比这两种模值。

    对比前需要先将串口打印出的两组数据加载到Matlab中，arm_rfft_fast_f32的计算结果起名signal，arm_cfft_f32的计算结果起名sampledata，加载方法在前面的教程中已经讲解过，这里不做赘述了。Matlab中运行的代码如下：

Fs = 1000;              % 采样率

N  = 1024;            % 采样点数

' s. T6 e' N1 m) x- v6 G) q

n  = 0:N-1;            % 采样序列

f = n * Fs / N;          %真实的频率

! Z% o; q( g& a+ L
: P. c" x+ V! z3 M1 b( M

subplot(3,1,1);

plot(f,  signal);        %绘制RFFT结果

title('实数FFT');

xlabel('时间');

ylabel('幅值');

subplot(3,1,2);

plot(f,  sampledata);   %CFFT结果

title('复数FFT');

xlabel('时间');

ylabel('幅值');

* j/ n% h# m6 w! q6 `
1 k$ p3 V4 a. f5 ]' G: ~, ^" `1 m

Matlab运行结果如下：

    从上面的前512点对比中，我们可以看出两者的计算结果是相符的。这里有一点要特别注意，官方文档中对于函数arm_rfft_fast_f32输出结果的实部，虚部排列顺序说明是错误的。函数arm_rfft_fast_f32的输出结果仍然是实部，虚部，实部，虚部….. 依次排列下去。

    函数arm_rfft_fast_f32在计算直流分量（也就是频率为0的值）的虚部上是有错误的。关于这点大家可以将实际的实部和虚部输出结果打印出来做对比，但差别很小，基本可以忽略。

32.2.2 arm_rfft_q15

函数定义如下：

    void arm_rfft_q15(

          const arm_rfft_instance_q15 * S,

          q15_t * pSrc,

          q15_t * pDst)

参数定义：

    [in]  *S     points to an instance of the Q15 RFFT/RIFFT structure.   

    [in]  *pSrc  points to the input buffer.   

    [out] *pDst  points to the output buffer.   

    return       none.  

注意事项：

结构arm_rfft_instance_q15的定义如下（在文件arm_math.h文件）：

      typedef struct

      {

      uint32_t fftLenReal;   

      uint8_t ifftFlagR;   

          uint8_t bitReverseFlagR;                 

          uint32_t twidCoefRModifier;   

          q15_t *pTwiddleAReal;                    

          q15_t *pTwiddleBReal;                     

          const arm_cfft_instance_q15 *pCfft;      

      } arm_rfft_instance_q15;

    下面通过在开发板上运行函数arm_rfft_q15和arm_cfft_f32计算幅频响应，然后将相应的频率响应结果在Matlab上面绘制出来。

1. /*
     e: V' [: o( d! z
2. *********************************************************************************************************
   
3. *        函 数 名: arm_rfft_q15_app
   
4. *        功能说明: 调用函数arm_rfft_q15计算1024点实数序列的幅频响应并跟使用函数arm_cfft_f32计算的结果做对比。
   - l/ i! _6 v- z; n1 X
5. *        形    参：无
   , C" l. D5 x" ]9 e( |1 @
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   7 w) ]- l/ {2 l) J  \. G/ u" f" \
8. */
   ; j' _+ Q0 t/ @8 Q( m! k5 ]
9. static void arm_rfft_q15_app(void)
   8 y  P' {% {2 _, |: ^9 D
10. {
    2 |6 `% k0 @+ K
11. uint16_t i,j;
    
12. arm_rfft_instance_q15 S;
    8 @$ j1 e+ [; X3 ], W% s+ N
13. /* 实数序列FFT长度 */
    8 X1 f5 i* n, Z/ r# J4 j" H0 ]
14. fftSize = 1024;
    - Q6 q+ A+ v3 W3 U
15. /* 正变换 */
    
16.     ifftFlag = 0;
    / l$ K5 n+ r1 F# A+ n% X3 @# o6 q6 ]) c
17. /* 码位倒序 */
    ) t; \( N. W" f) |5 l2 k9 P4 Q
18.     doBitReverse = 1;
    . S8 g. K& M4 X
19. /* 初始化结构体S */
    1 [# o# J! u% a* V" A6 d
20.          arm_rfft_init_q15(&S, fftSize, ifftFlag, doBitReverse);
    
21. /* 按照实部，虚部，实部，虚部..... 的顺序存储数据 */
    
22. for(i=0; i<1024; i++)
    
23. {
    , ~' S7 @) x" O
24. /* 51.2Hz正弦波，采样率1024Hz。
    " x, n" r$ u8 T: L' R5 u% Q
25.    arm_sin_q15输入参数的范围[0, 32768)， 这里每20次为一个完整的正弦波，
    
26.    32768 / 20 = 1638.4
    
27. */
    & W6 s& v  F  Q" K9 Z% `
28. j = i % 20;
    
29.           testInput_q15_50hz[i] = arm_sin_q15(1638*j);
    
30. }
    
31. /* 1024点实序列快速FFT */
    . c- W# c0 X( j7 Z- l
32. arm_rfft_q15(&S, testInput_q15_50hz, testOutput_q15_50hz);
    
33. /* 由于输出结果的格式是Q5，所以这里将定点数转换为浮点数 */
    
34. for(i = 0; i < fftSize; i++)
    
35. {
    
36. testOutput_f32_10khz[i] = (float32_t)testOutput_q15_50hz[i]/32;
    
37. }
    
38. /* 为了方便对比，这里求解了1024组复数，实际上面的变化只有512组  
    
39.    实际函数arm_rfft_q15只求解出了512组  */
    3 W  L5 I8 d& W& [; S/ S& N! K' O
40.          arm_cmplx_mag_f32(testOutput_f32_10khz, testOutput, fftSize);
    5 U& `' @9 r0 X6 s9 @
41. 
    
42. /* 串口打印求解的模值 */
    2 c3 y" y7 |/ ^
43. for(i=0; i<fftSize; i++)
    * c5 `) ^4 R& c6 |' I/ ^$ W
44. {
    
45. printf("%f\r\n", testOutput[i]);
    4 c8 a0 m- R( e7 o6 _( c" L6 z
46. }
    . H( N+ o9 z2 F
47. printf("****************************分割线***************************************\r\n");
    : R% n: E  z8 f* X$ T5 V
48. for(i=0; i<1024; i++)
    
49. {
    8 o" y( V5 E6 y" |- M3 w
50. /* 51.2Hz正弦波，采样率1024Hz。
    , l5 u4 g$ a$ p1 I
51.    arm_sin_q15输入参数的范围[0, 32768)， 这里每20次为一个完整的正弦波，
    ) o' w1 d# M/ ?. r3 m* e
52.    32768 / 20 = 1638.4
    
53. */
    
54. j = i % 20;
    % y1 }" e- q/ _5 l  e) a8 F
55. testInput_f32_10khz[i*2] = (float32_t) arm_sin_q15(1638*j)/32768;
    
56. /* 虚部全部置零 */
    + b+ C* W' a: v2 @7 j
57. testInput_f32_10khz[i*2+1] = 0;
    ) b  Z+ A8 P* V' K
58. }
    ' g7 q) S8 r# ?9 c5 }
59. arm_cfft_f32(&arm_cfft_sR_f32_len1024, testInput_f32_10khz, ifftFlag, doBitReverse);
    
60. /* 求解模值  */
    + ?5 O5 a5 k+ `( j: {8 y& V* V
61.          arm_cmplx_mag_f32(testInput_f32_10khz, testOutput, fftSize);
    - F9 ~8 n* l- ~% Q2 z& q
62. /* 串口打印求解的模值 */
    : N) M4 b' W" x- m! ]
63. for(i=0; i<fftSize; i++)
    % Q, l/ n  g1 a! a  O8 T5 {5 O3 z+ C
64. {
    $ C8 H2 l5 |8 @+ R7 w
65. printf("%f\r\n", testOutput[i]);
    % s& w9 Y: ?9 i0 y5 V& F
66. }
    4 N4 k9 e% h% v
67. }

复制代码

运行如上函数可以通过串口打印出函数arm_rfft_q15和arm_cfft_f32计算的幅频模值，下面通过Matlab绘制波形来对比这两种模值。

    对比前需要先将串口打印出的两组数据加载到Matlab中，arm_rfft_q15的计算结果起名signal，arm_cfft_f32的计算结果起名sampledata，加载方法在前面的教程中已经讲解过，这里不做赘述了。Matlab中运行的代码如下：

Fs = 1000;             % 采样率

N  = 1024;            % 采样点数

4 ]' P" C3 ?& p& ?! C

n  = 0:N-1;            % 采样序列

f = n * Fs / N;          %真实的频率

& Z$ j2 [% s6 e. f% l* h/ ]2 s
& z5 I/ S' E6 |! T: @

subplot(3,1,1);

plot(f,  signal);        %绘制RFFT结果

title('实数FFT');

xlabel('时间');

ylabel('幅值');

* F( h! z4 B2 M

subplot(3,1,2);

plot(f,  sampledata);   %CFFT结果

title('复数FFT');

xlabel('时间');

ylabel('幅值');

$ ?) H! ]8 f8 O. K7 U9 E) m; n: u

Matlab运行结果如下：

    从上面的前512点对比中，我们可以看出两者的计算结果是相符的。这里有一点要特别注意，官方文档中对于函数arm_rfft_q31输出结果的实部，虚部排列顺序说明是错误的。函数arm_rfft_q31的输出结果仍然是实部，虚部，实部，虚部….. 依次排列下去。

32.2.3 arm_rfft_q31

函数定义如下：

    void arm_rfft_q31(

          const arm_rfft_instance_q31 * S,

          q31_t * pSrc,

          q31_t * pDst)

参数定义：

    [in]  *S     points to an instance of the Q31 RFFT/RIFFT structure.   

    [in]  *pSrc  points to the input buffer.   

    [out] *pDst  points to the output buffer.   

    return       none.  

注意事项：

结构arm_rfft_instance_q31的定义如下（在文件arm_math.h文件）：

      typedef struct

      {

          uint32_t fftLenReal;                     

          uint8_t ifftFlagR;                          

          uint8_t bitReverseFlagR;                  

          uint32_t twidCoefRModifier;                 

           q31_t *pTwiddleAReal;                       

          q31_t *pTwiddleBReal;                       

          const arm_cfft_instance_q31 *pCfft;      

      } arm_rfft_instance_q31;

    下面通过在开发板上运行函数arm_rfft_q31和arm_cfft_f32计算幅频响应，然后将相应的频率响应结果在Matlab上面绘制出来。

1. /*
   ; \" U8 T- \' }' O! P
2. *********************************************************************************************************
   
3. *        函 数 名: arm_rfft_q31_app
   . C1 J! d+ \; E- S2 q
4. *        功能说明: 调用函数arm_rfft_q31计算1024点实数序列的幅频响应并跟使用函数arm_cfft_f32计算的结果做对比。
   ( r! s1 U9 r8 c3 E
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   ! q/ {" L2 H4 l8 h( W
8. */
   5 S# U# {. b( P: L/ ^2 X- ?+ q
9. static void arm_rfft_q31_app(void)
   : D) U: P) d6 \
10. {
    ! R, w2 X) s/ r; s! X0 h
11. uint16_t i,j;
    5 D& N0 n! w) @4 Q( u
12. arm_rfft_instance_q31 S;
    
13. /* 实数序列FFT长度 */
    
14. fftSize = 1024;
    
15. /* 正变换 */
    
16.     ifftFlag = 0;
    
17. /* 码位倒序 */
    
18.     doBitReverse = 1;
    
19. /* 初始化结构体S */
    
20.          arm_rfft_init_q31(&S, fftSize, ifftFlag, doBitReverse);
    
21. /* 按照实部，虚部，实部，虚部..... 的顺序存储数据 */
    8 Y4 I: S; l# P- o& L! d( p$ [' w4 Q
22. for(i=0; i<1024; i++)
    3 R% b; H4 e8 K! S* `( n2 G( c
23. {
    
24. /* 51.2Hz正弦波，采样率1024Hz。
    ( z+ c, K3 r9 _2 w
25.    arm_sin_q31输入参数的范围0-2^31， 这里每20次为一个完整的正弦波，
    / S' \+ ^- I6 k4 ~
26.    2^31 / 20 = 107374182.4
    1 u% u% @0 O+ i6 |: z# d! p$ K. t
27. */
    
28. j = i % 20;
    ) F! o1 M3 ?. N( t6 d
29.           testInput_q31_50hz[i] = arm_sin_q31(107374182*j);
    
30. }
    
31. /* 1024点实序列快速FFT */
    
32. arm_rfft_q31(&S, testInput_q31_50hz, testOutput_q31_50hz);
    
33. /* 由于输出结果的格式是Q21，所以这里将定点数转换为浮点数 */
    0 s, d7 t3 I% n9 t# R. G1 S: x/ z- j
34. for(i = 0; i < fftSize; i++)
    
35. {
    5 n; F2 x& W9 }7 j
36. /* 输出的数据是11.21格式，2^21 = 4194304*/
    " o4 g  X/ h- j0 U
37. testOutput_f32_10khz[i] = (float32_t)testOutput_q31_50hz[i]/2097152;
    
38. }
    . i' L- o* H# M: }( q! Z
39. /* 为了方便对比，这里求解了1024组复数，实际上面的变化只有512组  
    
40.    实际函数arm_rfft_q31只求解出了512组  */
    
41.          arm_cmplx_mag_f32(testOutput_f32_10khz, testOutput, fftSize);
    
42. /* 串口打印求解的模值 */
    
43. for(i=0; i<fftSize; i++)
    " q+ S9 C# \6 n" W
44. {
    9 L( s+ q6 R: t
45. printf("%f\r\n", testOutput[i]);
    
46. }
    + N  e( [2 w+ n) x$ u% v! m
47. printf("****************************分割线***************************************\r\n");
    9 a/ B+ J+ a$ l& {3 M, _. y7 R
48. for(i=0; i<1024; i++)
    
49. {
    ( V7 @. a' j7 ^, d
50. /* 51.2Hz正弦波，采样率1024Hz。
    & Y( p. R! z" I; w
51.    arm_sin_q31输入参数的范围0-2^31， 这里每20次为一个完整的正弦波，
    + s- z" Q3 m& S7 e
52.    2^31 / 20 = 107374182.4
    : p+ {( o/ q6 f2 I0 ~
53. */
    
54. j = i % 20;
    3 M( J% N. Z1 W/ Q( [
55.           testInput_f32_10khz[i*2] = (float32_t)arm_sin_q31(107374182*j)/2147483648;
    
56. /* 虚部全部置零 */
    ( p& V8 d4 |0 i+ Y5 X" `3 [
57. testInput_f32_10khz[i*2+1] = 0;
    , Y/ R# Q% O9 p4 c
58. }
    
59. arm_cfft_f32(&arm_cfft_sR_f32_len1024, testInput_f32_10khz, ifftFlag, doBitReverse);
    
60. /* 求解模值  */
    5 \& J2 [6 I2 I; q0 s, {! Z1 ^4 x
61.          arm_cmplx_mag_f32(testInput_f32_10khz, testOutput, fftSize);
    
62. /* 串口打印求解的模值 */
    
63. for(i=0; i<fftSize; i++)
    
64. {
    
65. printf("%f\r\n", testOutput[i]);
    8 c- r- O0 f. B5 x' }/ h8 ]) R( ^
66. }
    - p: m; @  n; t- T- V
67. }

复制代码

运行如上函数可以通过串口打印出函数arm_rfft_q15和arm_cfft_f32计算的幅频模值，下面通过Matlab绘制波形来对比这两种模值。

    对比前需要先将串口打印出的两组数据加载到Matlab中，arm_rfft_q15的计算结果起名signal，arm_cfft_f32的计算结果起名sampledata，加载方法在前面的教程中已经讲解过，这里不做赘述了。Matlab中运行的代码如下：

Fs = 1000;             % 采样率

N  = 1024;            % 采样点数

" h3 ?' d8 R; t* y; u* @
7 ]9 R- K. ^$ C- |: g# X

n  = 0:N-1;            % 采样序列

f = n * Fs / N;          %真实的频率

subplot(3,1,1);

plot(f,  signal);        %绘制RFFT结果

title('实数FFT');

xlabel('时间');

ylabel('幅值');

" g4 ~, x- c! ?  N
' q4 r! L5 O6 z

subplot(3,1,2);

plot(f,  sampledata);   %CFFT结果

title('复数FFT');

xlabel('时间');

ylabel('幅值');

3 y; \- {& d  k, \8 U6 J. V

Matlab运行结果如下：

    从上面的前512点对比中，我们可以看出两者的计算结果是相符的。这里有一点要特别注意，官方文档中对于函数arm_rfft_q31输出结果的实部，虚部排列顺序说明是错误的。函数arm_rfft_q31的输出结果仍然是实部，虚部，实部，虚部….. 依次排列下去。

7 j) ?0 i3 Q$ e, Z& `32.3 总结

    使用实数FFT计算的时候要特别的注意本章节提到的几个错误点。

9 R! Y7 W+ V9 a; k6 t( ~; C+ h+ t

楼主你好，请问怎么看出来的信号的频率以及幅值的啊？

沙发，楼主对算法很有研究，赞一个

stary666 发表于 2015-4-17 10:30
3 Y6 e  ]! w1 @0 X( o3 j8 V5 M2 Q沙发，楼主对算法很有研究，赞一个

2 }- h. p& l; e% D谢谢！希望继续支持啊~~

算法在程序里很重要

支持。。。。。。。

好高端，看不懂，

谢谢分享！！

请教一下：我这样计算出来的值是不是对的？为什么每个频率上都有值啊？
) X9 Y$ g' N" Z% }/ r) x
, K6 ~  k# H) ?0 v5 T( t程序是这样子：
/ q- m9 h+ k. T5 R/ X用ADC采集值填入fft输入buff
void ADC_proc(void)
{
    uint16_t ai,cnt;
3 E5 M, P- l! H/ F! ^8 W       
    if(adc_conv_done)
    {
       adc_conv_done = 0;
# T$ u, e3 x$ L# i8 o8 T6 j, [

            for(ai=0;ai<NPT;ai++)
                {
                      lbufin[ai*2] = (float)(adc_buf[ai*2]-2048);
  Y* Z6 P- ^1 _2 }                          lbufin[ai*2+1] = (float)0;
                }
( h6 R7 a; U) A: Q6 e8 y7 S6 {          FFT_proc();      
2 l/ T( q0 F! e7 Q3 q- R0 D         HAL_ADC_Start_DMA(&hadc,(uint32_t*)adc_buf,sizeof(adc_buf)/2);
2 P  ?  K" a" z/ ^$ E    }
}
2 d/ t+ |; u4 c" A

: M$ O6 h+ Y" a, \" c! E- v$ H
FFT处理
# H$ g: ^0 @- w" B, F
9 R" s% {2 }0 H' M) K
' x6 j( B5 z- V" h( Q- [* p
float  lbufin[NPT*2];                                                           /* Complex input vector */
5 N. V" l4 u! }0 f" F+ @float  lbufout[NPT];                                                          /* Complex output vector */
float  lbufmag;                                                                  /* Magnitude vector */
uint16_t fftSize = 64;
3 |: Y* [- H: k
: Y# O& A8 ~( y% F8 y+ d
uint8_t ifftFlag = 0;
1 e2 A. b" C2 V" {- I, f( juint8_t doBitReverse = 1;
uint16_t audio_mag;
extern  uint8_t  audio_intf_flag;
7 Z. l. G8 u( v& \5 ?//uint32_t refIndex = 213,
uint32_t testIndex = 0;
__IO uint8_t  new_mag_flag;


! F9 t+ ?. q) @void FFT_proc()
{                      
    arm_cfft_f32(&arm_cfft_sR_f32_len64, lbufin, ifftFlag, doBitReverse);
        arm_cmplx_mag_f32(lbufin,lbufout,fftSize);
    arm_max_f32(lbufout, NPT, &lbufmag, &testIndex);
! d1 m" c9 \3 v+ Y* A& B! n}