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

第22章 math_help中函数的使用

    本期教程主要讲解math_help文件中函数的使用，这个文件也是ARM官方提供的，这些函数相对都比较容易，同时使用频率也很高。希望初学的同学学习并掌握。

    22.1 函数讲解

    22.3 总结

22.1 函数讲解
/ H' z8 c2 j: G5 C22.1.1 函数目录

    在文件math_help文件中主要有以下函数：

1. float arm_snr_f32(float *pRef, float *pTest,  uint32_t buffSize);  
   5 l4 K0 @0 A( {: x
2. void arm_float_to_q12_20(float *pIn, q31_t * pOut, uint32_t numSamples);
   
3. void arm_provide_guard_bits_q15(q15_t *input_buf, uint32_t blockSize, uint32_t guard_bits);
   ( J: b# N* W* a$ N
4. void arm_provide_guard_bits_q31(q31_t *input_buf, uint32_t blockSize, uint32_t guard_bits);
   
5. void arm_float_to_q14(float *pIn, q15_t *pOut, uint32_t numSamples);
   % s1 I5 Q7 e) B9 }+ ^
6. void arm_float_to_q30(float *pIn, q31_t *pOut, uint32_t numSamples);
   ' Y5 z- p. O7 C! A
7. void arm_clip_f32(float *pIn, uint32_t numSamples);
   
8. uint32_t arm_calc_guard_bits(uint32_t num_adds);
   . x. L) q) f' ]
9. void arm_apply_guard_bits (float32_t * pIn, uint32_t numSamples, uint32_t guard_bits);
   
10. uint32_t arm_compare_fixed_q15(q15_t *pIn, q15_t * pOut, uint32_t numSamples);
    
11. uint32_t arm_compare_fixed_q31(q31_t *pIn, q31_t *pOut, uint32_t numSamples);
    
12. uint32_t arm_calc_2pow(uint32_t guard_bits);

复制代码

+ @  ]# L, A+ F22.1.2 arm_snr_f32

    这个函数用于求信噪比：

1. /**                                                                                                   (1)
   
2. * @brief  Caluclation of SNR
   
3. * @param  float*         Pointer to the reference buffer
   " |$ @/ R5 h, }4 `
4. * @param  float*        Pointer to the test buffer
   
5. * @param  uint32_t        total number of samples
   
6. * @return float        SNR
   1 t# f% n+ Y3 @# m
7. * The function Caluclates signal to noise ratio for the reference output
   $ I7 ]. h( f. X, w0 D- C
8. * and test output
     w- s6 j* p% i6 E% B
9. */
   / ?9 f$ K% D; F* Z
10. 
    
11. float arm_snr_f32(float *pRef, float *pTest, uint32_t buffSize)
    
12. {
    
13.   float EnergySignal = 0.0, EnergyError = 0.0;
    
14.   uint32_t i;
    
15.   float SNR;
    ( X7 z' Q  O! J! t+ J9 X
16.   int temp;
    : U9 S" R1 L8 P6 g: c$ B8 j
17.   int *test;
    
18. 
    $ s  m* T7 i+ r! a2 J: ^8 P8 B, J
19.   for (i = 0; i < buffSize; i++)
    
20.     {
    
21.            /* Checking for a NAN value in pRef array */
    * Z' p& n+ f& d3 q) |. a
22.   test =   (int *)(&pRef[i]);
    
23.       temp =  *test;
    2 a* F& C6 w: U. i* p/ f
24. 
    
25.   if(temp == 0x7FC00000)
    ; k5 L. e! q9 ]# p
26.   {
    
27.            return(0);
    
28.   }
    2 Y6 U6 F/ I" s! K1 b0 u
29. 
    , C" w4 }/ J8 x5 U( g1 d% l1 f4 t
30.   /* Checking for a NAN value in pTest array */
    . Z* ^9 ^! }8 [
31.   test =   (int *)(&pTest[i]);
    
32.       temp =  *test;
      s) U' z# c  T9 f3 r/ l
33. 
    
34.   if(temp == 0x7FC00000)
    & z# M3 r3 g9 n' e: r0 V
35.   {
    8 F* N! P( I6 S0 {5 C
36.            return(0);
    1 p' N; S4 h: t# v4 ~- j; j
37.   }
    
38.       EnergySignal += pRef[i] * pRef[i];
    # d) u$ B) n$ f+ o/ W- l/ U9 W
39.       EnergyError += (pRef[i] - pTest[i]) * (pRef[i] - pTest[i]);
    
40.     }
    4 v1 G& k% H0 o
41. 
    
42. /* Checking for a NAN value in EnergyError */
    3 T. V; v. x/ O$ A. {
43. test =   (int *)(&EnergyError);
    ; M0 b5 k1 _, d% ]6 Q
44.     temp =  *test;
    
45. 
    3 I  d- A/ ?4 _% J! m, \: V9 t$ [
46.     if(temp == 0x7FC00000)
    2 u9 G7 d3 V: M3 H) U( [+ i
47.     {
    # O/ T. z  u0 y6 H; Z; O5 g5 a  R
48.            return(0);
    
49.     }
    ; G; ]" m/ _+ ^+ ~7 r
50. 
    
51.   SNR = 10 * log10 (EnergySignal / EnergyError);                                                       (2)
    $ H7 H3 D6 d# ~- k
52. 
    
53.   return (SNR);
    $ P: a5 U' N$ S" b
54. 
    8 H! t4 i/ N# E) I* T7 J
55. }

复制代码

1. 这里先补充一些信噪比方面的基础知识：

    信噪比，即SNR（Signal to Noise Ratio），又称为讯噪比。反映摄像机成像的抗干扰能力，反应在画质上就是画面是否干净无噪点；狭义来讲是指放大器的输出信号的功率与同时输出的噪声功率的比，常常用分贝数表示，设备的信噪比越高表明它产生的杂音越少。一般来说，信噪比越大，说明混在信号里的噪声越小，声音回放的音质量越高，否则相反。信噪比一般不应该低于70dB，高保真音箱的信噪比应达到110dB以上。公式如下：

3 i+ K; ~  o! v0 {! s4 k

    关于信噪比更详细的知识，大家可以查阅相关资料进行了解。

2. 这里实现的就是上面所说的信噪比公式。

22.1.3 arm_float_to_q12_20

1. /**
   ( d+ G) i! }6 M0 |" C1 n  }/ ^
2. * @brief  Converts float to fixed in q12.20 format                                                    (1)
   
3. * @param  uint32_t         number of samples in the buffer
   5 V% c; E) J0 E3 Y
4. * @return none
   
5. * The function converts floating point values to fixed point(q12.20) values
   & X. G# ^* Y6 y$ |& u# x/ a
6. */
   * Z" {9 X, y: H
7. 
   
8. void arm_float_to_q12_20(float *pIn, q31_t * pOut, uint32_t numSamples)
   
9. {
   . Z$ q* x# ~" @9 J- M  s7 M
10.   uint32_t i;
    9 C* O7 A# i5 B  q
11. 
    
12.   for (i = 0; i < numSamples; i++)
    
13.     {
    ( b* {" `2 Q8 |' I5 q
14.   /* 1048576.0f corresponds to pow(2, 20) */
    ; ]. |' o& Y9 U7 L) \# i
15.       pOut[i] = (q31_t) (pIn[i] * 1048576.0f);                                                        (2)
    ' a2 H* D% `8 C
16. 
    
17.       pOut[i] += pIn[i] > 0 ? 0.5 : -0.5;
    , p+ u9 j) N2 \" h
18. 
    2 D: R# J* g  }' W  ?
19.       if (pIn[i] == (float) 1.0)
    
20.         {
    ) m2 R# m* }* e% o
21.           pOut[i] = 0x000FFFFF;
    8 Z9 l" G& {' `- v  e1 ?
22.         }
    " b% Z% y% m) u. d( `
23.     }
    
24. }

复制代码

1. 这个函数用于将浮点数转换成Q12.20格式的数据。

2. 浮点数转换成Q12.20格式需要乘以2^20，然后再做舍入处理，特别注意这里的浮点数末尾要加符号f，这样才能保证是单精度。

' D& M4 u. h  v* H! H1 X22.1.4 arm_provide_guard_bits_q15

1. /**
   6 a+ W& Q3 m7 H8 V/ M
2. * @brief  Provide guard bits for Input buffer
   + B) t8 X8 }/ ]9 b) R
3. * @param  q15_t*             Pointer to input buffer
   * p9 |4 r% X8 p
4. * @param  uint32_t         blockSize
   
5. * @param  uint32_t         guard_bits
   
6. * @return none
   
7. * The function Provides the guard bits for the buffer
   & [& Q: u# o+ q
8. * to avoid overflow
   1 d# g  k% ?* t
9. */
   + e% A, I  F  T" H. Y
10. 
    
11. void arm_provide_guard_bits_q15 (q15_t * input_buf, uint32_t blockSize,
    
12.                             uint32_t guard_bits)
    : y; J' T; \, X& K
13. {
    
14.   uint32_t i;
    
15. 
    
16.   for (i = 0; i < blockSize; i++)
    . q$ b$ t& o) g7 L+ U3 M
17.     {
    
18.       input_buf[i] = input_buf[i] >> guard_bits;
    
19.     }
    $ ^2 p) F; O, V& X0 f' }, g
20. }

复制代码

1. 这个函数用于给q15_t类型的数据提供保护位，防止溢出。从函数的实现上看，保护位的实现是通过右移数据实现的。

22.1.5 arm_provide_guard_bits_q31

1. /**
   7 ]- W3 |* o8 D4 Y) ]' Q5 i
2. * @brief  Provide guard bits for Input buffer
   
3. * @param  q31_t*         Pointer to input buffer
   ( g% _" R7 G% N' f! q% k7 B) R
4. * @param  uint32_t         blockSize
   7 w, F# u' ~( u
5. * @param  uint32_t         guard_bits
   9 a) ^) k/ u. B* `; y5 f1 v$ H
6. * @return none
   
7. * The function Provides the guard bits for the buffer
   $ s! L  ]* T7 e2 ~
8. * to avoid overflow
   
9. */
   : v0 ]: f9 e, m! O2 D
10. 
    
11. void arm_provide_guard_bits_q31 (q31_t * input_buf,
    
12. uint32_t blockSize,
    
13.                                  uint32_t guard_bits)
    
14. {
    
15.   uint32_t i;
    
16. 
      P. S; d5 f# D, v( ^
17.   for (i = 0; i < blockSize; i++)
    ; D9 m- j5 e; S) v( N  g  T
18.     {
    
19.       input_buf[i] = input_buf[i] >> guard_bits;
    ' _, ^+ C) |. Y- r8 M
20.     }
    
21. }

复制代码

1. 这个函数用于给q31_t类型的数据提供保护位，防止溢出。从函数的实现上看，保护位的实现是通过右移数据实现的。

22.1.6 arm_float_to_q14

1. /**
   
2. * @brief  Converts float to fixed q14
   
3. * @param  uint32_t         number of samples in the buffer
   
4. * @return none
   4 u- {) V3 A9 k. g1 H% k% [5 I; Q' Q
5. * The function converts floating point values to fixed point values
   2 C% \, b) D  I$ A3 @
6. */
   
7. 
   
8. void arm_float_to_q14 (float *pIn, q15_t * pOut,
   - q' P6 H, n. a3 W# g1 B3 u- D
9.                        uint32_t numSamples)
   % U9 I, z2 t1 A7 K5 E& Q8 M
10. {
    
11.   uint32_t i;
    
12. 
    0 a( Z5 f7 p9 O$ a& U1 Y
13.   for (i = 0; i < numSamples; i++)
    & T0 G) \% k7 s) l
14.     {
    
15.   /* 16384.0f corresponds to pow(2, 14) */
    
16.       pOut[i] = (q15_t) (pIn[i] * 16384.0f);
    
17. 
    
18.       pOut[i] += pIn[i] > 0 ? 0.5 : -0.5;
    
19. 
    $ h9 W$ g/ l' h
20.       if (pIn[i] == (float) 2.0)
    & P& H4 w4 h6 {5 U/ V
21.         {
    
22.           pOut[i] = 0x7FFF;
    " F; i4 Y1 h  \# M; B" L
23.         }
    1 {; X, T. ^$ w+ S
24. 
    ! ^+ a# P4 e$ M! H
25.     }
    3 v% H9 E. n9 o  a1 N
26. 
    - f8 u& M* t( F, R
27. }

复制代码

1. 这个函数用于将浮点数转换成Q14格式的数据。

2. 浮点数转换成Q14格式需要乘以2^14，然后再做舍入处理，特别注意这里的浮点数末尾要加符号f，这样才能保证是单精度。

22.1.7 arm_float_to_q30

1. /**
   
2. * @brief Converts float to fixed q30 format
   + ^  w" v6 j& z
3. * @param uint32_t number of samples in the buffer
   6 L% {& L% S. a: A+ ~* p/ H, i
4. * @return none
   
5. * The function converts floating point values to fixed point values
   ; n- P/ p9 Q* g& E; a
6. */
   , u, g0 S* K8 {' v% J" A
7. 
   0 x5 J9 ~$ y$ |' C9 U6 j- k8 }
8. void arm_float_to_q29 (float *pIn, q31_t * pOut,
   
9. uint32_t numSamples)
   
10. {
    ; R: L/ C3 o6 F8 A0 _% c: h8 j
11. uint32_t i;
    + {5 n9 @, f, Q( O& u5 \$ }; ~
12. 
    % }1 {, B+ N2 r  W
13. for (i = 0; i < numSamples; i++)
    7 B5 H1 U/ B+ L( {: |' [! n% z
14. {
    2 C' t* t1 T, j# E
15. /* 1073741824.0f corresponds to pow(2, 30) */
    # _2 m" \1 x( G2 E( y) o0 c6 b
16. pOut[i] = (q31_t) (pIn[i] * 536870912.0f);
    
17. 
    3 a4 K% F2 C+ f7 ^' r3 o4 ]
18. pOut[i] += pIn[i] > 0 ? 0.5 : -0.5;
    % E, e9 F! r5 a' T) b; ^: ]! g
19. 
    
20. if (pIn[i] == (float) 4.0)
    
21. {
    
22. pOut[i] = 0x7FFFFFFF;
    9 D: M* {3 P6 O  B: n
23. }
    
24. }
    
25. }

复制代码

1. 这个函数用于将浮点数转换成Q30格式的数据。

2. 浮点数转换成Q30格式需要乘以2^30，然后再做舍入处理，特别注意这里的浮点数末尾要加符号f，这样才能保证是单精度。

# g9 ^) ~- Z' G( O- K) T22.1.8 arm_calc_guard_bits

1. /**
   ' l9 u9 k7 L/ g
2. * @brief Caluclates number of guard bits
   
3. * @param uint32_t number of additions
   
4. * @return none
   % c* ^' A- L5 \
5. * The function Caluclates the number of guard bits
   & c( e- |* P& X* {1 W
6. * depending on the numtaps
   
7. */
   * k0 f( P/ i1 S# ^2 k' m6 c
8. 
   
9. uint32_t arm_calc_guard_bits (uint32_t num_adds)
   
10. {
    
11. uint32_t i = 1, j = 0;
    $ M- C8 ?' l$ I# ?4 i
12. 
    
13. if (num_adds == 1)
      a0 z  K7 g+ G2 _/ G+ u1 y  E* h
14. {
    8 p% }0 H$ S1 c6 f: i
15. return (0);
    ! F1 a& N6 U' q
16. }
    
17. 
    : _& ^% m/ l* p7 q3 O7 p3 o
18. while (i < num_adds)
    & K0 X* C+ S6 K4 G
19. {
    6 ]# y$ Z. H4 K% P
20. i = i * 2;
    
21. j++;
    
22. }
    
23. 
    
24. return (j);
    " f9 k8 {( I2 V8 _; k3 N* K
25. }

复制代码

1. 这个函数是根据加数的个数来计算最终结果需要的保护位格式，从而防止溢出。

7 R/ x* ?! x6 ^' N6 u: ^22.1.9 arm_apply_guard_bits

1. /**
   
2. * @brief Converts Q15 to floating-point
   
3. * @param uint32_t number of samples in the buffer
   ) s5 f1 |4 g% c0 p4 V- j6 G
4. * @return none
   
5. */
   9 Y3 [1 q% A7 ?; |
6. 
   / a  ^4 J4 l" i3 e" H* W
7. void arm_apply_guard_bits (float32_t * pIn,
   
8. uint32_t numSamples,
   3 Y4 j9 X4 `* R; x2 b) N, g& X
9. uint32_t guard_bits)
   
10. {
    
11. uint32_t i;
    ; y# Z4 ?' N4 {" z4 B0 n
12. 
    
13. for (i = 0; i < numSamples; i++)
    * o5 k, g$ @4 f( R- a3 o6 [
14. {
    " }0 t$ G$ Y. T9 N, }
15. pIn[i] = pIn[i] * arm_calc_2pow(guard_bits);
    
16. }
    # v, M( J" ]; x- O. z) m, B0 y
17. }

复制代码

1. 这个函数不是很理解在实际应用中的作用。

22.1.10 arm_calc_2pow

1. /**
   
2. * @brief Calculates pow(2, numShifts)
   5 n, d% F1 O. ?+ {5 i- o6 |' x- s
3. * @param uint32_t number of shifts
     @' L! \& R2 }
4. * @return pow(2, numShifts)
   
5. */
   
6. uint32_t arm_calc_2pow(uint32_t numShifts)
   6 m3 L" f. {9 M0 w8 R  X
7. {
   $ B0 q6 x3 a# P) E0 U
8. 
   
9. uint32_t i, val = 1;
   
10. 
    ( c6 i& p: e$ r5 w
11. for (i = 0; i < numShifts; i++)
    
12. {
    ' K- p$ o+ T9 X% \. [! [
13. val = val * 2;
    / a* r  T! q9 a( g
14. }
    
15. 
    1 ]  h6 X) F2 \; r" d8 b  j  e- f; A( w
16. return(val);
    
17. }

复制代码

1. 这个函数用于求解2的n次方。

22.1.11 arm_compare_fixed_q15

1. /**
   1 I2 P3 G8 j6 Y& T, S
2. * @brief Compare MATLAB Reference Output and ARM Test output
     \! o2 j$ H$ E9 [. V
3. * @param q15_t* Pointer to Ref buffer
   4 J8 L7 I; Z$ z. z3 ^
4. * @param q15_t* Pointer to Test buffer
   
5. * @param uint32_t number of samples in the buffer
   % v- a. ?3 m  A1 l- l/ ?
6. * @return none
   
7. */
   
8. 
   
9. uint32_t arm_compare_fixed_q15(q15_t *pIn, q15_t * pOut, uint32_t numSamples)
   
10. {
    
11. uint32_t i;
    + p* {' a" ]' @) p& p  X& t
12. int32_t diff, diffCrnt = 0;
    
13. uint32_t maxDiff = 0;
    6 a+ }7 \8 C' f/ U8 c3 P
14. 
    
15. for (i = 0; i < numSamples; i++)
    
16. {
    
17. diff = pIn[i] - pOut[i];
      o* l% }7 \5 r, I. O! ~2 K  D7 R
18. diffCrnt = (diff > 0) ? diff : -diff;
    5 `: d2 n9 H- G- D% r6 _+ y/ v. e5 O
19. 
    
20. if(diffCrnt > maxDiff)
    
21. {
    
22. maxDiff = diffCrnt;
    $ r  E% T& Y/ ]
23. }
    ! z( E$ M  b0 N. ]1 @0 ]# E
24. }
    
25. 
    4 M3 l% V: Z+ _3 r  S
26. return(maxDiff);
    
27. }

复制代码

1. 这个函数用于对比matlab和ARM实际计算的输出，并返回最大的差值（Q15）。

" j) f( L; C# K8 _+ d) `0 ~# T22.1.12 arm_compare_fixed_q15

1. /**
   % f; n$ a, s# E; ^. i0 T" o  j
2. * @brief Compare MATLAB Reference Output and ARM Test output
   
3. * @param q31_t* Pointer to Ref buffer
   
4. * @param q31_t* Pointer to Test buffer
   
5. * @param uint32_t number of samples in the buffer
   0 Q* S6 [) a3 w8 S
6. * @return none
   & W9 g# Q0 i; K8 e' ~
7. */
   
8. 
   
9. uint32_t arm_compare_fixed_q31(q31_t *pIn, q31_t * pOut, uint32_t numSamples)
   ' }! e' l- L! m, K" I" K
10. {
    & u& J2 b) A# ^: Q1 X  C9 z
11. uint32_t i;
    
12. int32_t diff, diffCrnt = 0;
    
13. uint32_t maxDiff = 0;
    
14. 
    ! ~/ j9 X  k2 K' T0 U
15. for (i = 0; i < numSamples; i++)
    ' ~' C5 }, K/ m/ j# r
16. {
    
17. diff = pIn[i] - pOut[i];
    ' M' ^3 }0 H  s1 {+ h5 s0 p
18. diffCrnt = (diff > 0) ? diff : -diff;
    " ^3 J( Z3 s/ i0 o3 c% k
19. 
    - b! e1 n5 ]. Y# B7 q( F9 V
20. if(diffCrnt > maxDiff)
    
21. {
    
22. maxDiff = diffCrnt;
    
23. }
    
24. }
    8 e0 ?( S- K& z* [
25. 
    & z0 ^" ]( M4 P! v) p0 [' _
26. return(maxDiff);
    1 A' r$ {: }- k1 S: T: A% f
27. }

复制代码

1. 这个函数用于对比matlab和ARM实际计算的输出，并返回最大的差值（Q31）。

" C2 a/ I3 G  j* J22.2 总结

    本期教程就跟大家讲这么多，本期教程就不配套例子了，这些函数会在后面的应用中都用到。

/ Y, ]* D" [' c5 N8 m9 V

纯粹路过