特别说明：完整45期数字信号处理教程，原创高性能示波器代码全开源地址：链接
: u. Q( B/ P& [! ~$ E( I

第8章 BasicMathFunctions的使用（一）

0 _$ z$ W, ^  V& K, X

    本期教程开始学习ARM官方的DSP库，这里我们先从基本数学函数开始。本期教程主要讲绝对值，加法，点乘和乘法四种运算。

    8.1 绝对值（Vector Absolute Value）

    8.2 求和（Vector Addition）

    8.3 点乘（Vector Dot Product）

    8.4 乘法（Vector Multiplication）

8.1 绝对值（Vector Absolute Value）

    这部分函数主要用于求绝对值，公式描述如下：

    pDst[n] = abs(pSrc[n]),   0 <= n < blockSize.

    特别注意，这部分函数支持目标指针和源指针指向相同的缓冲区。

8.1.1 arm_abs_f32

    这个函数用于求32位浮点数的绝对值，源代码分析如下：

1. /**        
   
2. * @brief Floating-point vector absolute value.                                                    （1）
   
3. * @param[in]       *pSrc points to the input buffer        
   2 l( p( ?3 t4 O) c- S" c
4. * @param[out]      *pDst points to the output buffer        
   
5. * @param[in]       blockSize number of samples in each vector        
   
6. * @return none.        
   
7. */
   
8. 
   0 p/ Y& D/ p: K& j: F. H" o
9. void arm_abs_f32(                                                                                  （2）
   
10.   float32_t * pSrc,
    
11.   float32_t * pDst,
    
12.   uint32_t blockSize)
    
13. {
    ' R* i% i  O% |6 b8 R3 v( u
14.   uint32_t blkCnt;                               /* loop counter */
    
15. 
    
16. #ifndef ARM_MATH_CM0_FAMILY                                                                        （3）
    
17. 
    5 A, `% N! g$ }3 Y: |
18.   /* Run the below code for Cortex-M4 and Cortex-M3 */
    # g/ d$ p% B+ {0 ~2 f; V
19.   float32_t in1, in2, in3, in4;                  /* temporary variables */
    
20. 
    
21.   /*loop Unrolling */
    
22.   blkCnt = blockSize >> 2u;                                                                        （4）
    
23. 
    # k  |* X: C6 _0 z: I8 M2 E
24.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    
25.    ** a second loop below computes the remaining 1 to 3 samples. */
    
26.   while(blkCnt > 0u)
    
27.   {
    4 ]7 m2 j7 h% q5 _. `7 s/ r
28.     /* C = |A| */
    6 o- \. A+ H1 @) ~4 Q
29.     /* Calculate absolute and then store the results in the destination buffer. */
    
30.     /* read sample from source */
    0 W( U; P0 a1 r6 v" ?- X
31.     in1 = *pSrc;
    
32.     in2 = *(pSrc + 1);
    3 k' X7 F0 m1 g6 C7 x, V
33.     in3 = *(pSrc + 2);
    
34. 
    
35.     /* find absolute value */
    
36.     in1 = fabsf(in1);                                                                             （5）
    
37. 
    # ^! E) d' D+ J. F  D) K" K
38.     /* read sample from source */
    & o$ U. T: X! V7 p7 y
39.     in4 = *(pSrc + 3);
    
40. 
    
41.     /* find absolute value */
    
42.     in2 = fabsf(in2);
    
43. 
    
44.     /* read sample from source */
    
45.     *pDst = in1;
    
46. 
    
47.     /* find absolute value */
    
48.     in3 = fabsf(in3);
    4 H' g  ~* I6 i- K
49. 
    % @' l5 }$ G' B9 H
50.     /* find absolute value */
    $ o2 \/ F/ _9 x! b# K
51.     in4 = fabsf(in4);
    ' j7 l; v4 Z1 T. X# _
52. 
    5 S* z0 Q1 G$ h% d) u
53.     /* store result to destination */
    
54.     *(pDst + 1) = in2;
    
55. 
    2 f4 D0 U( u( o1 n% h1 E
56.     /* store result to destination */
    
57.     *(pDst + 2) = in3;
    
58. 
    
59.     /* store result to destination */
    
60.     *(pDst + 3) = in4;
    8 g0 s7 l$ ~: U7 U. A( t/ s; k
61. 
    8 V; n8 k, Z1 V& o3 d
62. 
    
63.     /* Update source pointer to process next sampels */                                            （6）
    
64.     pSrc += 4u;
    
65. 
    
66.     /* Update destination pointer to process next sampels */
    * q2 o. _' W* p+ Q
67.     pDst += 4u;
    7 P' ?1 `/ _1 S- U8 p
68. 
    
69.     /* Decrement the loop counter */
    ' ]7 H, ?. t1 y4 p
70.     blkCnt--;
    
71.   }
    ! A9 R. i/ X& `0 o: c2 K1 ^
72. 
    
73.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
74.    ** No loop unrolling is used. */
    * r1 [: T8 r5 M9 q) D5 f
75.   blkCnt = blockSize % 0x4u;
    ! |; U7 ?5 h9 Z: v! A
76. 
    " n9 m& J4 U& U2 D! b- H0 Y3 A
77. #else                                                                                             （7）
    8 ?* q: Q, _( k& Y4 s: j
78. 
    1 R7 S! K5 ^- N9 \" M" V* G4 L1 b
79.   /* Run the below code for Cortex-M0 */
    5 n) E1 a+ S4 {# S; I6 Y
80. 
    
81.   /* Initialize blkCnt with number of samples */
    0 [/ X8 a& j- F3 b1 N8 e/ t8 k. K6 G
82.   blkCnt = blockSize;
    0 \. o5 E0 I, y! \! _8 B  S: m
83. 
    
84. #endif /*   #ifndef ARM_MATH_CM0_FAMILY   */
    0 Y# [2 D- o6 t
85. 
    + q" q# m. R$ v
86.   while(blkCnt > 0u)                                                                              （8）
    - C) x* |1 L0 J5 i4 a
87.   {
    + e* S' z( r4 u7 O/ v
88.     /* C = |A| */
    
89.     /* Calculate absolute and then store the results in the destination buffer. */
    . b  N2 @# q4 C( z6 P! a% }
90.     *pDst++ = fabsf(*pSrc++);
    
91. 
    : v6 ?+ q. y* y) Y7 i/ H
92.     /* Decrement the loop counter */
    ) H5 e. c0 v1 C- _) M
93.     blkCnt--;
    ) Z, a( Q1 y- J4 a5 b" C6 q7 S) ~5 O
94.   }
    
95. }

复制代码

1. 在这里简单的跟大家介绍一下DSP库中函数的通用格式，后面就不再赘述了。

    （1） 基本所有的函数都是可重入的。

    （2） 大部分函数都支持一组数的计算，比如这个函数arm_abs_f32就可以计算一组数的绝对值。所以如果只是就几个数的绝对值，用这个库函数就没有什么优势了。

    （3） 库函数基本是CM0，CM3和CM4都支持的（最新的DSP库已经添加CM7的支持）。

    （4） 每组数据基本上都是以4个数为一个单位进行计算，不够四个再单独计算。

    （5） 大部分函数都是配有f32，Q31，Q15和Q7四种格式。

2. 函数参数，支持输入一个数组进行计算绝对值。

3. 这部分代码是用于CM3和CM4内核。

4. 左移两位从而实现每4个数据为一组进行计算。

5. fabsf：这个函数不是用Cortex-M4F支持的DSP指令实现的，而是用C语言实现的，这个函数是被MDK封装起来的。

6. 切换到下一组数据。

7. 这部分代码用于CM0.

8. 用于不够4个数据的计算或者CM0内核。

8.1.2 arm_abs_q31

    这个函数用于求32位定点数的绝对值，源代码分析如下：

1. /**   
   : F1 w6 j$ ]' P: ^, L
2. * @brief Q31 vector absolute value.   
   ) ~2 ?! Q" ?- h8 p+ X/ y
3. * @param[in]       *pSrc points to the input buffer   
   
4. * @param[out]      *pDst points to the output buffer   
   
5. * @param[in]       blockSize number of samples in each vector   
   / R5 l. Y! e' G. ^. ]! u9 r0 ]
6. * @return none.   
   
7. *   
   8 q" s( X' I! u. l1 [- O3 f+ @
8. * <b>Scaling and Overflow Behavior:</b>                                                              （1）
   
9. * \par   
   : ]' \8 T5 p/ H
10. * The function uses saturating arithmetic.   
    / G5 P4 @# V2 r' |* K( i
11. * The Q31 value -1 (0x80000000) will be saturated to the maximum allowable positive value 0x7FFFFFFF.   
    4 ]$ O1 n. F$ O, ?6 w4 U% @& ?
12. */
    
13. 
    
14. void arm_abs_q31(
    ' o, U) Q  f9 l& x) K/ ?
15.   q31_t * pSrc,
    
16.   q31_t * pDst,
    # k, S' r  m7 D7 ^% V
17.   uint32_t blockSize)
    8 g  W* F1 M7 [( h3 p0 O
18. {
    ; O# r& R0 X; B5 }" a- f  i% L
19.   uint32_t blkCnt;                               /* loop counter */
    
20.   q31_t in;                                      /* Input value */
    " o: {% q) ^" C4 l/ u& s' h; g6 x4 w
21. 
    : D* R9 w( t: R* A3 o, Q
22. #ifndef ARM_MATH_CM0_FAMILY
    - Z  T' ]2 |0 i2 ]+ t
23. 
    
24.   /* Run the below code for Cortex-M4 and Cortex-M3 */
    
25.   q31_t in1, in2, in3, in4;
    
26. 
    1 h) E# N. E* f& X6 n2 o4 t
27.   /*loop Unrolling */
    
28.   blkCnt = blockSize >> 2u;
    2 `' z& B. R, X2 c/ H; o
29. 
    ( {; e" M7 j( ^! u
30.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    
31.    ** a second loop below computes the remaining 1 to 3 samples. */
      y; c6 s. a9 p2 q( n
32.   while(blkCnt > 0u)
    
33.   {
    
34.     /* C = |A| */
    
35.     /* Calculate absolute of input (if -1 then saturated to 0x7fffffff) and then store the results in the destination buffer. */
    
36.     in1 = *pSrc++;
    
37.     in2 = *pSrc++;
    ; `" L9 z  `6 }1 L7 T; u, ~
38.     in3 = *pSrc++;
    
39.     in4 = *pSrc++;
    
40. 
    + W  h( k& q% @0 W/ i4 `; _( I0 c
41.     *pDst++ = (in1 > 0) ? in1 : (q31_t)__QSUB(0, in1);                                              （2）
    1 W/ K6 S9 Y: c! Z2 Y
42.     *pDst++ = (in2 > 0) ? in2 : (q31_t)__QSUB(0, in2);
    
43.     *pDst++ = (in3 > 0) ? in3 : (q31_t)__QSUB(0, in3);
    : d/ F2 J2 v# m) J0 ?/ i
44.     *pDst++ = (in4 > 0) ? in4 : (q31_t)__QSUB(0, in4);
    
45. 
    
46.     /* Decrement the loop counter */
    1 `" Q# [- C" U1 y
47.     blkCnt--;
    + Z% P: b. e+ |+ V- n  `* ~" K
48.   }
    
49. 
    7 P6 T8 l# d) p- i$ x
50.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
51.    ** No loop unrolling is used. */
    # {. G0 \7 v6 Y# U6 y
52.   blkCnt = blockSize % 0x4u;
    
53. 
    , U4 O; ?3 J& B
54. #else
    
55. 
    
56.   /* Run the below code for Cortex-M0 */
    & a& M: i0 W6 O  y3 l; I# Y3 Y
57. 
    
58.   /* Initialize blkCnt with number of samples */
    
59.   blkCnt = blockSize;
    
60. 
    ( w8 e$ L5 ^8 o# H- \6 l4 W( f5 U
61. #endif /*   #ifndef ARM_MATH_CM0_FAMILY   */
    
62. 
    
63.   while(blkCnt > 0u)
    & g4 K$ K. u& Y# v- ~
64.   {
    
65.     /* C = |A| */
    $ J! W. q2 y/ n. `7 v/ j
66.     /* Calculate absolute value of the input (if -1 then saturated to 0x7fffffff) and then store the results in the destination buffer. */
    7 [2 m. l2 ^( ]' e; b% J
67.     in = *pSrc++;
    9 B) m# T5 ~7 e+ r4 o/ O
68.     *pDst++ = (in > 0) ? in : ((in == INT32_MIN) ? INT32_MAX : -in);
    
69. 
    
70.     /* Decrement the loop counter */
    
71.     blkCnt--;
    
72.   }
    + H2 I/ b0 ~0 h% B' ]  y
73. 
    
74. }

复制代码

1. 这个函数使用了饱和运算，其实不光这个函数，后面很多函数都是使用了饱和运算的，关于什么是饱和运算，大家看Cortex-M3权威指南中文版的4.3.6 小节：汇编语言：饱和运算即可。

    对于Q31格式的数据，饱和运算会使得数据0x80000000变成0x7fffffff（这个数比较特殊，算是特殊处理，记住即可）。

2. 这里重点说一下函数__QSUB，其实这个函数算是Cortex-M4/M3的一个指令，用于实现饱和减法。

    比如函数：__QSUB(0, in1) 的作用就是实现0 – in1并返回结果。这里__QSUB实现的是32位数的饱和减法。还有__QSUB16和__QSUB8实现的是16位和8位数的减法。

8.1.3 arm_abs_q15

    这个函数用于求15位定点数的绝对值，源代码分析如下：

1. /**   
   
2. * @brief Q15 vector absolute value.   
   + e! K% N6 z; @. E
3. * @param[in]       *pSrc points to the input buffer   
   0 g4 V1 c, X  E3 D
4. * @param[out]      *pDst points to the output buffer   
   * p( P6 Q* A# H  ~! T
5. * @param[in]       blockSize number of samples in each vector   
   ( |: N- Z, c' {+ r% b
6. * @return none.   
   3 c( v9 ]" J- a* Q
7. *   
   
8. * <b>Scaling and Overflow Behavior:</b>   
     M) U! q% L# K' F# s9 Q$ Q9 Y
9. * \par   
   
10. * The function uses saturating arithmetic.   
    # z  ~2 S; e; y: i( l8 n
11. * The Q15 value -1 (0x8000) will be saturated to the maximum allowable positive value 0x7FFF.       （1）
    
12. */
    8 ~6 M& A, \- V5 P
13. 
    
14. void arm_abs_q15(
    & p" D8 N5 i  ^: y
15.   q15_t * pSrc,
    8 J' Y: G- t( ]% z, W& i3 n$ I
16.   q15_t * pDst,
    ! Q. x9 `, ?6 |5 A
17.   uint32_t blockSize)
    
18. {
    
19.   uint32_t blkCnt;                               /* loop counter */
    
20. 
    % Y/ W5 w. E3 I' S" K( |
21. #ifndef ARM_MATH_CM0_FAMILY
    
22.   __SIMD32_TYPE *simd;                                                                               （2）
    : ^7 x- O3 \- \, R
23. 
    
24. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
25. 
    + v6 v& |* V2 E/ @# X' H
26.   q15_t in1;                                     /* Input value1 */
    3 U9 L) w3 Z& Z( T1 g8 Q1 o
27.   q15_t in2;                                     /* Input value2 */
    4 A# ]% V0 x( ~# f
28. 
    
29. 
    ; i) i, ^: z1 {2 j6 Q
30.   /*loop Unrolling */
    9 t+ ^( T( B% X- ?
31.   blkCnt = blockSize >> 2u;
    
32. 
    5 Z6 [5 v) }3 C5 N) _' ?/ ]& G2 J3 C+ n
33.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    
34.    ** a second loop below computes the remaining 1 to 3 samples. */
    
35.   simd = __SIMD32_CONST(pDst);                                                                       （3）
    
36.   while(blkCnt > 0u)
    
37.   {
    
38.     /* C = |A| */
    ( D+ g% H& }- e+ G: U8 r7 J. }
39.     /* Read two inputs */
    4 C' I- f3 m' a2 \) H5 `0 ~! o
40.     in1 = *pSrc++;
    9 [1 U1 ]- [- {6 @8 |8 c8 A% E
41.     in2 = *pSrc++;
    
42. 
    3 |4 Q) b1 D9 \. n
43. 
    
44.     /* Store the Absolute result in the destination buffer by packing the two values, in a single cycle */
    4 {" C0 J) }' ^' b% R0 a
45. #ifndef  ARM_MATH_BIG_ENDIAN
    
46.     *simd++ =
    - F0 w1 l, N. X& Z7 ^  p
47.       __PKHBT(((in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1)),                                           （4）
    
48.               ((in2 > 0) ? in2 : (q15_t)__QSUB16(0, in2)), 16);
    
49. 
    4 j% Z) w  O  u6 E
50. #else
    
51. 
    
52. 
    
53.     *simd++ =
    ! c/ O$ y# b1 z2 T% U8 d
54.       __PKHBT(((in2 > 0) ? in2 : (q15_t)__QSUB16(0, in2)),
    
55.               ((in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1)), 16);
    
56. 
    + g5 o% G; P  ?% U# \
57. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
    
58. 
    $ Y  U, n4 t) n% h# E) d% f
59.     in1 = *pSrc++;
      E  C) O7 U; O& j4 Z% {8 t
60.     in2 = *pSrc++;
    
61. 
    ! i6 \  ]5 R, o2 [2 S( J' S; b
62. 
    ) W) j, p+ B, P% X9 w# a
63. #ifndef  ARM_MATH_BIG_ENDIAN
    
64. 
    1 `. [  r3 J5 K2 N
65.     *simd++ =
    % V1 E; W% w4 z1 k0 A8 Q+ Z
66.       __PKHBT(((in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1)),
    
67.               ((in2 > 0) ? in2 : (q15_t)__QSUB16(0, in2)), 16);
    9 A" V! ?- _+ V9 r9 Z
68. 
    ; t; W$ I# P& ~/ p/ E
69. #else
    
70. 
    
71. 
    
72.     *simd++ =
    
73.       __PKHBT(((in2 > 0) ? in2 : (q15_t)__QSUB16(0, in2)),
    / U4 a) F+ g5 R9 r+ h, _
74.               ((in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1)), 16);
    # \& z9 I% v6 W7 j% `. z4 E
75. 
    6 H0 R# G: k8 J4 {: ]! j
76. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
    
77. 
    
78.     /* Decrement the loop counter */
    1 t6 {& S; Z  n" U
79.     blkCnt--;
    
80.   }
    
81.   pDst = (q15_t *)simd;
      k7 D$ I4 _+ f& I1 e
82.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    / m) M  i9 H2 i4 Q; J/ O4 c% k
83.    ** No loop unrolling is used. */
    4 v5 \8 b. N" t" B7 m, d
84.   blkCnt = blockSize % 0x4u;
    3 T+ t' m! B' |: B* J  k7 v
85. 
    
86.   while(blkCnt > 0u)
    
87.   {
    
88.     /* C = |A| */
      i0 k* B  O- W+ y
89.     /* Read the input */
    0 r' L( }, A: o; C( s5 `
90.     in1 = *pSrc++;
    
91. 
    
92.     /* Calculate absolute value of input and then store the result in the destination buffer. */
    
93.     *pDst++ = (in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1);
    6 _5 [0 k3 ^' U: V* j, O% h
94. 
    : _8 N  X1 K* l: R4 _; E/ ^" b
95.     /* Decrement the loop counter */
    
96.     blkCnt--;
    # ^. G* {  o& P6 l" [2 L- {. x
97.   }
    
98. 
    
99. #else
    
100. 
     
101.   /* Run the below code for Cortex-M0 */
     3 |: h; K+ U3 {. ^8 [" o# N
102. 
     
103.   q15_t in;                                      /* Temporary input variable */
     ) W  r5 }  n: k$ z
104. 
     
105.   /* Initialize blkCnt with number of samples */
     
106.   blkCnt = blockSize;
     * K: T! s' g# j7 V- y
107. 
     " I* o5 \9 E8 `. i9 p& f, ]
108.   while(blkCnt > 0u)
     
109.   {
     0 g  w  i+ o$ }5 W4 I
110.     /* C = |A| */
     
111.     /* Read the input */
     1 v4 R* M* F+ z9 C( t2 V) o
112.     in = *pSrc++;
     
113. 
     
114.     /* Calculate absolute value of input and then store the result in the destination buffer. */
     # J* V7 n; y# e& i5 c  S8 q
115.     *pDst++ = (in > 0) ? in : ((in == (q15_t) 0x8000) ? 0x7fff : -in);
     ' _3 W& {. t' M% U
116. 
     
117.     /* Decrement the loop counter */
     
118.     blkCnt--;
     
119.   }
     & x/ v4 K0 h( ?  U  F4 J
120. 
     , K- a2 K0 k4 e0 r
121. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
     ! a- N: S2 r7 n' \  h, }
122. 
     # L, M5 T8 b  L+ B
123. }

复制代码

1. 对于Q15格式的数据，饱和运算会使得数据0x8000变成0x7fff。

2. __SIMD32_TYPE的定义在文件arm_math.h中，具体定义如下：

        #define __SIMD32_TYPE int32_t __packed

    SIMD就是咱们上期教程所将的单指令多数据流。简单的理解就是__SIMD32_TYPE就是定义了一个int32_t类型的数据，__packed的含义就是实现字节的对齐功能，方便两个16位数据的都存入到这个数据类型中。

3. 函数__SIMD32_CONST的定义如下：

    #define __SIMD32_CONST(addr)  ((__SIMD32_TYPE *)(addr))

4. 函数__PKHBT的定义在文件core_cm4_simd.h，定义如下：

    #define __PKHBT(ARG1,ARG2,ARG3)   ( ((((uint32_t)(ARG1)) ) & 0x0000FFFFUL) |  \

                                                          ((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL) )

        这个宏定义的作用就是将将两个16位的数据合并成32位数据。但是有一点要特别说明__PKHBT也是CM4内核支持的SIMD指令，上面的宏定义的C函数会被MDK自动识别并调用相应的PKHBT指令。

        __QSUB16用于实现16位数据的饱和减法。

8.1.4 arm_abs_q7

    这个函数用于求8位定点数的绝对值，源代码分析如下：

1. /**        
   
2. * @brief Q7 vector absolute value.        
   0 i+ D3 c  c  l5 ?
3. * @param[in]       *pSrc points to the input buffer        
   
4. * @param[out]      *pDst points to the output buffer        
   " ?/ d& ^' R" q9 r2 }0 p4 p
5. * @param[in]       blockSize number of samples in each vector        
   
6. * @return none.        
   & V+ V- j+ b1 ?# F# [; x* G
7. *   
   , \% d& b6 w, |7 Z) G
8. * \par Conditions for optimum performance   
   
9. *  Input and output buffers should be aligned by 32-bit   
   ) i; J5 S* L+ |. {
10. *   
    
11. *        
    ( [2 G' T0 `: a$ ]. S# d9 r
12. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
    " f$ N& G8 l, \8 Q
13. * \par        
    
14. * The function uses saturating arithmetic.        
    
15. * The Q7 value -1 (0x80) will be saturated to the maximum allowable positive value 0x7F.        
    " L8 |! \3 C7 B& \) J
16. */
    ( t5 b* l3 |" _+ U9 X8 P3 A
17. 
    * f; w0 L4 `5 l& z3 {+ c. E
18. void arm_abs_q7(
    , ?( s3 D2 q0 r' r
19.   q7_t * pSrc,
    
20.   q7_t * pDst,
    : o; \. t' h( D% n0 c
21.   uint32_t blockSize)
    " a' y3 ?; _. O7 Z2 L5 j5 ~
22. {
    
23.   uint32_t blkCnt;                               /* loop counter */
    
24.   q7_t in;                                       /* Input value1 */
    
25. 
    - ~" w0 q0 a! ^% p& u+ j
26. #ifndef ARM_MATH_CM0_FAMILY
    0 C+ T+ `) Y% E4 S
27. 
    9 {6 R9 p5 Z: x3 P
28.   /* Run the below code for Cortex-M4 and Cortex-M3 */
    
29.   q31_t in1, in2, in3, in4;                      /* temporary input variables */
    
30.   q31_t out1, out2, out3, out4;                  /* temporary output variables */
    6 p& ]6 I$ s- h% j# j
31. 
    
32.   /*loop Unrolling */
    
33.   blkCnt = blockSize >> 2u;
      B& F6 W" ~+ S+ x
34. 
    3 e! l; N/ K0 X, V5 k
35.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    
36.    ** a second loop below computes the remaining 1 to 3 samples. */
    / q+ Z# e4 e9 J6 A5 B, G9 [6 F9 `
37.   while(blkCnt > 0u)
    
38.   {
    ( {3 @+ C* N0 t% q" {
39.     /* C = |A| */
    
40.     /* Read inputs */
    
41.     in1 = (q31_t) * pSrc;
    + `7 p$ H* ?1 ]- ^! g1 H; r
42.     in2 = (q31_t) * (pSrc + 1);
    
43.     in3 = (q31_t) * (pSrc + 2);
    
44. 
    5 w$ ?9 ?. T) z" F) O! O: S
45.     /* find absolute value */
    + o. x7 T$ y2 m0 s4 J/ U6 x
46.     out1 = (in1 > 0) ? in1 : (q31_t)__QSUB8(0, in1);                                                  (2)
    : Z: {+ E2 B) r+ J* l
47. 
    9 u& X  s# _2 w) ]
48.     /* read input */
    
49.     in4 = (q31_t) * (pSrc + 3);
    
50. 
    ) p" K$ N& c$ V! o5 U+ }
51.     /* find absolute value */
    
52.     out2 = (in2 > 0) ? in2 : (q31_t)__QSUB8(0, in2);
    
53. 
    
54.     /* store result to destination */
    
55.     *pDst = (q7_t) out1;
    
56. 
    
57.     /* find absolute value */
      B  ?! e8 r- j$ l$ S3 L
58.     out3 = (in3 > 0) ? in3 : (q31_t)__QSUB8(0, in3);
    
59. 
    
60.     /* find absolute value */
    
61.     out4 = (in4 > 0) ? in4 : (q31_t)__QSUB8(0, in4);
    
62. 
    0 d8 X% j7 Z# f! t  @: [
63.     /* store result to destination */
    7 H' h) q' I! a. h
64.     *(pDst + 1) = (q7_t) out2;
    
65. 
    
66.     /* store result to destination */
    
67.     *(pDst + 2) = (q7_t) out3;
    
68. 
    
69.     /* store result to destination */
    # G2 ]( j* D# N& _
70.     *(pDst + 3) = (q7_t) out4;
    
71. 
    
72.     /* update pointers to process next samples */
    
73.     pSrc += 4u;
    
74.     pDst += 4u;
    
75. 
    - j% M( y2 d1 k$ w( {' |/ {1 y- _
76.     /* Decrement the loop counter */
    
77.     blkCnt--;
    $ }2 {( K) J2 y; [% E
78.   }
    5 H  l! e7 @0 {
79. 
    
80.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
81.    ** No loop unrolling is used. */
    1 I1 C  t" ^+ B3 ], R
82.   blkCnt = blockSize % 0x4u;
    6 u: W4 t1 ]6 e8 N8 s% |
83. #else
    
84. 
    4 B9 v' W9 d3 K5 D+ T  J2 v
85.   /* Run the below code for Cortex-M0 */
    
86.   blkCnt = blockSize;
    ' e9 _$ `. p% _: s
87. 
    
88. #endif //      #define ARM_MATH_CM0_FAMILY
    
89. 
    % e2 G8 M9 d. m( p
90.   while(blkCnt > 0u)
    3 L  ^, B* _* i. a* n: F- q
91.   {
    
92.     /* C = |A| */
    
93.     /* Read the input */
    * W* F  L/ f) @# y, }1 [1 w! Y
94.     in = *pSrc++;
    ! }+ U! b0 z7 @8 t- t( k6 M. F
95. 
    0 H% H$ Y2 z: Y- B" J: u- m
96.     /* Store the Absolute result in the destination buffer */
    ! ~% G3 M; h5 r  L' I9 f7 [
97.     *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? 0x7f : -in);
    3 Q4 I  {$ @8 H
98. 
    8 F# f) @2 g' g( O7 ^
99.     /* Decrement the loop counter */
    
100.     blkCnt--;
     , u2 w4 Y1 b* t. M6 X* n) H3 o6 m
101.   }
     
102. }

复制代码

1. 由于饱和运算，0x80求绝对值将变成数据0x7F。

2. __QSUB8用以实现8位数的饱和减法运算。

8.1.5 实例讲解

实验目的：

    1. 四种数据类型数据绝对值求解

实验内容：

    1. 按下按键K1, 串口打印输出结果

实验现象：

        通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
   # \8 H2 K. K" {3 S" a, [/ V
2. *********************************************************************************************************
   
3. *        函 数 名: DSP_ABS
   
4. *        功能说明: 求绝对值
   
5. *        形    参：无
   
6. *        返 回 值: 无
   ! c) V& w$ g* ~2 a3 r( N
7. *********************************************************************************************************
   $ j" U  U- a9 M) ^! |
8. */
   
9. static void DSP_ABS(void)
   2 c3 B! b  {1 u* a' i
10. {
    , d7 c! l8 W( K* |9 g! ~( t
11. static float32_t pSrc;
    
12.     static float32_t pDst;
    * z$ v' t: J$ }& M% N6 T
13. static q31_t pSrc1;
    
14. static q31_t pDst1;
    
15. static q15_t pSrc2;
    6 Q: R/ L! T4 A2 s) g
16. static q15_t pDst2;
    6 \" k% M, r& J7 O" b1 T
17. static q7_t pSrc3 = 127; /* 为了说明问题，在这里设置初始值为127，然后查看0x80是否饱和为0x7F */
    
18. static q7_t pDst3;
    
19. pSrc -= 1.23f;
    
20. arm_abs_f32(&pSrc, &pDst, 1);                                                                    (1)
    
21. printf("arm_abs_f32 = %f\r\n", pDst);
    9 W9 M( m- I4 B' H
22. 
    
23. pSrc1 -= 1;
    
24. arm_abs_q31(&pSrc1, &pDst1, 1);                                                                  (2)
    7 j7 L9 t4 o) M$ S6 @
25. printf("arm_abs_q31 = %d\r\n", pDst1);
    
26. 
    
27. pSrc2 -= 1;
    
28. arm_abs_q15(&pSrc2, &pDst2, 1);                                                                  (3)
      ~, [7 i# O8 M. x4 n, D
29. printf("arm_abs_q15 = %d\r\n", pDst2);
    
30. 
    7 }9 u( K# ]* @. L5 u( K& ?
31. pSrc3 += 1;
    / s3 Z) z# y/ b/ B
32. printf("pSrc3 = %d\r\n", pSrc3);
    + @  f4 X- J8 x% u
33. arm_abs_q7(&pSrc3, &pDst3, 1);                                                                   (4)
    
34. printf("arm_abs_q7 = %d\r\n", pDst3);
    $ p8 [- e. x9 @7 L% M9 k
35. printf("***********************************\r\n");
    " s5 a; {) o' ~7 W; @4 x
36. }

复制代码

(1)到(4)实现相应格式下绝对值的求解。这里只求了一个数，大家可以尝试求解一个数组的绝对值。

8.3 点乘（Vector Dot Product）

    这部分函数主要用于点乘，公式描述如下：

     sum = pSrcA[0]*pSrcB[0] + pSrcA[1]*pSrcB[1] + ... + pSrcA[blockSize-1]*pSrcB[blockSize-1]

8.3.1 arm_dot_prod_f32

    这个函数用于求32位浮点数的点乘，源代码分析如下：

1. /**
   
2. * @defgroup dot_prod Vector Dot Product
   
3. *
   
4. * Computes the dot product of two vectors.
   6 \) H5 m7 A1 e3 y! |( Y& ^: j
5. * The vectors are multiplied element-by-element and then summed.
   & m2 V7 F5 ^1 B3 D/ |7 A
6. *
   
7. * <pre>
   3 J# q" e0 a; @
8. *     sum = pSrcA[0]*pSrcB[0] + pSrcA[1]*pSrcB[1] + ... + pSrcA[blockSize-1]*pSrcB[blockSize-1]
   + @/ @" h0 @8 [* D8 l7 Y! d
9. * </pre>     
   & g. e0 a8 ]& N# }# I$ R. k
10. *
    / Y* n6 \' @- \. J
11. * There are separate functions for floating-point, Q7, Q15, and Q31 data types.   
    
12. */
    
13. 
    " H" ]7 k# {0 F: f. B% U" {- p
14. /**   
    
15. * @addtogroup dot_prod   
    4 L+ `% W+ ^5 [; N! y
16. * @{   
    . Z! o4 V& y. d2 k) S: ]1 a, Q
17. */
    
18. 
    0 v9 c/ x( @# J( G3 j
19. /**   
    
20. * @brief Dot product of floating-point vectors.   
    1 ~4 ]" {8 r2 v
21. * @param[in]       *pSrcA points to the first input vector   
    
22. * @param[in]       *pSrcB points to the second input vector   
    * R! O& q3 q  |. B+ W
23. * @param[in]       blockSize number of samples in each vector   
    
24. * @param[out]      *result output result returned here   
    
25. * @return none.   
    
26. */
    
27. 
    
28. 
    ( n8 ^/ K1 |2 I8 e1 s: T" v5 G7 Z
29. void arm_dot_prod_f32(
    : Y# A. b- C/ y1 t6 \
30.   float32_t * pSrcA,
    6 C9 w# b; \+ M) a7 ?3 I, q
31.   float32_t * pSrcB,
    * z6 Q7 s0 H' d4 v$ m- z0 {: ^% ^& K
32.   uint32_t blockSize,
    # [( |. b6 l8 [6 D. l
33.   float32_t * result)
      U: X; X/ {+ J& Z% g( W5 Y
34. {
    
35.   float32_t sum = 0.0f;                          /* Temporary result storage */                      (1)
    
36.   uint32_t blkCnt;                               /* loop counter */
    , ?; g3 N" ?1 L
37. 
    
38. 
    
39. #ifndef ARM_MATH_CM0_FAMILY
    4 g* Y$ t5 b" @8 e
40. 
    
41. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
42.   /*loop Unrolling */
    
43.   blkCnt = blockSize >> 2u;
    
44. 
      j0 d/ P* y- u! e
45.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    / W. [0 u) E) J9 W; g
46.    ** a second loop below computes the remaining 1 to 3 samples. */
    : ~. P- W$ L- j' U, G
47.   while(blkCnt > 0u)
    
48.   {
    & ?* h5 x6 X. b3 G; ~0 [  Q# x( P
49.     /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
    
50.     /* Calculate dot product and then store the result in a temporary buffer */
    " j3 p$ F. f: @
51.     sum += (*pSrcA++) * (*pSrcB++);                                                                  (2)
    
52.     sum += (*pSrcA++) * (*pSrcB++);
    : r8 b5 a4 {; _) ?: s/ }+ L
53.     sum += (*pSrcA++) * (*pSrcB++);
    
54.     sum += (*pSrcA++) * (*pSrcB++);
    ( ^3 R5 v3 {. V6 w# J4 R
55. 
    
56.     /* Decrement the loop counter */
    
57.     blkCnt--;
    
58.   }
    
59. 
    
60.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    9 ^, A9 _  }% {
61.    ** No loop unrolling is used. */
    ' {$ k: M4 Q8 U" |1 R' s2 C
62.   blkCnt = blockSize % 0x4u;
    3 l0 y  Z$ R+ h( @5 b; S( S% n
63. 
    
64. #else
    2 j! s& T6 c! L/ w% Z
65. 
    : H9 g) u, \3 o. ]; T
66.   /* Run the below code for Cortex-M0 */
    9 Y/ F, ]+ ?& q- i& g1 ^+ c4 x
67. 
    8 `# L4 o! d! g, N6 P
68.   /* Initialize blkCnt with number of samples */
    4 y. p. ?3 Q, Z  ~% l
69.   blkCnt = blockSize;
    / T" _3 p* h1 J4 _3 s. k1 z% m# {
70. 
    
71. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
72. 
    
73. 
    2 @3 G: x$ e; V+ ?- W% u5 C8 `6 G
74.   while(blkCnt > 0u)
    
75.   {
    
76.     /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
    
77.     /* Calculate dot product and then store the result in a temporary buffer. */
    
78.     sum += (*pSrcA++) * (*pSrcB++);
    5 s1 Y2 N6 v( m# V- s" h
79. 
    
80.     /* Decrement the loop counter */
    
81.     blkCnt--;
    9 q+ Y& }7 T6 f9 P5 d
82.   }
    
83.   /* Store the result back in the destination buffer */
    
84.   *result = sum;
      u& }# ^/ S0 v
85. }

复制代码

1. 由于CM4上带的FPU是单精度的，所以初始化float32_t类型的浮点数时需要在数据的末尾加上f。

2. 类似函数sum += (*pSrcA++) * (*pSrcB++)最终会通过浮点的MAC（乘累加）实现，从而加快执行时间。

8.3.2 arm_dot_prod_q31

    这个函数用于求32位定点数的点乘，源代码分析如下：

1. /**   
   
2. * @brief Dot product of Q31 vectors.   
   
3. * @param[in]       *pSrcA points to the first input vector   
   0 F0 E8 [; l" C+ t3 n, r
4. * @param[in]       *pSrcB points to the second input vector   
   . G5 |8 Y6 K9 Q& L, ^) R9 i$ I7 l
5. * @param[in]       blockSize number of samples in each vector   
   
6. * @param[out]      *result output result returned here   
   
7. * @return none.   
   : v: d8 M7 m3 p; k: q( b  M
8. *   
   7 v. e; N1 A7 `* ]
9. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
   
10. * \par   
    4 _# ?, I- u; J
11. * The intermediate multiplications are in 1.31 x 1.31 = 2.62 format and these   
    5 _/ W# ^! H  ?9 `9 M$ X, c) Y
12. * are truncated to 2.48 format by discarding the lower 14 bits.   
    
13. * The 2.48 result is then added without saturation to a 64-bit accumulator in 16.48 format.   
      z& W; ^0 l( X' w. y$ c+ ~/ [2 J
14. * There are 15 guard bits in the accumulator and there is no risk of overflow as long as   
    / {, X5 U' M' c) v1 ^) [% r
15. * the length of the vectors is less than 2^16 elements.   
    
16. * The return result is in 16.48 format.   
    - N/ d% }5 K$ L2 m. p; ?1 [2 f
17. */
    
18. 
    
19. void arm_dot_prod_q31(
    5 F) A/ Q* k( F. Z( s
20.   q31_t * pSrcA,
    2 q( h4 i7 R- m; o$ j3 ]3 T
21.   q31_t * pSrcB,
    , Y- N6 Y8 d$ _- {
22.   uint32_t blockSize,
    " Q) _! G5 ^% C7 L  Y
23.   q63_t * result)
    
24. {
    7 n+ i, {+ G5 a( ?! z4 B
25.   q63_t sum = 0;                                 /* Temporary result storage */
    
26.   uint32_t blkCnt;                               /* loop counter */
    
27. 
    
28. 
    
29. #ifndef ARM_MATH_CM0_FAMILY
    $ p# a9 f# v  `: r7 B
30. 
    1 N( w5 Z3 _8 K0 o& t) |
31. /* Run the below code for Cortex-M4 and Cortex-M3 */
    $ R* [$ Q) }& x0 T! f' S' T
32.   q31_t inA1, inA2, inA3, inA4;
    
33.   q31_t inB1, inB2, inB3, inB4;
    
34. 
    4 T$ ~  e4 ?! u& ~4 V8 k) ?
35.   /*loop Unrolling */
    
36.   blkCnt = blockSize >> 2u;
    & L5 o3 v+ e8 U
37. 
    
38.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    & u2 c  p' y) U2 A+ {
39.    ** a second loop below computes the remaining 1 to 3 samples. */
    
40.   while(blkCnt > 0u)
    + b4 ^/ `; c9 ?( F4 }
41.   {
    - E; q5 m( ~6 _/ H9 a% u
42.     /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
    2 I  q$ q% v! k( Q0 M
43.     /* Calculate dot product and then store the result in a temporary buffer. */
    " [$ V, O. L  V* e+ _( P
44.     inA1 = *pSrcA++;
    
45.     inA2 = *pSrcA++;
    . N* ~' e+ v. q! C
46.     inA3 = *pSrcA++;
    
47.     inA4 = *pSrcA++;
    6 g$ Z$ T# T8 \" p1 U& y0 y' F
48.     inB1 = *pSrcB++;
    
49.     inB2 = *pSrcB++;
    
50.     inB3 = *pSrcB++;
    
51.     inB4 = *pSrcB++;
    
52. 
    
53.     sum += ((q63_t) inA1 * inB1) >> 14u;                                                               (2)
    
54.     sum += ((q63_t) inA2 * inB2) >> 14u;
    & M) J7 u- R/ I. L# M9 y* K
55.     sum += ((q63_t) inA3 * inB3) >> 14u;
    4 v. i8 s1 {; P# r+ \( }  X1 q
56.     sum += ((q63_t) inA4 * inB4) >> 14u;
    
57. 
    
58.     /* Decrement the loop counter */
    
59.     blkCnt--;
    
60.   }
    
61. 
    7 z* q& a* Y$ `5 r
62.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    # E7 s8 |$ @. ?' \/ ~) p. Y
63.    ** No loop unrolling is used. */
    8 A+ ~  A8 s# A
64.   blkCnt = blockSize % 0x4u;
    . b$ M+ u( b6 Y/ Q/ S$ {6 L  }
65. 
    * X/ J0 r" A. G, h& S" u& M7 ~* ]
66. #else
    
67. 
    
68.   /* Run the below code for Cortex-M0 */
    - Q/ W5 L) R0 r/ ^/ w
69. 
    
70.   /* Initialize blkCnt with number of samples */
    
71.   blkCnt = blockSize;
    
72. 
    . M4 N, i1 E8 r4 g7 d: Z
73. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    8 g5 |2 x) t. p# W
74. 
    ) r5 G- w9 s/ m& Q+ v; U3 d
75. 
    9 J/ \5 D( Y. |/ r" l# e6 H
76.   while(blkCnt > 0u)
    
77.   {
    % H: n1 J/ a9 {" q
78.     /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
    
79.     /* Calculate dot product and then store the result in a temporary buffer. */
    
80.     sum += ((q63_t) * pSrcA++ * *pSrcB++) >> 14u;
    
81. 
    : d- k! Z9 T1 e) h
82.     /* Decrement the loop counter */
    
83.     blkCnt--;
    
84.   }
    , C9 V2 Q2 E. v+ G6 H  s2 U3 h
85. 
    5 R0 }$ x2 R9 X: f$ V4 ]* I/ ]+ H
86.   /* Store the result in the destination buffer in 16.48 format */
    6 p  j4 `0 q3 `% Q1 O, d0 m
87.   *result = sum;
    
88. }

复制代码

1. 两个Q31格式的32位数相乘，那么输出结果的格式是1.31*1.31 = 2.62。实际应用中基本不需要这么高的精度，这个函数将低14位的数据截取掉，反应在函数中就是两个数的乘积左移14位，也就是定点数的小数点也左移14位，那么最终的结果的格式是16.48。所以只要乘累加的个数小于2^16就没有输出结果溢出的危险（不知道这里为什么不是2^14，留作以后解决）。

2. 将获取的结果左移14位。

8.3.3 arm_dot_prod_q15

    这个函数用于求16位定点数的点乘，源代码分析如下：

1. /**   
   
2. * @brief Dot product of Q15 vectors.   
   " k8 S- w, t$ y, `% L; f) j* N
3. * @param[in]       *pSrcA points to the first input vector   
   
4. * @param[in]       *pSrcB points to the second input vector   
   7 W. M1 k* {1 i# q1 H; ^; c- n
5. * @param[in]       blockSize number of samples in each vector   
   
6. * @param[out]      *result output result returned here   
   0 s( o0 _$ a5 D# P+ V4 o
7. * @return none.   
   # x% r& X' p0 V
8. *   
   
9. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
   2 J9 L4 q( d+ }& O
10. * \par   
    
11. * The intermediate multiplications are in 1.15 x 1.15 = 2.30 format and these   
    ' M: C% X6 g2 v
12. * results are added to a 64-bit accumulator in 34.30 format.   
      K: e. m) M- f. o  |8 `6 L
13. * Nonsaturating additions are used and given that there are 33 guard bits in the accumulator   
    
14. * there is no risk of overflow.   
    " x$ O4 m- l, ^' K4 l; Q" ?! b
15. * The return result is in 34.30 format.   
    
16. */
    3 ]! {- W4 Z7 f/ R! T* E
17. 
    
18. void arm_dot_prod_q15(
    : ~" T& v, f$ [! j2 G' T$ @
19.   q15_t * pSrcA,
    
20.   q15_t * pSrcB,
    
21.   uint32_t blockSize,
    
22.   q63_t * result)
    ( X$ [( S$ E8 ]
23. {
    % n, l, j( \  S& x9 j$ E4 C
24.   q63_t sum = 0;                                 /* Temporary result storage */
    
25.   uint32_t blkCnt;                               /* loop counter */
    6 K6 d- _3 F7 w! _
26. 
    
27. #ifndef ARM_MATH_CM0_FAMILY
    
28. 
      |5 M* h6 I5 L8 t" N% [* m# C6 |
29. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
30. 
    
31. 
    
32.   /*loop Unrolling */
    
33.   blkCnt = blockSize >> 2u;
    
34. 
    
35.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    5 [- N7 C6 w9 e, l
36.    ** a second loop below computes the remaining 1 to 3 samples. */
    3 I% w* K. n; J' e
37.   while(blkCnt > 0u)
    5 x: S" h7 C" s9 B& V; g9 u9 f& b& i, E
38.   {
    . q+ e- t8 Y* M1 ~4 D" W
39.     /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */           (2)
    
40.     /* Calculate dot product and then store the result in a temporary buffer. */
    5 C: u( U& s* y' P. V
41.     sum = __SMLALD(*__SIMD32(pSrcA)++, *__SIMD32(pSrcB)++, sum);
    
42.     sum = __SMLALD(*__SIMD32(pSrcA)++, *__SIMD32(pSrcB)++, sum);
    
43. 
    % g( K' ]# w* B1 ^) T* c
44.     /* Decrement the loop counter */
    
45.     blkCnt--;
    
46.   }
    
47. 
    
48.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    1 H! ^( @: n7 u0 ~' a
49.    ** No loop unrolling is used. */
    ' B  u( g- g. l) t
50.   blkCnt = blockSize % 0x4u;
    % T$ p+ w7 N1 |% _% e
51. 
    
52.   while(blkCnt > 0u)
    2 g/ `" F+ S* T" m6 ~
53.   {
    4 Z8 u4 x2 B9 A" H' R7 v
54.     /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
    
55.     /* Calculate dot product and then store the results in a temporary buffer. */
    
56.     sum = __SMLALD(*pSrcA++, *pSrcB++, sum);
    
57. 
    
58.     /* Decrement the loop counter */
    
59.     blkCnt--;
    
60.   }
    
61. 
    / o6 G7 @% U" C  a$ A3 ^- `) j
62. 
    
63. #else
    
64. 
    
65.   /* Run the below code for Cortex-M0 */
    " @. f$ E7 @7 t5 A. z
66. 
    % ]2 N9 {- l; O5 K1 H' J9 l- `3 o
67.   /* Initialize blkCnt with number of samples */
    . P9 E  `9 z4 @# s% J( v
68.   blkCnt = blockSize;
    . K! M: K7 I# ^( z( _6 A; e5 I+ Y
69. 
    ' J; f5 f; v( w* A6 m
70.   while(blkCnt > 0u)
    
71.   {
    6 h5 }; d. E9 M1 n- d$ p/ D
72.     /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
    ) M, i/ E8 y% y9 r2 c) V1 R# ]3 [
73.     /* Calculate dot product and then store the results in a temporary buffer. */
    6 D  N' c  R/ X, r  k& p
74.     sum += (q63_t) ((q31_t) * pSrcA++ * *pSrcB++);
    
75. 
    
76.     /* Decrement the loop counter */
    
77.     blkCnt--;
    
78.   }
    
79. 
    , D& w0 o. p/ r- F8 R! Y
80. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    ' r* Y- T; W- M
81. 
    # ^% i9 M5 l' ^* C
82.   /* Store the result in the destination buffer in 34.30 format */
    7 D$ n1 X, N' u" Z  ^) \7 ]
83.   *result = sum;
    
84. 
    
85. }

复制代码

1． 两个Q15格式的数据相乘，那么输出结果的格式是1.15*1.15 = 2.30，这个函数将输出结果赋值给了64位变量，那么输出结果就是34.30格式。所以基本没有溢出的危险。

2． __SMLALD也是SIMD指令，实现两个16位数相乘，并把结果累加给64位变量。

8.3.4 arm_dot_prod_q7

    这个函数用于求8位定点数的点乘，源代码分析如下：

1. /**   
   ( m$ d  g( H% z& m, s
2. * @brief Dot product of Q7 vectors.   
   
3. * @param[in]       *pSrcA points to the first input vector   
   
4. * @param[in]       *pSrcB points to the second input vector   
   : X+ S# A, M& S: t9 L
5. * @param[in]       blockSize number of samples in each vector   
   
6. * @param[out]      *result output result returned here   
   7 q% J0 z0 ^1 T! y# e
7. * @return none.   
   
8. *   
   
9. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
   ' p$ p8 o4 ]! M
10. * \par   
    ( q% _* A: W9 R, f7 _5 @/ x
11. * The intermediate multiplications are in 1.7 x 1.7 = 2.14 format and these   
    ) w# G1 K/ B/ b3 N
12. * results are added to an accumulator in 18.14 format.   
    - T% M5 x0 b" F# u
13. * Nonsaturating additions are used and there is no danger of wrap around as long as   
    
14. * the vectors are less than 2^18 elements long.   
    
15. * The return result is in 18.14 format.   
    
16. */
    
17. 
    ( c$ M( F6 a- h, K+ L% t
18. void arm_dot_prod_q7(
    
19.   q7_t * pSrcA,
    
20.   q7_t * pSrcB,
    
21.   uint32_t blockSize,
    * m  i  [' U# _& ]) P0 I. |" g
22.   q31_t * result)
    
23. {
    
24.   uint32_t blkCnt;                               /* loop counter */
    % A0 T' J+ C0 o( y2 Q: b! y/ j
25. 
    / U5 r* ~/ o$ p5 R4 C! O: w
26.   q31_t sum = 0;                                 /* Temporary variables to store output */
    
27. 
    
28. #ifndef ARM_MATH_CM0_FAMILY
    4 D8 T  S( b% j2 I
29. 
    0 w+ Y4 [7 ~( u/ o
30. /* Run the below code for Cortex-M4 and Cortex-M3 */
    ; A% [$ R/ m' T5 p8 ?! _
31. 
    3 X) ~$ ]: i1 i  e7 B
32.   q31_t input1, input2;                          /* Temporary variables to store input */
    : S# g# M5 @  A! _) Z  @7 ~
33.   q31_t inA1, inA2, inB1, inB2;                  /* Temporary variables to store input */
    1 C# K: t1 P4 R3 n# s
34. 
    
35. 
    3 D" {$ S, y$ T1 D. k0 G
36. 
    
37.   /*loop Unrolling */
    5 w: f! V3 p: T
38.   blkCnt = blockSize >> 2u;
    7 p5 X* Z6 K  l$ L; L
39. 
    ) n$ r; |0 a8 v+ {# r3 Q
40.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    
41.    ** a second loop below computes the remaining 1 to 3 samples. */
    8 `$ k! U, n9 K3 T! x
42.   while(blkCnt > 0u)
    
43.   {
    
44.     /* read 4 samples at a time from sourceA */                                                       (2)
    
45.     input1 = *__SIMD32(pSrcA)++;
    
46.     /* read 4 samples at a time from sourceB */
    8 A, t6 W- t* V, T& ^
47.     input2 = *__SIMD32(pSrcB)++;
    % U  H" I  W0 L9 S" I( h
48. 
    
49.     /* extract two q7_t samples to q15_t samples */
    
50.     inA1 = __SXTB16(__ROR(input1, 8));                                                                (3)
    8 U. n" M9 k4 H" S- Z7 I6 W5 {
51.     /* extract reminaing two samples */
    & e1 C  A" q) D7 P& h3 z
52.     inA2 = __SXTB16(input1);
    
53.     /* extract two q7_t samples to q15_t samples */
    
54.     inB1 = __SXTB16(__ROR(input2, 8));
    + z# \% I/ i# f
55.     /* extract reminaing two samples */
    % R8 w' r! H& r& Z1 B3 ?% f
56.     inB2 = __SXTB16(input2);
    
57. 
    $ S& M" I3 c5 l; B9 z- t$ ]6 p% v+ E2 \
58.     /* multiply and accumulate two samples at a time */
    
59.     sum = __SMLAD(inA1, inB1, sum);                                                                   (4)
    
60.     sum = __SMLAD(inA2, inB2, sum);
    - C+ ]# l$ P3 x  M7 o# G- }
61. 
    4 n: r# ?6 e( U) c
62.     /* Decrement the loop counter */
    ' E/ I1 m% E0 Q& q  v- z+ x
63.     blkCnt--;
    / H6 f1 z0 o) g) m2 K
64.   }
    " j! C! n) v$ C- X
65. 
    * b2 r" p- u- ]) u5 J3 |1 N1 C& l5 N
66.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
67.    ** No loop unrolling is used. */
    
68.   blkCnt = blockSize % 0x4u;
    & X+ o6 A4 |- V4 R0 @) c
69. 
    
70.   while(blkCnt > 0u)
    
71.   {
    
72.     /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
    
73.     /* Dot product and then store the results in a temporary buffer. */
    
74.     sum = __SMLAD(*pSrcA++, *pSrcB++, sum);
    
75. 
    
76.     /* Decrement the loop counter */
    ( N2 t2 N2 T2 f5 K8 J  r, \
77.     blkCnt--;
    9 s; W) F7 b! f/ v, p  u
78.   }
    
79. 
    + u# }) ]2 h$ g7 o7 c7 B
80. #else
    
81. 
    2 ]$ q  P' m$ d, F6 N1 a) g
82.   /* Run the below code for Cortex-M0 */
    ) _8 L  B* _; G- L; G- \1 f" g
83. 
    3 N* _! n7 p  M) R. Y3 N
84. 
    
85. 
    " J4 B# B; p' u: ~
86.   /* Initialize blkCnt with number of samples */
    
87.   blkCnt = blockSize;
    
88. 
    
89.   while(blkCnt > 0u)
    
90.   {
    
91.     /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
    
92.     /* Dot product and then store the results in a temporary buffer. */
    ! Y- x7 p: `/ B- D
93.     sum += (q31_t) ((q15_t) * pSrcA++ * *pSrcB++);
    
94. 
    + A! h$ ]: j$ p$ V+ T
95.     /* Decrement the loop counter */
    9 L7 B. b& S( m
96.     blkCnt--;
    
97.   }
    
98. 
    
99. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    , ^0 u$ h  K1 e: M: q7 w+ g
100. 
     
101. 
     
102.   /* Store the result in the destination buffer in 18.14 format */
     
103.   *result = sum;
     4 M2 \5 V- u! `* U  M' g; M
104. }

复制代码

1. 两个Q8格式的数据相乘，那么输出结果就是1.7*1.7 = 2.14格式。这里将最终结果赋值给了32位的变量，那么最终的格式就是18.14。如果乘累加的个数小于2^18那么就不会有溢出的危险（感觉这里应该是2^16）。

2. 一次读取4个8位的数据。

3. __SXTB16也是SIMD指令，用于将两个8位的有符号数扩展成16位。__ROR用于实现数据的循环右移。

4. __SMLAD也是SIMD指令，用于实现如下功能：

    sum = __SMLAD(x, y, z)

    sum = z + ((short)(x>>16) * (short)(y>>16)) + ((short)x * (short)y)

8.3.5 实例讲解

实验目的：

    1. 四种类型数据的点乘。

实验内容：

    1. 按下按键K3, 串口打印输出结果

实验现象：

        通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: DSP_DotProduct
   
4. *        功能说明: 乘积
   ; a' t! Y7 q* g9 `5 i/ W. }6 V. h
5. *        形    参：无
   " i8 k. C% r- b0 c& r
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   ) n0 b$ G6 D: O5 L& X* }/ I  O: k
8. */
   
9. static void DSP_DotProduct(void)
   & L: H7 p! q: _0 _
10. {
    % k7 D3 V* B7 L8 Z
11. static float32_t   pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
    
12. static float32_t   pSrcB[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};  
    
13. static float32_t   result;  
    
14. static q31_t  pSrcA1[5] = {0x7ffffff0,1,1,1,1};  
    
15. static q31_t  pSrcB1[5] = {1,1,1,1,1};  
    # h6 y/ s3 l1 p$ i
16. static q63_t   result1;   
    
17. 
    
18. static q15_t  pSrcA2[5] = {1,1,1,1,1};  
    
19. static q15_t  pSrcB2[5] = {1,1,1,1,1};  
    3 N3 R- b# i& G
20. static q63_t  result2;   
    0 D( B3 w9 u7 u9 t9 c: z; V8 p
21. 
    7 P% o3 n/ `0 d2 G; h
22. static q7_t  pSrcA3[5] = {1,1,1,1,1};
    ' b; H- K: g: B" t2 Z
23. static q7_t  pSrcB3[5] = {1,1,1,1,1};  
    % }  {; u  g" o' H/ L; p
24. static q31_t result3;  
    # O2 {$ f$ {. R7 ~+ I* r9 S
25. 
    
26. pSrcA[0] -= 1.1f;
    
27. arm_dot_prod_f32(pSrcA, pSrcB, 5, &result);
    
28. printf("arm_dot_prod_f32 = %f\r\n", result);
    
29. pSrcA1[0] -= 0xffff;
    . y% o. ^4 b8 m. B( Y6 Y) f
30. arm_dot_prod_q31(pSrcA1, pSrcB1, 5, &result1);
    / B' v" U. _  |! W
31. printf("arm_dot_prod_q31 = %lld\r\n", result1);
    . m: Z9 J3 W" v+ ^/ m3 s4 j$ O
32. 
    
33. pSrcA2[0] -= 1;
    
34. arm_dot_prod_q15(pSrcA2, pSrcB2, 5, &result2);
    . J% e$ y0 c$ X; z/ x
35. printf("arm_dot_prod_q15 = %lld\r\n", result2);
    ; U8 a$ @+ J6 I( C0 p
36. 
    3 i( v& K% W, [* M( n  I
37. pSrcA3[0] -= 1;
    1 ?2 D$ n- b) b* R8 o, \3 Z9 F
38. arm_dot_prod_q7(pSrcA3, pSrcB3, 5, &result3);
    
39. printf("arm_dot_prod_q7 = %d\r\n", result3);
    
40. printf("***********************************\r\n");
    & m/ b- o9 `: U2 p  W1 s7 J8 A) Z! ~
41. }

复制代码

$ |& [3 E' q- J9 \2 }) M; K

) j$ M- M" p( }+ O

8.2 求和（Vector Addition）

    这部分函数主要用于求和，公式描述如下：

    pDst[n] = pSrcA[n] + pSrcB[n],   0 <= n < blockSize.

8.2.1 arm_add_f32

    这个函数用于求32位浮点数的和，源代码分析如下：

1. /**        
   
2. * @brief Floating-point vector addition.        
   : ~. Q$ k5 s& h. h/ D1 _
3. * @param[in]       *pSrcA points to the first input vector        
   
4. * @param[in]       *pSrcB points to the second input vector        
   2 p6 Z2 _# p- U: E
5. * @param[out]      *pDst points to the output vector        
   & U, ?5 V$ k% ^- L; w3 ~
6. * @param[in]       blockSize number of samples in each vector        
   
7. * @return none.        
   
8. */
   
9. 
     W1 j4 ^1 M  h  e8 `4 R5 l. Q5 W
10. void arm_add_f32(
    
11.   float32_t * pSrcA,
    
12.   float32_t * pSrcB,
    
13.   float32_t * pDst,
    
14.   uint32_t blockSize)
    / }2 M( n" r1 {1 j& N
15. {
    
16.   uint32_t blkCnt;                               /* loop counter */
    # g# I4 N, v7 e+ ^+ ?7 r
17. 
    
18. #ifndef ARM_MATH_CM0_FAMILY
    & p; `3 ~1 Y# S/ p9 N
19. 
    8 y, G- }5 @! Y/ M' }
20. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
21.   float32_t inA1, inA2, inA3, inA4;              /* temporary input variabels */
    - Z9 k1 q4 e. r* K- i- [. \
22.   float32_t inB1, inB2, inB3, inB4;              /* temporary input variables */
    
23. 
    
24.   /*loop Unrolling */
    
25.   blkCnt = blockSize >> 2u;
    
26. 
    
27.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
    5 F, p2 h6 a) o2 m* \7 n& x- I. W
28.    ** a second loop below computes the remaining 1 to 3 samples. */
    
29.   while(blkCnt > 0u)
    . r9 J) y3 [8 G- e9 c' s0 j  O
30.   {
    
31.     /* C = A + B */
    
32.     /* Add and then store the results in the destination buffer. */
    . v0 p( [: j2 m7 V/ [
33. 
    2 g+ M- a, Y/ {4 K
34.     /* read four inputs from sourceA and four inputs from sourceB */
    ) y5 I! G' B8 a. l' D8 @* \1 F  |
35.     inA1 = *pSrcA;
    
36.     inB1 = *pSrcB;
    ) r7 `6 P: r9 Z- d2 I8 v7 V8 E9 {
37.     inA2 = *(pSrcA + 1);
    
38.     inB2 = *(pSrcB + 1);
    9 e+ R( f- N% e' a
39.     inA3 = *(pSrcA + 2);
    8 o' l. p: w$ \3 Y  q
40.     inB3 = *(pSrcB + 2);
    
41.     inA4 = *(pSrcA + 3);
    
42.     inB4 = *(pSrcB + 3);
    ; p7 `% }0 A4 W( W9 v
43. 
    
44.     /* C = A + B */                                                                                  (1)
    3 v$ k3 G  l& g+ D
45.     /* add and store result to destination */
    
46.     *pDst = inA1 + inB1;
    
47.     *(pDst + 1) = inA2 + inB2;
    % O" t: U& a7 R/ P& I1 q
48.     *(pDst + 2) = inA3 + inB3;
    
49.     *(pDst + 3) = inA4 + inB4;
    
50. 
    % t, L# k& R5 ?7 @! s" ?
51.     /* update pointers to process next samples */
    ) }' _( Y$ V; I" G; ]) k0 h3 f4 T
52.     pSrcA += 4u;
    , y( c6 s+ u, R  v1 M7 p
53.     pSrcB += 4u;
    
54.     pDst += 4u;
    , o, x5 Q$ s+ Z9 [2 t
55. 
    
56. 
    
57.     /* Decrement the loop counter */
    
58.     blkCnt--;
    
59.   }
    1 G# k; p# Y* L6 R* B
60. 
    % G- O; Z/ S% p9 i+ s+ x
61.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
    
62.    ** No loop unrolling is used. */
    
63.   blkCnt = blockSize % 0x4u;
    1 v+ L$ M* G+ @
64. 
    
65. #else
    - t; ~, u  @6 q, E. ^9 d
66. 
      H5 S) u6 d; j0 Z
67.   /* Run the below code for Cortex-M0 */
    ; Z, ^! t2 h: i8 @8 |" q- x
68. 
    ) [6 \  q' I+ d" c# J6 B8 p
69.   /* Initialize blkCnt with number of samples */
    
70.   blkCnt = blockSize;
    ! {1 c- h' v* H
71. 
    - O" A0 E2 U8 N+ i6 Q/ p1 }
72. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    - ], t9 [5 z" G0 q
73. 
    
74.   while(blkCnt > 0u)
    ) z( S0 x0 @: C- o
75.   {
    
76.     /* C = A + B */
    
77.     /* Add and then store the results in the destination buffer. */
    
78.     *pDst++ = (*pSrcA++) + (*pSrcB++);
    % l9 f/ ~$ G4 o+ h4 e3 g! A
79. 
    5 Y& O) |; n2 \/ R6 N, s. _
80.     /* Decrement the loop counter */
    9 U3 i+ |) m; K# g7 Y
81.     blkCnt--;
    
82.   }
    
83. }

复制代码

1. 这部分的代码比较简单，只是求解两个数的和。

8.2.2 arm_add_q31

    这个函数用于求32位定点数的和，源代码分析如下：

1. /**   
   * H% q+ w. ?1 h: Z
2. * @brief Q31 vector addition.   
   , ]: H& `, v7 v8 R5 X" ^, {
3. * @param[in]       *pSrcA points to the first input vector   
   
4. * @param[in]       *pSrcB points to the second input vector   
   2 c* i2 P- x! K1 A1 s
5. * @param[out]      *pDst points to the output vector   
   
6. * @param[in]       blockSize number of samples in each vector   
   4 b! A- H; c* L2 A, [3 o
7. * @return none.   
   ' z4 B* Z" Z$ n) n/ j$ \
8. *   
   + `6 g+ \. _2 s% M2 q1 o+ T9 @
9. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
   # y) Q" U  C6 m/ G' M
10. * \par   
    ' c. v3 J( J7 O! R
11. * The function uses saturating arithmetic.   
    
12. * Results outside of the allowable Q31 range[0x80000000 0x7FFFFFFF] will be saturated.   
    # b  ^9 h2 r, b2 I. p. C- F
13. */
    
14. 
    ) m, L) a0 O( L/ b; e
15. void arm_add_q31(
    
16.   q31_t * pSrcA,
    1 B6 o; S, @) H, l
17.   q31_t * pSrcB,
    
18.   q31_t * pDst,
    3 [- L9 j% G- [- p+ }, [! {
19.   uint32_t blockSize)
    
20. {
    4 v5 o# |" y3 X; w- x9 i! N7 ~
21.   uint32_t blkCnt;                               /* loop counter */
    
22. 
    
23. #ifndef ARM_MATH_CM0_FAMILY
    
24. 
    
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
26.   q31_t inA1, inA2, inA3, inA4;
    : o# O& L5 h! c: g
27.   q31_t inB1, inB2, inB3, inB4;
    
28. 
      |6 Y9 o' y  e1 V+ x
29.   /*loop Unrolling */
    3 o3 Q- f9 N9 u2 D
30.   blkCnt = blockSize >> 2u;
    * \7 q. T: S$ ~& D: _4 u- ]7 s$ Q1 X
31. 
    9 G( R, e) i+ }
32.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    ( t9 N* X: R* G: n+ i" r
33.    ** a second loop below computes the remaining 1 to 3 samples. */
    
34.   while(blkCnt > 0u)
    # \8 @7 N6 b0 t+ v! \$ s, C
35.   {
    / c: A7 ^! e+ e& j% ?9 Z
36.     /* C = A + B */
    0 i) x% @, k. j2 x4 @9 s6 T
37.     /* Add and then store the results in the destination buffer. */
    5 H! _; m6 o1 d
38.     inA1 = *pSrcA++;
    
39.     inA2 = *pSrcA++;
    7 G. _9 ~' Z4 u; I( q4 n. J
40.     inB1 = *pSrcB++;
    6 [6 K: ^' j" V& A* x# r
41.     inB2 = *pSrcB++;
    9 I! _: z' x1 N) E
42. 
    $ }: d* c) I% `% S) z
43.     inA3 = *pSrcA++;
    
44.     inA4 = *pSrcA++;
    $ Z, L% J1 }# s# b4 r+ w0 t6 B
45.     inB3 = *pSrcB++;
    
46.     inB4 = *pSrcB++;
    + K* B% F3 ~  J! J! j& M1 t# |" H
47. 
    
48.     *pDst++ = __QADD(inA1, inB1);                                                                   (2)
    
49.     *pDst++ = __QADD(inA2, inB2);
    & A" x$ z. D. J" t0 e( r7 M  M
50.     *pDst++ = __QADD(inA3, inB3);
    
51.     *pDst++ = __QADD(inA4, inB4);
    $ m" B7 ~3 n, n
52. 
    0 V9 o+ \8 w( j% C
53.     /* Decrement the loop counter */
    : J; r4 G% q2 ^% c8 M# s- k+ n
54.     blkCnt--;
    
55.   }
    5 U# y1 ]$ R4 ^
56. 
    
57.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    ) m4 k8 F& E# L' N; a* T6 {4 K
58.    ** No loop unrolling is used. */
    
59.   blkCnt = blockSize % 0x4u;
    ( O/ _# X6 {1 [4 N
60. 
    ) C5 Q6 D7 C) A0 ^  a2 C
61.   while(blkCnt > 0u)
    " _; U9 O' n9 E6 J8 Q4 C9 X
62.   {
    # M5 M& |" h* }
63.     /* C = A + B */
    8 S7 f' [; j+ e( ^
64.     /* Add and then store the results in the destination buffer. */
    
65.     *pDst++ = __QADD(*pSrcA++, *pSrcB++);
    
66. 
    + m/ C7 i, }1 k7 X. x9 V
67.     /* Decrement the loop counter */
    
68.     blkCnt--;
    
69.   }
    
70. 
    
71. #else
    
72. 
    
73.   /* Run the below code for Cortex-M0 */
    
74. 
    
75. 
    ! ~3 }/ q5 H6 G% H, q' c
76. 
    
77.   /* Initialize blkCnt with number of samples */
    8 N* C( u# J# L) J; i7 z3 w' V& T% g
78.   blkCnt = blockSize;
    
79. 
    9 O  b1 j9 U9 b8 c7 R7 e! R
80.   while(blkCnt > 0u)
    
81.   {
    
82.     /* C = A + B */
    9 y5 ]5 \/ ~. M
83.     /* Add and then store the results in the destination buffer. */
    
84.     *pDst++ = (q31_t) clip_q63_to_q31((q63_t) * pSrcA++ + *pSrcB++);                                  (3)
    
85. 
    7 H6 N- [( q5 E) I$ @) Y
86.     /* Decrement the loop counter */
    * ]2 k" E2 Y9 ^' n: Y
87.     blkCnt--;
    
88.   }
    $ x0 L6 D* m0 R! d
89. 
    
90. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
91. 
    
92. }

复制代码

1. 这个函数也是饱和运算，输出结果的范围[0x80000000 0x7FFFFFFF]，超出这个结果将产生饱和结果。

2. __QADD实现32位数的加法。

3. 函数clip_q63_to_q31的定义在文件arm_math.h里面

      static __INLINE q31_t clip_q63_to_q31(

      q63_t x)

      {

           return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ?

             ((0x7FFFFFFF ^ ((q31_t) (x >> 63)))) : (q31_t) x;

          }

    这个函数的作用是实现饱和结果。

8.2.3 arm_add_q15

    这个函数用于求16位定点数的和，源代码分析如下：

1. /**   
   9 g/ Y" k3 j. m+ B2 d
2. * @brief Q15 vector addition.   
   
3. * @param[in]       *pSrcA points to the first input vector   
   
4. * @param[in]       *pSrcB points to the second input vector   
   $ M. E5 B) V$ a2 C6 x2 I2 g
5. * @param[out]      *pDst points to the output vector   
   0 f. G- [- s* b/ Z% y
6. * @param[in]       blockSize number of samples in each vector   
   + J6 K6 H- |, p9 `- y7 M
7. * @return none.   
   0 Y1 q' `% C7 Z$ Y' F4 e# C
8. *   
   
9. * <b>Scaling and Overflow Behavior:</b>                                                               (1)
   4 R+ V. L$ d+ e8 |
10. * \par   
    2 D; U2 p' w6 ?/ r; p
11. * The function uses saturating arithmetic.   
    
12. * Results outside of the allowable Q15 range [0x8000 0x7FFF] will be saturated.   
    1 m1 z1 b* T) z0 @" S
13. */
    
14. 
    $ u4 X8 D% G3 n) f* {
15. void arm_add_q15(
    / c2 q( c+ H5 J5 _; g* n
16.   q15_t * pSrcA,
    
17.   q15_t * pSrcB,
    0 l/ \/ e4 \8 U. m8 r9 W( x
18.   q15_t * pDst,
    
19.   uint32_t blockSize)
      d! Z8 `0 L! H6 [
20. {
    , o# V1 \' p; Y3 G  i# G
21.   uint32_t blkCnt;                               /* loop counter */
    " o- s2 s$ t/ Z
22. 
    3 d7 r; k$ [! R
23. #ifndef ARM_MATH_CM0_FAMILY
    
24. 
    8 i, w2 O8 r! z% h9 G! y$ O! e
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
    7 z+ G" u; s& X8 S4 Z0 d" p# X
26.   q31_t inA1, inA2, inB1, inB2;
    
27. 
    
28.   /*loop Unrolling */
    
29.   blkCnt = blockSize >> 2u;
    ! G7 O' K+ Y6 j9 Z8 h( f
30. 
    
31.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    
32.    ** a second loop below computes the remaining 1 to 3 samples. */
    
33.   while(blkCnt > 0u)
    
34.   {
    0 R. X: }! u, j
35.     /* C = A + B */                                                                                    (2)
    
36.     /* Add and then store the results in the destination buffer. */
    
37.     inA1 = *__SIMD32(pSrcA)++;
    
38.     inA2 = *__SIMD32(pSrcA)++;
    
39.     inB1 = *__SIMD32(pSrcB)++;
    
40.     inB2 = *__SIMD32(pSrcB)++;
    
41. 
    
42.     *__SIMD32(pDst)++ = __QADD16(inA1, inB1);
    6 m' w" x# H& c7 }3 D/ O: C
43.     *__SIMD32(pDst)++ = __QADD16(inA2, inB2);
    
44. 
      t( n& G% v) c' b) m0 v. X( x
45.     /* Decrement the loop counter */
    ' r7 u3 P! {% P
46.     blkCnt--;
    
47.   }
    4 R# D2 ~1 z3 {8 d1 Q
48. 
    
49.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
50.    ** No loop unrolling is used. */
    
51.   blkCnt = blockSize % 0x4u;
    
52. 
    
53.   while(blkCnt > 0u)
    3 _6 E% E1 i3 x* w4 V' Z2 M
54.   {
    
55.     /* C = A + B */
    % i# [8 R' O# ?* O
56.     /* Add and then store the results in the destination buffer. */
    
57.     *pDst++ = (q15_t) __QADD16(*pSrcA++, *pSrcB++);
    
58. 
    
59.     /* Decrement the loop counter */
    0 y% s) t7 ^# [" H! ^. H
60.     blkCnt--;
    3 W) @! ?! v2 `4 c
61.   }
    
62. 
    
63. #else
    
64. 
    ; l% G9 d! u& _& U' m8 P
65.   /* Run the below code for Cortex-M0 */
    
66. 
    7 P$ L, ~9 [- o4 r
67. 
    
68. 
    $ o* N: c8 j1 X+ A  \/ P) X
69.   /* Initialize blkCnt with number of samples */
    ' i! C& {, Q! L+ x0 g
70.   blkCnt = blockSize;
    7 i- p8 K0 w) H, W5 ]
71. 
    # O& j7 u3 A4 u  M* c3 U
72.   while(blkCnt > 0u)
    
73.   {
    
74.     /* C = A + B */
    5 D4 O6 y( L2 k" W0 ?' S1 M
75.     /* Add and then store the results in the destination buffer. */
    / H2 S  U" \) M
76.     *pDst++ = (q15_t) __SSAT(((q31_t) * pSrcA++ + *pSrcB++), 16);                                      (3)
    
77. 
    ; [' w# A" q" m) Y
78.     /* Decrement the loop counter */
    6 h' J! v. @& c1 I  k8 W' M5 z; k
79.     blkCnt--;
    
80.   }
    0 w' L0 r. Z$ D4 L
81. 
    
82. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
83. 
    5 {% m6 W, Y9 m" u) A
84. 
    ; B8 d+ b. l$ X( P
85. }

复制代码

1. 这个函数也是饱和运算，输出结果的范围[0x8000 0x7FFF]，超出这个结果将产生饱和结果。

2. 函数inA1 = *__SIMD32(pSrcA)++仅需要一条SIMD指令即可完成将两个16位数存到32位的变量inA1中。

3. __SSAT也是SIMD指令，这里是将结果饱和到16位精度。

8.2.4 arm_add_q7

    这个函数用于求8位定点数的绝对值，源代码分析如下：

1. /**   
   3 j9 @4 Z! P% e
2. * @brief Q7 vector addition.   
   
3. * @param[in]       *pSrcA points to the first input vector   
   
4. * @param[in]       *pSrcB points to the second input vector   
   
5. * @param[out]      *pDst points to the output vector   
   3 W! i) X; n; ]7 B6 T6 A9 M
6. * @param[in]       blockSize number of samples in each vector   
   9 P- H) V+ s# S( s. Y9 F# S, V; N  N  t
7. * @return none.   
   
8. *   
   1 ]1 P7 Y8 v; N; f( n
9. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
   % \/ ~7 @0 I2 ], M$ S" t4 @8 ~' a
10. * \par   
    
11. * The function uses saturating arithmetic.   
    
12. * Results outside of the allowable Q7 range [0x80 0x7F] will be saturated.   
    
13. */
    
14. 
    8 k) i8 m' I' f& I5 A! @
15. void arm_add_q7(
    
16.   q7_t * pSrcA,
    6 [9 W0 B% |2 \7 O: t+ X, C
17.   q7_t * pSrcB,
    
18.   q7_t * pDst,
    
19.   uint32_t blockSize)
    
20. {
    $ |( _: C9 _" C5 W4 G+ K
21.   uint32_t blkCnt;                               /* loop counter */
    1 v! Z4 U$ y1 B( M) _2 _& H" l( x
22. 
    
23. #ifndef ARM_MATH_CM0_FAMILY
    
24. 
    
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
    5 H7 v' w6 `8 a
26. 
    
27. 
    
28.   /*loop Unrolling */
    1 k1 k; M, u* K" l% u6 z
29.   blkCnt = blockSize >> 2u;
    ' X* i4 c1 h0 S# X; a( i
30. 
    
31.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    
32.    ** a second loop below computes the remaining 1 to 3 samples. */
    ( x5 m) Q: Z7 W5 [6 {
33.   while(blkCnt > 0u)
    
34.   {
    
35.     /* C = A + B */
    
36.     /* Add and then store the results in the destination buffer. */                                 (2)
    6 l  a% @6 \- r
37.     *__SIMD32(pDst)++ = __QADD8(*__SIMD32(pSrcA)++, *__SIMD32(pSrcB)++);
    
38. 
    
39.     /* Decrement the loop counter */
    0 H3 M+ {  ~; }5 P6 Z' b' m, F8 c$ K
40.     blkCnt--;
    ' P1 u/ g$ f8 h& ~1 `. k
41.   }
    
42. 
    
43.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
44.    ** No loop unrolling is used. */
    
45.   blkCnt = blockSize % 0x4u;
    ) T; I  ]; l  u" v/ g
46. 
    + T* r5 Q4 ^1 B( E2 M
47.   while(blkCnt > 0u)
    : l4 Q5 L# s3 N) _: S
48.   {
    
49.     /* C = A + B */
    
50.     /* Add and then store the results in the destination buffer. */
    2 U4 o8 ?* X7 d& \8 q. q1 W
51.     *pDst++ = (q7_t) __SSAT(*pSrcA++ + *pSrcB++, 8);
    
52. 
    6 ~) a% ~: z* f. h
53.     /* Decrement the loop counter */
    ' K3 O4 D; P) Y" z9 G
54.     blkCnt--;
    # x- H# K/ H7 I2 L
55.   }
    
56. 
    
57. #else
    + T( b5 y" y9 P3 J& L1 b1 O  b
58. 
    5 A0 p& G" b: ^; a+ i$ ^* u
59.   /* Run the below code for Cortex-M0 */
    
60. 
    
61. 
    , D; q7 ?, t' n; C5 p9 w7 U5 \
62. 
    
63.   /* Initialize blkCnt with number of samples */
    ( L; D# w7 [( g3 _- Z" v
64.   blkCnt = blockSize;
    
65. 
    9 u, w; C, ^, D
66.   while(blkCnt > 0u)
    
67.   {
    
68.     /* C = A + B */
    * P0 [0 B! i1 F; i  `3 r
69.     /* Add and then store the results in the destination buffer. */
    
70.     *pDst++ = (q7_t) __SSAT((q15_t) * pSrcA++ + *pSrcB++, 8);
    2 D! g; g" H( I7 p
71. 
    
72.     /* Decrement the loop counter */
    
73.     blkCnt--;
    
74.   }
    ( }; Y5 N; F# ?/ \$ F" [4 v; E
75. 
    " N' A8 v& L* E2 T$ D" k5 O
76. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    ' q- c" G* ^. e- p) g, J. H# e
77. 
    
78. 
    
79. }

复制代码

1． 这个函数也是饱和运算，输出结果的范围[0x80 0x7F]，超出这个结果将产生饱和。

2． 这里通过SIMD指令实现4组8位数的加法。

8.2.5 实例讲解

实验目的：

    1. 四种类似数据的求和

实验内容：

    1. 按下按键K2, 串口打印输出结果

实验现象：

    通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
   
2. *********************************************************************************************************
   / A* N1 `* M. X4 _3 y% M; j* b$ ]
3. *        函 数 名: DSP_ABS
   
4. *        功能说明: 加法
   
5. *        形    参：无
   
6. *        返 回 值: 无
   1 a* m) T- K% S8 y8 L' r( c2 G6 {3 C
7. *********************************************************************************************************
   ' L( H4 ~/ r) f& L! M3 y4 v
8. */
   
9. static void DSP_Add(void)
   ; X/ a9 h2 q% w+ B) P+ H- y
10. {
    
11. static float32_t   pSrcA;
    
12. static float32_t   pSrcB;  
    & c+ w! J" `) w: c: ?4 e3 g; v# u) w
13. static float32_t   pDst;  
    
14. static q31_t  pSrcA1;  
    ' r7 I( n2 d5 [; `" a3 d& N1 k3 p
15. static q31_t  pSrcB1;  
    
16. static q31_t  pDst1;  
    3 m! a& P$ Q2 Z' c/ n; i9 e
17. 
    & \8 B9 i/ C" p  ~. f  U9 V1 |
18. static q15_t  pSrcA2;  
    + I8 {. h9 x; m
19. static q15_t  pSrcB2;  
    & U( c2 q- T0 z& t8 G. y
20. static q15_t  pDst2;
    " c( b9 ]2 m( N2 e0 W
21. 
    $ N# t( a' f! y" a% @& y+ }
22. static q7_t  pSrcA3;
    
23. static q7_t  pSrcB3;  
    
24. static q7_t  pDst3;  
    
25. 
    , Y$ r7 _' b% v$ X# o  U# ~
26. pSrcA--;
    
27. arm_add_f32(&pSrcA, &pSrcB, &pDst, 1);
    * B1 l5 i8 [, Q% E, d* H& C
28. printf("arm_add_f32 = %f\r\n", pDst);
    ) l( I% B; c# E) ~& E. a
29. 
    ! e( j, t# Z4 q! `" l
30. pSrcA1--;
    . m( n1 U, V8 u# Z
31. arm_add_q31(&pSrcA1, &pSrcB1, &pDst1, 1);
    
32. printf("arm_add_q31 = %d\r\n", pDst1);
    . Z  F" T+ _' ]4 z6 D/ }0 K
33. 
    $ z0 {/ e- s) N! @. a; C: n
34. pSrcA2--;
    3 I  U) {! s3 z) s+ K
35. arm_add_q15(&pSrcA2, &pSrcB2, &pDst2, 1);
    
36. printf("arm_add_q15 = %d\r\n", pDst2);
    
37. 
    & ]+ ]  w% U8 |+ M/ s
38. pSrcA3--;
    # S* S* z5 P; ~1 b  I
39. arm_add_q7(&pSrcA3, &pSrcB3, &pDst3, 1);
    
40. printf("arm_add_q7 = %d\r\n", pDst3);
    3 L+ `  G7 `$ M* [/ [) ]! I4 F$ _
41. printf("***********************************\r\n");
    
42. }

复制代码

8.4 乘法（Vector Multiplication）

    这部分函数主要用于乘法，公式描述如下：

     pDst[n] = pSrcA[n] * pSrcB[n],   0 <= n < blockSize.   

8.4.1 arm_mult_f32

     这个函数用于求32位浮点数的乘法，源代码分析如下：

1. /**        
   
2. * @brief Floating-point vector multiplication.        
   
3. * @param[in]       *pSrcA points to the first input vector        
   
4. * @param[in]       *pSrcB points to the second input vector        
   ! z! {$ Y/ u0 l+ M$ f& F8 e
5. * @param[out]      *pDst points to the output vector        
   
6. * @param[in]       blockSize number of samples in each vector        
   : r% X3 f- U4 l
7. * @return none.        
   ) ^# p% G5 v- U% o* X2 d' r0 d
8. */
   ' X; `, M7 V& v' R2 a) R, W
9. 
   
10. void arm_mult_f32(
    5 @( k1 \3 w6 ]# i/ `! p/ B
11.   float32_t * pSrcA,
    
12.   float32_t * pSrcB,
    $ s, A4 I: _# m) I4 N5 [
13.   float32_t * pDst,
    9 t# L0 g4 c3 q% l; ]. w7 Z
14.   uint32_t blockSize)
    : H! R/ T& G: r' U: R. a
15. {
    
16.   uint32_t blkCnt;                               /* loop counters */
    
17. #ifndef ARM_MATH_CM0_FAMILY
    " U5 F# M) p- K/ X
18. 
    
19.   /* Run the below code for Cortex-M4 and Cortex-M3 */
    
20.   float32_t inA1, inA2, inA3, inA4;              /* temporary input variables */
    
21.   float32_t inB1, inB2, inB3, inB4;              /* temporary input variables */
      M9 s8 J  n- H/ c4 S$ Y% K  ?
22.   float32_t out1, out2, out3, out4;              /* temporary output variables */
    + r) O1 V4 N1 V& k) B
23. 
    
24.   /* loop Unrolling */
    ( E/ m1 y  z7 f5 S/ O8 Z
25.   blkCnt = blockSize >> 2u;
    8 u2 d. B$ g( W9 O
26. 
    
27.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
    
28.    ** a second loop below computes the remaining 1 to 3 samples. */
    
29.   while(blkCnt > 0u)
    
30.   {
    # q" g& M$ x. b4 \
31.     /* C = A * B */
    
32.     /* Multiply the inputs and store the results in output buffer */                                 (1)
    
33.     /* read sample from sourceA */
    
34.     inA1 = *pSrcA;
    ) C# Z6 m8 s" [8 D
35.     /* read sample from sourceB */
    . p$ G; ]  b, n1 f5 k
36.     inB1 = *pSrcB;
    " v( B+ L5 B: v) c9 `  t
37.     /* read sample from sourceA */
    ! \5 C; d) S3 E  m0 j5 s# J- m
38.     inA2 = *(pSrcA + 1);
    , k3 `9 @6 A' P1 _& [( H! I
39.     /* read sample from sourceB */
    
40.     inB2 = *(pSrcB + 1);
    ; i0 J2 J; j( Z& J4 d) a7 o: c- q9 _
41. 
    1 v+ p% S# F5 S1 g
42.     /* out = sourceA * sourceB */
    
43.     out1 = inA1 * inB1;
    
44. 
    8 f& J4 o$ H# W% x& a! F: t
45.     /* read sample from sourceA */
    & P5 b# Q$ ~9 a' Y- s
46.     inA3 = *(pSrcA + 2);
    
47.     /* read sample from sourceB */
    
48.     inB3 = *(pSrcB + 2);
    ) J# p& Y0 f" ^2 v, W" v9 D
49. 
    
50.     /* out = sourceA * sourceB */
    ' ?* s# f& _: h5 T
51.     out2 = inA2 * inB2;
    
52. 
    0 E: [! V. m  |
53.     /* read sample from sourceA */
    
54.     inA4 = *(pSrcA + 3);
    3 g' Y4 U/ D9 N# Q! ~, ]
55. 
    7 A; i$ j4 M2 C4 r( }3 N
56.     /* store result to destination buffer */
    1 P+ A1 w# _1 Y! [. t
57.     *pDst = out1;
    1 |9 p' B7 _9 P$ I/ D. H) M
58. 
    
59.     /* read sample from sourceB */
    
60.     inB4 = *(pSrcB + 3);
    
61. 
    
62.     /* out = sourceA * sourceB */
      b2 d) M  }! f. V. w
63.     out3 = inA3 * inB3;
    ! V, d1 H2 h+ @. S; _9 s8 p5 P
64. 
    0 ?9 }0 F0 I7 }% L
65.     /* store result to destination buffer */
    
66.     *(pDst + 1) = out2;
    * H9 q* y( {& f( p" J# ^0 [0 V% \
67. 
    
68.     /* out = sourceA * sourceB */
    4 _. f# s, M) r$ m2 C, [
69.     out4 = inA4 * inB4;
    6 U4 D2 c; u4 b$ f& c
70.     /* store result to destination buffer */
    & P+ m# t+ w# o- J$ M
71.     *(pDst + 2) = out3;
    % ?0 y( A, M# m6 }* L' s
72.     /* store result to destination buffer */
    
73.     *(pDst + 3) = out4;
    
74. 
    ; F0 z' b' X: @% G% a) C+ T
75. 
    
76.     /* update pointers to process next samples */
    % }$ S: n! g/ i" U1 \( `! ?3 {9 ~
77.     pSrcA += 4u;
    
78.     pSrcB += 4u;
    
79.     pDst += 4u;
    , j. s6 f  [1 K
80. 
      ]2 U. v- @1 m: R
81.     /* Decrement the blockSize loop counter */
    
82.     blkCnt--;
    $ c5 P* T% c* N6 j7 ]) `1 D& X
83.   }
    
84. 
    
85.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
    
86.    ** No loop unrolling is used. */
    
87.   blkCnt = blockSize % 0x4u;
    . Y6 ~1 a* c. T2 c( [$ M) q$ t( U  _
88. 
    & ~8 L- a$ m/ p0 s+ Y
89. #else
    
90. 
    
91.   /* Run the below code for Cortex-M0 */
    # z& Y) r3 M' T4 Y- z& m% f) o
92. 
    * S* S' |) r1 b
93.   /* Initialize blkCnt with number of samples */
    
94.   blkCnt = blockSize;
    
95. 
    
96. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
97. 
    ) v$ H% f2 {$ g+ F, D9 E
98.   while(blkCnt > 0u)
    ( B( r; L3 C8 U( G! U+ D
99.   {
    : S' U! q4 P* s7 ^! ^- w7 q! H
100.     /* C = A * B */
     
101.     /* Multiply the inputs and store the results in output buffer */
       }& ^; p$ j) k( @' t
102.     *pDst++ = (*pSrcA++) * (*pSrcB++);
     
103. 
     
104.     /* Decrement the blockSize loop counter */
     
105.     blkCnt--;
       U, q9 F" @4 t* t7 {8 T- Q
106.   }
     
107. }

复制代码

1. 浮点的32位乘法比较简单，这里依然是以4次的计算为一组。

8.4.2 arm_mult_q31

    这个函数用于求32位定点数的乘法，源代码分析如下：

1. /**   
   ) t, y  `0 D% n1 k5 o2 Z* C; f7 U
2. * @brief Q31 vector multiplication.   
   
3. * @param[in]       *pSrcA points to the first input vector   
   9 v+ Q4 D  V6 |5 f6 x" B7 N
4. * @param[in]       *pSrcB points to the second input vector   
   / t) v" Q; H- e$ r  Y9 ~$ M
5. * @param[out]      *pDst points to the output vector   
   
6. * @param[in]       blockSize number of samples in each vector   
   . L' b6 p& L$ E: P
7. * @return none.   
   
8. *   
   
9. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
   % a6 V% `6 ]9 }, Z: r, J( X
10. * \par   
    
11. * The function uses saturating arithmetic.   
    
12. * Results outside of the allowable Q31 range[0x80000000 0x7FFFFFFF] will be saturated.   
    ) Z& x; E# o  u- W/ L6 z
13. */
    
14. 
    $ T* l) s1 G1 d& t' Z5 [
15. void arm_mult_q31(
    ' ]' r0 Y  N- {
16.   q31_t * pSrcA,
    1 f+ X3 K. N- H5 K9 g4 }- z7 C
17.   q31_t * pSrcB,
    + l  s& L2 x: C% e& L& {- f
18.   q31_t * pDst,
    
19.   uint32_t blockSize)
    
20. {
    . ~2 ]& e7 j& ]8 ]7 v+ Z
21.   uint32_t blkCnt;                               /* loop counters */
    
22. 
    : A6 s6 O& P8 B- S& ~# v& u/ k
23. #ifndef ARM_MATH_CM0_FAMILY
    
24. 
    
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
26.   q31_t inA1, inA2, inA3, inA4;                  /* temporary input variables */
    / o2 i9 C3 [( Y3 q- t1 q) y; g
27.   q31_t inB1, inB2, inB3, inB4;                  /* temporary input variables */
    7 Z( n1 C$ Z( t4 G( k
28.   q31_t out1, out2, out3, out4;                  /* temporary output variables */
    
29. 
    4 N* S% B' h/ F$ s- H& P; F
30.   /* loop Unrolling */
    
31.   blkCnt = blockSize >> 2u;
    
32. 
    - j" `1 r* ]/ m: c, f. \0 W& O4 D
33.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    
34.    ** a second loop below computes the remaining 1 to 3 samples. */
    
35.   while(blkCnt > 0u)
    
36.   {
    
37.     /* C = A * B */
    
38.     /* Multiply the inputs and then store the results in the destination buffer. */
    # l4 N. ?6 W7 j' _" p# z: s7 \
39.     inA1 = *pSrcA++;
    
40.     inA2 = *pSrcA++;
    2 W9 N$ C8 L! Z* _
41.     inA3 = *pSrcA++;
    9 y1 w8 f0 \' C! t4 I
42.     inA4 = *pSrcA++;
    # G8 V* @3 g8 \- @# J
43.     inB1 = *pSrcB++;
    4 Q1 d: y9 I* E3 U0 ]& V
44.     inB2 = *pSrcB++;
    
45.     inB3 = *pSrcB++;
    8 i2 c2 K. d& P0 Q
46.     inB4 = *pSrcB++;
    * K8 k  C7 A0 h9 t2 E- s' k2 f% k( B! ~
47. 
    
48.     out1 = ((q63_t) inA1 * inB1) >> 32;                                                              (2)
    
49.     out2 = ((q63_t) inA2 * inB2) >> 32;
    
50.     out3 = ((q63_t) inA3 * inB3) >> 32;
    ' }& n) U) ~, v
51.     out4 = ((q63_t) inA4 * inB4) >> 32;
    , R1 H' x* ^" I/ y2 I
52. 
    
53.     out1 = __SSAT(out1, 31);                                                                         (3)
    9 Q, t" L0 T2 s  Y" t( i' V
54.     out2 = __SSAT(out2, 31);
    
55.     out3 = __SSAT(out3, 31);
    - k  V& G$ @. H# K# D8 c0 ~
56.     out4 = __SSAT(out4, 31);
    
57. 
    3 Y, G, ^5 b4 f% c
58.     *pDst++ = out1 << 1u;                                                                            (4)
    2 q5 _, l- d# ]2 K6 I$ D. c: u
59.     *pDst++ = out2 << 1u;
    
60.     *pDst++ = out3 << 1u;
    / n4 u9 u. Z* p) t
61.     *pDst++ = out4 << 1u;
    3 M5 C* m1 z4 {6 S
62. 
    
63.     /* Decrement the blockSize loop counter */
    
64.     blkCnt--;
    6 B+ J4 a& P! G7 l
65.   }
    
66. 
    
67.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    + j8 P7 `0 N) R) D/ f9 L) Z
68.    ** No loop unrolling is used. */
    & V- y) ^7 X* ]$ Y, D+ Z2 T
69.   blkCnt = blockSize % 0x4u;
    + X; b% D7 R1 |7 j' ^! t) W+ H
70. 
    
71. #else
    
72. 
    
73.   /* Run the below code for Cortex-M0 */
    
74. 
    
75.   /* Initialize blkCnt with number of samples */
    
76.   blkCnt = blockSize;
    / I: j. V6 q0 k& u) A" a3 ^
77. 
    
78. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    # W" D# A0 w' P
79. 
    
80.   while(blkCnt > 0u)
    
81.   {
    
82.     /* C = A * B */
    
83.     /* Multiply the inputs and then store the results in the destination buffer. */
    
84.     *pDst++ =
    
85.       (q31_t) clip_q63_to_q31(((q63_t) (*pSrcA++) * (*pSrcB++)) >> 31);
    
86. 
    
87.     /* Decrement the blockSize loop counter */
    % H5 d+ m) @5 }- t( v) Y
88.     blkCnt--;
    
89.   }
    , I- N# h- L! Q  r. R
90. }

复制代码

1. 这个函数使用了饱和算法。

     所得结果是Q31格式，范围Q31 range[0x80000000 0x7FFFFFFF]。

2. 所得乘积左移32位。

3. 实现31位精度的饱和运算。

4. 右移一位，保证所得结果是Q31格式。

8.4.3 arm_mult_q15

    这个函数用于求16位定点数的乘法，源代码分析如下：

1. /**   
   / e% F& p: Z- R, I; {- L5 L
2. * @brief           Q15 vector multiplication   
   ! P- o4 C# ]! a- ~) F
3. * @param[in]       *pSrcA points to the first input vector   
   7 `% S0 d# l, A: D+ \8 `+ [% t+ Z
4. * @param[in]       *pSrcB points to the second input vector   
   
5. * @param[out]      *pDst points to the output vector   
   ) I/ @+ C/ f" @' N
6. * @param[in]       blockSize number of samples in each vector   
   
7. * @return none.   
   5 W1 T4 W3 l: w% M( E* D
8. *   
   
9. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
   + e) a( `2 G. P% U, r
10. * \par   
    
11. * The function uses saturating arithmetic.   
    
12. * Results outside of the allowable Q15 range [0x8000 0x7FFF] will be saturated.   
    
13. */
    * E/ Z0 A1 ^4 d! g4 c  D
14. 
    
15. void arm_mult_q15(
    ( r+ j/ a! z! q
16.   q15_t * pSrcA,
    
17.   q15_t * pSrcB,
    
18.   q15_t * pDst,
    8 `8 u/ F  s# L  e+ \7 ~
19.   uint32_t blockSize)
    % u; Q) g2 S* u" E+ ]2 E
20. {
    5 ?0 ]. c6 d# |7 }
21.   uint32_t blkCnt;                               /* loop counters */
    
22. 
    
23. #ifndef ARM_MATH_CM0_FAMILY
    
24. 
    * f- j/ O/ I# O' L) i7 w0 T
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
    ; ]) \, \$ K  k$ |8 g6 [% k$ t8 }
26.   q31_t inA1, inA2, inB1, inB2;                  /* temporary input variables */
    " d3 F; e6 L; R4 D
27.   q15_t out1, out2, out3, out4;                  /* temporary output variables */
    
28.   q31_t mul1, mul2, mul3, mul4;                  /* temporary variables */
    + E% X: j8 s& O+ l4 G/ v+ n# C
29. 
    
30.   /* loop Unrolling */
    
31.   blkCnt = blockSize >> 2u;
    ( H1 O& Q+ _, `2 s
32. 
    
33.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
    . t- Q- F- N% l4 h
34.    ** a second loop below computes the remaining 1 to 3 samples. */
    6 C# I) N5 a/ w6 l/ h0 E8 g& @
35.   while(blkCnt > 0u)
    
36.   {
    
37.     /* read two samples at a time from sourceA */
    $ R' l' ~# D( }+ @2 L$ c; a
38.     inA1 = *__SIMD32(pSrcA)++;                                                                     (2)
    
39.     /* read two samples at a time from sourceB */
    4 l" u  ?- x3 V5 s8 i+ O( x3 k
40.     inB1 = *__SIMD32(pSrcB)++;
    
41.     /* read two samples at a time from sourceA */
    
42.     inA2 = *__SIMD32(pSrcA)++;
    5 O7 q- ~4 ?+ C2 _5 @/ A5 d
43.     /* read two samples at a time from sourceB */
    ; R! x* y  W$ E4 B9 r6 X# S0 t4 G2 _
44.     inB2 = *__SIMD32(pSrcB)++;
    
45. 
    
46.     /* multiply mul = sourceA * sourceB */
    
47.     mul1 = (q31_t) ((q15_t) (inA1 >> 16) * (q15_t) (inB1 >> 16));                                  (3)
    1 \5 r4 X+ X" J( t' {# e
48.     mul2 = (q31_t) ((q15_t) inA1 * (q15_t) inB1);
    # Q5 I- d5 Q0 w' D# |2 Y9 X
49.     mul3 = (q31_t) ((q15_t) (inA2 >> 16) * (q15_t) (inB2 >> 16));
    
50.     mul4 = (q31_t) ((q15_t) inA2 * (q15_t) inB2);
    - o% K3 P) J* f8 f" `6 Q
51. 
    
52.     /* saturate result to 16 bit */
    
53.     out1 = (q15_t) __SSAT(mul1 >> 15, 16);                                                         (4)
    
54.     out2 = (q15_t) __SSAT(mul2 >> 15, 16);
    
55.     out3 = (q15_t) __SSAT(mul3 >> 15, 16);
    
56.     out4 = (q15_t) __SSAT(mul4 >> 15, 16);
    
57. 
    
58.     /* store the result */
    
59. #ifndef ARM_MATH_BIG_ENDIAN
    9 d: X+ B5 J0 s# {$ J! Z
60. 
    
61.     *__SIMD32(pDst)++ = __PKHBT(out2, out1, 16);                                                   (5)
    
62.     *__SIMD32(pDst)++ = __PKHBT(out4, out3, 16);
    1 ]8 u+ u1 U8 k. K2 }
63. 
    
64. #else
    
65. 
    
66.     *__SIMD32(pDst)++ = __PKHBT(out2, out1, 16);
    
67.     *__SIMD32(pDst)++ = __PKHBT(out4, out3, 16);
    $ ?( J/ j1 y& ]+ G1 L8 Q. A
68. 
    
69. #endif //      #ifndef ARM_MATH_BIG_ENDIAN
    
70. 
    
71.     /* Decrement the blockSize loop counter */
      T' f. W9 N/ f' u" k' s4 {' T) r! s
72.     blkCnt--;
    
73.   }
    ' x9 B$ @0 {5 O8 {- g) ^/ A0 t
74. 
    
75.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    ) b6 O; W# q! h' e' Z7 q: q( v
76.    ** No loop unrolling is used. */
    
77.   blkCnt = blockSize % 0x4u;
    
78. 
    
79. #else
    
80. 
    
81.   /* Run the below code for Cortex-M0 */
    7 E. D. D& z& |. @5 Z5 ~
82. 
    
83.   /* Initialize blkCnt with number of samples */
    
84.   blkCnt = blockSize;
    / P( @' J) t" V4 p9 Z6 z( r* K, F) b
85. 
    
86. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
87. 
    + s7 \$ K5 A- c; R( i
88. 
    8 \. ?. T% o; b
89.   while(blkCnt > 0u)
    
90.   {
    4 t+ ~& ]9 _+ |0 B) P
91.     /* C = A * B */
    
92.     /* Multiply the inputs and store the result in the destination buffer */
    6 v0 o/ O7 L/ ?$ d- e- s% ]5 h$ K
93.     *pDst++ = (q15_t) __SSAT((((q31_t) (*pSrcA++) * (*pSrcB++)) >> 15), 16);
    
94. 
    
95.     /* Decrement the blockSize loop counter */
    ) c) k' G3 N% A% L" ]
96.     blkCnt--;
    ) q6 u4 f$ ]& e2 w5 n1 x
97.   }
    
98. }

复制代码

1. 这个函数使用了饱和算法。

    所得结果是Q15格式，范围 [0x8000  0x7FFF]。

2. 一次读取两个Q15格式的数据。

3. 将四组数的乘积保存到Q31格式的变量mul1，mul2，mul3，mul4。

4. 丢弃32位数据的低15位，并把最终结果饱和到16位精度。

5. 通过SIMD指令__PKHBT将两个Q15格式的数据保存的结果数组中，从而一个指令周期就能完成两个数据的存储。

8.4.4 arm_mult_q7

    这个函数用于求8位定点数的乘法，源代码分析如下：

1. /**   
   
2. * @brief           Q7 vector multiplication   
   & U6 S3 f& D& b' t2 {1 P9 p
3. * @param[in]       *pSrcA points to the first input vector   
   9 R7 c" v. E, ~8 [# o. @
4. * @param[in]       *pSrcB points to the second input vector   
   8 l  k7 p1 E, X
5. * @param[out]      *pDst points to the output vector   
     Q7 {+ Z( i: B0 P* J3 ?9 D
6. * @param[in]       blockSize number of samples in each vector   
   
7. * @return none.   
   ! A& s" M: H( R0 p( T  x3 F
8. *   
   . F* U4 A  u, i5 C
9. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
   
10. * \par   
    
11. * The function uses saturating arithmetic.   
    ! _5 m1 h3 b9 T" \, ?
12. * Results outside of the allowable Q7 range [0x80 0x7F] will be saturated.   
    % ^+ N1 {7 \# m
13. */
    : H; L" M- [: S. c0 e
14. 
    4 X1 _( L' w- v- H) n2 _+ S
15. void arm_mult_q7(
    
16.   q7_t * pSrcA,
    
17.   q7_t * pSrcB,
    
18.   q7_t * pDst,
    9 \% I! N. P1 F3 F( D5 b- |9 F
19.   uint32_t blockSize)
    
20. {
    5 q9 O1 W7 c7 {. t. K
21.   uint32_t blkCnt;                               /* loop counters */
    ( U+ M) t1 l+ e; M% n; P6 S* v3 u/ i
22. 
    9 K) e: ]: U2 T0 J
23. #ifndef ARM_MATH_CM0_FAMILY
    1 R8 A5 Y6 K6 E! J) b' ?
24. 
    
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
    8 r, ~! h. b# q% {
26.   q7_t out1, out2, out3, out4;                   /* Temporary variables to store the product */
    $ x1 B' v+ \/ o2 u; \, F
27. 
    
28.   /* loop Unrolling */
    
29.   blkCnt = blockSize >> 2u;
    
30. 
    
31.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    + z# u/ H0 D! r* j  M4 P& A
32.    ** a second loop below computes the remaining 1 to 3 samples. */
    - j/ {( R. b! }8 G/ g4 E( p
33.   while(blkCnt > 0u)
    
34.   {
    
35.     /* C = A * B */
    8 v  a( k- ], ~, S: A; G& f
36.     /* Multiply the inputs and store the results in temporary variables */                          (2)
    2 }9 N8 F& y, b- v/ c- o; X6 }
37.     out1 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
    
38.     out2 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
    ; N5 z2 S2 j$ `+ s
39.     out3 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
    - W; |+ N* R$ k! O/ C: X5 n
40.     out4 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
    3 ?5 V* z& T/ C$ i
41. 
    
42.     /* Store the results of 4 inputs in the destination buffer in single cycle by packing */
    
43.     *__SIMD32(pDst)++ = __PACKq7(out1, out2, out3, out4);                                          (3)
    
44. 
    + B5 a4 O* b4 f
45.     /* Decrement the blockSize loop counter */
    0 B+ p* S! G0 p7 a5 I
46.     blkCnt--;
    $ W2 E9 @; K. l  J5 w/ O. c/ c. g) ?  P
47.   }
    ( T+ b% ~' l/ a
48. 
    " m: [7 @+ v# ^* {" }0 U+ b
49.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    * q0 l: `# D3 r& |* n
50.    ** No loop unrolling is used. */
    
51.   blkCnt = blockSize % 0x4u;
    " ?7 `9 W, e6 v3 [6 |. D5 w0 ]( k
52. 
    
53. #else
    2 J. l5 s, x. _
54. 
    
55.   /* Run the below code for Cortex-M0 */
    $ i# \5 K+ L/ f7 `4 e. h' k
56. 
    ; {8 q( i5 ?7 B2 K( K
57.   /* Initialize blkCnt with number of samples */
    
58.   blkCnt = blockSize;
    
59. 
    
60. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
61. 
    & m: T% z8 G4 G1 L/ W# Y/ Q
62. 
    
63.   while(blkCnt > 0u)
    8 p* s& b+ j. F7 }& i8 I+ ]
64.   {
    
65.     /* C = A * B */
    * a, G7 P% E/ T5 n
66.     /* Multiply the inputs and store the result in the destination buffer */
    
67.     *pDst++ = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
    
68. 
    9 K" ^9 z' H3 O
69.     /* Decrement the blockSize loop counter */
    
70.     blkCnt--;
    
71.   }
    
72. }

复制代码

1. 这个函数使用了饱和算法。

    所得结果是Q7格式，范围 [0x80  0x7F]。

2. 将两个Q7格式的数据乘积左移7位，也就是丢掉低7位的数据，并将所得结果饱和到8位精度。

3. __PACKq7函数可以在一个时钟周期就能完成相应操作。

8.4.5 实例讲解

实验目的：

1. 四种类型数据的乘法。

实验内容：

1. 按下摇杆的UP键, 串口打印输出结果

实验现象：

        通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
   
2. *********************************************************************************************************
   % ?! Y" I7 ^; n
3. *        函 数 名: DSP_Multiplication
   5 ]- @; f0 H2 F; L) n% j
4. *        功能说明: 乘法
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void DSP_Multiplication(void)
   ! h* k8 v. ~! u) s5 d
10. {
    + \  a9 E! B; e( D3 l
11. static float32_t   pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
    / W" e$ Q! v$ g7 M
12. static float32_t   pSrcB[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};  
    ' C( d9 T! |# _
13. static float32_t   pDst[5];  
    % W- S, y: t( I/ M' x/ t7 w7 r: Y( P
14. static q31_t  pSrcA1[5] = {1,1,1,1,1};  
    # _& u5 C  z8 i4 j; e- {8 n
15. static q31_t  pSrcB1[5] = {1,1,1,1,1};  
    8 t0 k7 Q  \& Q! n. i( r+ f
16. static q31_t  pDst1[5];   
    
17. 
    8 c1 F( y+ k; K- _4 z+ U0 i* q
18. static q15_t  pSrcA2[5] = {1,1,1,1,1};  
    5 |2 l6 H. M5 t6 |5 t, X
19. static q15_t  pSrcB2[5] = {1,1,1,1,1};  
    
20. static q15_t  pDst2[5];   
    : M( I  n( X9 k
21. 
    
22. static q7_t  pSrcA3[5] = {0x70,1,1,1,1};
    
23. static q7_t  pSrcB3[5] = {0x7f,1,1,1,1};  
    7 C. s( p7 q& \# Y
24. static q7_t pDst3[5];  
    # o6 {# N1 ^1 }( G
25. 
    , C  b# g+ O6 ?
26. pSrcA[0] += 1.1f;
    , t9 I1 h- |' H* [7 u6 a% {
27. arm_mult_f32(pSrcA, pSrcB, pDst, 5);
    4 U' G0 L* t5 ?! W% x4 ~: @
28. printf("arm_mult_f32 = %f\r\n", pDst[0]);
    
29. pSrcA1[0] += 1;
    , o4 U8 }; w. G& w" L
30. arm_mult_q31(pSrcA1, pSrcB1, pDst1, 5);
    9 G+ \5 z. T: K$ \" d: O! C% k
31. printf("arm_mult_q31 = %d\r\n", pDst1[0]);
    
32. 
      n0 y) ^/ \5 O: ~5 ^2 `$ p) ^4 P4 }
33. pSrcA2[0] += 1;
    , Y4 `. m& S0 W' p/ Y5 q
34. arm_mult_q15(pSrcA2, pSrcB2, pDst2, 5);
    
35. printf("arm_mult_q15 = %d\r\n", pDst2[0]);
    0 l, E$ v* y; T& |' _* Q+ B+ R
36. 
    3 Z, ^. N, P$ i; x( V8 }- m
37. pSrcA3[0] += 1;
    8 x5 m7 H  i. _4 U6 u, s
38. arm_mult_q7(pSrcA3, pSrcB3, pDst3, 5);
    " S8 I) a5 x$ n4 P3 k- I
39. printf("arm_mult_q7 = %d\r\n", pDst3[0]);
    * j4 ?  T% l8 ^* j2 c3 x, G
40. printf("***********************************\r\n");
    
41. }

复制代码

8.5 总结

    本期教程就跟大家讲这么多，还是那句话，可以自己写些代码调用本期教程中讲的这几个函数，如果可以的话，可以自己尝试直接调用这些DSP指令。

沙发，收藏

谢谢分享啊