特别说明：完整45期数字信号处理教程，原创高性能示波器代码全开源地址：链接
! ?' k1 o3 ^1 [" j  j1 E; h

第9章 BasicMathFunctions的使用（二）

' F9 U: }$ o' a# A

    本期教程主要讲基本函数中的相反数，偏移，位移，减法和比例因子。

    9.1 相反数（Vector Negate）

    9.2 求和（Vector Offset）

    9.3 点乘（Vector Shift）

    9.4 减法（Vector Sub）

    9.5 比例因子（Vector Scale）

    9.6 BasicMathFunctions的重要说明

    9.7 总结

- d; V2 [, Y5 y' q9.1 相反数（Vector Negate）

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

     pDst[n] = -pSrc[n],   0 <= n < blockSize.   

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

9.1.1 arm_negate_f32

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

1. /**        
   
2. * @brief  Negates the elements of a floating-point vector.        
   6 d' C2 s( {/ d6 K' |" ^( M4 w
3. * @param[in]  *pSrc points to the input vector        
   
4. * @param[out]  *pDst points to the output vector        
   
5. * @param[in]  blockSize number of samples in the vector        
   
6. * @return none.        
   
7. */
   : Q. b8 e1 i9 @6 M2 Q
8. 
   
9. void arm_negate_f32(
   ; \5 c+ ]" F5 ^! Q1 R- d
10.   float32_t * pSrc,
    
11.   float32_t * pDst,
    
12.   uint32_t blockSize)
    
13. {
    8 b" R  R# N+ g0 }. Z' G' m
14.   uint32_t blkCnt;                               /* loop counter */
    $ X1 _; t1 x) U
15. 
    
16. 
    
17. #ifndef ARM_MATH_CM0_FAMILY
    2 s% x; B4 ?/ a. r% B( w$ d9 Q
18. 
    % U, G  L- p& [! p8 |/ y6 e
19. /* Run the below code for Cortex-M4 and Cortex-M3 */
    ' @, D. J5 V- z# ^; L$ v
20.   float32_t in1, in2, in3, in4;                  /* temporary variables */
    
21. 
    , }2 M, q8 t, T/ H' M; o
22.   /*loop Unrolling */
    
23.   blkCnt = blockSize >> 2u;
    3 J- Q" e9 C/ J' [' \& R" R
24. 
    + N- l$ S& p; s3 X2 Z
25.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
    
26.    ** a second loop below computes the remaining 1 to 3 samples. */
    6 L7 E2 }. O& B& P+ n
27.   while(blkCnt > 0u)
    
28.   {
    $ s" u$ I" A# ~( [+ F) N0 U
29.     /* read inputs from source */
    
30.     in1 = *pSrc;
    
31.     in2 = *(pSrc + 1);
    
32.     in3 = *(pSrc + 2);
    
33.     in4 = *(pSrc + 3);
    
34. 
    3 I5 W# R$ @6 `3 V4 F6 U& d
35.     /* negate the input */                                                                            (1)
    
36.     in1 = -in1;
    
37.     in2 = -in2;
    / ?( c6 s% M5 O2 w$ V* {! e0 K% p
38.     in3 = -in3;
    
39.     in4 = -in4;
    
40. 
    9 m5 X! ]  D& ^* l) O7 S
41.     /* store the result to destination */
    
42.     *pDst = in1;
    - ]9 V' w) m. E* d
43.     *(pDst + 1) = in2;
    % V# s5 m3 E- `" M! W5 J' |& \
44.     *(pDst + 2) = in3;
    
45.     *(pDst + 3) = in4;
    
46. 
    3 s! M- z# w& E/ `5 x9 z+ f& I
47.     /* update pointers to process next samples */
    " [$ k5 v! D0 i/ L+ ^' Q
48.     pSrc += 4u;
      Y, ]7 [, z0 z  z- o4 ?4 n) S; f
49.     pDst += 4u;
    % S3 M( U; x" R
50. 
    1 Y6 D5 u2 M' g
51.     /* Decrement the loop counter */
    
52.     blkCnt--;
    + }4 x  @$ X5 Q; z
53.   }
    3 g' d3 L- Q$ v
54. 
    
55.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
    
56.    ** No loop unrolling is used. */
    
57.   blkCnt = blockSize % 0x4u;
    
58. 
    7 g! P# G% M2 e
59. #else
    
60. 
    
61.   /* Run the below code for Cortex-M0 */
    
62. 
    
63.   /* Initialize blkCnt with number of samples */
    0 Q; q) n* g$ Q. t& n" n
64.   blkCnt = blockSize;
    
65. 
    
66. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
67. 
    
68.   while(blkCnt > 0u)
    
69.   {
    ; q  j- b% k' i6 J" v
70.     /* C = -A */
    ; T  N% F* m1 w# V8 t  G
71.     /* Negate and then store the results in the destination buffer. */
    
72.     *pDst++ = -*pSrc++;
    6 d& q* `. K3 d4 T
73. 
    
74.     /* Decrement the loop counter */
    ; z5 M8 s* h5 z6 c5 ]* Q
75.     blkCnt--;
    
76.   }
    
77. }

复制代码

1. 浮点数的相反数求解比较简单，直接在相应的变量前加上负号即可。

7 ^: Q6 j6 Y; @( H9.1.2 arm_negate_q31

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

1. /**   
   8 A* O0 e1 X  x+ o3 \- f
2. * @brief  Negates the elements of a Q31 vector.   
   % m% s1 O5 J3 e2 j" F
3. * @param[in]  *pSrc points to the input vector   
   7 l: p3 j' S$ o
4. * @param[out]  *pDst points to the output vector   
   
5. * @param[in]  blockSize number of samples in the vector   
   
6. * @return none.   
   
7. *   
   % N: ~2 c, O; l- m
8. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
   2 p+ T% X" P2 j. R) ]+ E9 a
9. * \par   
   6 |+ I$ h' e5 D) d3 r6 B1 w
10. * The function uses saturating arithmetic.   
    
11. * The Q31 value -1 (0x80000000) will be saturated to the maximum allowable positive value 0x7FFFFFFF.   
    - X$ X0 I+ C2 }0 u% Y2 }2 b6 Y
12. */
    
13. 
    , z3 V/ |2 f- Z5 F/ i
14. void arm_negate_q31(
    9 j( B( ]! I' y# p7 ?9 F
15.   q31_t * pSrc,
    
16.   q31_t * pDst,
    & U* N* m- U% C$ r$ A6 i
17.   uint32_t blockSize)
    / a8 d/ {8 y8 K  s* Z2 ?/ Z+ u# H( \
18. {
    - U3 R+ g; U8 ?5 W& G
19.   q31_t in;                                      /* Temporary variable */
    
20.   uint32_t blkCnt;                               /* loop counter */
    
21. 
    - F9 O# [6 E9 m6 H9 V, W
22. #ifndef ARM_MATH_CM0_FAMILY
    0 I* @% s4 C  t1 `
23. 
    4 C, V2 p# [6 A+ n2 N
24. /* Run the below code for Cortex-M4 and Cortex-M3 */
    9 n7 s/ w/ B! L& W& _, g& g- t( E
25.   q31_t in1, in2, in3, in4;
    
26. 
    8 k0 |0 e" N" J: M5 w  a% U
27.   /*loop Unrolling */
    - M2 q6 s3 D7 O  }# i" E0 k
28.   blkCnt = blockSize >> 2u;
    
29. 
    
30.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    6 l3 g! |% F, F; d3 ~1 l
31.    ** a second loop below computes the remaining 1 to 3 samples. */
    8 ?& ?! @( |+ v% u5 v: Z
32.   while(blkCnt > 0u)
    * w+ q6 s. P) c0 [& p7 d
33.   {
    % S( r# W& }+ _
34.     /* C = -A */
    - D- O% F, w3 y
35.     /* Negate and then store the results in the destination buffer. */
    
36.     in1 = *pSrc++;
    
37.     in2 = *pSrc++;
    4 S( H' |; ~, A5 L2 h" m
38.     in3 = *pSrc++;
    
39.     in4 = *pSrc++;
    
40. 
    8 f8 ]* l  n4 I- W' n6 _7 T# a5 F  m
41.     *pDst++ = __QSUB(0, in1);                                                                      (2)
    
42.     *pDst++ = __QSUB(0, in2);
    & V9 e- @/ n0 B# f1 ]
43.     *pDst++ = __QSUB(0, in3);
    - y- Z( B3 M# Q) K
44.     *pDst++ = __QSUB(0, in4);
    5 [( q0 [1 a! i2 t8 ^* Q
45. 
    
46.     /* Decrement the loop counter */
    ; T/ A! R. E3 i( w3 ]4 W, y% h
47.     blkCnt--;
    
48.   }
    
49. 
    " r# E3 N# X) h& x1 [
50.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
51.    ** No loop unrolling is used. */
    
52.   blkCnt = blockSize % 0x4u;
    / n2 ]( r8 e: x
53. 
    : S( G- Y% {8 w# S3 Y& q0 U
54. #else
    + d, J+ s# h" D6 k" ?4 o
55. 
    . W- F1 D% D3 z, W
56.   /* Run the below code for Cortex-M0 */
    
57. 
    
58.   /* Initialize blkCnt with number of samples */
    
59.   blkCnt = blockSize;
      a" \3 v4 ?, z- m! p0 d
60. 
    3 Q( Y1 L' D6 j
61. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    + o' {* v3 ^) b
62. 
    
63. 
    
64.   while(blkCnt > 0u)
    ' [) f0 h8 d6 ~) Y6 @
65.   {
    / x' y5 F8 w  s' ?# a% h3 [. h
66.     /* C = -A */
    5 r) F7 W. z4 A  Q' h# |
67.     /* Negate and then store the result in the destination buffer. */
    ' c& p5 G5 \& ^/ g0 u, J
68.     in = *pSrc++;
    
69.     *pDst++ = (in == INT32_MIN) ? INT32_MAX : -in;
    
70. 
    
71.     /* Decrement the loop counter */
    / ?3 [+ S( U* `6 R4 \$ b
72.     blkCnt--;
    
73.   }
    
74. }

复制代码

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

    饱和运算数值0x80000000将变成0x7FFFFFFF。

2. 饱和运算__QSUB我们在上一章已经详细讲述了，这就就是实现数值0减去相应的参数变量。

2 C. |& j( [$ j/ N# B9 R& h. K9.1.3 arm_negate_q15

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

1. /**        
   1 [+ u! k) G4 M2 ^, j& W
2. * @brief  Negates the elements of a Q15 vector.        
   
3. * @param[in]  *pSrc points to the input vector        
   
4. * @param[out]  *pDst points to the output vector        
   
5. * @param[in]  blockSize number of samples in the vector        
   
6. * @return none.        
   
7. *   
   
8. * \par Conditions for optimum performance   
   
9. *  Input and output buffers should be aligned by 32-bit   
   - J. z) s+ y+ w2 c9 E4 ]
10. *   
    # Y- C, c/ d  i
11. *        
    
12. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
    
13. * \par        
    
14. * The function uses saturating arithmetic.        
    9 c* h" m% g. U/ Q7 W' e( G3 S
15. * The Q15 value -1 (0x8000) will be saturated to the maximum allowable positive value 0x7FFF.        
    1 L7 {5 z# q- Q9 V) h0 a1 m
16. */
    9 N  Z  C. D9 @2 l, l
17. 
    1 |+ f. {9 |; d0 {6 G( a
18. void arm_negate_q15(
    
19.   q15_t * pSrc,
    * r- Q4 k, E. O  M0 h( ?
20.   q15_t * pDst,
    
21.   uint32_t blockSize)
    ( ^8 c* X5 ~6 b
22. {
    
23.   uint32_t blkCnt;                               /* loop counter */
    
24.   q15_t in;
    
25. 
    
26. #ifndef ARM_MATH_CM0_FAMILY
    
27. 
    
28. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
29. 
    4 C+ n, @- B2 L+ a* j
30.   q31_t in1, in2;                                /* Temporary variables */
      }/ h3 V7 y  X( Y
31. 
    ' w( d" X* |% u2 X# O3 K
32. 
    6 |& I8 x7 d2 Q, u7 f; v
33.   /*loop Unrolling */
    : `+ h, L# J8 I8 m! R, A( m" }
34.   blkCnt = blockSize >> 2u;
    
35. 
    3 z4 m  V3 M) b1 o2 X; W, @
36.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
    " p2 m2 R" q1 m, v
37.    ** a second loop below computes the remaining 1 to 3 samples. */
    6 }2 m2 I+ c0 [+ C  p7 f9 F
38.   while(blkCnt > 0u)
    6 \6 J% ~" E$ Y( w$ Y' I" S" q
39.   {
    
40.     /* C = -A */
    
41.     /* Read two inputs at a time */                                                                  (2)
    
42.     in1 = _SIMD32_OFFSET(pSrc);
    
43.     in2 = _SIMD32_OFFSET(pSrc + 2);
    
44. 
    4 {) C5 h3 O8 y( g8 v  b) L
45.     /* negate two samples at a time */                                                               (3)
    9 o+ X* i: Q& _  ~1 b6 C
46.     in1 = __QSUB16(0, in1);
    7 b6 c! T+ R7 c/ H) ]8 f
47. 
    % v' ]& Z& H0 c! L
48.     /* negate two samples at a time */
    6 D  t1 |  k+ |* E
49.     in2 = __QSUB16(0, in2);
    
50. 
    
51.     /* store the result to destination 2 samples at a time */                                        (4)
    
52.     _SIMD32_OFFSET(pDst) = in1;
    9 [1 e- F$ c: v) c2 `/ k2 V
53.     /* store the result to destination 2 samples at a time */
    
54.     _SIMD32_OFFSET(pDst + 2) = in2;
    
55. 
    
56. 
    ; T5 \$ {( C& d3 K( w  L
57.     /* update pointers to process next samples */
    7 m9 Z! ^3 @0 k
58.     pSrc += 4u;
    ; p/ ?: I0 _2 V* I
59.     pDst += 4u;
    
60. 
    
61.     /* Decrement the loop counter */
    
62.     blkCnt--;
    
63.   }
    
64. 
    
65.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
    
66.    ** No loop unrolling is used. */
    
67.   blkCnt = blockSize % 0x4u;
    
68. 
    
69. #else
    * P8 u6 z9 ]. f$ e' I* B0 b
70. 
    
71.   /* Run the below code for Cortex-M0 */
    2 W- x! n/ S! D1 [4 r
72. 
    5 N3 h' f  p7 C+ g
73.   /* Initialize blkCnt with number of samples */
    
74.   blkCnt = blockSize;
    
75. 
    % H! Y+ ?( W2 z$ Z! F/ ^8 G
76. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
77. 
    
78.   while(blkCnt > 0u)
    
79.   {
    - x, R6 [% h; M0 @* v; C, b& [$ |
80.     /* C = -A */
    
81.     /* Negate and then store the result in the destination buffer. */
    
82.     in = *pSrc++;
    
83.     *pDst++ = (in == (q15_t) 0x8000) ? 0x7fff : -in;
    
84. 
    ' L- J( A5 [+ T) w; J( P
85.     /* Decrement the loop counter */
    # N3 L# D0 f: y4 M7 o# U& R, Q, F0 O
86.     blkCnt--;
    
87.   }
    " I9 x* |8 c1 E% Q7 h
88. }

复制代码

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

    饱和运算数值0x8000将变成0x7FFF。

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

3. 由于__QSUB是SIMD指令，这里可以实现一次计算两个Q15数据的相反数。

4. 这里实现一次赋值两个Q15数据。

& D$ X1 A2 S- c8 z. p) z% A9.1.4 arm_negate_q7

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

1. /**   
   7 Q( {: r- L3 e" j% z  d
2. * @brief  Negates the elements of a Q7 vector.   
   
3. * @param[in]  *pSrc points to the input vector   
   
4. * @param[out]  *pDst points to the output vector   
   
5. * @param[in]  blockSize number of samples in the vector   
   & I( x3 l( G3 D, b% q' Y
6. * @return none.   
   
7. *   
   ' ]( O; F4 u  H; \( S$ d2 M* \
8. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
   8 ]" _# q6 X# X
9. * \par   
   
10. * The function uses saturating arithmetic.   
    8 J! {: n: P4 a' X! F  v
11. * The Q7 value -1 (0x80) will be saturated to the maximum allowable positive value 0x7F.   
    
12. */
    
13. 
    
14. void arm_negate_q7(
    
15.   q7_t * pSrc,
    
16.   q7_t * pDst,
    
17.   uint32_t blockSize)
    
18. {
    
19.   uint32_t blkCnt;                               /* loop counter */
    
20.   q7_t in;
    7 P: I; B0 L. e6 U; O) B( I
21. 
    
22. #ifndef ARM_MATH_CM0_FAMILY
    * C# _) Y/ Z0 N! J
23. 
    
24. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
25.   q31_t input;                                   /* Input values1-4 */
    
26.   q31_t zero = 0x00000000;                                                                           (2)
    ; G$ C! x* t; U  {) C& v0 a  [
27. 
    
28. 
    
29.   /*loop Unrolling */
    : C" F  {' p+ W
30.   blkCnt = blockSize >> 2u;
    
31. 
    
32.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    ) Z/ ^* M- M9 t% h) Y6 \' e$ ^# b
33.    ** a second loop below computes the remaining 1 to 3 samples. */
    
34.   while(blkCnt > 0u)
    8 y3 ?) w& c) J1 r
35.   {
    
36.     /* C = -A */
    ( Q. ]( H( w4 J$ n3 X5 q2 B
37.     /* Read four inputs */
    * a; ]5 O3 C7 P+ L4 }1 I
38.     input = *__SIMD32(pSrc)++;                                                                        (3)
    
39. 
    $ Q" V1 C! s: G6 F9 }6 j
40.     /* Store the Negated results in the destination buffer in a single cycle by packing the results */
    ! {6 R- i7 I; O8 i
41.     *__SIMD32(pDst)++ = __QSUB8(zero, input);                                                         (4)
    
42. 
    / A  Q" T$ o/ a& ~; X8 _1 c4 g
43.     /* Decrement the loop counter */
    
44.     blkCnt--;
    
45.   }
    # d5 ]2 p  @- k+ ]6 r; g: P7 q0 P( z/ N
46. 
    0 R) s, V/ D" u# @. k: i, s
47.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
48.    ** No loop unrolling is used. */
    ( f6 P2 a. r! ^+ a6 B
49.   blkCnt = blockSize % 0x4u;
    # c3 u/ y% W9 K3 l2 B
50. 
    2 k% v! m6 l) b2 o: c
51. #else
    
52. 
    + ^8 X" P1 b2 R  P
53.   /* Run the below code for Cortex-M0 */
    
54. 
    % T$ h$ t& J1 V8 b' ^
55.   /* Initialize blkCnt with number of samples */
    : U0 l( j4 O' M7 i! d) X% g8 u' Y  W
56.   blkCnt = blockSize;
    
57. 
    
58. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    ) f) o1 b0 r/ b8 P0 O% E# |
59. 
    3 Q* e  k$ C% r- a3 g9 c2 Y( J3 p5 I
60.   while(blkCnt > 0u)
    
61.   {
    ! J+ h5 g# i  J5 B- c
62.     /* C = -A */
    % F9 d0 O4 C. X) t: m7 d2 c
63.     /* Negate and then store the results in the destination buffer. */ \
    + u) o4 V/ `/ n% c1 {4 ?- U9 e8 {9 x
64.       in = *pSrc++;
    
65.     *pDst++ = (in == (q7_t) 0x80) ? 0x7f : -in;
    
66. 
    : n# C" i9 C/ ~& f2 a% b% N; r% U
67.     /* Decrement the loop counter */
    , e) `4 t$ I, U9 r
68.     blkCnt--;
    " {1 U& g7 _: r+ k; _; f
69.   }
    . \; i. S2 H8 v
70. }

复制代码

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

    饱和运算数值0x80将变成0x7F。

2. 给局部变量赋初值，防止默认初始值不是0，所以从某种意义上来说，给变量赋初值是很有必要的。

3. 一次读取4个Q7格式的数据到input里面。

4. 通过__QSUB8实现一次计算四个Q7格式数据的相反数。

& V- i6 x+ E' M- M9.1.5 实例讲解

实验目的：

    1. 四种类型数据的相反数。

实验内容：

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

实验现象：

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

程序设计：

1. /*
   3 x& z0 c% ?" `
2. *********************************************************************************************************
   
3. *        函 数 名: DSP_Negate
   
4. *        功能说明: 求相反数
   
5. *        形    参：无
   
6. *        返 回 值: 无
   2 W$ Q  m# b! p) C, G
7. *********************************************************************************************************
   
8. */
   
9. static void DSP_Negate(void)
   1 k+ `8 P  L# {3 P/ \& d. P7 T
10. {
    0 S8 e2 k& k7 a1 s5 B
11. static float32_t pSrc;
    9 l! K$ a$ P0 A% \
12.     static float32_t pDst;
    
13. static q31_t pSrc1;
    , A& h5 a: O8 V( L+ l% B4 ]
14. static q31_t pDst1;
    . l1 ~( j( Y2 O6 x
15. static q15_t pSrc2;
    
16. static q15_t pDst2;
    1 X1 d7 A  z  Q7 q4 V
17. static q7_t pSrc3 = 127; /* 为了说明问题，在这里设置初始值为127，然后查看0x80是否饱和为0x7F */
    # X: C. `' G: j0 |3 C6 I
18. static q7_t pDst3;
    
19. pSrc -= 1.23f;
    
20. arm_negate_f32(&pSrc, &pDst, 1);
    , {# U3 S( f- p8 u& }* |& P
21. printf("arm_negate_f32 = %f\r\n", pDst);
    
22. 
    % F; a" O+ ?+ H7 ~; B, w$ n: u
23. pSrc1 -= 1;
    " G9 z, }  E* v) \4 C3 ~
24. arm_negate_q31(&pSrc1, &pDst1, 1);
    
25. printf("arm_negate_q31 = %d\r\n", pDst1);
    6 D: H! S6 d: a. f6 a
26. 
    
27. pSrc2 -= 1;
    
28. arm_negate_q15(&pSrc2, &pDst2, 1);
    , ^/ A; k* S$ c8 l
29. printf("arm_negate_q15 = %d\r\n", pDst2);
    9 g, N+ J3 @) Y8 C% G
30. 
    % z. s( p4 m4 H& N  v. g
31. pSrc3 += 1;
    . r, z& H7 l; j
32. arm_negate_q7(&pSrc3, &pDst3, 1);
    
33. printf("arm_negate_q7 = %d\r\n", pDst3);
      B3 b' o& V( v) Z* p) p
34. printf("***********************************\r\n");
    + \; E# ?' P1 J1 e/ ^
35. }

复制代码

9.2 偏移（Vector Offset）

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

     pDst[n] = pSrc[n] + offset,   0 <= n < blockSize.

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

9.2.1 arm_offset_f32

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

1. /**        
   
2. * @brief  Adds a constant offset to a floating-point vector.        
   
3. * @param[in]  *pSrc points to the input vector        
   
4. * @param[in]  offset is the offset to be added        
   
5. * @param[out]  *pDst points to the output vector        
   
6. * @param[in]  blockSize number of samples in the vector        
   
7. * @return none.        
   
8. */
   
9. void arm_offset_f32(
   
10.   float32_t * pSrc,
      H1 y+ ]  P  Y
11.   float32_t offset,
    
12.   float32_t * pDst,
    
13.   uint32_t blockSize)
    
14. {
    
15.   uint32_t blkCnt;                               /* loop counter */
    7 b# w9 V: r  n- ?
16. 
    
17. #ifndef ARM_MATH_CM0_FAMILY
    2 u: J( U9 E- R* Z
18. 
    " {4 e8 q3 I! m& Z8 b
19. /* Run the below code for Cortex-M4 and Cortex-M3 */
    % k# [% g. [5 w/ b% ?  B( o+ E
20.   float32_t in1, in2, in3, in4;
    
21. 
    
22.   /*loop Unrolling */
    ! o* ?! T4 o6 R! ]: P9 |/ u: N
23.   blkCnt = blockSize >> 2u;
    1 u/ s# Z2 p- I) F" _- D9 y4 [
24. 
    
25.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
    ) ~4 b8 Y7 d" Y4 H5 F5 N' x
26.    ** a second loop below computes the remaining 1 to 3 samples. */
    
27.   while(blkCnt > 0u)
    
28.   {
    5 \2 p$ j) h# \# X. q6 V
29.     /* C = A + offset */                                                                            (1)
    
30.     /* Add offset and then store the results in the destination buffer. */
    - I; G+ r2 b$ k
31.     /* read samples from source */
    * O7 u0 L/ X' V1 Q- V, _, R
32.     in1 = *pSrc;
    
33.     in2 = *(pSrc + 1);
    # Q7 W0 f# d1 R/ c" {) f. ?- u
34. 
    8 s( z  i$ ]% C
35.     /* add offset to input */
    
36.     in1 = in1 + offset;
    
37. 
    ( t6 C9 e  X/ R$ l8 H# P
38.     /* read samples from source */
    
39.     in3 = *(pSrc + 2);
    
40. 
    + r0 C- F7 t8 u1 z8 [
41.     /* add offset to input */
    . n; l4 B- M4 ?2 o% ]
42.     in2 = in2 + offset;
    
43. 
    . l3 F" H+ S  R; O
44.     /* read samples from source */
    * w7 ?9 g- W' L# V, u: D9 U- C
45.     in4 = *(pSrc + 3);
    
46. 
    1 S0 g+ [( N+ ~  \) T, S# Z
47.     /* add offset to input */
    3 e! W" M3 k$ |+ z( z5 b. T/ F
48.     in3 = in3 + offset;
    : ^0 N4 E* k7 |2 E# x
49. 
    
50.     /* store result to destination */
    8 M' g# u) T3 O6 [, W! q$ q* C  Y
51.     *pDst = in1;
    9 K) J5 I9 u' u# T* w
52. 
    8 i" ^0 l5 J3 \; _$ N# ~# k' ]0 i
53.     /* add offset to input */
    ' v7 [& H; H4 ~! x9 a# ?) \
54.     in4 = in4 + offset;
    " v7 i; y" k9 o
55. 
    ' K, o( a: L, v. s0 h9 w9 s
56.     /* store result to destination */
    + M' H* h: W" q% c
57.     *(pDst + 1) = in2;
    % |* `6 S. E7 t/ K- M
58. 
    
59.     /* store result to destination */
    ; c7 `8 X  v2 S0 O3 {
60.     *(pDst + 2) = in3;
    8 Y# l7 N- G2 A& o; ^; ]$ m$ J
61. 
    ' e1 I7 p3 Z  H/ n) j4 K
62.     /* store result to destination */
    , p- x. l  ]6 j( D
63.     *(pDst + 3) = in4;
    2 P2 D0 F$ o) u8 H  f
64. 
    
65.     /* update pointers to process next samples */
    % Q% K5 P& E) _" j( T1 V
66.     pSrc += 4u;
    
67.     pDst += 4u;
    9 _- I$ c/ M' k0 @) |) R2 S( l
68. 
    
69.     /* Decrement the loop counter */
      C6 m$ Y9 _  h
70.     blkCnt--;
    $ _0 k/ f  S& f: o, Z' a
71.   }
    
72. 
    
73.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
    
74.    ** No loop unrolling is used. */
    " x& C/ w% K+ u0 N# l9 y
75.   blkCnt = blockSize % 0x4u;
    
76. 
    & Q7 N* t% {; W* Y/ ~
77. #else
    
78. 
    
79.   /* Run the below code for Cortex-M0 */
    2 |; K5 b6 q- Q$ g  f
80. 
    
81.   /* Initialize blkCnt with number of samples */
    
82.   blkCnt = blockSize;
    4 i1 E+ _, `& n
83. 
    
84. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
85. 
    ; K5 s! Q: T; `; E! I& _
86.   while(blkCnt > 0u)
    
87.   {
    6 c+ ?  \+ u3 h  L5 C6 ~
88.     /* C = A + offset */
    , O/ t5 ?3 {- V: G$ a
89.     /* Add offset and then store the result in the destination buffer. */
    
90.     *pDst++ = (*pSrc++) + offset;
    1 o& {( i  X. y) B2 q, b- T
91. 
    
92.     /* Decrement the loop counter */
    
93.     blkCnt--;
    
94.   }
    
95. }

复制代码

1. 浮点数的偏移值求解比较简单，加上相应的偏移值并赋值给目标变量即可。

, V6 K( _; p' X" O3 h9.2.2 arm_offset_q31

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

1. /**   
   
2. * @brief  Adds a constant offset to a Q31 vector.   
   
3. * @param[in]  *pSrc points to the input vector   
   
4. * @param[in]  offset is the offset to be added   
   7 z9 ^' p4 e. r7 c5 S5 Q& P( r
5. * @param[out]  *pDst points to the output vector   
   . x- T# \  W. ?+ l- w, R  ~4 L! N. n
6. * @param[in]  blockSize number of samples in the vector   
     t0 U" m0 J+ f* \7 I
7. * @return none.   
   
8. *   
   9 D4 x0 _; s/ g5 W: X0 K0 h. Y. q- U1 |
9. * <b>Scaling and Overflow Behavior:</b>                                                               (1)
   * F0 h! z3 R. ?5 \! S
10. * \par   
    9 b' Q0 b3 w" N& p- n! @" Z
11. * The function uses saturating arithmetic.   
    5 ~9 C+ ^/ t, P, s
12. * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.   
    
13. */
    
14. 
    - N) G3 d6 L& K2 ~! Z1 s; E+ d' W
15. void arm_offset_q31(
    - S, E0 v9 N. v* x* \
16.   q31_t * pSrc,
    ( y/ A+ C% q* l; @, M! _8 o: {# m
17.   q31_t offset,
    ; l$ `* u" w) u  ^& z
18.   q31_t * pDst,
      ^# G& _) R/ l5 I
19.   uint32_t blockSize)
    
20. {
    6 T) c/ z6 c2 }* Y1 |& z
21.   uint32_t blkCnt;                               /* loop counter */
    
22. 
    
23. #ifndef ARM_MATH_CM0_FAMILY
    - `: v8 x1 U' U  o! p9 f' b9 b* A- G
24. 
    $ x/ {" M+ y' |3 L+ ~! s
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
26.   q31_t in1, in2, in3, in4;
    : T2 R9 i$ i, |; B1 e
27. 
    
28. 
    
29.   /*loop Unrolling */
    " J- z9 l* B3 z; ^* B
30.   blkCnt = blockSize >> 2u;
    4 V* G+ C$ V- _( R( d0 D
31. 
    1 i2 H( |, q$ j0 u/ z
32.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    
33.    ** a second loop below computes the remaining 1 to 3 samples. */
    ' p$ G- Q: W: j9 w' O& H
34.   while(blkCnt > 0u)
    $ U0 y/ C5 T: [% d5 r
35.   {
    
36.     /* C = A + offset */
    
37.     /* Add offset and then store the results in the destination buffer. */
    
38.     in1 = *pSrc++;
    
39.     in2 = *pSrc++;
    # Y, @5 c) B5 D! ]1 N
40.     in3 = *pSrc++;
    8 ~4 o: J% q  V  W- R
41.     in4 = *pSrc++;
      U9 J: w5 d1 H  z
42. 
    8 g" t3 W0 M+ g4 `) V
43.     *pDst++ = __QADD(in1, offset);                                                                   (2)
    . c" f  X0 g! W- O
44.     *pDst++ = __QADD(in2, offset);
    # u" u( [# r+ v4 r$ E. [
45.     *pDst++ = __QADD(in3, offset);
    6 |, |6 X5 |; n2 M  T5 m) }
46.     *pDst++ = __QADD(in4, offset);
    : z  J' j6 |4 s( s& u% o$ G+ N
47. 
    4 ?% F3 P+ T; p7 g
48.     /* Decrement the loop counter */
    
49.     blkCnt--;
    
50.   }
    
51. 
    & r* L! P; L/ c0 _
52.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
53.    ** No loop unrolling is used. */
    
54.   blkCnt = blockSize % 0x4u;
    - f' d) F5 Z! C3 e, }3 a- J
55. 
    0 t" O/ Q; w) O/ b
56.   while(blkCnt > 0u)
    * _" F5 w; o  [, z4 K, u1 L
57.   {
    ; T; ?$ X1 A# }0 h
58.     /* C = A + offset */
    
59.     /* Add offset and then store the result in the destination buffer. */
    
60.     *pDst++ = __QADD(*pSrc++, offset);
    1 m. a* A) K% J( c6 ~/ r
61. 
    
62.     /* Decrement the loop counter */
    
63.     blkCnt--;
    " M8 ^7 K3 g5 x5 |) M9 t) v  R9 n
64.   }
    3 v2 n0 t* n/ g2 _7 U/ f3 d
65. 
    2 V3 K( g; v, e& p4 H& s
66. #else
    ( j8 v7 h; u( E- L) G) S, U
67. 
    " Y2 B0 C  K% Y; p9 @" V- h
68.   /* Run the below code for Cortex-M0 */
    0 X5 }( k$ X/ M# V) Q  u3 \
69. 
    
70.   /* Initialize blkCnt with number of samples */
    
71.   blkCnt = blockSize;
    2 s  ?$ V5 ?0 ^1 P3 G( S
72. 
    * W: X/ c1 [' L6 U
73.   while(blkCnt > 0u)
    . N! z: u  C1 x; v# m
74.   {
    " ]% q. t& N/ \) }' C
75.     /* C = A + offset */
    
76.     /* Add offset and then store the result in the destination buffer. */
    : z# Y( T. V' V) `1 E: w' U& ]
77.     *pDst++ = (q31_t) clip_q63_to_q31((q63_t) * pSrc++ + offset);
    
78. 
    
79.     /* Decrement the loop counter */
    
80.     blkCnt--;
    
81.   }
    . \: m- |5 R  @  J9 f% t) @, C
82. 
    
83. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
84. 
    4 `/ p5 S0 m5 P2 [4 h
85. }

复制代码

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

    饱和运算数值0x80000000将变成0x7FFFFFFF。

2. 指令__QADD我们在上章教程中已经讲解过，这里是实现两个参数相加。

9.2.3 arm_offset_q15

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

1. /**   
   
2. * @brief  Adds a constant offset to a Q15 vector.   
   
3. * @param[in]  *pSrc points to the input vector   
   
4. * @param[in]  offset is the offset to be added   
   . `" @- t  n1 d
5. * @param[out]  *pDst points to the output vector   
   
6. * @param[in]  blockSize number of samples in the vector   
   2 V, R. J) H( G' ]8 ?
7. * @return none.   
   ( O/ d# y  W* b0 W6 {
8. *   
   5 W/ ?3 I, q- ^  Z. N
9. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
   3 U9 A+ A* Z* U8 ?7 o
10. * \par   
    
11. * The function uses saturating arithmetic.   
    
12. * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.   
    ' t; \& h& V1 N# }3 M: r
13. */
    ) j4 M8 {) [+ g. r
14. 
    
15. void arm_offset_q15(
    
16.   q15_t * pSrc,
    % p$ b3 o/ D- x" J) N0 W
17.   q15_t offset,
    
18.   q15_t * pDst,
    
19.   uint32_t blockSize)
    
20. {
    
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 */
    ' q, z1 [! v7 f
26.   q31_t offset_packed;                           /* Offset packed to 32 bit */
    
27. 
    
28. 
    ) \+ j" ^( {2 e" N! V3 \/ V
29.   /*loop Unrolling */
    
30.   blkCnt = blockSize >> 2u;
    
31. 
    
32.   /* Offset is packed to 32 bit in order to use SIMD32 for addition */
    , e: u- w% P* T, Z2 l# M* K
33.   offset_packed = __PKHBT(offset, offset, 16);                                                       (2)
    
34. 
    9 \% Y0 x8 N; r0 F" C. q) Y. A
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. */
    # e& J. d" G2 O4 [
37.   while(blkCnt > 0u)
    / ~% i, S" s4 s# _* o
38.   {
      m9 q: a8 r9 H+ T( `7 `, d+ Q
39.     /* C = A + offset */
    
40.     /* Add offset and then store the results in the destination buffer, 2 samples at a time. */
    - p. ?( p! k5 |' R
41.     *__SIMD32(pDst)++ = __QADD16(*__SIMD32(pSrc)++, offset_packed);                                  (3)
    
42.     *__SIMD32(pDst)++ = __QADD16(*__SIMD32(pSrc)++, offset_packed);
    " k( \- Y( z; B. x5 P$ ?5 u
43. 
    8 |7 L' Q; X- u6 C
44.     /* Decrement the loop counter */
    
45.     blkCnt--;
    
46.   }
    
47. 
    / x, o9 H( L4 n0 }' U5 b; |
48.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    ( k. i& u. k1 ^
49.    ** No loop unrolling is used. */
    
50.   blkCnt = blockSize % 0x4u;
    ! l& Q) S+ s8 X' Z' i  p8 Q; f5 U
51. 
    8 ]  V& F1 ?, ~
52.   while(blkCnt > 0u)
    
53.   {
    
54.     /* C = A + offset */
    
55.     /* Add offset and then store the results in the destination buffer. */
    ! U1 ]7 @7 z! _- X
56.     *pDst++ = (q15_t) __QADD16(*pSrc++, offset);
    
57. 
    5 J7 m1 F* H% l- y. P$ d0 t  k
58.     /* Decrement the loop counter */
    
59.     blkCnt--;
    
60.   }
    ; }3 Y' i; n7 t( q2 z
61. 
    
62. #else
    
63. 
      W) j3 a4 m# G: I  c7 Y6 z
64.   /* Run the below code for Cortex-M0 */
    
65. 
    ) ~4 Z; a7 D) E( Z
66.   /* Initialize blkCnt with number of samples */
    
67.   blkCnt = blockSize;
    - j6 _: V% m& ^9 ?3 G) E- l$ c2 f
68. 
    
69.   while(blkCnt > 0u)
      z0 t. Q/ E  Q* Y
70.   {
    
71.     /* C = A + offset */
    7 O" L/ y8 Z! c, T8 ?. u3 y( o. E
72.     /* Add offset and then store the results in the destination buffer. */
    ) E# A! |& `6 e4 K
73.     *pDst++ = (q15_t) __SSAT(((q31_t) * pSrc++ + offset), 16);
    
74. 
    ' Q! t4 ?" t, y/ N1 c$ A; H9 _
75.     /* Decrement the loop counter */
    
76.     blkCnt--;
    
77.   }
    1 C4 }9 x4 h: ]* F% d( V/ v
78. 
    
79. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    0 _. \+ b( v) e$ v/ T1 ]/ O
80. 
    3 [9 N* J! e; Y
81. }

复制代码

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

    饱和运算数值0x8000将变成0x7FFF。

2. 将两个Q15格式的变量合并成一个Q31格式的数据，方便指令__QADD16的调用。

3. 由于__QADD16是SIMD指令，这里调用一次就能实现两个Q15格式数据的计算。

9.2.4 arm_offset_q7

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

1. /**   
   
2. * @brief  Adds a constant offset to a Q7 vector.   
   3 H& @' |! ]) [2 T( k& S6 h
3. * @param[in]  *pSrc points to the input vector   
   
4. * @param[in]  offset is the offset to be added   
   : x% `& Y& ^, V/ T) f7 e2 n/ |
5. * @param[out]  *pDst points to the output vector   
   ! Y2 X7 ], F3 \$ |
6. * @param[in]  blockSize number of samples in the vector   
   
7. * @return none.   
   * y" {4 }& W& j5 ]5 m5 C2 t
8. *   
   
9. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
   ! X! b3 `9 v. F. k& h0 w
10. * \par   
    & H1 J$ B1 P5 j$ \, u
11. * The function uses saturating arithmetic.   
    + l9 h8 a( h* _7 Q$ i' x1 }9 Z
12. * Results outside of the allowable Q7 range [0x80 0x7F] are saturated.   
    
13. */
    4 Z1 w8 F7 Q# N3 p0 z. v7 I
14. 
    
15. void arm_offset_q7(
    7 {- c4 T7 P* ~. t! s$ |# o  D
16.   q7_t * pSrc,
    6 U; G  k2 u# j) ]  y
17.   q7_t offset,
    
18.   q7_t * pDst,
    
19.   uint32_t blockSize)
    
20. {
    0 @+ E( c6 X+ m* l7 G- W; I
21.   uint32_t blkCnt;                               /* loop counter */
    4 T: C" f( d; w1 D9 N6 m
22. 
    6 M* n- M1 G1 X
23. #ifndef ARM_MATH_CM0_FAMILY
    
24. 
    
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
26.   q31_t offset_packed;                           /* Offset packed to 32 bit */
    / M4 E% ?  e# t  A8 A* ^- \
27. 
    
28. 
    
29.   /*loop Unrolling */
    
30.   blkCnt = blockSize >> 2u;
    
31. 
    ! p  c# h( j/ k  D5 h2 w% z
32.   /* Offset is packed to 32 bit in order to use SIMD32 for addition */                               (2)
    
33.   offset_packed = __PACKq7(offset, offset, offset, offset);
    
34. 
    
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. */
    * J( Q$ i2 f- V4 a8 E+ e0 v7 d0 r
37.   while(blkCnt > 0u)
    
38.   {
    
39.     /* C = A + offset */
    8 P% Q2 ?$ Z  _; P) t5 u+ }5 `
40.     /* Add offset and then store the results in the destination bufferfor 4 samples at a time. */
    
41.     *__SIMD32(pDst)++ = __QADD8(*__SIMD32(pSrc)++, offset_packed);                                   (3)
    ) ~  ^" C3 E7 J" \
42. 
    
43.     /* Decrement the loop counter */
    * z* Z: C- H* N2 j
44.     blkCnt--;
    8 S! Z) q+ ?  ^8 ?& e# ^
45.   }
    
46. 
    
47.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    8 H" f3 P$ c, `7 h- Q
48.    ** No loop unrolling is used. */
    
49.   blkCnt = blockSize % 0x4u;
    
50. 
    9 v/ v  l" X9 \2 U) ]2 t
51.   while(blkCnt > 0u)
    + {+ C0 ^5 o: |* v, N
52.   {
    % d) Q( ~5 V; r! X* Z, U
53.     /* C = A + offset */
    . C, C$ R7 |( S5 H, {, Z& @6 z! v9 @& o
54.     /* Add offset and then store the result in the destination buffer. */
    " J* V6 L2 f+ k' C8 Y$ u
55.     *pDst++ = (q7_t) __SSAT(*pSrc++ + offset, 8);
    
56. 
    - g. L/ u) l) |
57.     /* Decrement the loop counter */
    
58.     blkCnt--;
    8 L9 F1 i  ]3 M! C0 y. L
59.   }
    4 \, p3 t! ]% U% `7 }! t
60. 
    
61. #else
    
62. 
    # z! [7 @; L& m: u2 G3 b1 A
63.   /* Run the below code for Cortex-M0 */
    
64. 
    
65.   /* Initialize blkCnt with number of samples */
    
66.   blkCnt = blockSize;
    
67. 
    
68.   while(blkCnt > 0u)
    ) s! W; d, l3 H7 E4 J
69.   {
    ! n& e: l4 K' C
70.     /* C = A + offset */
    
71.     /* Add offset and then store the result in the destination buffer. */
    + h7 h3 P, J7 i9 D, R+ I
72.     *pDst++ = (q7_t) __SSAT((q15_t) * pSrc++ + offset, 8);
    
73. 
    
74.     /* Decrement the loop counter */
    ! Z. p% X3 w9 W9 r# U1 _1 ^& L
75.     blkCnt--;
    
76.   }
    . C$ A3 K% J$ m  @: d
77. 
    
78. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
79. 
    8 A' l% b+ V+ x$ O$ U. t
80. }

复制代码

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

    饱和运算数值0x80将变成0x7F。

2. 通过__PACKq7将4个Q7格式的数据合并成一个Q31格式的数据。

3. 由于__QADD8是SIMD指令，这里调用一次就能实现四个Q8格式数据的计算。

9.2.5 实例讲解

实验目的：

    1. 四种类型数据的相反数。

实验内容：

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

实验现象：

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

程序设计：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: DSP_Offset
     Z5 o) z9 D# v- i! n
4. *        功能说明: 偏移
   : V  M* X  q0 y: K( s
5. *        形    参：无
   2 b3 Z  C5 u  S4 O
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void DSP_Offset(void)
   
10. {
    
11. static float32_t   pSrcA;
    ) f' r) y& s  c+ F2 h7 S
12. static float32_t   Offset = 0.0f;  
    : \* c/ T, [* w) ~* L0 H
13. static float32_t   pDst;  
    ! U, q7 I: U6 D* E- A9 V
14. static q31_t  pSrcA1;  
    
15. static q31_t  Offset1 = 0;  
    
16. static q31_t  pDst1;  
    
17. 
    
18. static q15_t  pSrcA2;  
    
19. static q15_t  Offset2 = 0;  
    ! ^" X' K, h: g2 P2 k
20. static q15_t  pDst2;
    
21. 
    
22. static q7_t  pSrcA3;
    
23. static q7_t  Offset3 = 0;  
    & V3 \% h8 j& @; O, Q0 _
24. static q7_t  pDst3;  
    
25. 
      m' @+ O" D) c) ^. E$ Q/ z" V2 e
26. Offset--;
    7 J) |  n& A% ?* h  D
27. arm_offset_f32(&pSrcA, Offset, &pDst, 1);
    
28. printf("arm_add_f32 = %f\r\n", pDst);
    3 Z) ]' X1 x; f
29. 
    
30. Offset1--;
    
31. arm_offset_q31(&pSrcA1, Offset1, &pDst1, 1);
    ) e3 I7 S8 N6 o5 i$ H3 ^! H
32. printf("arm_add_q31 = %d\r\n", pDst1);
    - o! D" T7 ?# {& r7 p
33. 
    ! W4 G, \7 P, N( q. p$ Z! }6 Q3 c
34. Offset2--;
    
35. arm_offset_q15(&pSrcA2, Offset2, &pDst2, 1);
    
36. printf("arm_add_q15 = %d\r\n", pDst2);
    3 w5 e7 P7 S; r& H6 x0 [
37. 
    - j. s4 k3 U$ l
38. Offset3--;
    
39. arm_offset_q7(&pSrcA3, Offset3, &pDst3, 1);
    $ C" z* L1 A. F( U6 B
40. printf("arm_add_q7 = %d\r\n", pDst3);
    
41. printf("***********************************\r\n");
    % c9 N. p7 Q2 L
42. }

复制代码

9.3 位移（Vector Shift）

    这部分函数主要用于实现位移，公式描述如下：

    pDst[n] = pSrc[n] << shift,   0 <= n < blockSize.  

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

9.3.1 arm_shift_q31

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

1. /**        
   
2. * @brief  Shifts the elements of a Q31 vector a specified number of bits.        
   . _) M+ ^  Z! y- s9 ~
3. * @param[in]  *pSrc points to the input vector        
   
4. * @param[in]  shiftBits number of bits to shift.  
   
5. *              A positive value shifts left; a negative value shifts right.                           (1)
   # |( t' P& q- K2 ~) s
6. * @param[out]  *pDst points to the output vector        
   5 b5 v8 P# E# Q, @8 R# B
7. * @param[in]  blockSize number of samples in the vector        
   
8. * @return none.        
   % O/ `6 Y( t" H
9. *        
   
10. *        
    2 q9 ~. }; K: f! c& X
11. * <b>Scaling and Overflow Behavior:</b>                                                              (2)
    0 \; K. K5 t; e8 E4 P5 k0 ~2 K
12. * \par        
    
13. * The function uses saturating arithmetic.        
    + n/ @9 a: z! ]
14. * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] will be saturated.        
    % c* K2 E% d3 U1 i) ?5 E' H$ h4 p
15. */
    ( U; F, P& M% J% f/ Q% K! A
16. 
    
17. void arm_shift_q31(
    
18.   q31_t * pSrc,
    % m3 Z& V+ J9 ]1 f  q% |
19.   int8_t shiftBits,
    2 ^* ?  N) S. m" t
20.   q31_t * pDst,
    1 g* Q2 E8 i8 k+ a' x
21.   uint32_t blockSize)
    
22. {
    0 }- {- z$ o2 ~/ o3 {
23.   uint32_t blkCnt;                               /* loop counter */
    
24.   uint8_t sign = (shiftBits & 0x80);             /* Sign of shiftBits */                              (3)
    4 ?1 m8 P2 N2 N& V- }6 q) F9 {
25. 
    / V' o2 p. J' ~: @% p2 X! V* d
26. #ifndef ARM_MATH_CM0_FAMILY
    
27. 
    " D, `, y0 _) F" a$ g
28.   q31_t in1, in2, in3, in4;                      /* Temporary input variables */
    , i* K( ?% H' }% a3 Z
29.   q31_t out1, out2, out3, out4;                  /* Temporary output variables */
    
30. 
    
31.   /*loop Unrolling */
    4 x* @8 |* b& J- a" J& G8 Y
32.   blkCnt = blockSize >> 2u;
    
33. 
    
34. 
    5 t" E+ e+ p/ y
35.   if(sign == 0u)                                                                                     (4)
    
36.   {
    
37.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    7 ~3 o* @( c/ [! v. L+ n6 b  ]
38.      ** a second loop below computes the remaining 1 to 3 samples. */
    
39.     while(blkCnt > 0u)
    . d7 w8 b8 G6 l# t* h
40.     {
    
41.       /* C = A  << shiftBits */
    
42.       /* Shift the input and then store the results in the destination buffer. */
    / E4 i$ Q7 ?: F! T6 k+ f7 H  X0 R
43.       in1 = *pSrc;
    
44.       in2 = *(pSrc + 1);
    ( a9 A4 \: q: _- _& `
45.       out1 = in1 << shiftBits;
    ( a; x+ J) I' S; n) @
46.       in3 = *(pSrc + 2);
    ' |9 A2 D+ g4 ~8 h! o6 _& G
47.       out2 = in2 << shiftBits;
    $ W' ]$ o% j+ P1 T" v0 d6 ?8 B; g9 ?
48.       in4 = *(pSrc + 3);
    
49.       if(in1 != (out1 >> shiftBits))                                                                (5)
    0 O; |( x# M# s9 k) }+ R1 Q
50.         out1 = 0x7FFFFFFF ^ (in1 >> 31);
    ) Z5 r" _$ b9 K/ n- l- u2 ^9 x" D4 S
51. 
    
52.       if(in2 != (out2 >> shiftBits))
    
53.         out2 = 0x7FFFFFFF ^ (in2 >> 31);
    
54. 
    $ u/ s. G5 r+ Z- v5 G
55.       *pDst = out1;
    & Y( ^- N7 ]; h; T6 Y
56.       out3 = in3 << shiftBits;
    
57.       *(pDst + 1) = out2;
    
58.       out4 = in4 << shiftBits;
    7 F- n3 K0 F( [( R; D
59. 
    
60.       if(in3 != (out3 >> shiftBits))
    . s( S6 C6 d4 m
61.         out3 = 0x7FFFFFFF ^ (in3 >> 31);
    - ^, F1 s' q. p. R( K
62. 
    
63.       if(in4 != (out4 >> shiftBits))
    ; F6 Y1 U' T& Z; q$ c0 d4 K0 a& q
64.         out4 = 0x7FFFFFFF ^ (in4 >> 31);
    0 B; b* j# F8 e7 [
65. 
    , ?, z2 E$ G$ G) u4 Q
66.       *(pDst + 2) = out3;
    
67.       *(pDst + 3) = out4;
    4 J0 Y% t  A3 \) v
68. 
    & N0 p& a1 Z  ^, d/ F3 S" T$ v5 |' U
69.       /* Update destination pointer to process next sampels */
    . n' e2 I! f9 |" Z: f6 {
70.       pSrc += 4u;
    6 _9 Y* ]/ `8 T0 P  _
71.       pDst += 4u;
    ! p& E6 D! C1 V
72. 
    
73.       /* Decrement the loop counter */
    
74.       blkCnt--;
    ! b3 n- b6 ~! e% s+ a" O* s
75.     }
    ) E3 S0 m( c" ^1 u' Y! a
76.   }
    ( A1 R4 E  s9 p
77.   else                                                                                              (6)
    
78.   {
    
79. 
    
80.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    5 z# s8 O( U0 s( S
81.      ** a second loop below computes the remaining 1 to 3 samples. */
    
82.     while(blkCnt > 0u)
    9 j1 c' a% Z$ K. G( O
83.     {
    & V2 c- E2 a8 o3 T: s5 F) f# k
84.       /* C = A >>  shiftBits */
    
85.       /* Shift the input and then store the results in the destination buffer. */
    
86.       in1 = *pSrc;
    
87.       in2 = *(pSrc + 1);
    
88.       in3 = *(pSrc + 2);
    + E5 L$ \! Z+ G9 c
89.       in4 = *(pSrc + 3);
    - U3 L# [; [; F. H6 _4 D! O1 a* q4 t
90. 
    
91.       *pDst = (in1 >> -shiftBits);                                                                  (7)
    
92.       *(pDst + 1) = (in2 >> -shiftBits);
    
93.       *(pDst + 2) = (in3 >> -shiftBits);
    . B; }& |$ S) z- a  V; a  J
94.       *(pDst + 3) = (in4 >> -shiftBits);
    
95. 
    + ?9 l: {# F9 C" k5 X0 _2 M; Y
96. 
    
97.       pSrc += 4u;
    
98.       pDst += 4u;
    
99. 
    & T; a3 h, a" Y7 n
100.       blkCnt--;
     
101.     }
     
102. 
     
103.   }
     
104. 
     + r7 P7 k- u& ?+ f% b
105.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
     $ a+ i( ?, ^4 r! _* B! m" A0 M& u
106.    ** No loop unrolling is used. */
     + G- b. v3 k( O) n4 Y$ Q
107.   blkCnt = blockSize % 0x4u;
     
108. 
     1 U* v5 i4 T) z& y0 E
109. #else
     & {" [1 Q! q$ a7 B* u
110. 
     ) d; O$ x; Y& I# \0 J9 N% H. k; E# e3 w
111.   /* Run the below code for Cortex-M0 */
     
112. 
     
113. 
     
114.   /* Initialize blkCnt with number of samples */
     
115.   blkCnt = blockSize;
     
116. 
     2 {9 C- ~0 T0 h" d4 L
117. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
     5 c. L: F: u; Z' x8 z
118. 
     
119. 
     
120.   while(blkCnt > 0u)
     ! D* y& z0 Y3 I' _5 U" c* v
121.   {
     
122.     /* C = A (>> or <<) shiftBits */
     + i* i- W. c% f
123.     /* Shift the input and then store the result in the destination buffer. */                       (8)
     $ J/ f, Y/ `6 G2 Q# y
124.     *pDst++ = (sign == 0u) ? clip_q63_to_q31((q63_t) * pSrc++ << shiftBits) :
     
125.       (*pSrc++ >> -shiftBits);
     . ?; K* p2 j' \1 U: H  R/ u3 H
126. 
     / o8 Z+ Q& C7 Y) w8 g' j" M/ w9 r
127.     /* Decrement the loop counter */
     
128.     blkCnt--;
     3 J8 P' K. z+ G" V8 \
129.   }
     % j  X9 m  }  z$ e$ `5 U
130. 
     + l2 I- I& E) h8 K2 Z+ y
131. 
     " E6 m# t* }5 T1 R( G
132. }

复制代码

1. 如果函数的参数shiftBits是正数那么表示左移，如果参数shiftBits是负数那么就是右移。

2. 这个函数使用了饱和运算。

    饱和运算数值0x80000000将变成0x7FFFFFFF。

3. 获取偏移值shiftBits是正数还是负数。

4. 如果移位值是正数，那么就是左移。

5. 数值的左移仅支持将其左移后再右移相应的位数后数值不变的情况，如果不满足这个条件，那么输出结果只有两种结果（这里就是实现输出结果的饱和运算）。

    out = 0x7FFFFFFF & 0xFFFFFFFF =0x80000000

    out = 0x7FFFFFFF & 0x0000000 =0x7FFFFFFF

6. 如果移位值是负数，那么就是右移。

7. 将偏移值取反然后左移即可。

8. 用于实现剩余数值偏移的计算。

4 `  F' ]2 W1 _' w9.3.2 arm_shift_q15

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

1. /**   
   8 V' ^# b6 y) i9 e/ c5 |! H
2. * @brief  Shifts the elements of a Q15 vector a specified number of bits.   
   ( Y- y% d9 p) {; E
3. * @param[in]  *pSrc points to the input vector   
   
4. * @param[in]  shiftBits number of bits to shift.  
   
5. *            A positive value shifts left; a negative value shifts right.                           (1)
   7 x4 K6 h. T: ]6 w
6. * @param[out]  *pDst points to the output vector   
   0 K- g8 ~0 i: \# N
7. * @param[in]  blockSize number of samples in the vector   
   ( R5 A- L7 g- ~4 S' J' Z4 J
8. * @return none.   
   
9. *   
     r& n/ s( x  ~$ ]# c
10. * <b>Scaling and Overflow Behavior:</b>                                                             (2)
    
11. * \par   
    
12. * The function uses saturating arithmetic.   
      ^# f, d8 {! f0 G7 q
13. * Results outside of the allowable Q15 range [0x8000 0x7FFF] will be saturated.   
    $ t- F( r, y; W4 `4 G5 [  K
14. */
    
15. 
    
16. void arm_shift_q15(
    
17.   q15_t * pSrc,
    
18.   int8_t shiftBits,
    
19.   q15_t * pDst,
    ( D6 W& }- z; e' F# V- D' D. V3 @
20.   uint32_t blockSize)
    
21. {
    + x  V7 w  [) Q
22.   uint32_t blkCnt;                               /* loop counter */
    
23.   uint8_t sign;                                  /* Sign of shiftBits */
    # M& J; C) W& G- b: r
24. 
    ) l' a6 C/ a9 g/ a. T( r, r3 \% D; F
25. #ifndef ARM_MATH_CM0_FAMILY
    
26. 
    
27. /* Run the below code for Cortex-M4 and Cortex-M3 */
    9 D# m) Y  {& O
28. 
    
29.   q15_t in1, in2;                                /* Temporary variables */
    & X. |' |9 H# ]
30. 
    # b& F. o, v8 k2 ]* f* h% G
31. 
    
32.   /*loop Unrolling */
    
33.   blkCnt = blockSize >> 2u;
    
34. 
    
35.   /* Getting the sign of shiftBits */
    % \" L/ c- z  z5 A
36.   sign = (shiftBits & 0x80);                                                                        (3)
    
37. 
    
38.   /* If the shift value is positive then do right shift else left shift */
    " |2 @0 a- c4 f
39.   if(sign == 0u)
    1 c' e% M4 T% y& k- E
40.   {
    * S9 }8 x1 V3 }1 {  s; C5 p; u
41.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    
42.      ** a second loop below computes the remaining 1 to 3 samples. */
    ) G  e. J7 f9 V) Z, s! L( ~* d+ X$ _9 w
43.     while(blkCnt > 0u)
    7 T/ R* r: r' j# Y' r8 r
44.     {
    
45.       /* Read 2 inputs */
    2 j: f2 _4 G$ z
46.       in1 = *pSrc++;
    ; l0 e! a* C( L% b0 p9 L" d( I
47.       in2 = *pSrc++;
    ! }) S6 o  J) ^5 @2 b# m5 w
48.       /* C = A << shiftBits */
    9 y* B$ H% i, N: h- T1 G2 A
49.       /* Shift the inputs and then store the results in the destination buffer. */
    " M( I. O, ]3 j: k
50. #ifndef  ARM_MATH_BIG_ENDIAN
    
51. 
    
52.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in1 << shiftBits), 16),
    : H' v: j0 _8 ?6 B# H( T$ \5 ?7 y
53.                                   __SSAT((in2 << shiftBits), 16), 16);
    
54. 
    
55. #else
    
56. 
    
57.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in2 << shiftBits), 16),                                   (4)
    
58.                                   __SSAT((in1 << shiftBits), 16), 16);
    
59. 
    
60. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
    
61. 
    
62.       in1 = *pSrc++;
    0 {& ]/ l5 S2 q/ {
63.       in2 = *pSrc++;
    " {- Y* K. i3 Y0 y. C' N$ D( T  c
64. 
    
65. #ifndef  ARM_MATH_BIG_ENDIAN
    
66. 
    ' a8 u$ w( ]6 n* K) A
67.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in1 << shiftBits), 16),
    
68.                                   __SSAT((in2 << shiftBits), 16), 16);
    5 F3 q0 ^' E7 D  V& v$ Q8 X* z7 R
69. 
    3 u8 ^) C) z# j' I/ n5 @: g' w
70. #else
    
71. 
    
72.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in2 << shiftBits), 16),                                 
    
73.                                   __SSAT((in1 << shiftBits), 16), 16);
    
74. 
    # @2 [8 M: |+ M. j
75. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
    5 w# ]8 I3 U! ]! p
76. 
    
77.       /* Decrement the loop counter */
    
78.       blkCnt--;
    
79.     }
    8 y! i% T; v6 p  A' A4 t: K
80. 
    
81.     /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
82.      ** No loop unrolling is used. */
    2 R+ s; \0 _7 o  @( J  u
83.     blkCnt = blockSize % 0x4u;
    
84. 
    
85.     while(blkCnt > 0u)
    1 ~* A8 W( F  \3 x+ v+ b
86.     {
    
87.       /* C = A << shiftBits */
    
88.       /* Shift and then store the results in the destination buffer. */
    
89.       *pDst++ = __SSAT((*pSrc++ << shiftBits), 16);                                                 (5)
    1 T6 W7 o7 U6 [  E% K( B+ O
90. 
    
91.       /* Decrement the loop counter */
    
92.       blkCnt--;
    
93.     }
    + P7 t- S) D% T/ ]
94.   }
    
95.   else                                                                                              (6)
    
96.   {
    1 c  O9 t2 @1 X+ h8 Y. u
97.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
    / c5 w% b- ?- g0 ?' j3 }* @% @) r
98.      ** a second loop below computes the remaining 1 to 3 samples. */
    & O' y+ B9 d1 T$ e1 T
99.     while(blkCnt > 0u)
    : L; [. _& W" W( h. \6 N$ F
100.     {
     5 p3 |1 Q: O0 Q- K# {/ g0 P
101.       /* Read 2 inputs */
     1 X  n8 a! p, _  i; u. X
102.       in1 = *pSrc++;
     
103.       in2 = *pSrc++;
     
104. 
     
105.       /* C = A >> shiftBits */
     
106.       /* Shift the inputs and then store the results in the destination buffer. */
     
107. #ifndef  ARM_MATH_BIG_ENDIAN
     
108. 
     : j. l7 d  N& X' n
109.       *__SIMD32(pDst)++ = __PKHBT((in1 >> -shiftBits),
     
110.                                   (in2 >> -shiftBits), 16);
     
111. 
     ( F8 _6 Y3 @7 |5 ~0 C! I( J
112. #else
     
113. 
     6 c/ ?# E0 u1 L
114.       *__SIMD32(pDst)++ = __PKHBT((in2 >> -shiftBits),                                              (7)
     
115.                                   (in1 >> -shiftBits), 16);
     / I9 S, d/ o8 q' o4 X0 `8 K
116. 
     
117. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
     
118. 
     
119.       in1 = *pSrc++;
     
120.       in2 = *pSrc++;
     ; F$ q; x+ ]& T" \" Y8 u
121. 
     % a2 @; J; c5 Y% X/ c7 O% M* W
122. #ifndef  ARM_MATH_BIG_ENDIAN
     
123. 
     
124.       *__SIMD32(pDst)++ = __PKHBT((in1 >> -shiftBits),
     7 J* V6 E' Z( l" s8 I( ?; z4 X
125.                                   (in2 >> -shiftBits), 16);
     
126. 
     
127. #else
     
128. 
     3 T4 l1 U# ]* z. `, y% _; R$ T
129.       *__SIMD32(pDst)++ = __PKHBT((in2 >> -shiftBits),                                             
     
130.                                   (in1 >> -shiftBits), 16);
     9 m" s  Y1 l+ k5 C) I
131. 
     
132. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
     
133. 
     
134.       /* Decrement the loop counter */
     4 a3 M2 h) N) V; }7 D4 P4 h
135.       blkCnt--;
     # j$ T; T6 O1 G5 o# D3 i
136.     }
     
137. 
     2 a& M  I% F- |* t) [
138.     /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
     ' f, {8 E1 `2 g; h8 Q
139.      ** No loop unrolling is used. */
     * x, K- H8 r1 Y1 r& o
140.     blkCnt = blockSize % 0x4u;
     ) v" q( W- u2 W. c# Q9 y
141. 
     % r' C6 X: B% Y/ W( n
142.     while(blkCnt > 0u)
     
143.     {
     5 i: g; ~. w' t- }' x' M
144.       /* C = A >> shiftBits */
     # J6 P/ ?3 r/ `! h+ p% H  _% O
145.       /* Shift the inputs and then store the results in the destination buffer. */
     ' b- C7 i' z) o& U
146.       *pDst++ = (*pSrc++ >> -shiftBits);
     ! ^* Y1 K1 U) R3 W1 ]
147. 
     
148.       /* Decrement the loop counter */
     * X$ D8 v4 ~- w+ }, l/ D
149.       blkCnt--;
     0 U  ^+ S& s/ `, p  z6 C. Y
150.     }
     * U+ h  ]- u4 @* N4 q. f/ _
151.   }
     # i( B% B6 M) W1 \
152. 
     
153. #else
     , ]# U- }+ |7 {. ?% E2 w
154. 
     8 x* u* b! V2 \; k8 E8 p- `
155.   /* Run the below code for Cortex-M0 */
     
156. 
     " K/ U* w' a) @9 ?( V0 C
157.   /* Getting the sign of shiftBits */
     * J* a) S7 ^7 f# W" p# L  Y9 {
158.   sign = (shiftBits & 0x80);
     0 {5 a# j. u/ g7 w, G
159. 
     
160.   /* If the shift value is positive then do right shift else left shift */
     
161.   if(sign == 0u)
     
162.   {
     ; F& u6 A* n  c$ b9 Y) ]" a
163.     /* Initialize blkCnt with number of samples */
     " A! b6 P& q0 ?# W; `
164.     blkCnt = blockSize;
     
165. 
     
166.     while(blkCnt > 0u)
     
167.     {
     
168.       /* C = A << shiftBits */
     2 z, A6 F1 y" L, l
169.       /* Shift and then store the results in the destination buffer. */
     
170.       *pDst++ = __SSAT(((q31_t) * pSrc++ << shiftBits), 16);
     
171. 
     & Z3 ]# t( l% I9 M: I0 `4 O9 i* l) N5 n+ r
172.       /* Decrement the loop counter */
     # w  ?% u* u: {; h- M' I. j7 r
173.       blkCnt--;
     . s* D0 p8 X4 ~! k' E
174.     }
     
175.   }
     ) J9 y, M$ Y" O0 g
176.   else
     $ t7 z. U3 U. c( i% {  e0 H
177.   {
     
178.     /* Initialize blkCnt with number of samples */
     
179.     blkCnt = blockSize;
     " j5 Z+ ]' N6 r/ H/ N/ q! A5 _
180. 
     
181.     while(blkCnt > 0u)
     
182.     {
     6 l+ P' H! C  L2 G  m$ E( ?
183.       /* C = A >> shiftBits */
     
184.       /* Shift the inputs and then store the results in the destination buffer. */
     
185.       *pDst++ = (*pSrc++ >> -shiftBits);
     
186. 
     1 n7 w1 H! _. p1 v( E
187.       /* Decrement the loop counter */
     - E/ b1 `9 c) W: C
188.       blkCnt--;
     + \) f8 j9 g$ x7 v* x2 Y! T" L
189.     }
     " p5 |( D" g' l( B. S" E! M' W* {
190.   }
     6 |% X/ e% W/ \. a: b. b0 B
191. 
     
192. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
     
193. 
     : J) Q; w  N2 n8 j6 K0 c
194. }

复制代码

1. 如果函数的参数shiftBits是正数那么表示左移，如果参数shiftBits是负数那么就是右移。

2. 这个函数使用了饱和运算。

    饱和运算数值0x8000将变成0x7FFF。

3. 获取偏移值是正数还是负数。

4. 通过调用一次__PKHBT实现两个Q15格式数据的计算。

5. 剩余几个数值的计算。

6. 如果位移值为负数，那么就是右移。

7. 将位移值取反以后，通过调用一次__PKHBT实现两个Q15格式数据的计算。

9.3.3 arm_shift_q7

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

1. /**
   * c4 o5 l$ S! j
2. * @brief Shifts the elements of a Q7 vector a specified number of bits.
   , C, l; z7 \. H3 K5 j
3. * @param[in] *pSrc points to the input vector
   
4. * @param[in] shiftBits number of bits to shift.
   
5. * A positive value shifts left; a negative value shifts right. (1)
   8 g3 Q) _+ F0 M4 _
6. * @param[out] *pDst points to the output vector
   
7. * @param[in] blockSize number of samples in the vector
   
8. * @return none.
   
9. *
   
10. * \par Conditions for optimum performance
    
11. * Input and output buffers should be aligned by 32-bit
    : r) p) L' I0 n; o: S5 y, q2 E
12. *
    
13. *
    
14. * <b>Scaling and Overflow Behavior:</b> (2)
    9 x  r) {9 t9 J, L9 H& U9 A0 ~
15. * \par
    
16. * The function uses saturating arithmetic.
      U' ]% f5 w& v4 A) C
17. * Results outside of the allowable Q7 range [0x8 0x7F] will be saturated.
    
18. */
    
19. 
    
20. void arm_shift_q7(
    , W; s7 |( C1 `+ c- e
21. q7_t * pSrc,
    
22. int8_t shiftBits,
    8 I' N( I) l4 Y) D4 `
23. q7_t * pDst,
    - W/ {% Q( N" [0 s; H# m
24. uint32_t blockSize)
    1 Y$ l# T& w8 Z$ }2 W
25. {
    1 N, v* q' O5 k7 e9 e% X6 h: P
26. uint32_t blkCnt; /* loop counter */
    ! }% i% p7 V! i; @2 J( P
27. uint8_t sign; /* Sign of shiftBits */
    
28. 
    , H/ d5 V+ l, b: D! B, W  V8 e( C
29. #ifndef ARM_MATH_CM0_FAMILY
    
30. 
    - |# s3 |; J7 n1 M, x
31. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
32. q7_t in1; /* Input value1 */
    
33. q7_t in2; /* Input value2 */
    
34. q7_t in3; /* Input value3 */
    
35. q7_t in4; /* Input value4 */
    4 I; J+ F4 C5 X( P
36. 
    
37. 
    
38. /*loop Unrolling */
    * ]* V2 p3 ?; d6 C5 n- }' p2 Q
39. blkCnt = blockSize >> 2u;
    
40. 
    
41. /* Getting the sign of shiftBits */
    
42. sign = (shiftBits & 0x80); (3)
    
43. 
    $ o6 M& ?! g& c! k8 m
44. /* If the shift value is positive then do right shift else left shift */
    / O0 P: B4 l& A; g5 \# i2 X0 \
45. if(sign == 0u)
    - D% @, h3 [* i1 R  [; e+ O: q
46. {
    
47. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
    4 A/ k. S, u) E' A, T# p
48. ** a second loop below computes the remaining 1 to 3 samples. */
    
49. while(blkCnt > 0u)
    
50. {
    ( R( Y, H0 U+ C+ _% G. }  i
51. /* C = A << shiftBits */
    
52. /* Read 4 inputs */
    " p8 B7 [4 ^2 u3 P$ W4 @2 t- k
53. in1 = *pSrc;
    
54. in2 = *(pSrc + 1);
    ' ~2 V7 u2 w8 H  ^
55. in3 = *(pSrc + 2);
    
56. in4 = *(pSrc + 3);
      ^- F8 x# \9 ^8 R* L3 S6 T' [
57. (4)
    
58. /* Store the Shifted result in the destination buffer in single cycle by packing the outputs */
    , K9 k: s4 g5 i! c% H
59. *__SIMD32(pDst)++ = __PACKq7(__SSAT((in1 << shiftBits), 8),
    ) t. \0 n  y' x3 a7 T
60. __SSAT((in2 << shiftBits), 8),
    - I4 e7 O' i+ B
61. __SSAT((in3 << shiftBits), 8),
    
62. __SSAT((in4 << shiftBits), 8));
    ! s" `/ Y! G# G
63. /* Update source pointer to process next sampels */
    - `+ Y- c% C7 s2 w* T$ O2 g
64. pSrc += 4u;
    
65. 
    
66. /* Decrement the loop counter */
    1 {) q! l. o8 H! y% S
67. blkCnt--;
      J9 @# t1 g' m% C3 ^8 O6 {
68. }
    
69. 
    # F$ p1 i) H8 N# G9 S& U
70. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
    
71. ** No loop unrolling is used. */
    
72. blkCnt = blockSize % 0x4u;
    
73. 
    . w- j+ j2 M3 a6 O4 R4 H7 r
74. while(blkCnt > 0u)
    ) t# d, e* l0 H/ M9 C6 |7 z, R
75. {
    
76. /* C = A << shiftBits */ (5)
    7 A$ L% W  D2 Z& |
77. /* Shift the input and then store the result in the destination buffer. */
    $ ?1 D. Q& a  e( v+ L! t& C
78. *pDst++ = (q7_t) __SSAT((*pSrc++ << shiftBits), 8);
    - D7 C4 ?9 |$ L% `
79. 
    9 T+ n* L! Q; X4 v
80. /* Decrement the loop counter */
    
81. blkCnt--;
    
82. }
    
83. }
    " U- S' s. r$ ]% o; C% D0 s- E6 r1 `
84. else (6)
    - K4 k8 `$ A9 c6 t% W; U8 G& H
85. {
    : e1 T+ I+ o5 V
86. shiftBits = -shiftBits;
    6 p! U. H+ p# g$ w3 [7 o) h
87. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
    ' a* ^: |/ P/ P. ~, V
88. ** a second loop below computes the remaining 1 to 3 samples. */
    
89. while(blkCnt > 0u)
    
90. {
    . k( C4 x/ s" v5 A6 A
91. /* C = A >> shiftBits */
    2 r; D% y' k7 |6 s
92. /* Read 4 inputs */
    
93. in1 = *pSrc;
    
94. in2 = *(pSrc + 1);
    & K$ V; n  H- {5 L) k
95. in3 = *(pSrc + 2);
    9 @* B4 w- I3 j/ h- l$ S' D- B
96. in4 = *(pSrc + 3);
    
97. 
    
98. /* Store the Shifted result in the destination buffer in single cycle by packing the outputs */
    
99. *__SIMD32(pDst)++ = __PACKq7((in1 >> shiftBits), (in2 >> shiftBits),
    
100. (in3 >> shiftBits), (in4 >> shiftBits));
     
101. 
     
102. 
     1 E- @, Y: x. Q+ V7 ]( b! T$ Z
103. pSrc += 4u;
     
104. 
     2 A( \8 v& }- `3 N
105. /* Decrement the loop counter */
     0 W# `( `* z- C+ r% w6 H# ?3 {9 r4 K9 J
106. blkCnt--;
     
107. }
     / F2 R4 l4 D# s3 R) w- \
108. 
     
109. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
     
110. ** No loop unrolling is used. */
     
111. blkCnt = blockSize % 0x4u;
     & \) L$ V+ A+ N9 t& N0 g
112. 
     
113. while(blkCnt > 0u)
     
114. {
     7 w, I9 T0 H5 z5 u  d
115. /* C = A >> shiftBits */
       W1 \7 v  ]5 n* U' }8 b+ U2 Q  `
116. /* Shift the input and then store the result in the destination buffer. */
     / s/ k$ Y* `" t+ s
117. in1 = *pSrc++;
     % D7 [+ h1 }! O7 j% p: o, C$ p
118. *pDst++ = (in1 >> shiftBits);
     
119. 
     4 w" B: x7 \" c. w) H# @
120. /* Decrement the loop counter */
     0 J/ A2 O  T" I. y) Y5 m* V8 R
121. blkCnt--;
     1 t9 d& Y+ W1 x3 O. Z
122. }
     3 P$ g2 m3 T1 ?' _$ D/ n
123. }
     
124. 
     1 F* H9 Z7 ]+ S% I' T" d1 F
125. #else
     / k$ U" }6 t  {1 d8 a
126. 
     / X2 F5 z- s0 f8 O$ y
127. /* Run the below code for Cortex-M0 */
     
128. 
     ; |' d+ h/ ]1 ]8 n1 {5 m( K5 g% a
129. /* Getting the sign of shiftBits */
     
130. sign = (shiftBits & 0x80);
     ; e7 b: n  R8 `9 v( Q# [
131. 
     
132. /* If the shift value is positive then do right shift else left shift */
     
133. if(sign == 0u)
     + k# R9 O+ r- L& m% B
134. {
     
135. /* Initialize blkCnt with number of samples */
     
136. blkCnt = blockSize;
     
137. 
     
138. while(blkCnt > 0u)
       O! C! H  P8 _9 J& R
139. {
     ( O# j0 c) t% g: |
140. /* C = A << shiftBits */
     
141. /* Shift the input and then store the result in the destination buffer. */
     # ~! J- Q& q9 m! N0 i2 c9 E
142. *pDst++ = (q7_t) __SSAT(((q15_t) * pSrc++ << shiftBits), 8);
     7 S9 P8 f4 R+ ]; v& j
143. 
     & I- \5 S4 y0 z+ l7 t9 r/ s$ x5 Y
144. /* Decrement the loop counter */
     
145. blkCnt--;
     ; W- C4 O2 f3 z# L
146. }
     . H1 F: E5 q! y( s* r4 {
147. }
     
148. else
     ( ^) h9 Q( f$ K" Y; q( ?
149. {
     . l- k. p- k% \" r& ]. ~. M
150. /* Initialize blkCnt with number of samples */
     
151. blkCnt = blockSize;
     $ H" [) D, o6 f, f6 ?( k/ j
152. 
     
153. while(blkCnt > 0u)
     
154. {
     : g6 @2 [; t2 Z& ^5 K( M* d
155. /* C = A >> shiftBits */
     ; M' q. A& G2 b  @
156. /* Shift the input and then store the result in the destination buffer. */
     ( I0 p7 _" c! Q8 C( {; m6 I
157. *pDst++ = (*pSrc++ >> -shiftBits);
     ! O8 z7 @6 b9 Q& w
158. 
     : z, A! I/ s; H; \# L# R
159. /* Decrement the loop counter */
     % R6 @. q2 H- y7 ^
160. blkCnt--;
     
161. }
     . R: N( t* u6 @
162. }
     
163. 
     ( ^+ b( N0 p% b& x% p% g
164. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
     # b: X4 b( \7 l5 F
165. }

复制代码

1. 如果函数的参数shiftBits是正数那么表示左移，如果参数shiftBits是负数那么就是右移。

2. 这个函数使用了饱和运算。

    饱和运算数值0x80将变成0x7F。

3. 获取偏移值是正数还是负数。

4. 通过调用一次__PACKq7实现四个Q7格式数据的位移。

5. 剩余几不足4个数据的位移求解。

6. 如果移位值是负数，那么就是右移。

$ A5 f$ j" l' |4 C5 }, G* x) q* [9.3.4 实例讲解

实验目的：

    1. 三种类型数据的位移。

实验内容：

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

实验现象：

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

程序设计：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: DSP_Shift
   
4. *        功能说明: 位移
   / n% X$ Q5 z. ?0 Z" l( K
5. *        形 参：无
   
6. *        返 回 值: 无
   : T( {- k3 \) U3 P$ u# `
7. *********************************************************************************************************
   / p8 P2 q; V. G% M! F8 S: C8 D
8. */
   3 L8 }5 W' ~9 V* n& n
9. static void DSP_Shift(void)
   
10. {
    % V9 Z3 i# H' A2 @) O
11. static q31_t pSrcA1 = 0x88886666;
    
12. static q31_t pDst1;
    
13. 
    . b. @$ C% t  W! s& ?" e
14. static q15_t pSrcA2 = 0x8866;
    - V' u* k. `2 T* F, ^* d  j
15. static q15_t pDst2;
      t: R* z: l+ N+ g
16. 
    
17. static q7_t pSrcA3 = 0x86;
    $ ?1 P# ?5 U8 w0 P
18. static q7_t pDst3;
    
19. 
    * p- i( f: ]  l, Y
20. 
    6 l7 S; }* C0 ?& }3 i
21. arm_shift_q31(&pSrcA1, 3, &pDst1, 1);
    
22. printf("arm_shift_q31 = %8x\r\n", pDst1);
    
23. 
    
24. arm_shift_q15(&pSrcA2, -3, &pDst2, 1);
    
25. printf("arm_shift_q15 = %4x\r\n", pDst2);
    
26. 
    
27. arm_shift_q7(&pSrcA3, 3, &pDst3, 1);
    
28. printf("arm_shift_q7 = %2x\r\n", pDst3);
    9 K) f0 [: r8 x; f3 ?! Q$ J
29. printf("***********************************\r\n");
    
30. }

复制代码

: U. h: q' \% U

9.4 减法（Vector Sub）

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

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

9.4.1 arm_sub_f32

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

1. /**        
   
2. * @brief Floating-point vector subtraction.        
   
3. * @param[in]       *pSrcA points to the first input vector        
   1 \, Q& o' r; x
4. * @param[in]       *pSrcB points to the second input vector        
   
5. * @param[out]      *pDst points to the output vector        
   4 X% D1 x( {4 v9 d: L- g6 z! r
6. * @param[in]       blockSize number of samples in each vector        
   
7. * @return none.        
   
8. */
   
9. 
   1 t5 }7 c9 r! C) A2 C9 y& N1 P/ p
10. void arm_sub_f32(
    
11.   float32_t * pSrcA,
    
12.   float32_t * pSrcB,
    % Q+ p- \( `" d9 t2 v6 i
13.   float32_t * pDst,
    
14.   uint32_t blockSize)
    
15. {
    2 D" E, j4 o4 }- B! R
16.   uint32_t blkCnt;                               /* loop counter */
    
17. 
    
18. #ifndef ARM_MATH_CM0_FAMILY
    
19. 
    ; @/ m5 R+ P. q8 n, K, i/ L( S$ @
20. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
21.   float32_t inA1, inA2, inA3, inA4;              /* temporary variables */
    
22.   float32_t inB1, inB2, inB3, inB4;              /* temporary variables */
    # L6 E3 E) \1 m4 S% s
23. 
    , x6 Y& K; G& a
24.   /*loop Unrolling */
    $ N+ s. R, ]3 e/ `+ G4 Y2 ?
25.   blkCnt = blockSize >> 2u;
    
26. 
    5 O3 N$ t6 s5 x' L: P: L
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. */
    ! d2 A  v& b; }4 i* R- R# [
29.   while(blkCnt > 0u)
    + w/ z0 ^9 `4 o; V5 o1 ]
30.   {
    
31.     /* C = A - B */
    / _$ H0 g- ?! ~9 |2 K* l) u
32.     /* Subtract and then store the results in the destination buffer. */
    " k* b: K4 n- |
33.     /* Read 4 input samples from sourceA and sourceB */
    . S+ a1 i9 j  i8 c* k* S
34.     inA1 = *pSrcA;
    
35.     inB1 = *pSrcB;
    
36.     inA2 = *(pSrcA + 1);
    " [2 t7 Q7 S8 X, j, g8 @
37.     inB2 = *(pSrcB + 1);
    7 v9 U9 x2 u7 G2 ?3 I# b1 z
38.     inA3 = *(pSrcA + 2);
    
39.     inB3 = *(pSrcB + 2);
    
40.     inA4 = *(pSrcA + 3);
    
41.     inB4 = *(pSrcB + 3);
    
42. 
    5 \2 B6 G/ ?2 o; e+ q
43.     /* dst = srcA - srcB */
    # K" R  g2 K5 y9 [
44.     /* subtract and store the result */                                                              (1)
    ' U8 J2 W) x+ o. `2 e  ?! b
45.     *pDst = inA1 - inB1;
    
46.     *(pDst + 1) = inA2 - inB2;
    
47.     *(pDst + 2) = inA3 - inB3;
    ( v" p& p0 L3 ^
48.     *(pDst + 3) = inA4 - inB4;
    
49. 
    
50. 
    2 a9 g7 i! q4 ?; H2 D& W7 p9 M$ Z( e
51.     /* Update pointers to process next sampels */
    # |+ P! S- Y' V0 J! \; u: U) @- W; N6 S
52.     pSrcA += 4u;
    
53.     pSrcB += 4u;
    
54.     pDst += 4u;
    % ]' [+ P' E# P$ Z* i+ [- E% T
55. 
    ( q3 C' s6 S. k" k& d3 R/ f
56.     /* Decrement the loop counter */
    
57.     blkCnt--;
    
58.   }
    
59. 
    ) _* j$ V4 K9 T  ^( H
60.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
    - W, A) t5 ]* N7 x" W
61.    ** No loop unrolling is used. */
    
62.   blkCnt = blockSize % 0x4u;
    
63. 
    * c& i' U, z  G5 A
64. #else
    7 n* S: _- Q; q  K6 l9 z
65. 
    
66.   /* Run the below code for Cortex-M0 */
    
67. 
    
68.   /* Initialize blkCnt with number of samples */
    
69.   blkCnt = blockSize;
    
70. 
    
71. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
72. 
    5 ?0 j2 A+ {, D% C
73.   while(blkCnt > 0u)
    
74.   {
    
75.     /* C = A - B */
    ) m' [) x- f2 u0 E/ n
76.     /* Subtract and then store the results in the destination buffer. */
    
77.     *pDst++ = (*pSrcA++) - (*pSrcB++);
    ! u  ?9 b2 ~# B% y
78. 
    . S/ A% O0 W% i7 I+ {
79.     /* Decrement the loop counter */
    
80.     blkCnt--;
    ( z8 V/ A& s4 T
81.   }
    6 N8 a" S. Q4 u) B3 ~$ L+ B" I, _
82. }

复制代码

1. 浮点数的减法运算比较简单，直接两个数值相减即可。

) k4 t3 w! `$ {' c& L+ c" j9.4.2 arm_sub_q31

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

1. /**   
   9 q! K% c: r/ |0 W! i# h- Y7 v
2. * @brief Q31 vector subtraction.   
     \9 Y2 W* m( ~* X) @' K/ V
3. * @param[in]       *pSrcA points to the first input vector   
   - E6 e# D, L! e7 E; J6 t6 e3 l
4. * @param[in]       *pSrcB points to the second input vector   
   
5. * @param[out]      *pDst points to the output vector   
   
6. * @param[in]       blockSize number of samples in each vector   
   
7. * @return none.   
   
8. *   
   ; F1 W1 e, u3 f+ h1 D, C
9. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
   4 G/ R1 M) @1 ~1 Z
10. * \par   
    
11. * The function uses saturating arithmetic.   
    9 O% I$ n; i  f4 v+ F( H
12. * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] will be saturated.   
    
13. */
    
14. 
    . k+ m( _1 V7 d7 Z* s) \  K# q
15. void arm_sub_q31(
    8 t6 Q) F+ f  r( U' f# `; g: d) w
16.   q31_t * pSrcA,
    
17.   q31_t * pSrcB,
    8 v. H! v* {  v* Q- Y
18.   q31_t * pDst,
    " \+ V! D0 [- H
19.   uint32_t blockSize)
    % T! L1 W2 ?1 n- a: y' G" [
20. {
    
21.   uint32_t blkCnt;                               /* loop counter */
    / ?! `6 Q) n7 E6 Y: |+ Y% K
22. 
    # O4 \, H9 E4 ]! G
23. 
    9 Y  G- H: g' y4 }7 ]5 F. f
24. #ifndef ARM_MATH_CM0_FAMILY
    6 O: e8 N% Y2 Z+ c
25. 
    
26. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
27.   q31_t inA1, inA2, inA3, inA4;
    6 U8 h% y7 L( t% |+ m
28.   q31_t inB1, inB2, inB3, inB4;
    % W+ p9 D$ m' ?
29. 
    
30.   /*loop Unrolling */
    
31.   blkCnt = blockSize >> 2u;
    
32. 
    
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)
    8 [" f6 f4 r$ E, U. [3 h; E
36.   {
    ' I/ f4 c5 O1 ^, t
37.     /* C = A - B */
    
38.     /* Subtract and then store the results in the destination buffer. */
    ' \: M! b/ B6 W: t) j6 ?
39.     inA1 = *pSrcA++;
    4 d( I, p; Z/ q. z! ]0 I' O1 U& F
40.     inA2 = *pSrcA++;
    ' O6 F6 s7 }5 J' C0 ?, q3 E6 D6 t
41.     inB1 = *pSrcB++;
    
42.     inB2 = *pSrcB++;
    % b" L$ E+ J: S% Z6 z& N5 C1 |: T
43. 
    
44.     inA3 = *pSrcA++;
    , r1 C8 Y" j1 _9 g$ Q
45.     inA4 = *pSrcA++;
    
46.     inB3 = *pSrcB++;
    
47.     inB4 = *pSrcB++;
    
48. 
    9 W) R  z( v0 @4 P+ j# z. U
49.     *pDst++ = __QSUB(inA1, inB1);                                                                    (2)
    ! p- d' O* i/ U; x5 H9 a
50.     *pDst++ = __QSUB(inA2, inB2);
    * ~' [. K  q+ e6 Y3 o" B! \: W
51.     *pDst++ = __QSUB(inA3, inB3);
    
52.     *pDst++ = __QSUB(inA4, inB4);
    ( u" b( m! F6 E1 \' b
53. 
    3 L5 Q3 ]9 m% ?- ?5 t
54.     /* Decrement the loop counter */
    4 ^6 s7 O7 l$ G* g+ o  q+ I
55.     blkCnt--;
    7 Y: T; n. N0 j& }0 k3 r
56.   }
    2 B8 c* F5 c: F% }" B1 Q
57. 
    
58.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
59.    ** No loop unrolling is used. */
    
60.   blkCnt = blockSize % 0x4u;
    ( K" q' f5 D# G7 s! P( s% _
61. 
      ]' {% A' b  Y9 _  X: x
62.   while(blkCnt > 0u)
    
63.   {
    
64.     /* C = A - B */
    & h/ z: h) S$ a
65.     /* Subtract and then store the result in the destination buffer. */
    / a5 B) x  c4 n6 [- s$ g
66.     *pDst++ = __QSUB(*pSrcA++, *pSrcB++);
    
67. 
    
68.     /* Decrement the loop counter */
    & K& |  h6 `# ]( M; l
69.     blkCnt--;
    3 U: J& Q8 E& j, r& Z
70.   }
    
71. 
    4 h! D( H4 e2 b: H* _' C( d
72. #else
    ' J6 g) ~( E1 `3 V
73. 
    + p( y+ y. m; w5 E, y
74.   /* Run the below code for Cortex-M0 */
    
75. 
    9 [1 c5 P  X" @- U: n( o$ s5 \8 S
76.   /* Initialize blkCnt with number of samples */
    
77.   blkCnt = blockSize;
    - R2 n% x7 h$ @; _: S# a
78. 
    
79.   while(blkCnt > 0u)
    4 p) X  ~* ~& l
80.   {
    
81.     /* C = A - B */
    / h' O% i6 @) R0 \7 U! N8 N
82.     /* Subtract and then store the result in the destination buffer. */
    9 I1 |* n0 D; t: m7 I. b, O& U
83.     *pDst++ = (q31_t) clip_q63_to_q31((q63_t) * pSrcA++ - *pSrcB++);
    $ S. G- O+ B* d& n
84. 
    : c7 F& t% ^1 O  h
85.     /* Decrement the loop counter */
    
86.     blkCnt--;
    ) g  z9 @2 J  z. R3 C
87.   }
    
88. 
    % [0 a  s: R0 f6 b' A$ ~  P
89. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
90. 
    , M2 x# U0 E, ]/ p+ `
91. }

复制代码

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

    饱和运算数值0x80000000将变成0x7FFFFFFF。

2. __QSUB也是SIMD指令，这里可以用这个指令实现两个Q31格式数据的饱和减法。

9.4.3 arm_sub_q15

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

1. /**   
   
2. * @brief Q15 vector subtraction.   
   5 c! m  W. r* Q% W" U/ I. o
3. * @param[in]       *pSrcA points to the first input vector   
   & q4 c  b8 ~7 v) C
4. * @param[in]       *pSrcB points to the second input vector   
   
5. * @param[out]      *pDst points to the output vector   
   6 E3 {  w( |- t6 W, X6 S
6. * @param[in]       blockSize number of samples in each vector   
   3 k7 w" s/ Z$ I* g! ?" _9 Y
7. * @return none.   
   
8. *   
   
9. * <b>Scaling and Overflow Behavior:</b>   
   3 E0 v7 F& t7 S# T
10. * \par   
    " u$ E- o1 a3 e- j2 F
11. * The function uses saturating arithmetic.   
    * P. _5 R5 m) o) s8 s5 s
12. * Results outside of the allowable Q15 range [0x8000 0x7FFF] will be saturated.   
    ! F7 t1 C1 v8 y& @% S
13. */
    8 v# [2 O( J& }( o
14. 
    ( T  w% K) V( _6 U) D2 |) T7 {) D
15. void arm_sub_q15(
    . z! L9 }4 i1 B+ g6 e: b+ k; E
16.   q15_t * pSrcA,
    
17.   q15_t * pSrcB,
    
18.   q15_t * pDst,
    
19.   uint32_t blockSize)
    
20. {
    ' C$ M2 j/ F5 \9 E% d4 G# {
21.   uint32_t blkCnt;                               /* loop counter */
    9 `  q# h+ \0 z( ~2 q8 B  i
22. 
    
23. 
    
24. #ifndef ARM_MATH_CM0_FAMILY
    : A* o! a: X( c+ ^! v* B8 n5 Y
25. 
    
26. /* Run the below code for Cortex-M4 and Cortex-M3 */
    4 V/ M! v, Q1 F. M4 q. p) w
27.   q31_t inA1, inA2;
    * W; Q. B8 [2 D8 T$ U/ s; r
28.   q31_t inB1, inB2;
    6 R4 m) Q4 X4 o5 a; h( }3 {
29. 
    
30.   /*loop Unrolling */
    % p/ t+ p2 x' T* s0 }  {8 s
31.   blkCnt = blockSize >> 2u;
    
32. 
    
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. */
    ' }6 X3 s; R, H- z: z/ q
35.   while(blkCnt > 0u)
    5 V' ~) d0 `3 J, N$ Z: A9 g
36.   {
    2 d+ `2 u) ~4 A' J) P- x
37.     /* C = A - B */
    
38.     /* Subtract and then store the results in the destination buffer two samples at a time. */
      I" |4 t* {/ I6 \9 k8 I: J; ^, r6 T- `
39.     inA1 = *__SIMD32(pSrcA)++;                                                                      (1)
    5 S$ r6 m, n4 c# b1 Q
40.     inA2 = *__SIMD32(pSrcA)++;
    
41.     inB1 = *__SIMD32(pSrcB)++;
    2 p0 I$ |% e9 ~" s$ j4 @
42.     inB2 = *__SIMD32(pSrcB)++;
    
43. 
    
44.     *__SIMD32(pDst)++ = __QSUB16(inA1, inB1);                                                       (2)
    : }0 Y. H# }; d2 U
45.     *__SIMD32(pDst)++ = __QSUB16(inA2, inB2);
    
46. 
    
47.     /* Decrement the loop counter */
    
48.     blkCnt--;
    
49.   }
    8 Y4 E& p+ U* H# z
50. 
    0 c) X$ s% A. h: l& u" F6 u
51.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    & j! q/ ^3 O# o, E2 ]  ^
52.    ** No loop unrolling is used. */
    
53.   blkCnt = blockSize % 0x4u;
    % s, J" o! s7 s* `6 x/ ~8 v; Y0 E# j8 S) k
54. 
    
55.   while(blkCnt > 0u)
    
56.   {
    * {0 P7 x6 n4 W9 [2 B' _9 N) z
57.     /* C = A - B */
    / q8 G9 F- r" K; r8 y4 X; w$ c  ^
58.     /* Subtract and then store the result in the destination buffer. */
    / Y" w* L5 i, i: ]& ~
59.     *pDst++ = (q15_t) __QSUB16(*pSrcA++, *pSrcB++);
    2 M/ s8 P7 H1 v4 g5 b+ e$ I
60. 
    
61.     /* Decrement the loop counter */
    & D. b8 N1 t% Q! i& M* R% l/ D
62.     blkCnt--;
    ' O0 t3 B3 U3 R3 z0 P
63.   }
    
64. 
    9 S0 _& |/ f' b, y6 o% x% `7 y6 K3 ]
65. #else
    
66. 
    % ^, X' {" _' Y# w6 E3 e4 c
67.   /* Run the below code for Cortex-M0 */
    
68. 
    
69.   /* Initialize blkCnt with number of samples */
    
70.   blkCnt = blockSize;
    
71. 
    , y  `; x2 L$ n
72.   while(blkCnt > 0u)
    6 ]) l' q& w9 L
73.   {
    
74.     /* C = A - B */
    1 C: V  [, M9 V7 a) ?
75.     /* Subtract and then store the result in the destination buffer. */
    
76.     *pDst++ = (q15_t) __SSAT(((q31_t) * pSrcA++ - *pSrcB++), 16);
    
77. 
    ) ^; g# ]4 r5 n# p+ M  I
78.     /* Decrement the loop counter */
    : m( o1 r2 ^- p" Z  i
79.     blkCnt--;
    / S5 l' T4 a# O+ D
80.   }
    
81. 
    
82. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
83. 
    
84. 
    
85. }

复制代码

1. 这里一次读取两个Q15格式的数据。

2. 由于__QSUB16是SIMD指令，在这里调用一次__QSUB16可以实现两次减法运算。

. U+ p- T* B4 D) G! R1 @( O+ O, j9.4.4 arm_sub_q7

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

1. /**   
   
2. * @brief Q7 vector subtraction.   
     d$ v3 y9 C+ P
3. * @param[in]       *pSrcA points to the first input vector   
   2 E1 ^8 t" y1 e. `% x
4. * @param[in]       *pSrcB points to the second input vector   
   3 Y  j0 s- H8 f7 q
5. * @param[out]      *pDst points to the output vector   
   9 w& n2 k  `6 T# x9 m0 l3 x8 H" x
6. * @param[in]       blockSize number of samples in each vector   
   
7. * @return none.   
   
8. *   
   / d( G/ A! i6 z& I1 A+ E8 P
9. * <b>Scaling and Overflow Behavior:</b>   
   6 W7 Z# \* _! _
10. * \par   
    
11. * The function uses saturating arithmetic.   
    
12. * Results outside of the allowable Q7 range [0x80 0x7F] will be saturated.   
    
13. */
    
14. 
    5 T- E% ?! g  i' x1 f# a! p8 k
15. void arm_sub_q7(
    
16.   q7_t * pSrcA,
    8 X" [0 Q6 s; K# X- {& F
17.   q7_t * pSrcB,
    
18.   q7_t * pDst,
    3 n6 ]' _- e4 [, h! M- I
19.   uint32_t blockSize)
    
20. {
    
21.   uint32_t blkCnt;                               /* loop counter */
    
22. 
    . p$ T, [* D: k1 |+ h2 Q
23. #ifndef ARM_MATH_CM0_FAMILY
    , }( c+ G+ U/ ^9 z  O
24. 
    ! w5 {5 m0 L5 m# }4 [" O6 w* ], ~
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
26. 
    
27.   /*loop Unrolling */
    : Z4 |" v' a3 W7 J7 W
28.   blkCnt = blockSize >> 2u;
    
29. 
    / W% F0 ?8 Y. v$ H) v/ [$ O! E
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. */
    . D! b/ m3 W( q5 h1 g( W
32.   while(blkCnt > 0u)
    # G8 B+ f+ M. A2 Q6 T
33.   {
    
34.     /* C = A - B */
    
35.     /* Subtract and then store the results in the destination buffer 4 samples at a time. */
    8 ?( h& |0 E! t) T9 h3 l
36.     *__SIMD32(pDst)++ = __QSUB8(*__SIMD32(pSrcA)++, *__SIMD32(pSrcB)++);                              (1)
    
37. 
    , [, Y4 f( E( R7 [
38.     /* Decrement the loop counter */
    
39.     blkCnt--;
    1 c0 s/ m+ ^/ p) r6 [
40.   }
    
41. 
    . [9 F$ P& O- G& n. m
42.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
43.    ** No loop unrolling is used. */
    + m" L5 e. U( j7 c6 D; c3 r5 ]; m) f
44.   blkCnt = blockSize % 0x4u;
    
45. 
    8 I$ `7 L' W  `0 \$ a
46.   while(blkCnt > 0u)
    $ @( V+ t5 {' m7 `
47.   {
    & O1 X6 F, @8 \- [  ?6 F
48.     /* C = A - B */
    7 {0 i. }; }3 i- `3 W+ T' R$ S% B
49.     /* Subtract and then store the result in the destination buffer. */
    1 B9 F4 R9 e& M8 n) m
50.     *pDst++ = __SSAT(*pSrcA++ - *pSrcB++, 8);
    1 F3 {( P2 [7 F/ d1 S* c
51. 
    
52.     /* Decrement the loop counter */
    
53.     blkCnt--;
    
54.   }
    
55. 
    , d- Z; r: N2 M% ~! ~: [+ r
56. #else
    
57. 
    
58.   /* Run the below code for Cortex-M0 */
    
59. 
    6 u' \8 r, V% g+ l
60.   /* Initialize blkCnt with number of samples */
    
61.   blkCnt = blockSize;
    
62. 
    
63.   while(blkCnt > 0u)
    " s2 l6 h7 T! C& a; o8 D4 A
64.   {
    1 B+ r- ^/ |5 b- }+ q9 x
65.     /* C = A - B */
    $ t+ ^; c( g- U: ~9 s5 E* d
66.     /* Subtract and then store the result in the destination buffer. */
    ! P" J* ?, @- I
67.     *pDst++ = (q7_t) __SSAT((q15_t) * pSrcA++ - *pSrcB++, 8);
    
68. 
    : m6 [4 c$ s9 L2 R1 @! L9 u
69.     /* Decrement the loop counter */
    " b7 Z) c( T1 P6 `0 J
70.     blkCnt--;
    3 |8 ~5 ]3 P4 w+ \
71.   }
    
72. 
    
73. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    ; W1 V" v) U5 F$ Y+ M1 A( }/ U
74. 
    
75. 
    
76. }

复制代码

1. __QSUB8也是SIMD指令，调用一次就能实现4个Q7格式数据的减法运算。

9.4.5 实例讲解

实验目的：

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

实验内容：

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

实验现象：

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

程序设计：

1. /*
   : q; k6 B% A. L% r, M
2. *********************************************************************************************************
   
3. *        函 数 名: DSP_Sub
   ) b) A0 i+ B; Y0 n
4. *        功能说明: 减法
   ' q5 r6 _  _2 ?5 M' L7 A5 W
5. *        形    参：无
   & @% G9 R# I( j
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void DSP_Sub(void)
   7 |- J% m0 w. I3 @- z0 G/ R, R4 R/ R: x
10. {
    . F1 n% t6 k$ f; d6 l) n7 n7 c$ f
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   pDst[5];  
    
14. static q31_t  pSrcA1[5] = {1,1,1,1,1};  
    
15. static q31_t  pSrcB1[5] = {1,1,1,1,1};  
    
16. static q31_t  pDst1[5];   
    0 m* V% ?$ Q0 Q$ p3 e, N  Y7 S$ [
17. 
    
18. static q15_t  pSrcA2[5] = {1,1,1,1,1};  
    4 i  ]; Y4 S  P: L/ j3 L
19. static q15_t  pSrcB2[5] = {1,1,1,1,1};  
    2 c# {+ |) K( e5 F" }( ]; F; U
20. static q15_t  pDst2[5];   
    " v4 B& ]8 {5 [: F- h9 G
21. 
    
22. static q7_t  pSrcA3[5] = {0x70,1,1,1,1};
    
23. static q7_t  pSrcB3[5] = {0x7f,1,1,1,1};  
    
24. static q7_t pDst3[5];  
    ! a+ _0 A! W/ |3 I- e9 l
25. 
    
26. pSrcA[0] += 1.1f;
    
27. arm_sub_f32(pSrcA, pSrcB, pDst, 5);
    $ O' B! H6 h8 t
28. printf("arm_sub_f32 = %f\r\n", pDst[0]);
    
29. pSrcA1[0] += 1;
    
30. arm_sub_q31(pSrcA1, pSrcB1, pDst1, 5);
    + }7 A( K8 ^6 I9 H: I
31. printf("arm_sub_q31 = %d\r\n", pDst1[0]);
    , V* j3 a3 _  W" n+ q( w+ V( ]: S
32. 
    3 h$ W- A* r1 `1 w  H
33. pSrcA2[0] += 1;
    $ c2 w2 @( w, e3 G- k
34. arm_sub_q15(pSrcA2, pSrcB2, pDst2, 5);
    
35. printf("arm_sub_q15 = %d\r\n", pDst2[0]);
    
36. 
    
37. pSrcA3[0] += 1;
    3 e' n5 [' U( j- w/ s
38. arm_sub_q7(pSrcA3, pSrcB3, pDst3, 5);
    2 l4 M4 {8 ?* A/ D2 n
39. printf("arm_sub_q7 = %d\r\n", pDst3[0]);
    , o) U( S% _' o' E  L
40. printf("***********************************\r\n");
    
41. }

复制代码

9.5 比例因子（Vector Scale）

    这部分函数主要用于实现数据的比例放大和缩小，浮点数据公式描述如下：

      pDst[n] = pSrc[n] * scale,   0 <= n < blockSize.        

    如果是Q31，Q15，Q7格式的数据，公式描述如下：

      pDst[n] = (pSrc[n] * scaleFract) << shift,   0 <= n < blockSize.   

    这种情况下，比例因子就是：

      scale = scaleFract * 2^shift.      

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

9.5.1 arm_scale_f32

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

1. /**        
   
2. * @brief Multiplies a floating-point vector by a scalar.        
   
3. * @param[in]       *pSrc points to the input vector        
   , |9 O3 a" m: s, [: z
4. * @param[in]       scale scale factor to be applied        
   3 S# I$ V. J  p  x% y# L( Z. }% d
5. * @param[out]      *pDst points to the output vector        
   & E; O7 R. K4 d+ [6 s4 {4 B
6. * @param[in]       blockSize number of samples in the vector        
   
7. * @return none.        
   / s) V1 \/ }5 t' D# N
8. */
   0 e2 M+ q, m; q4 |
9. 
   ( N3 d' M* b1 |$ u  S# L" P! l
10. 
    7 Y" o9 E) v- q8 T, R
11. void arm_scale_f32(
    
12.   float32_t * pSrc,
    
13.   float32_t scale,
    % }( n1 g, B1 h) z. `, M
14.   float32_t * pDst,
    
15.   uint32_t blockSize)
    & A2 V: [/ L# J  o
16. {
    6 o4 |$ r# @* A3 ~% u+ l- ^
17.   uint32_t blkCnt;                               /* loop counter */
    8 r7 \& v  p. D( U4 c. j6 b
18. #ifndef ARM_MATH_CM0_FAMILY
    ; s" `& [9 j  e& a. h& p0 _7 F. o
19. 
    ) l4 c& S4 X/ Z2 }/ f, N7 S
20. /* Run the below code for Cortex-M4 and Cortex-M3 */
    3 |& i6 r! _1 ?+ x/ C% p) m
21.   float32_t in1, in2, in3, in4;                  /* temporary variabels */
    * ]# f$ }- }: ?) v- f" V
22. 
    
23.   /*loop Unrolling */
    
24.   blkCnt = blockSize >> 2u;
    # ~; H; S9 z# h$ o( L: T
25. 
    
26.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
    4 p: N) A- x5 H: ~- k; S
27.    ** a second loop below computes the remaining 1 to 3 samples. */
    2 I$ J2 U* }: E8 ]. A( ~  ^
28.   while(blkCnt > 0u)
    2 @1 c* a) l1 F1 m, W
29.   {
    
30.     /* C = A * scale */
    
31.     /* Scale the input and then store the results in the destination buffer. */
    
32.     /* read input samples from source */
    
33.     in1 = *pSrc;
    + v+ _5 }! w+ _9 G- L6 K
34.     in2 = *(pSrc + 1);
    ' X- L% i* k" B% C
35. 
    
36.     /* multiply with scaling factor */                                                               (1)
    
37.     in1 = in1 * scale;
    ( M9 d; ?# j( j1 `$ }
38. 
    
39.     /* read input sample from source */
    
40.     in3 = *(pSrc + 2);
    / E. m' w8 Z9 L' E/ G: `5 g
41. 
    
42.     /* multiply with scaling factor */
    
43.     in2 = in2 * scale;
    
44. 
    3 c3 `: p& ~* a$ x9 A7 S
45.     /* read input sample from source */
    
46.     in4 = *(pSrc + 3);
    
47. 
    9 G0 P& }; \- D% d5 A
48.     /* multiply with scaling factor */
    
49.     in3 = in3 * scale;
    $ g+ _4 i" U( t6 N5 N4 A( w3 K+ H* i# U
50.     in4 = in4 * scale;
    
51.     /* store the result to destination */
      L& L' c/ H& ~% v% M3 E& z
52.     *pDst = in1;
    
53.     *(pDst + 1) = in2;
    
54.     *(pDst + 2) = in3;
    
55.     *(pDst + 3) = in4;
    
56. 
    
57.     /* update pointers to process next samples */
    
58.     pSrc += 4u;
    
59.     pDst += 4u;
    $ J7 s7 N! z, l( P) T: m
60. 
    7 V- H# n0 J% G3 ]; z1 E3 l0 i6 U6 V; g
61.     /* Decrement the loop counter */
    - |. y% \8 s. M' d5 \' r
62.     blkCnt--;
    
63.   }
    ' X9 O8 x' q& x/ b4 i8 j. N0 w  A
64. 
      N# A: p2 E$ m* s, ]0 k
65.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
    ; M6 x# Y6 A1 ~# l4 G
66.    ** No loop unrolling is used. */
      w# X9 Y. `! D& j2 E
67.   blkCnt = blockSize % 0x4u;
    
68. 
    ! L+ _1 o* O3 P6 X0 B; s2 L' _
69. #else
    
70. 
    
71.   /* Run the below code for Cortex-M0 */
    
72. 
    9 S9 O, b8 x6 n. A9 l; h; l
73.   /* Initialize blkCnt with number of samples */
    - a, W  o, Y) k* |" ?% q+ |1 y
74.   blkCnt = blockSize;
    1 O5 z4 d- `6 v6 m9 Q7 G' J
75. 
    7 |3 q+ m  _' y6 b- m8 |
76. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    
77. 
    % ^9 f# Y# V/ N2 I9 D8 Z
78.   while(blkCnt > 0u)
    / h2 w4 k0 d: E7 U
79.   {
    7 J3 a$ a5 \/ O5 u" c7 _, l
80.     /* C = A * scale */
    
81.     /* Scale the input and then store the result in the destination buffer. */
    
82.     *pDst++ = (*pSrc++) * scale;
    / F+ o# M/ M! j; L& w( D
83. 
    
84.     /* Decrement the loop counter */
    
85.     blkCnt--;
    
86.   }
    / O0 U  V' M3 K* c! o) c$ B/ G
87. }

复制代码

1. 浮点数据的比例因子计算比较简单，源浮点数相应相应的比例因子即可。

4 _3 S* u) ^2 T% h/ q) v3 m9.5.2 arm_scale_q31

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

1. /**      
   
2. * @brief Multiplies a Q31 vector by a scalar.      
     B& F# D( w: i+ d5 S* v' l
3. * @param[in]       *pSrc points to the input vector      
   
4. * @param[in]       scaleFract fractional portion of the scale value      
   * t# `. B, g1 _/ `8 n/ m( X
5. * @param[in]       shift number of bits to shift the result by      
   $ @$ u/ P7 x. K" u
6. * @param[out]      *pDst points to the output vector      
   
7. * @param[in]       blockSize number of samples in the vector      
   
8. * @return none.      
   
9. *      
   ) i4 k" D9 D: U  p
10. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
    
11. * \par      
    
12. * The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.31 format.      
      W( Y3 R3 P* _- b: A6 Z6 u% O
13. * These are multiplied to yield a 2.62 intermediate result and this is shifted with saturation to 1.31 format.      
    
14. */
    
15. 
    1 @% m- I+ w) t5 Z( z3 G
16. void arm_scale_q31(
    / V1 ~* x) K5 \; x# F" `1 y, A" P% Z2 w* j
17.   q31_t * pSrc,
    
18.   q31_t scaleFract,
    3 q' v! v' Q% \' J/ r
19.   int8_t shift,
    + K! E6 N' q: d/ Y  ]6 G+ R8 s
20.   q31_t * pDst,
    
21.   uint32_t blockSize)
    
22. {
    
23.   int8_t kShift = shift + 1;                     /* Shift to apply after scaling */                 (2)
    & P# v. |0 Q9 E# G
24.   int8_t sign = (kShift & 0x80);
    $ c; j" g" V( _4 I: k# Y: ~. [& U
25.   uint32_t blkCnt;                               /* loop counter */
    
26.   q31_t in, out;
    
27. 
    3 `* k1 f& y7 W4 X0 i
28. #ifndef ARM_MATH_CM0_FAMILY
    7 D& t* N3 B8 C7 ~. J7 c
29. 
    
30. /* Run the below code for Cortex-M4 and Cortex-M3 */
    - v9 F, c. E& t( {1 u+ [
31. 
    
32.   q31_t in1, in2, in3, in4;                      /* temporary input variables */
    
33.   q31_t out1, out2, out3, out4;                  /* temporary output variabels */
    
34. 
    ; v* Z/ Z$ t* F( L# V) z/ R
35. 
    8 |( X  u( C( e0 M- N& y* g
36.   /*loop Unrolling */
    % _9 C6 X9 g- |
37.   blkCnt = blockSize >> 2u;
    2 a- `  i( i, l- O9 b% b" T$ @/ d
38. 
    
39.   if(sign == 0u)                                                                                    (3)
    
40.   {
    
41.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.      
    
42.      ** a second loop below computes the remaining 1 to 3 samples. */
    * j6 J, T2 O$ R4 W1 [( X' ^: O" f
43.     while(blkCnt > 0u)
    " u1 f& A2 g3 j0 x% x9 U
44.     {
    ) i( P/ \: M  W  Q6 u5 K% p. R
45.       /* read four inputs from source */
    
46.       in1 = *pSrc;
    
47.       in2 = *(pSrc + 1);
    1 t7 J% k; l7 ~5 v0 c( J" y
48.       in3 = *(pSrc + 2);
    7 L" Z5 t3 V7 [8 X- `( n
49.       in4 = *(pSrc + 3);
    
50. 
    
51.       /* multiply input with scaler value */                                                        (4)
    ; l9 g7 j2 h$ \. R8 d  o- g, ?
52.       in1 = ((q63_t) in1 * scaleFract) >> 32;
    + o2 e  \) ?- `3 {
53.       in2 = ((q63_t) in2 * scaleFract) >> 32;
    " d5 G1 B, |9 s: b
54.       in3 = ((q63_t) in3 * scaleFract) >> 32;
    % R+ H. t5 X' b( j) U
55.       in4 = ((q63_t) in4 * scaleFract) >> 32;
    ) v3 `# u$ \, Q' n; p
56. 
    ! I) H. }; h$ ]* U2 W# b* J
57.       /* apply shifting */
    
58.       out1 = in1 << kShift;
    
59.       out2 = in2 << kShift;
    
60. 
    
61.       /* saturate the results. */
    
62.       if(in1 != (out1 >> kShift))                                                                   (5)
    
63.         out1 = 0x7FFFFFFF ^ (in1 >> 31);
    ' E$ W7 Q$ ^  z# `3 J
64. 
    
65.       if(in2 != (out2 >> kShift))
    / q! W8 G7 ^; j3 d9 o
66.         out2 = 0x7FFFFFFF ^ (in2 >> 31);
    
67. 
    7 `: E9 a- c7 x; H
68.       out3 = in3 << kShift;
    
69.       out4 = in4 << kShift;
    ' D! e4 \  X+ ]/ O
70. 
    ! N& K5 o; G& p5 S/ V
71.       *pDst = out1;
    
72.       *(pDst + 1) = out2;
    0 Q  Z! t) v+ r
73. 
    
74.       if(in3 != (out3 >> kShift))
    
75.         out3 = 0x7FFFFFFF ^ (in3 >> 31);
    6 s' P% L" n7 P( g2 L! D
76. 
    : h! \0 ^) D" U
77.       if(in4 != (out4 >> kShift))
    3 n( k# r8 a* ^, N
78.         out4 = 0x7FFFFFFF ^ (in4 >> 31);
    : f, E6 _! ~$ l" J6 J
79. 
    
80.       /* Store result destination */
    # l& [; x! O1 _" ~& ]
81.       *(pDst + 2) = out3;
    9 |  w5 [; |0 J# p
82.       *(pDst + 3) = out4;
    
83. 
    3 e% Z! Z& `6 X5 x
84.       /* Update pointers to process next sampels */
    
85.       pSrc += 4u;
    ' s- F6 Q/ K  }
86.       pDst += 4u;
    
87. 
    : J* R0 t3 r" L: ~8 v, n1 _- K
88.       /* Decrement the loop counter */
    
89.       blkCnt--;
    $ N7 d) Q5 d" {( R
90.     }
    & f! m" @$ A+ d1 Q
91. 
    
92.   }
    
93.   else                                                                                               {
    1 l& a' Y1 h* g% W$ v7 @
94.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.      
    
95.      ** a second loop below computes the remaining 1 to 3 samples. */
    3 L& N6 e9 m( r, I1 [, o& {+ \
96.     while(blkCnt > 0u)
    9 g; M/ u/ Q; W4 K, h
97.     {
    
98.       /* read four inputs from source */
    # a3 E" E0 Q" A7 f2 T0 K
99.       in1 = *pSrc;
    
100.       in2 = *(pSrc + 1);
     * s2 t' i: B2 L$ \
101.       in3 = *(pSrc + 2);
     
102.       in4 = *(pSrc + 3);
     
103. 
     
104.       /* multiply input with scaler value */
     1 N% @9 G, I0 Z5 b
105.       in1 = ((q63_t) in1 * scaleFract) >> 32;
     
106.       in2 = ((q63_t) in2 * scaleFract) >> 32;
     ( Z, z+ S- c2 Q' g5 c
107.       in3 = ((q63_t) in3 * scaleFract) >> 32;
     8 C; n2 H- V" B0 s
108.       in4 = ((q63_t) in4 * scaleFract) >> 32;
     
109. 
     
110.       /* apply shifting */                                                                           (6)
     & T4 l8 q/ N, b. m5 X0 J4 E
111.       out1 = in1 >> -kShift;
     5 @( h) L% g2 e% K
112.       out2 = in2 >> -kShift;
     2 {- J; S. b, |. `
113. 
     6 a5 N2 H6 S; T5 u+ \1 I
114.       out3 = in3 >> -kShift;
     8 l$ Y$ _; j- T) D5 j" y$ t
115.       out4 = in4 >> -kShift;
     8 v( c) j% H0 c" f; x
116. 
     
117.       /* Store result destination */
     - U5 l$ J  O. X  d4 _/ y
118.       *pDst = out1;
     
119.       *(pDst + 1) = out2;
     $ H0 T8 B" U8 J) H, I
120. 
     & {3 c/ y6 p& N' F
121.       *(pDst + 2) = out3;
     
122.       *(pDst + 3) = out4;
     3 i( }* U& `8 P& ^4 U+ y6 Y
123. 
     " }% Q. F6 G5 z) c
124.       /* Update pointers to process next sampels */
     2 E9 S; k2 B0 B1 ^
125.       pSrc += 4u;
     
126.       pDst += 4u;
     5 i6 {3 A9 t( _1 _/ E; L# c
127. 
     
128.       /* Decrement the loop counter */
     ) X* y: {; y: r" t
129.       blkCnt--;
     7 B; V& W) n- r9 C
130.     }
     
131.   }
     
132.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.      
     
133.    ** No loop unrolling is used. */
     
134.   blkCnt = blockSize % 0x4u;
     
135. 
     6 Q/ q1 \( Q+ p. \6 R
136. #else
     
137. 
     
138.   /* Run the below code for Cortex-M0 */
     
139. 
     5 N5 E1 y' d- d
140.   /* Initialize blkCnt with number of samples */
     
141.   blkCnt = blockSize;
     
142. 
     
143. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
     $ V2 A$ F5 \- o: M9 h
144. 
     
145.   if(sign == 0)
     
146.   {
     ) ]' U. w1 r# u" m1 D. P/ K& s9 [0 S7 s5 W
147.   while(blkCnt > 0u)
     # z( J7 }, ?* G/ g" t6 B; J7 u
148.   {
     
149. /* C = A * scale */
     
150. /* Scale the input and then store the result in the destination buffer. */
     
151. in = *pSrc++;
     . W# v4 o+ l6 y( U3 \! {; y
152. in = ((q63_t) in * scaleFract) >> 32;
     
153. 
     . X5 V, j& [' y8 z
154. out = in << kShift;
     
155. if(in != (out >> kShift))
     / ^  f' z/ D" n6 `6 F5 [) N' ]
156. out = 0x7FFFFFFF ^ (in >> 31);
     4 _$ {1 D0 r+ ~5 G- |
157. 
     
158. *pDst++ = out;
     ' I: j1 k& L  N3 C3 b
159. 
     ; j4 W+ a  y* U/ k4 N) b
160. /* Decrement the loop counter */
     * I% C0 d' ^) q+ [
161. blkCnt--;
     7 w9 P7 {9 \1 Y
162.   }
     
163.   }
     9 \* n0 @  N7 n/ u2 ]: b/ K. o
164.   else
     " Q: z, Q0 Y# e' c7 U
165.   {
     
166.   while(blkCnt > 0u)
     
167.   {
     
168. /* C = A * scale */
     
169. /* Scale the input and then store the result in the destination buffer. */
     
170. in = *pSrc++;
     & ?" x6 R( W# M7 ?- c( Q  q
171. in = ((q63_t) in * scaleFract) >> 32;
     
172. 
     * c: j9 ]. |5 K# J# p- t
173. out = in >> -kShift;
     
174. 
     0 @! c5 H+ m" C' S2 @" W  l
175. *pDst++ = out;
     
176. 
     7 }' X( Z$ }5 I9 ^! ?
177. /* Decrement the loop counter */
     . k  Q$ }5 D4 R# n
178. blkCnt--;
     . |/ e+ s' Z. j6 m
179.   }
     
180.   
     
181.   }
     - {% x8 ~% j2 u7 u  s& F0 b/ A9 v/ K
182. }

复制代码

1. 源数据和比例因子都是Q31格式。这样他们的乘积就是1.31 * 1.31 = 2.62格式。由于输出结果也是Q31格式，那么源数据和比例因子的乘积需要右移32位，并且输出结果需要饱和处理。

2. 这里不清楚为什么要加1操作，留作以后解决。

3. 如果位移是正值，那么就是左移位，否则就是右移位。

4. 将源数据和比例因子的乘积左移32位，保证结果也是Q31格式。

5. 这里是对结果的饱和处理。

6. 数值的右移不存在饱和问题，这里直接取反即可。

# G5 A6 [" g, n+ g9.5.3 arm_scale_q15

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

1. /**   
   & j7 p' w2 ]" I& }! j
2. * @brief Multiplies a Q15 vector by a scalar.   
   1 u2 X) L8 U7 X+ b8 J. c% o- n
3. * @param[in]       *pSrc points to the input vector   
   
4. * @param[in]       scaleFract fractional portion of the scale value   
   7 l* z! O& c7 M
5. * @param[in]       shift number of bits to shift the result by   
   5 Q8 O$ T( d) n- T* M
6. * @param[out]      *pDst points to the output vector   
   0 l) `, Q+ N; w+ o: }; c# m8 {
7. * @param[in]       blockSize number of samples in the vector   
   
8. * @return none.   
   1 R# ?# q, F9 F
9. *   
   8 G9 E, L& U6 m$ W2 N( _
10. * <b>Scaling and Overflow Behavior:</b>                                                               (1)
    0 A" y% s: c3 T+ c& ~$ c/ b1 S
11. * \par   
    
12. * The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.15 format.   
    
13. * These are multiplied to yield a 2.30 intermediate result and this is shifted with saturation to 1.15 format.   
    3 a, D) F- Y! E4 O
14. */
    
15. 
    
16. 
    ; e( t( {' I% N1 s+ q3 t
17. void arm_scale_q15(
    
18.   q15_t * pSrc,
    4 H0 j! x/ ^; D9 y
19.   q15_t scaleFract,
    * ^" }8 Y/ K$ f( w- H9 t8 V' A/ L3 [
20.   int8_t shift,
    . h6 M7 e! E1 G
21.   q15_t * pDst,
    
22.   uint32_t blockSize)
      L) `5 K2 N! J" w
23. {
    6 d9 D) s( n4 D+ p8 C, v
24.   int8_t kShift = 15 - shift;                    /* shift to apply after scaling */                   (2)
    - P+ ?* S& u7 x7 N
25.   uint32_t blkCnt;                               /* loop counter */
    ; Z. E. T& L: \0 ]1 N) J& Y$ `
26. 
    3 T0 p0 ]" ~3 X7 e" r
27. #ifndef ARM_MATH_CM0_FAMILY
    1 N; j- ~7 h! B7 x# |$ N. Q, [
28. 
    
29. /* Run the below code for Cortex-M4 and Cortex-M3 */
    
30.   q15_t in1, in2, in3, in4;
      E1 E1 ~' t& Y# m, T) c* B  P
31.   q31_t inA1, inA2;                              /* Temporary variables */
    
32.   q31_t out1, out2, out3, out4;
    ( l* B; p; x0 Y! }6 v+ e
33. 
    : [8 K2 g2 X5 @. d# w( x6 M
34. 
    
35.   /*loop Unrolling */
    
36.   blkCnt = blockSize >> 2u;
    
37. 
    $ d6 f6 q6 |! e6 P, g9 C
38.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
    ! @* z- \% E3 f' z/ U7 [
39.    ** a second loop below computes the remaining 1 to 3 samples. */
    
40.   while(blkCnt > 0u)
    
41.   {
    : W% h+ l5 P. g1 T
42.     /* Reading 2 inputs from memory */
    1 p8 z* l9 i4 e8 T0 l/ @5 b
43.     inA1 = *__SIMD32(pSrc)++;                                                                       (3)
    
44.     inA2 = *__SIMD32(pSrc)++;
    
45. 
    8 v( J6 D# p  }# ~. z( r* l
46.     /* C = A * scale */
    : ^7 a/ g. `) s0 M2 ^; _  w/ f
47.     /* Scale the inputs and then store the 2 results in the destination buffer        
    
48.      * in single cycle by packing the outputs */
    
49.     out1 = (q31_t) ((q15_t) (inA1 >> 16) * scaleFract);                                             (4)
    
50.     out2 = (q31_t) ((q15_t) inA1 * scaleFract);
    
51.     out3 = (q31_t) ((q15_t) (inA2 >> 16) * scaleFract);
    0 A7 U& m8 O" C- G
52.     out4 = (q31_t) ((q15_t) inA2 * scaleFract);
    
53. 
    3 p, Q/ {0 ]- ^' e" |3 g
54.     /* apply shifting */
    $ x8 g& }7 h/ e& c9 v' L
55.     out1 = out1 >> kShift;
    . c$ h7 i' Q9 D( F7 J. [8 [
56.     out2 = out2 >> kShift;
    
57.     out3 = out3 >> kShift;
    
58.     out4 = out4 >> kShift;
    
59. 
    - ~* S- |1 o& w* W2 A
60.     /* saturate the output */
    6 T  o$ y/ d8 g' F4 @4 M
61.     in1 = (q15_t) (__SSAT(out1, 16));                                                               (5)
    : L2 T6 ~- P8 T9 d# V" b
62.     in2 = (q15_t) (__SSAT(out2, 16));
    # d- V7 e- S) h2 C& q
63.     in3 = (q15_t) (__SSAT(out3, 16));
    
64.     in4 = (q15_t) (__SSAT(out4, 16));
    
65. 
    , w# C, P' @  L$ E  g2 I$ A1 J
66.     /* store the result to destination */                                                           (6)
      i  l$ \* V8 _; ?
67.     *__SIMD32(pDst)++ = __PKHBT(in2, in1, 16);
    5 m& Q7 [2 _% U, c7 [, e5 J
68.     *__SIMD32(pDst)++ = __PKHBT(in4, in3, 16);
    
69. 
    7 A$ N/ S! y, \3 b
70.     /* Decrement the loop counter */
    
71.     blkCnt--;
    4 C; M1 v! T% O9 H9 q
72.   }
    5 r$ Q8 i/ n1 w1 }+ ]
73. 
    
74.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
    
75.    ** No loop unrolling is used. */
    0 O: S0 ]5 C$ z0 O8 B
76.   blkCnt = blockSize % 0x4u;
      G; }: U1 }* @" E7 P
77. 
    
78.   while(blkCnt > 0u)
    9 g, i  J$ g2 f  t3 c, x
79.   {
    % N; O( U4 q) T+ c, S
80.     /* C = A * scale */
    $ E6 E0 x6 V3 l7 k' O
81.     /* Scale the input and then store the result in the destination buffer. */
    
82.     *pDst++ = (q15_t) (__SSAT(((*pSrc++) * scaleFract) >> kShift, 16));
    
83. 
    
84.     /* Decrement the loop counter */
    
85.     blkCnt--;
    * ?6 |3 b# W8 e: }4 ?
86.   }
    0 M+ ~2 j- c7 t$ e/ ]9 }( Q2 @% Z( s
87. 
    
88. #else
    : Q# K! d2 b/ ^9 {$ N8 r5 g
89. 
    
90.   /* Run the below code for Cortex-M0 */
    ) A+ R, X9 A6 }8 a$ X) {+ c& ]
91. 
    
92.   /* Initialize blkCnt with number of samples */
    0 |2 U$ w% ?8 @
93.   blkCnt = blockSize;
    # A/ T$ v2 E# H- r& p& b
94. 
    % j% K: X! M" H1 e- b% j$ |
95.   while(blkCnt > 0u)
    
96.   {
    
97.     /* C = A * scale */
    $ h% b4 _5 H& a+ Q) j$ f7 c/ L" X+ `
98.     /* Scale the input and then store the result in the destination buffer. */
    " m/ O# B# p/ P6 C
99.     *pDst++ = (q15_t) (__SSAT(((q31_t) * pSrc++ * scaleFract) >> kShift, 16));
    
100. 
     / B8 p& Z! F: H) C9 p
101.     /* Decrement the loop counter */
     3 D! }3 k- D! {. Y
102.     blkCnt--;
     ; l, v$ C% H$ V$ j$ m& H
103.   }
     3 n& s" z# k- Q" d- r( Q) G
104. 
     
105. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
     
106. 
     5 X6 a/ X( U1 Y+ u3 E3 Z
107. }

复制代码

1. 源数据和比例因子的数据格式都是Q15，这样的话，输出结果就是1.15 * 1.15 = 2.30格式，由于输出结果也是Q15格式，所以输出结果需要饱和处理。

2. 这个变量设计很巧妙，这样下面处理正数左移和负数右移就很方面了，可以直接使用一个右移就可以实现。

3. 读取两个Q15格式的数据。

4. 将源数据乘以比例因子后赋值给Q31格式的变量。

5. 对输出结果做饱和处理。

6. 通过调用一次__PKHBT指令，将两个Q15格式的数据都赋值给目的变量。

9.5.4 arm_scale_q7

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

1. /**
   
2. * @brief Multiplies a Q7 vector by a scalar.
   + k+ _0 z* N3 C6 Z" x2 R/ H4 q& W
3. * @param[in] *pSrc points to the input vector
   
4. * @param[in] scaleFract fractional portion of the scale value
   
5. * @param[in] shift number of bits to shift the result by
   
6. * @param[out] *pDst points to the output vector
   
7. * @param[in] blockSize number of samples in the vector
   ) _6 V# n" M. c# s0 k
8. * @return none.
   
9. *
   
10. * <b>Scaling and Overflow Behavior:</b> (1)
    ' B, o% c2 l/ e& J. l$ B. V
11. * \par
    4 Z: S  g$ G: {4 R
12. * The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.7 format.
    
13. * These are multiplied to yield a 2.14 intermediate result and this is shifted with saturation to 1.7 format.
    
14. */
    ! r1 l* A* f7 `. _( X: X7 m7 k
15. 
    
16. void arm_scale_q7(
      M* g$ }3 w; N& h/ [. [% O6 c5 l
17. q7_t * pSrc,
    
18. q7_t scaleFract,
    
19. int8_t shift,
    
20. q7_t * pDst,
    
21. uint32_t blockSize)
    
22. {
    
23. int8_t kShift = 7 - shift; /* shift to apply after scaling */ (2)
    , \- \' E9 J1 \3 d- M8 \9 {, j
24. uint32_t blkCnt; /* loop counter */
    
25. 
    
26. #ifndef ARM_MATH_CM0_FAMILY
    
27. 
    
28. /* Run the below code for Cortex-M4 and Cortex-M3 */
    # |2 [7 G& h/ G; K6 p0 V; M
29. q7_t in1, in2, in3, in4, out1, out2, out3, out4; /* Temporary variables to store input & output */
    . B% l( Z) \: F5 a( `& {
30. 
    - x9 V; }( Z8 ~5 U5 x/ p, o
31. 
    * _. f8 O6 F8 ~) d1 @
32. /*loop Unrolling */
    
33. blkCnt = blockSize >> 2u;
    ( A3 Z, ~; a; ]2 O% G4 b
34. 
    ; q9 h4 D& ~+ q* G. o- e
35. 
    2 Z( D. ~9 d6 v' Z
36. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
    : u) k, v1 _1 F
37. ** a second loop below computes the remaining 1 to 3 samples. */
    7 j5 |7 T8 [" b* v: B
38. while(blkCnt > 0u)
    , ~' m, g) U7 ]' e* Y
39. {
    
40. /* Reading 4 inputs from memory */
    7 j- `5 m" ]3 o6 o4 l2 v0 L; i* H5 s. o
41. in1 = *pSrc++;
    6 s3 A5 w) n3 M% F' H& x  K% J
42. in2 = *pSrc++;
    
43. in3 = *pSrc++;
    
44. in4 = *pSrc++;
    0 t9 X) S8 W$ S5 G$ |9 T9 T$ n8 U
45. 
    7 d% \  ?' R- D8 T4 }
46. /* C = A * scale */
    
47. /* Scale the inputs and then store the results in the temporary variables. */
    # j9 p& A2 A+ F* Y& g0 r1 z( A+ i
48. out1 = (q7_t) (__SSAT(((in1) * scaleFract) >> kShift, 8)); (3)
    ' z+ I! a6 ^8 N
49. out2 = (q7_t) (__SSAT(((in2) * scaleFract) >> kShift, 8));
    6 M3 A+ G! Z, M% t7 Y  \3 D
50. out3 = (q7_t) (__SSAT(((in3) * scaleFract) >> kShift, 8));
    
51. out4 = (q7_t) (__SSAT(((in4) * scaleFract) >> kShift, 8));
    
52. 
    ! J2 Y6 r& _0 K' ?$ F' o5 E
53. /* Packing the individual outputs into 32bit and storing in
    
54. * destination buffer in single write */
    
55. *__SIMD32(pDst)++ = __PACKq7(out1, out2, out3, out4); (4)
    
56. 
    6 B' b+ S) T, l- r( W- e% `$ w
57. /* Decrement the loop counter */
    ! B1 }" E* b( m; J5 g4 c: K4 p5 X
58. blkCnt--;
    
59. }
      s. }7 y2 @+ G8 r4 Z4 H( r
60. 
    
61. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
    6 o" e0 n9 {% b" b* n' W( C
62. ** No loop unrolling is used. */
    
63. blkCnt = blockSize % 0x4u;
    & U4 ^. f3 n! Z# C
64. 
    1 y" V( [- U3 W! L% w9 n9 ~
65. while(blkCnt > 0u)
    . O" k+ N/ a8 f8 M
66. {
    7 z% o8 G( T& W/ Q
67. /* C = A * scale */
    - E' a+ g# D0 V3 n
68. /* Scale the input and then store the result in the destination buffer. */
    
69. *pDst++ = (q7_t) (__SSAT(((*pSrc++) * scaleFract) >> kShift, 8));
    3 o. g/ h9 D! {4 ~$ X+ [
70. 
    8 Q; s; ?7 k! Q6 i
71. /* Decrement the loop counter */
    # C% \0 A# N3 u) l
72. blkCnt--;
    
73. }
    
74. 
    
75. #else
    : ], V7 j! F3 x. o
76. 
    
77. /* Run the below code for Cortex-M0 */
    $ E: A9 G' s' }/ [7 H
78. 
    5 x2 g5 q% Q$ R% _5 D
79. /* Initialize blkCnt with number of samples */
    ) z& A9 n8 Q# l4 N2 T: s
80. blkCnt = blockSize;
    # q- Q8 a( y' H' P' g
81. 
    - g" q' |& D/ G# q) W3 A" M/ Z( O
82. while(blkCnt > 0u)
    
83. {
    0 z, V9 z% Z* Z  s5 C# ^# {
84. /* C = A * scale */
    ) A6 K. v% {0 N0 a$ a( a
85. /* Scale the input and then store the result in the destination buffer. */
    2 u% Y- ~1 g6 ]4 j
86. *pDst++ = (q7_t) (__SSAT((((q15_t) * pSrc++ * scaleFract) >> kShift), 8));
    + R$ ?% G% p  v" E0 i) F- x2 e" r/ i
87. 
    % t! v: O! S4 {8 [) D2 F! h
88. /* Decrement the loop counter */
    
89. blkCnt--;
    5 _+ M% L+ ^9 |0 j" W; [: h
90. }
    + _: l6 U% t9 ~1 l" `- V+ F- l% [
91. 
    
92. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
    3 M+ x$ g+ j* t
93. 
    3 t9 ^( G  y0 T. W- [& I5 b6 E
94. }

复制代码

1. 源数据和比例因子的数据格式都是Q7，这样的话，输出结果就是1.7 * 1.7 = 2.14格式，由于输出结果也是Q7格式，所以输出结果需要饱和处理。

2. 这个变量设计很巧妙，这样下面处理正数左移和负数右移就很方面了，可以直接使用一个右移就可以实现。

3. 对源数据和比例因子的输出结果做8位精度的饱和处理。

1 y7 g9 t" J# k! c' I9.5.5 实例讲解

实验目的：

    1. 四种种类型数据的比例放缩。

实验内容：

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

实验现象：

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

程序设计：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: DSP_Scale
   - K8 S, [' k. c% b' W* ?# U
4. *        功能说明: 比例因子
   ( D' R9 ^2 r1 e# l' R; N' @8 D
5. *        形 参：无
   
6. *        返 回 值: 无
   8 M2 C7 n$ D' q9 t9 O" B6 \; b
7. *********************************************************************************************************
   
8. */
   : f, x  s: z( J3 {% V( K% d
9. static void DSP_Scale(void)
   
10. {
    
11. static float32_t pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
    
12. static float32_t scale = 0.0f;
    
13. static float32_t pDst[5];
    
14. static q31_t pSrcA1[5] = {0x6fffffff,1,1,1,1};
    
15. static q31_t scale1 = 0x6fffffff;
    
16. static q31_t pDst1[5];
    " `4 K" ?+ p2 @  d
17. 
    $ ~! `0 k3 W" @' r% W' t% H2 r
18. static q15_t pSrcA2[5] = {0x6fff,1,1,1,1};
    # t7 D! o) S% b) s
19. static q15_t scale2 = 0x6fff;
    
20. static q15_t pDst2[5];
    + G, ^' e; z) T/ T- n. o
21. 
    4 \8 x* r4 y* t% W9 T0 g* \
22. static q7_t pSrcA3[5] = {0x70,1,1,1,1};
    2 }8 o/ L2 L: Z, O% a5 k
23. static q7_t scale3 = 0x6f;
    
24. static q7_t pDst3[5];
    : s. s+ _+ U# }1 X
25. 
    
26. scale += 0.1f;
    & G" P  C) g4 x
27. arm_scale_f32(pSrcA, scale, pDst, 5);
    1 O2 R) n/ c8 c5 O+ e- E- G& \
28. printf("arm_sub_f32 = %f\r\n", pDst[0]);
    7 k- P$ H0 h2 D( _! G$ @7 _
29. scale1 += 1;
    
30. arm_scale_q31(pSrcA1, scale1, 0, pDst1, 5);
    
31. printf("arm_scale_q31 = %x\r\n", pDst1[0]);
    7 F' n' _3 q  s! C! ?, F7 L$ ~. H
32. 
    & {) C4 H  X6 z7 e
33. scale2 += 1;
    
34. arm_scale_q15(pSrcA2, scale2, 0, pDst2, 5);
    & m6 r) s, e+ A7 V" I: v+ d6 r$ ]
35. printf("arm_scale_q15 = %x\r\n", pDst2[0]);
    . a$ J, L) A0 L" r+ s+ Q  ^6 ~1 l
36. 
    $ J/ e2 k6 D) f0 P, v! h
37. scale3 += 1;
    ! h  G( i/ k! l, \% G. T7 j" G
38. arm_scale_q7(pSrcA3, scale3, 0, pDst3, 5);
    
39. printf("arm_scale_q7 = %x\r\n", pDst3[0]);
    
40. printf("***********************************\r\n");
    # c6 q. }8 Q' N8 y0 H% r
41. }

复制代码

9.6 BasicMathFunctions的重要说明

    截至到这里，BasicMathFunctions函数已经讲解完了，也许大家也发现了这些函数的一些共同点，在前面第8章的时候我们简单的阐述过，这里再进一步的阐述一下：

l 这些函数基本都是支持重入的。

l 基本每个函数都有四种数据类型，F32，Q31，Q15，Q7。

l 函数中数值的处理基本都是4个为一组，这么做的原因是F32，Q31，Q15，Q7就可以统一采用一个程序设计架构，便于管理。更重要的是可以在Q15和Q7数据处理中很好的发挥SIMD指令的作用（因为4个为一组的话，可以用SIMD指令正好处理2个Q15数据或者4个Q7数据）。

l 部分函数是支持目标指针和源指针指向相同的缓冲区。

    关于这个的使用，我们没有在前面的讲解中举例子，下面举一个简单的例子进行说明，这里就以9.5小节中scale函数进行说明：

1. static void DSP_Scale(void)
   
2. {
   
3. static float32_t   pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
   
4. static float32_t   scale = 0.0f;  
   
5. static q31_t  pSrcA1[5] = {0x6fffffff,1,1,1,1};  
   - r! u* |4 p+ P
6. static q31_t  scale1 = 0x6fffffff;  
   1 R, @; g" W, d+ @
7. 
   
8. static q15_t  pSrcA2[5] = {0x6fff,1,1,1,1};  
   5 [( H" J& r$ V  v
9. static q15_t  scale2 = 0x6fff;  
   & M, E) b4 e( t, H, T% q- _. E
10. static q7_t  pSrcA3[5] = {0x70,1,1,1,1};
    
11. static q7_t  scale3 = 0x6f;  
    2 ^% ]8 Y- h3 ?; f: R% n) n' @- @
12. 
    6 I" B0 L" U1 o4 `: E( L
13. scale += 0.1f;
    
14. arm_scale_f32(pSrcA, scale, pSrcA, 5);              (1)
    . Q: w8 o- _0 [# n: S
15. printf("arm_sub_f32 = %f\r\n", pSrcA[0]);
    
16. scale1 += 1;
    1 [; p/ m7 f0 F2 O9 `' p
17. arm_scale_q31(pSrcA1, scale1, 0, pSrcA1, 5);        (2)
    / U6 L( B% ?$ @( F0 W2 {
18. printf("arm_scale_q31 = %x\r\n", pSrcA1[0]);
    ; }, G) @% g4 E+ ]% ^1 k7 z' w
19. 
    
20. scale2 += 1;
    
21. arm_scale_q15(pSrcA2, scale2, 0, pSrcA2, 5);        (3)
    
22. printf("arm_scale_q15 = %x\r\n", pSrcA2[0]);
    
23. 
    ; b: |/ I- {* q' O- v/ V+ U
24. scale3 += 1;
    $ |$ G5 X2 l/ h7 u
25. arm_scale_q7(pSrcA3, scale3, 0, pSrcA3, 5);         (4)
    % _' Q7 k& a" V  L: G( @
26. printf("arm_scale_q7 = %x\r\n", pSrcA3[0]);
    & ^1 \3 C% k8 f4 j% ~
27. printf("***********************************\r\n");
    ( l; l1 ]0 k9 I
28. }

复制代码

上面代码的（1）至（4）目标指针和源指针指向相同的缓冲区。

' Q4 Z* L6 ~; d$ x! k
/ p2 P$ U8 ~2 i( J7 I9.7 总结

    BasicMathFunctions函数就跟大家讲这么多，希望初学的同学多多的联系，并在自己以后的项目中多多使用，效果必将事半功倍。

学习一下。。。

不懂帮顶