你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

【安富莱——DSP教程】第22章 math_help中函数的使用

[复制链接]
baiyongbin2009 发布时间:2015-4-3 11:30
特别说明:完整45期数字信号处理教程,原创高性能示波器代码全开源地址:链接
) H& ^2 m/ N# x  g/ [/ Z+ x2 G7 J$ I6 ?! `
第22章 math_help中函数的使用

) t5 t# ^$ t0 k
    本期教程主要讲解math_help文件中函数的使用,这个文件也是ARM官方提供的,这些函数相对都比较容易,同时使用频率也很高。希望初学的同学学习并掌握。
    22.1 函数讲解
    22.3 总结
) p+ Q  i* N" Z) f- r
22.1 函数讲解: o( F( R7 B4 {9 I& r
22.1.1 函数目录
    在文件math_help文件中主要有以下函数:
  1. float arm_snr_f32(float *pRef, float *pTest,  uint32_t buffSize);  ) f: y! c0 G/ _" ]
  2. void arm_float_to_q12_20(float *pIn, q31_t * pOut, uint32_t numSamples);
    7 C  r0 f% K8 l8 Q; u9 c3 b, U
  3. void arm_provide_guard_bits_q15(q15_t *input_buf, uint32_t blockSize, uint32_t guard_bits);
    2 z* ~: C! K0 [  L7 o: {
  4. void arm_provide_guard_bits_q31(q31_t *input_buf, uint32_t blockSize, uint32_t guard_bits);
    " g% I+ Z. f5 a% D# f) f+ B1 F
  5. void arm_float_to_q14(float *pIn, q15_t *pOut, uint32_t numSamples);# K6 y" D) o' i! S  ^4 h7 }# d7 ^
  6. void arm_float_to_q30(float *pIn, q31_t *pOut, uint32_t numSamples);5 N9 n( O* ]9 l6 Z7 |
  7. void arm_clip_f32(float *pIn, uint32_t numSamples);
    $ N/ a' x8 D* a
  8. uint32_t arm_calc_guard_bits(uint32_t num_adds);8 x+ w! o& q5 J- F2 N- w5 s
  9. void arm_apply_guard_bits (float32_t * pIn, uint32_t numSamples, uint32_t guard_bits);
    5 D) a) R& h  R& U. s: c  L
  10. uint32_t arm_compare_fixed_q15(q15_t *pIn, q15_t * pOut, uint32_t numSamples);( ?# F% w( I' N5 Q7 y
  11. uint32_t arm_compare_fixed_q31(q31_t *pIn, q31_t *pOut, uint32_t numSamples);
    " a0 \5 F  g4 O. b
  12. uint32_t arm_calc_2pow(uint32_t guard_bits);
复制代码
; q$ R7 ^. H; z% ~. k
22.1.2 arm_snr_f32
    这个函数用于求信噪比:
  1. /**                                                                                                   (1): c; e% D2 M) ?, s) e$ `2 Q
  2. * @brief  Caluclation of SNR
    ) l$ t* I. i& g7 @
  3. * @param  float*         Pointer to the reference buffer
    6 a6 X: m7 X; {, e, h6 p5 I+ h$ a
  4. * @param  float*        Pointer to the test buffer5 e$ U: ?1 Q4 w# o! D% M
  5. * @param  uint32_t        total number of samples
    * @+ f  U3 ^) J5 d, X' }
  6. * @return float        SNR( F; S7 m7 f4 L2 W8 H
  7. * The function Caluclates signal to noise ratio for the reference output
    2 t* R- D, y+ F  s
  8. * and test output
    ) ]5 F; {( E0 e& O+ l: B( P, q& {
  9. */+ @2 z2 i6 Q* S4 x6 n# ?
  10. 2 C  E' L- w! r- b
  11. float arm_snr_f32(float *pRef, float *pTest, uint32_t buffSize)
    ( V. Z( }& _2 V  @+ `
  12. {7 E/ a. j4 `* D: p
  13.   float EnergySignal = 0.0, EnergyError = 0.0;4 d+ }% g4 n2 l1 W& l* Z
  14.   uint32_t i;: H8 G0 s* y; D+ H
  15.   float SNR;3 Q$ ?: q3 J. Q3 ~
  16.   int temp;# x( M$ o( ?2 }* {& p3 w4 ]4 \
  17.   int *test;% g# o' q1 m1 A7 v9 F

  18. 9 K* Y2 ]  {3 U4 j: J2 w8 x: I+ R
  19.   for (i = 0; i < buffSize; i++)
    - x+ {  }: C5 a, N1 ^
  20.     {3 X$ Q" p* f4 @- ~
  21.            /* Checking for a NAN value in pRef array */9 s2 Q4 F3 o( L: r) q5 A% H8 r( }
  22.   test =   (int *)(&pRef[i]);
    ) l4 `, q# M; m& |! C
  23.       temp =  *test;' A% y- G  y( @. Z4 K) l, P& X6 C

  24. * n  W, g- s  }$ f0 f4 b+ w4 d
  25.   if(temp == 0x7FC00000)! f. K4 c, ]; z5 F' P) O% l
  26.   {* c  n0 Z* `) K8 o
  27.            return(0);9 x& W/ i# h! g& V
  28.   }) C) ^5 \) y. W4 a3 p' _3 j) T
  29. $ x* f( B2 \! S
  30.   /* Checking for a NAN value in pTest array */! x  Q4 q) K7 ?+ a: X$ f. ?8 W
  31.   test =   (int *)(&pTest[i]);
    ! T! |; K8 k! K+ R
  32.       temp =  *test;4 a( B9 k+ A: r8 v6 k
  33. 0 @8 ~, h: z2 p- e" b
  34.   if(temp == 0x7FC00000). Z# R, ]; h& K6 O8 T; d/ G& [
  35.   {6 j3 ]' F( ~+ \( F. h. ~' b
  36.            return(0);6 y5 G  o# S1 y4 a" T, T6 [. Q
  37.   }
    8 Y0 F. ?/ W+ k! N4 ?, J
  38.       EnergySignal += pRef[i] * pRef[i];
    + m' W2 ~9 P! _6 `. n! c3 B# C
  39.       EnergyError += (pRef[i] - pTest[i]) * (pRef[i] - pTest[i]); ( X3 T* ?; c' J- R, Y
  40.     }7 J  N* W: e2 x; x: j/ n5 B1 t

  41. 7 B; ]; a5 ^# x8 F, ~" b
  42. /* Checking for a NAN value in EnergyError */( I( G& ]/ B9 A; m* D, r
  43. test =   (int *)(&EnergyError);3 G7 S$ o2 ]: h0 P; e
  44.     temp =  *test;9 H6 \! u' z$ a+ K! B4 m- I  \& e( }

  45. ' X8 y$ B* n- c1 _) `* W
  46.     if(temp == 0x7FC00000)3 ^" \- K0 b! M# F+ }( [; T% i
  47.     {
    4 _: b8 w0 d; I8 X8 P( ?
  48.            return(0);
    8 _- u: @7 m/ z/ `" Q2 \
  49.     }/ J$ f1 ^% }9 h% Z

  50. ; l; ?( F3 S9 v; V; g; k
  51.   SNR = 10 * log10 (EnergySignal / EnergyError);                                                       (2)9 f; W: G$ h' a9 d/ T
  52. 2 s4 w* V! T( L
  53.   return (SNR);2 `3 F& }: {5 w  p. j
  54. * D; K5 S% o6 ]
  55. }
复制代码
1. 这里先补充一些信噪比方面的基础知识:
    信噪比,即SNR(Signal to Noise Ratio),又称为讯噪比。反映摄像机成像的抗干扰能力,反应在画质上就是画面是否干净无噪点;狭义来讲是指放大器的输出信号的功率与同时输出的噪声功率的比,常常用分贝数表示,设备的信噪比越高表明它产生的杂音越少。一般来说,信噪比越大,说明混在信号里的噪声越小,声音回放的音质量越高,否则相反。信噪比一般不应该低于70dB,高保真音箱的信噪比应达到110dB以上。公式如下:
22.1.png
- Y7 H& ?9 e6 e! m3 r$ S
    关于信噪比更详细的知识,大家可以查阅相关资料进行了解。
2. 这里实现的就是上面所说的信噪比公式。
5 c6 m% L2 Y2 E* d
22.1.3 arm_float_to_q12_20
  1. /**
    1 x9 k4 v' N2 o- g% Q+ ^" X' X( d
  2. * @brief  Converts float to fixed in q12.20 format                                                    (1)
    % L( Q5 r, Y/ p5 J, r! `
  3. * @param  uint32_t         number of samples in the buffer
    ' B, a7 F) X: ?2 O' o
  4. * @return none' R3 f( k1 I7 o3 {- A# `* V" u
  5. * The function converts floating point values to fixed point(q12.20) values
    6 ?! @% E, T  U% r7 T' g: u
  6. */. e! Z5 G: @, |  h

  7. - q& k" m( K$ f) u7 L
  8. void arm_float_to_q12_20(float *pIn, q31_t * pOut, uint32_t numSamples)4 z" i! r& _" B3 l, v3 y0 a
  9. {
    & p' a* w: _0 i+ G8 K) i
  10.   uint32_t i;+ V0 T7 J/ x8 ~) ^
  11. * A7 X8 ^. V0 S1 K3 U' c3 u6 f# ]
  12.   for (i = 0; i < numSamples; i++)  z; t. Q# z& N
  13.     {
    + i! u# j% D, h# M6 F) j
  14.   /* 1048576.0f corresponds to pow(2, 20) */7 I7 O3 M* ~5 s  r& k2 n
  15.       pOut[i] = (q31_t) (pIn[i] * 1048576.0f);                                                        (2)& p& V( Y. l# n
  16. * }( F2 z/ H9 @# @- y+ |5 b/ _
  17.       pOut[i] += pIn[i] > 0 ? 0.5 : -0.5;
      _0 [; v7 |4 c# o4 [+ O  ~

  18. / O/ V9 B* D5 q# p/ F: _
  19.       if (pIn[i] == (float) 1.0)0 v& {4 N: Z. I3 W: ^( P
  20.         {
      ~2 o0 ?" L9 V) R8 v
  21.           pOut[i] = 0x000FFFFF;1 D, ]! S3 b7 Y7 C( l# N, ?$ \
  22.         }
    / G0 c, c& G0 d6 y! N4 S
  23.     }4 {& L0 D& y. t& `5 s) H
  24. }
复制代码
1. 这个函数用于将浮点数转换成Q12.20格式的数据。
2. 浮点数转换成Q12.20格式需要乘以2^20,然后再做舍入处理,特别注意这里的浮点数末尾要加符号f,这样才能保证是单精度。

) C5 [( N9 [2 T) e; V* a& m9 D
22.1.4 arm_provide_guard_bits_q15
  1. /** ( ?9 w5 ~* p1 U7 M
  2. * @brief  Provide guard bits for Input buffer  `3 H' X" M. ]& L( r. g- F: A/ Z
  3. * @param  q15_t*             Pointer to input buffer6 y) {; t! G4 }8 y& {
  4. * @param  uint32_t         blockSize
    1 z9 _. n. I$ L) h0 u
  5. * @param  uint32_t         guard_bits7 B1 W- L( H6 C: Y" b9 G6 P
  6. * @return none! A. W3 J. w! h+ i* I
  7. * The function Provides the guard bits for the buffer
    4 o+ e1 b# c  |+ }3 W/ u/ H* K
  8. * to avoid overflow 2 I# c# F1 ?2 ~# }/ m5 s
  9. */- h' E9 d) ?6 T2 U, \% l; ^; }/ q

  10. 4 N4 f4 [/ G5 v+ H9 M+ O; R1 A: s
  11. void arm_provide_guard_bits_q15 (q15_t * input_buf, uint32_t blockSize,
    4 T5 i2 s; }* [. {$ L. O7 T
  12.                             uint32_t guard_bits)
    # G1 r  x: t/ x/ P1 h( s9 a
  13. {% l+ ?* x% ^  g; _/ Y! j7 C
  14.   uint32_t i;
    " P( I# W. z* S5 |% h+ R' `- s
  15. 4 k9 D  D/ b4 o. |- y0 T9 Q
  16.   for (i = 0; i < blockSize; i++)
    " q8 Q! w5 q) |$ Q( Y# K% M! T# r
  17.     {9 n. @+ w0 Q. T$ X* A
  18.       input_buf[i] = input_buf[i] >> guard_bits;
    5 R4 B( d' }( y
  19.     }$ |1 J. |; G/ c
  20. }
复制代码
1. 这个函数用于给q15_t类型的数据提供保护位,防止溢出。从函数的实现上看,保护位的实现是通过右移数据实现的。

7 U+ s. g; H# _& C; i! }: r( J+ z
22.1.5 arm_provide_guard_bits_q31
  1. /**
    . z6 }+ k# \* C2 |4 E/ J6 z7 H# s. I
  2. * @brief  Provide guard bits for Input buffer" `: D% H9 i- N& N
  3. * @param  q31_t*         Pointer to input buffer$ I! q3 n" \: _2 U
  4. * @param  uint32_t         blockSize
    + c3 \: t; `7 |/ q+ {
  5. * @param  uint32_t         guard_bits
    ; ]1 F) c0 C3 h% M
  6. * @return none
    4 |8 F4 _+ }" ^, v! {. q% B
  7. * The function Provides the guard bits for the buffer 3 u8 T! s; |* Q& u  t2 {1 ]# o
  8. * to avoid overflow
    / U+ v: x) w0 b1 p6 f8 q" ?
  9. */9 v( O2 `: Y  R" ]$ {% W' ?* h

  10. 0 K3 J7 i+ l* B7 _* p% V, b4 D
  11. void arm_provide_guard_bits_q31 (q31_t * input_buf,
    ; M( G8 a; c/ Z
  12. uint32_t blockSize,( @0 i! w  H0 g
  13.                                  uint32_t guard_bits)
    ; m+ F  c. `9 A: h1 ^/ C" C$ a' n
  14. {
      ~# r3 J8 F3 A% G- i
  15.   uint32_t i;
    % n: }: }9 S9 h" F1 \
  16. 3 J* J4 S1 l! O
  17.   for (i = 0; i < blockSize; i++)* d$ k: v1 S% n. e; ^, `, G7 l
  18.     {# e2 g& W2 T* S  h9 l3 M
  19.       input_buf[i] = input_buf[i] >> guard_bits;
    ; o, g) q: U& f# K' `
  20.     }0 b  ?, X" @/ h8 p! @8 k
  21. }
复制代码
1. 这个函数用于给q31_t类型的数据提供保护位,防止溢出。从函数的实现上看,保护位的实现是通过右移数据实现的。
8 z: {0 f. i9 f- f- {4 a
22.1.6 arm_float_to_q14
  1. /** ! W8 k/ `6 B$ C& t' S6 z% g  B
  2. * @brief  Converts float to fixed q14 % Z& @" u" d! c, N, j
  3. * @param  uint32_t         number of samples in the buffer7 _  V9 W- Y9 Q3 f" L+ d' G# q0 w- Q$ J- N
  4. * @return none0 ]" b6 C8 R0 P4 x
  5. * The function converts floating point values to fixed point values 4 C& X- P* z9 p( x6 f: {- _7 [
  6. */- q" q8 O, M+ d/ U: H
  7. , l/ n6 O# s! @2 k8 m* m" P
  8. void arm_float_to_q14 (float *pIn, q15_t * pOut, 7 ?4 k% R" J+ V; j5 s
  9.                        uint32_t numSamples)
    # F4 x& i/ }8 L, m' _( I0 K( }' P
  10. {. i% T& K8 l, J+ D1 w/ V0 ~
  11.   uint32_t i;; ^- b( _0 q1 o' ?+ v8 l& |
  12. : T$ b6 }, i8 t6 H0 {- ?# C- b
  13.   for (i = 0; i < numSamples; i++)
    % O% K* T7 M4 o+ n! F6 x# ~
  14.     {  ]& z8 Q4 P: d# I1 j& B
  15.   /* 16384.0f corresponds to pow(2, 14) */2 c; F/ V/ x  m0 O5 B
  16.       pOut[i] = (q15_t) (pIn[i] * 16384.0f);7 p) u' f* k6 h; s: o: R5 w0 n
  17. & q$ w7 n+ O  f' C) v
  18.       pOut[i] += pIn[i] > 0 ? 0.5 : -0.5;
    . u6 X' n: {; ?  [: b6 s
  19. 0 u1 w  ]5 y3 x3 }& k# M: ~
  20.       if (pIn[i] == (float) 2.0)+ L: F2 u+ l6 f6 h1 ]
  21.         {
    7 S" d) q6 U4 n
  22.           pOut[i] = 0x7FFF;2 b1 i0 @* C! Q7 N0 `' [+ P9 W
  23.         }
    + t, @9 |7 Q; Z& W2 e% K! F
  24. 2 ^* K+ g; E' Y! W" |: z1 s: n: ~
  25.     }$ n, b6 z5 |* V3 [' u& `: J

  26. 2 S8 E9 s' F7 t! S5 e
  27. }
复制代码
1. 这个函数用于将浮点数转换成Q14格式的数据。
2. 浮点数转换成Q14格式需要乘以2^14,然后再做舍入处理,特别注意这里的浮点数末尾要加符号f,这样才能保证是单精度。

* D+ H+ J1 I# C. o" V- b- m
赞 收藏 评论2 发布时间:2015-4-3 11:30

举报

2个回答
baiyongbin2009 回答时间:2015-4-3 11:31:10
22.1.7 arm_float_to_q30
  1. /**
    . |4 R6 P& G' H4 l
  2. * @brief Converts float to fixed q30 format
    : n" B: S; H0 w
  3. * @param uint32_t number of samples in the buffer0 @& L' n" q% g4 ^, r; j/ }+ ~% V
  4. * @return none9 |4 F9 E9 a+ {# I7 W/ p3 m; A$ Q
  5. * The function converts floating point values to fixed point values ' {: ?& q# \8 x% v+ G9 q. X
  6. */1 Y! C: ~; j' c- }0 }& X( I( R4 W
  7. # ^( u! h" H; y6 D
  8. void arm_float_to_q29 (float *pIn, q31_t * pOut, 2 T' c$ i3 h4 R/ G* F/ I5 T
  9. uint32_t numSamples)
    3 Z0 h4 x8 B4 n+ |7 V$ P
  10. {
    # v' E/ Q% u8 B
  11. uint32_t i;3 Q1 Y) ~9 w* H) F8 z3 [8 b( v

  12. ( ]3 r6 U$ E! g: Q+ j( T8 {
  13. for (i = 0; i < numSamples; i++). I) G2 s: E& A& S$ A
  14. {
    8 x* I8 `4 ~9 `5 p, @! w
  15. /* 1073741824.0f corresponds to pow(2, 30) */8 x7 R( z: a+ X. p( f7 |
  16. pOut[i] = (q31_t) (pIn[i] * 536870912.0f);
    1 l% h1 q" {& @) I

  17. * N' L6 h( x' V7 V3 }7 Y
  18. pOut[i] += pIn[i] > 0 ? 0.5 : -0.5;9 \2 m' N3 M" ^) D- C$ x, a

  19. * O% B3 I! f; r8 z+ @
  20. if (pIn[i] == (float) 4.0)
    $ j4 z, i0 \: h1 H
  21. {6 i3 C3 Z: o* r0 d6 x
  22. pOut[i] = 0x7FFFFFFF;
    $ j+ G+ e( O/ q: t
  23. }- b8 X, s# a: i* V- E
  24. }1 s( |  |1 t: Z
  25. }
复制代码
1. 这个函数用于将浮点数转换成Q30格式的数据。
2. 浮点数转换成Q30格式需要乘以2^30,然后再做舍入处理,特别注意这里的浮点数末尾要加符号f,这样才能保证是单精度。
% Y2 |4 ^8 S, o
22.1.8 arm_calc_guard_bits
  1. /**
    8 `+ ?. D  N4 G- T' \* j6 |
  2. * @brief Caluclates number of guard bits
    5 ]; Q) ^4 w! b8 s
  3. * @param uint32_t number of additions; W7 v' i: T4 E% ~2 y
  4. * @return none
    9 G) k: G3 i+ m+ c; f
  5. * The function Caluclates the number of guard bits
    % F0 Q9 P; v: X
  6. * depending on the numtaps . m6 k! I1 p! {+ Q2 P$ Z
  7. */2 Y3 [' {' [$ s, {
  8. . b5 J4 c; N9 J$ z) o  O, _
  9. uint32_t arm_calc_guard_bits (uint32_t num_adds)* n0 R$ w8 Z. v, w6 X% y. O
  10. {0 I0 ~% v, S" V; D# \! |9 D
  11. uint32_t i = 1, j = 0;1 s2 e9 f% E. j$ @
  12.   n" `! {" j$ O' |" j1 i  _/ o
  13. if (num_adds == 1)) \' m3 [2 A7 @! ~( ~
  14. {
    9 E/ Z; r+ V; r; z" `
  15. return (0);
    # }( |. u* c  M) X, x2 G1 A
  16. }
    # {7 i0 L; t7 B0 Z# O6 m4 t

  17. * }1 e2 e5 ~5 s' ?+ h. {
  18. while (i < num_adds): }- F) E+ ~$ G" d% ~& |) U; X. A" r
  19. {  g% t- i, b# C: {
  20. i = i * 2;
    % y  H/ F3 Q" N
  21. j++;
    ) _: _1 V. j$ x0 U
  22. }! [2 W- m) r' d3 C2 I. {) b% X" R, n

  23. 3 |# u% l  a4 |
  24. return (j);
    - ^( h3 h9 i* w- Q. u6 }: |
  25. }
复制代码
1. 这个函数是根据加数的个数来计算最终结果需要的保护位格式,从而防止溢出。

# r- p3 }8 m: z/ Z6 \3 T
22.1.9 arm_apply_guard_bits
  1. /** : W" s4 G8 R' b6 ~" I1 u
  2. * @brief Converts Q15 to floating-point8 s# `2 q2 B$ ~$ a6 A* w
  3. * @param uint32_t number of samples in the buffer8 W4 _' L, V9 F5 {% G
  4. * @return none
    " t' a3 J5 H" s  v. }  A: }
  5. */& V% o  }) [" u* N6 Y& [4 D

  6. . j. E2 m  X! B) P
  7. void arm_apply_guard_bits (float32_t * pIn,
    - D' T  B2 U3 t8 K) F
  8. uint32_t numSamples,
    $ r9 r2 l$ ]; h
  9. uint32_t guard_bits)
    % H6 d6 _- _1 z/ a5 l( b3 o6 J
  10. {/ c7 G+ p7 L4 Y
  11. uint32_t i;
    % s: x0 j0 [6 R

  12. # I2 i, R) j/ n" x* E$ H4 a. q" m
  13. for (i = 0; i < numSamples; i++)
    2 Y) }! z+ `, @8 u) N+ w1 \( a
  14. {
    $ _( M( U8 \6 a/ f, F2 ]
  15. pIn[i] = pIn[i] * arm_calc_2pow(guard_bits);1 n' k1 v1 s- b; J3 k; w8 T
  16. }
      t: O$ a7 u$ f
  17. }
复制代码
1. 这个函数不是很理解在实际应用中的作用。

) d* Z8 U" W% [, u1 Q
22.1.10 arm_calc_2pow
  1. /** ( }  z9 o+ l& w' H" k
  2. * @brief Calculates pow(2, numShifts)
    5 `" Z$ a: o( l$ z# m" g5 Z
  3. * @param uint32_t number of shifts4 y4 z9 T2 s# I0 x. v- R; Z
  4. * @return pow(2, numShifts)+ [5 r* }* T7 h, Y2 D3 C
  5. */0 }3 Q0 S$ ~4 a4 l3 s$ J8 l
  6. uint32_t arm_calc_2pow(uint32_t numShifts)& I: G) i3 @+ u, d7 c
  7. {- p9 [& x* F  w: c

  8. 8 E, O0 b* @5 ^6 c
  9. uint32_t i, val = 1;
    5 k" L. l( D5 ?- _) Z

  10. / F1 n* f7 p# |4 ?5 ^
  11. for (i = 0; i < numShifts; i++)
    4 t8 f7 I4 [$ y- C  B2 L
  12. {+ i/ I& l, Z$ I" @) j3 s4 X. I; C4 c
  13. val = val * 2;
    7 A1 C/ f6 c- I0 n9 \' E6 x
  14. }- W- e* r7 {( k6 n% O! w  _

  15. - v8 @( f0 ?. v. P+ x$ Z
  16. return(val);. o, X, d' _* \) w- @
  17. }
复制代码
1. 这个函数用于求解2的n次方。

6 X% o6 i2 k% d4 [7 M3 P
22.1.11 arm_compare_fixed_q15
  1. /** 9 E3 r" E9 x5 K& j( i
  2. * @brief Compare MATLAB Reference Output and ARM Test output
    % y2 K/ H% a% G
  3. * @param q15_t* Pointer to Ref buffer4 ?' o. X, ?6 u8 _* b8 x
  4. * @param q15_t* Pointer to Test buffer
    % q$ ~' d# ]- P
  5. * @param uint32_t number of samples in the buffer! P% p* k; m, t; @6 m
  6. * @return none
    : \! I. G4 e) w+ _: U  ]
  7. */
    ; z5 c6 G. T& d( q$ v9 L

  8. / u# q' F8 d' H) m  Q- J: I
  9. uint32_t arm_compare_fixed_q15(q15_t *pIn, q15_t * pOut, uint32_t numSamples)
    1 h! \( g0 h% y6 Z5 m
  10. {
    / G% U4 u+ A9 H! _& [. `* R
  11. uint32_t i;
    7 t8 Y0 r2 d9 L4 u. }" J
  12. int32_t diff, diffCrnt = 0;
    * l% \/ \7 w+ Z
  13. uint32_t maxDiff = 0;
    ! j0 r8 |0 @- a; R3 y5 W8 c0 L" k
  14. ( r" r5 _' S$ H; I* F) d/ d
  15. for (i = 0; i < numSamples; i++)& x7 Y3 X1 M0 Y9 q+ {( d
  16. {6 h4 p0 J) p4 m% o; V
  17. diff = pIn[i] - pOut[i];
    % Z% @  I* O) ]% x; N
  18. diffCrnt = (diff > 0) ? diff : -diff;! Q4 }% {1 j, W  L2 h+ i* i

  19. + k) X+ X/ l" L* _
  20. if(diffCrnt > maxDiff)
    6 h% c' k; L, ~' H+ }
  21. {7 D9 P0 P$ s) b; }8 ?9 p8 M9 ]
  22. maxDiff = diffCrnt;
    # U% }& t& g! o% x2 k$ V+ u' H
  23. }
    - U( V7 m% v$ @6 q* E
  24. }& M) l% n* d' ~8 l9 ~6 f8 m% \
  25. . j* L; I( N5 I9 P
  26. return(maxDiff);- N" I% |1 D( j8 D
  27. }
复制代码
1. 这个函数用于对比matlab和ARM实际计算的输出,并返回最大的差值(Q15)。

' z. B4 }* A& @( p
22.1.12 arm_compare_fixed_q15
  1. /** 6 e" d: p) O* H3 }
  2. * @brief Compare MATLAB Reference Output and ARM Test output
    ' {7 a8 [% ?. M3 _$ z+ A+ g# a  @
  3. * @param q31_t* Pointer to Ref buffer
    4 x* r% ]0 l0 W/ C6 B& Q' b+ ^
  4. * @param q31_t* Pointer to Test buffer
    8 f2 g3 V" i$ f3 [9 B
  5. * @param uint32_t number of samples in the buffer8 S; W' X. q% \1 x
  6. * @return none   a8 j& n! d1 E' ^" |
  7. */: I6 b/ J% {1 E$ w9 t: P
  8. # H7 M3 P2 f6 W7 D2 i
  9. uint32_t arm_compare_fixed_q31(q31_t *pIn, q31_t * pOut, uint32_t numSamples)$ H, [3 q) W1 ?
  10. {9 g" P/ U9 {$ y2 O* {/ m% \6 s- i& N2 T
  11. uint32_t i;
    9 m; e, c. [$ w* a3 L9 \+ O9 v" a
  12. int32_t diff, diffCrnt = 0;
    2 \  `, e7 H! Z; O2 d6 p0 ^
  13. uint32_t maxDiff = 0;* q, U# l" F0 b7 v
  14. 6 O, {" }* c3 n; X+ a3 v+ X$ ~! ?; y
  15. for (i = 0; i < numSamples; i++)1 m3 Q7 n- O' u, j( _; T/ U, P
  16. {
    + r5 H. `( j; C8 G) ]; o" ^
  17. diff = pIn[i] - pOut[i];
    5 W9 O6 `. `6 r. x
  18. diffCrnt = (diff > 0) ? diff : -diff;
    2 E0 U+ r$ _2 {0 V2 f2 ~8 ~8 p4 `
  19. , q% b( j( d5 y' b
  20. if(diffCrnt > maxDiff). k6 r/ @* I0 \" l; K
  21. {
    ) Y3 I% n' z1 d6 M6 ^" Y
  22. maxDiff = diffCrnt;8 R; w* \. P  P* `6 ?
  23. }
    ! w8 o- j! p, R# p0 w
  24. }- i$ h( o6 B4 a+ k* H% L- W% z7 F
  25. $ p) J/ j, S" U4 a
  26. return(maxDiff);
    8 D& a- l6 t8 A5 I: {' W) y. r4 d& E
  27. }
复制代码
1. 这个函数用于对比matlab和ARM实际计算的输出,并返回最大的差值(Q31)。

! q' R# X. C% f22.2
总结
    本期教程就跟大家讲这么多,本期教程就不配套例子了,这些函数会在后面的应用中都用到。

4 v( _4 E$ C; c2 [" R9 N
nocoyou 回答时间:2015-4-3 13:47:42
纯粹路过
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版