【安富莱DSP教程】第8章 BasicMathFunctions的使用（一）

席萌0209

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

第8章 BasicMathFunctions的使用（一）

    本期教程开始学习ARM官方的DSP库，这里我们先从基本数学函数开始。本期教程主要讲绝对值，加法，点乘和乘法四种运算。
    8.1 绝对值（Vector Absolute Value）
    8.2 求和（Vector Addition）
    8.3 点乘（Vector Dot Product）
    8.4 乘法（Vector Multiplication）

8.1 绝对值（Vector Absolute Value）

    这部分函数主要用于求绝对值，公式描述如下：
    pDst[n] = abs(pSrc[n]),   0 <= n < blockSize.
    特别注意，这部分函数支持目标指针和源指针指向相同的缓冲区。

8.1.1 arm_abs_f32

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

1. /**        
2. * @brief Floating-point vector absolute value.                                                    （1）
3. * @param[in]       *pSrc points to the input buffer        
4. * @param[out]      *pDst points to the output buffer        
5. * @param[in]       blockSize number of samples in each vector        
6. * @return none.        
7. */
9. void arm_abs_f32(                                                                                  （2）
10.   float32_t * pSrc,
11.   float32_t * pDst,
12.   uint32_t blockSize)
13. {
14.   uint32_t blkCnt;                               /* loop counter */
16. #ifndef ARM_MATH_CM0_FAMILY                                                                        （3）
18.   /* Run the below code for Cortex-M4 and Cortex-M3 */
19.   float32_t in1, in2, in3, in4;                  /* temporary variables */
21.   /*loop Unrolling */
22.   blkCnt = blockSize >> 2u;                                                                        （4）
24.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
25.    ** a second loop below computes the remaining 1 to 3 samples. */
26.   while(blkCnt > 0u)
27.   {
28.     /* C = |A| */
29.     /* Calculate absolute and then store the results in the destination buffer. */
30.     /* read sample from source */
31.     in1 = *pSrc;
32.     in2 = *(pSrc + 1);
33.     in3 = *(pSrc + 2);
35.     /* find absolute value */
36.     in1 = fabsf(in1);                                                                             （5）
38.     /* read sample from source */
39.     in4 = *(pSrc + 3);
41.     /* find absolute value */
42.     in2 = fabsf(in2);
44.     /* read sample from source */
45.     *pDst = in1;
47.     /* find absolute value */
48.     in3 = fabsf(in3);
50.     /* find absolute value */
51.     in4 = fabsf(in4);
53.     /* store result to destination */
54.     *(pDst + 1) = in2;
56.     /* store result to destination */
57.     *(pDst + 2) = in3;
59.     /* store result to destination */
60.     *(pDst + 3) = in4;
63.     /* Update source pointer to process next sampels */                                            （6）
64.     pSrc += 4u;
66.     /* Update destination pointer to process next sampels */
67.     pDst += 4u;
69.     /* Decrement the loop counter */
70.     blkCnt--;
71.   }
73.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
74.    ** No loop unrolling is used. */
75.   blkCnt = blockSize % 0x4u;
77. #else                                                                                             （7）
79.   /* Run the below code for Cortex-M0 */
81.   /* Initialize blkCnt with number of samples */
82.   blkCnt = blockSize;
84. #endif /*   #ifndef ARM_MATH_CM0_FAMILY   */
86.   while(blkCnt > 0u)                                                                              （8）
87.   {
88.     /* C = |A| */
89.     /* Calculate absolute and then store the results in the destination buffer. */
90.     *pDst++ = fabsf(*pSrc++);
92.     /* Decrement the loop counter */
93.     blkCnt--;
94.   }
95. }

复制代码

1. 在这里简单的跟大家介绍一下DSP库中函数的通用格式，后面就不再赘述了。
    （1） 基本所有的函数都是可重入的。
    （2） 大部分函数都支持一组数的计算，比如这个函数arm_abs_f32就可以计算一组数的绝对值。所以如果只是就几个数的绝对值，用这个库函数就没有什么优势了。
    （3） 库函数基本是CM0，CM3和CM4都支持的（最新的DSP库已经添加CM7的支持）。
    （4） 每组数据基本上都是以4个数为一个单位进行计算，不够四个再单独计算。
    （5） 大部分函数都是配有f32，Q31，Q15和Q7四种格式。
2. 函数参数，支持输入一个数组进行计算绝对值。
3. 这部分代码是用于CM3和CM4内核。
4. 左移两位从而实现每4个数据为一组进行计算。
5. fabsf：这个函数不是用Cortex-M4F支持的DSP指令实现的，而是用C语言实现的，这个函数是被MDK封装起来的。
6. 切换到下一组数据。
7. 这部分代码用于CM0.
8. 用于不够4个数据的计算或者CM0内核。

8.1.2 arm_abs_q31

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

1. /**   
2. * @brief Q31 vector absolute value.   
3. * @param[in]       *pSrc points to the input buffer   
4. * @param[out]      *pDst points to the output buffer   
5. * @param[in]       blockSize number of samples in each vector   
6. * @return none.   
7. *   
8. * <b>Scaling and Overflow Behavior:</b>                                                              （1）
9. * \par   
10. * The function uses saturating arithmetic.   
11. * The Q31 value -1 (0x80000000) will be saturated to the maximum allowable positive value 0x7FFFFFFF.   
12. */
14. void arm_abs_q31(
15.   q31_t * pSrc,
16.   q31_t * pDst,
17.   uint32_t blockSize)
18. {
19.   uint32_t blkCnt;                               /* loop counter */
20.   q31_t in;                                      /* Input value */
22. #ifndef ARM_MATH_CM0_FAMILY
24.   /* Run the below code for Cortex-M4 and Cortex-M3 */
25.   q31_t in1, in2, in3, in4;
27.   /*loop Unrolling */
28.   blkCnt = blockSize >> 2u;
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. */
32.   while(blkCnt > 0u)
33.   {
34.     /* C = |A| */
35.     /* Calculate absolute of input (if -1 then saturated to 0x7fffffff) and then store the results in the destination buffer. */
36.     in1 = *pSrc++;
37.     in2 = *pSrc++;
38.     in3 = *pSrc++;
39.     in4 = *pSrc++;
41.     *pDst++ = (in1 > 0) ? in1 : (q31_t)__QSUB(0, in1);                                              （2）
42.     *pDst++ = (in2 > 0) ? in2 : (q31_t)__QSUB(0, in2);
43.     *pDst++ = (in3 > 0) ? in3 : (q31_t)__QSUB(0, in3);
44.     *pDst++ = (in4 > 0) ? in4 : (q31_t)__QSUB(0, in4);
46.     /* Decrement the loop counter */
47.     blkCnt--;
48.   }
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;
54. #else
56.   /* Run the below code for Cortex-M0 */
58.   /* Initialize blkCnt with number of samples */
59.   blkCnt = blockSize;
61. #endif /*   #ifndef ARM_MATH_CM0_FAMILY   */
63.   while(blkCnt > 0u)
64.   {
65.     /* C = |A| */
66.     /* Calculate absolute value of the input (if -1 then saturated to 0x7fffffff) and then store the results in the destination buffer. */
67.     in = *pSrc++;
68.     *pDst++ = (in > 0) ? in : ((in == INT32_MIN) ? INT32_MAX : -in);
70.     /* Decrement the loop counter */
71.     blkCnt--;
72.   }
74. }

复制代码

1. 这个函数使用了饱和运算，其实不光这个函数，后面很多函数都是使用了饱和运算的，关于什么是饱和运算，大家看Cortex-M3权威指南中文版的4.3.6 小节：汇编语言：饱和运算即可。
    对于Q31格式的数据，饱和运算会使得数据0x80000000变成0x7fffffff（这个数比较特殊，算是特殊处理，记住即可）。
2. 这里重点说一下函数__QSUB，其实这个函数算是Cortex-M4/M3的一个指令，用于实现饱和减法。
    比如函数：__QSUB(0, in1) 的作用就是实现0 – in1并返回结果。这里__QSUB实现的是32位数的饱和减法。还有__QSUB16和__QSUB8实现的是16位和8位数的减法。

8.1.3 arm_abs_q15

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

1. /**   
2. * @brief Q15 vector absolute value.   
3. * @param[in]       *pSrc points to the input buffer   
4. * @param[out]      *pDst points to the output buffer   
5. * @param[in]       blockSize number of samples in each vector   
6. * @return none.   
7. *   
8. * <b>Scaling and Overflow Behavior:</b>   
9. * \par   
10. * The function uses saturating arithmetic.   
11. * The Q15 value -1 (0x8000) will be saturated to the maximum allowable positive value 0x7FFF.       （1）
12. */
14. void arm_abs_q15(
15.   q15_t * pSrc,
16.   q15_t * pDst,
17.   uint32_t blockSize)
18. {
19.   uint32_t blkCnt;                               /* loop counter */
21. #ifndef ARM_MATH_CM0_FAMILY
22.   __SIMD32_TYPE *simd;                                                                               （2）
24. /* Run the below code for Cortex-M4 and Cortex-M3 */
26.   q15_t in1;                                     /* Input value1 */
27.   q15_t in2;                                     /* Input value2 */
30.   /*loop Unrolling */
31.   blkCnt = blockSize >> 2u;
33.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
34.    ** a second loop below computes the remaining 1 to 3 samples. */
35.   simd = __SIMD32_CONST(pDst);                                                                       （3）
36.   while(blkCnt > 0u)
37.   {
38.     /* C = |A| */
39.     /* Read two inputs */
40.     in1 = *pSrc++;
41.     in2 = *pSrc++;
44.     /* Store the Absolute result in the destination buffer by packing the two values, in a single cycle */
45. #ifndef  ARM_MATH_BIG_ENDIAN
46.     *simd++ =
47.       __PKHBT(((in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1)),                                           （4）
48.               ((in2 > 0) ? in2 : (q15_t)__QSUB16(0, in2)), 16);
50. #else
53.     *simd++ =
54.       __PKHBT(((in2 > 0) ? in2 : (q15_t)__QSUB16(0, in2)),
55.               ((in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1)), 16);
57. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
59.     in1 = *pSrc++;
60.     in2 = *pSrc++;
63. #ifndef  ARM_MATH_BIG_ENDIAN
65.     *simd++ =
66.       __PKHBT(((in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1)),
67.               ((in2 > 0) ? in2 : (q15_t)__QSUB16(0, in2)), 16);
69. #else
72.     *simd++ =
73.       __PKHBT(((in2 > 0) ? in2 : (q15_t)__QSUB16(0, in2)),
74.               ((in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1)), 16);
76. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
78.     /* Decrement the loop counter */
79.     blkCnt--;
80.   }
81.   pDst = (q15_t *)simd;
82.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
83.    ** No loop unrolling is used. */
84.   blkCnt = blockSize % 0x4u;
86.   while(blkCnt > 0u)
87.   {
88.     /* C = |A| */
89.     /* Read the input */
90.     in1 = *pSrc++;
92.     /* Calculate absolute value of input and then store the result in the destination buffer. */
93.     *pDst++ = (in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1);
95.     /* Decrement the loop counter */
96.     blkCnt--;
97.   }
99. #else
101.   /* Run the below code for Cortex-M0 */
103.   q15_t in;                                      /* Temporary input variable */
105.   /* Initialize blkCnt with number of samples */
106.   blkCnt = blockSize;
108.   while(blkCnt > 0u)
109.   {
110.     /* C = |A| */
111.     /* Read the input */
112.     in = *pSrc++;
114.     /* Calculate absolute value of input and then store the result in the destination buffer. */
115.     *pDst++ = (in > 0) ? in : ((in == (q15_t) 0x8000) ? 0x7fff : -in);
117.     /* Decrement the loop counter */
118.     blkCnt--;
119.   }
121. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
123. }

复制代码

1. 对于Q15格式的数据，饱和运算会使得数据0x8000变成0x7fff。
2. __SIMD32_TYPE的定义在文件arm_math.h中，具体定义如下：
    #define __SIMD32_TYPE int32_t __packed
    SIMD就是咱们上期教程所将的单指令多数据流。简单的理解就是__SIMD32_TYPE就是定义了一个int32_t类型的数据，__packed的含义就是实现字节的对齐功能，方便两个16位数据的都存入到这个数据类型中。
3. 函数__SIMD32_CONST的定义如下：
    #define __SIMD32_CONST(addr)  ((__SIMD32_TYPE *)(addr))
4. 函数__PKHBT的定义在文件core_cm4_simd.h，定义如下：
    #define __PKHBT(ARG1,ARG2,ARG3)   ( ((((uint32_t)(ARG1)) ) & 0x0000FFFFUL) |  \
                                                                 ((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL) )
    这个宏定义的作用就是将将两个16位的数据合并成32位数据。但是有一点要特别说明__PKHBT也是CM4内核支持的SIMD指令，上面的宏定义的C函数会被MDK自动识别并调用相应的PKHBT指令。__QSUB16用于实现16位数据的饱和减法。

8.1.4 arm_abs_q7

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

1. /**        
2. * @brief Q7 vector absolute value.        
3. * @param[in]       *pSrc points to the input buffer        
4. * @param[out]      *pDst points to the output buffer        
5. * @param[in]       blockSize number of samples in each vector        
6. * @return none.        
7. *   
8. * \par Conditions for optimum performance   
9. *  Input and output buffers should be aligned by 32-bit   
10. *   
11. *        
12. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
13. * \par        
14. * The function uses saturating arithmetic.        
15. * The Q7 value -1 (0x80) will be saturated to the maximum allowable positive value 0x7F.        
16. */
18. void arm_abs_q7(
19.   q7_t * pSrc,
20.   q7_t * pDst,
21.   uint32_t blockSize)
22. {
23.   uint32_t blkCnt;                               /* loop counter */
24.   q7_t in;                                       /* Input value1 */
26. #ifndef ARM_MATH_CM0_FAMILY
28.   /* Run the below code for Cortex-M4 and Cortex-M3 */
29.   q31_t in1, in2, in3, in4;                      /* temporary input variables */
30.   q31_t out1, out2, out3, out4;                  /* temporary output variables */
32.   /*loop Unrolling */
33.   blkCnt = blockSize >> 2u;
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. */
37.   while(blkCnt > 0u)
38.   {
39.     /* C = |A| */
40.     /* Read inputs */
41.     in1 = (q31_t) * pSrc;
42.     in2 = (q31_t) * (pSrc + 1);
43.     in3 = (q31_t) * (pSrc + 2);
45.     /* find absolute value */
46.     out1 = (in1 > 0) ? in1 : (q31_t)__QSUB8(0, in1);                                                  (2)
48.     /* read input */
49.     in4 = (q31_t) * (pSrc + 3);
51.     /* find absolute value */
52.     out2 = (in2 > 0) ? in2 : (q31_t)__QSUB8(0, in2);
54.     /* store result to destination */
55.     *pDst = (q7_t) out1;
57.     /* find absolute value */
58.     out3 = (in3 > 0) ? in3 : (q31_t)__QSUB8(0, in3);
60.     /* find absolute value */
61.     out4 = (in4 > 0) ? in4 : (q31_t)__QSUB8(0, in4);
63.     /* store result to destination */
64.     *(pDst + 1) = (q7_t) out2;
66.     /* store result to destination */
67.     *(pDst + 2) = (q7_t) out3;
69.     /* store result to destination */
70.     *(pDst + 3) = (q7_t) out4;
72.     /* update pointers to process next samples */
73.     pSrc += 4u;
74.     pDst += 4u;
76.     /* Decrement the loop counter */
77.     blkCnt--;
78.   }
80.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
81.    ** No loop unrolling is used. */
82.   blkCnt = blockSize % 0x4u;
83. #else
85.   /* Run the below code for Cortex-M0 */
86.   blkCnt = blockSize;
88. #endif //      #define ARM_MATH_CM0_FAMILY
90.   while(blkCnt > 0u)
91.   {
92.     /* C = |A| */
93.     /* Read the input */
94.     in = *pSrc++;
96.     /* Store the Absolute result in the destination buffer */
97.     *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? 0x7f : -in);
99.     /* Decrement the loop counter */
100.     blkCnt--;
101.   }
102. }

复制代码

1. 由于饱和运算，0x80求绝对值将变成数据0x7F。
2. __QSUB8用以实现8位数的饱和减法运算。

8.1.5 实例讲解

实验目的：
    1. 四种数据类型数据绝对值求解
实验内容：
    1. 按下按键K1, 串口打印输出结果
实验现象：
    通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: DSP_ABS
4. *    功能说明: 求绝对值
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void DSP_ABS(void)
10. {
11. static float32_t pSrc;
12.     static float32_t pDst;
13. static q31_t pSrc1;
14. static q31_t pDst1;
15. static q15_t pSrc2;
16. static q15_t pDst2;
17. static q7_t pSrc3 = 127; /* 为了说明问题，在这里设置初始值为127，然后查看0x80是否饱和为0x7F */
18. static q7_t pDst3;
19. pSrc -= 1.23f;
20. arm_abs_f32(&pSrc, &pDst, 1);                                                                    (1)
21. printf("arm_abs_f32 = %f\r\n", pDst);
23. pSrc1 -= 1;
24. arm_abs_q31(&pSrc1, &pDst1, 1);                                                                  (2)
25. printf("arm_abs_q31 = %d\r\n", pDst1);
27. pSrc2 -= 1;
28. arm_abs_q15(&pSrc2, &pDst2, 1);                                                                  (3)
29. printf("arm_abs_q15 = %d\r\n", pDst2);
31. pSrc3 += 1;
32. printf("pSrc3 = %d\r\n", pSrc3);
33. arm_abs_q7(&pSrc3, &pDst3, 1);                                                                   (4)
34. printf("arm_abs_q7 = %d\r\n", pDst3);
35. printf("***********************************\r\n");
36. }

复制代码

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

席萌0209

8.2 求和（Vector Addition）

    这部分函数主要用于求和，公式描述如下：
    pDst[n] = pSrcA[n] + pSrcB[n],   0 <= n < blockSize.

8.2.1 arm_add_f32

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

1. /**
2. * @brief Floating-point vector addition.
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[out] *pDst points to the output vector
6. * @param[in] blockSize number of samples in each vector
7. * @return none.
8. */
10. void arm_add_f32(
11. float32_t * pSrcA,
12. float32_t * pSrcB,
13. float32_t * pDst,
14. uint32_t blockSize)
15. {
16. uint32_t blkCnt; /* loop counter */
18. #ifndef ARM_MATH_CM0_FAMILY
20. /* Run the below code for Cortex-M4 and Cortex-M3 */
21. float32_t inA1, inA2, inA3, inA4; /* temporary input variabels */
22. float32_t inB1, inB2, inB3, inB4; /* temporary input variables */
24. /*loop Unrolling */
25. blkCnt = blockSize >> 2u;
27. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
28. ** a second loop below computes the remaining 1 to 3 samples. */
29. while(blkCnt > 0u)
30. {
31. /* C = A + B */
32. /* Add and then store the results in the destination buffer. */
34. /* read four inputs from sourceA and four inputs from sourceB */
35. inA1 = *pSrcA;
36. inB1 = *pSrcB;
37. inA2 = *(pSrcA + 1);
38. inB2 = *(pSrcB + 1);
39. inA3 = *(pSrcA + 2);
40. inB3 = *(pSrcB + 2);
41. inA4 = *(pSrcA + 3);
42. inB4 = *(pSrcB + 3);
44. /* C = A + B */ (1)
45. /* add and store result to destination */
46. *pDst = inA1 + inB1;
47. *(pDst + 1) = inA2 + inB2;
48. *(pDst + 2) = inA3 + inB3;
49. *(pDst + 3) = inA4 + inB4;
51. /* update pointers to process next samples */
52. pSrcA += 4u;
53. pSrcB += 4u;
54. pDst += 4u;
57. /* Decrement the loop counter */
58. blkCnt--;
59. }
61. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
62. ** No loop unrolling is used. */
63. blkCnt = blockSize % 0x4u;
65. #else
67. /* Run the below code for Cortex-M0 */
69. /* Initialize blkCnt with number of samples */
70. blkCnt = blockSize;
72. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
74. while(blkCnt > 0u)
75. {
76. /* C = A + B */
77. /* Add and then store the results in the destination buffer. */
78. *pDst++ = (*pSrcA++) + (*pSrcB++);
80. /* Decrement the loop counter */
81. blkCnt--;
82. }
83. }

复制代码

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

8.2.2 arm_add_q31

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

1. /**
2. * @brief Q31 vector addition.
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[out] *pDst points to the output vector
6. * @param[in] blockSize number of samples in each vector
7. * @return none.
8. *
9. * <b>Scaling and Overflow Behavior:</b> (1)
10. * par
11. * The function uses saturating arithmetic.
12. * Results outside of the allowable Q31 range[0x80000000 0x7FFFFFFF] will be saturated.
13. */
15. void arm_add_q31(
16. q31_t * pSrcA,
17. q31_t * pSrcB,
18. q31_t * pDst,
19. uint32_t blockSize)
20. {
21. uint32_t blkCnt; /* loop counter */
23. #ifndef ARM_MATH_CM0_FAMILY
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
26. q31_t inA1, inA2, inA3, inA4;
27. q31_t inB1, inB2, inB3, inB4;
29. /*loop Unrolling */
30. blkCnt = blockSize >> 2u;
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. */
34. while(blkCnt > 0u)
35. {
36. /* C = A + B */
37. /* Add and then store the results in the destination buffer. */
38. inA1 = *pSrcA++;
39. inA2 = *pSrcA++;
40. inB1 = *pSrcB++;
41. inB2 = *pSrcB++;
43. inA3 = *pSrcA++;
44. inA4 = *pSrcA++;
45. inB3 = *pSrcB++;
46. inB4 = *pSrcB++;
48. *pDst++ = __QADD(inA1, inB1); (2)
49. *pDst++ = __QADD(inA2, inB2);
50. *pDst++ = __QADD(inA3, inB3);
51. *pDst++ = __QADD(inA4, inB4);
53. /* Decrement the loop counter */
54. blkCnt--;
55. }
57. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
58. ** No loop unrolling is used. */
59. blkCnt = blockSize % 0x4u;
61. while(blkCnt > 0u)
62. {
63. /* C = A + B */
64. /* Add and then store the results in the destination buffer. */
65. *pDst++ = __QADD(*pSrcA++, *pSrcB++);
67. /* Decrement the loop counter */
68. blkCnt--;
69. }
71. #else
73. /* Run the below code for Cortex-M0 */
77. /* Initialize blkCnt with number of samples */
78. blkCnt = blockSize;
80. while(blkCnt > 0u)
81. {
82. /* C = A + B */
83. /* Add and then store the results in the destination buffer. */
84. *pDst++ = (q31_t) clip_q63_to_q31((q63_t) * pSrcA++ + *pSrcB++); (3)
86. /* Decrement the loop counter */
87. blkCnt--;
88. }
90. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
92. }

复制代码

1. 这个函数也是饱和运算，输出结果的范围[0x80000000 0x7FFFFFFF]，超出这个结果将产生饱和结果。
2. __QADD实现32位数的加法。
3. 函数clip_q63_to_q31的定义在文件arm_math.h里面
      static __INLINE q31_t clip_q63_to_q31(
      q63_t x)
      {
          return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ?
            ((0x7FFFFFFF ^ ((q31_t) (x >> 63)))) : (q31_t) x;
          }
    这个函数的作用是实现饱和结果。

8.2.3 arm_add_q15

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

1. /**
2. * @brief Q15 vector addition.
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[out] *pDst points to the output vector
6. * @param[in] blockSize number of samples in each vector
7. * @return none.
8. *
9. * <b>Scaling and Overflow Behavior:</b> (1)
10. * par
11. * The function uses saturating arithmetic.
12. * Results outside of the allowable Q15 range [0x8000 0x7FFF] will be saturated.
13. */
15. void arm_add_q15(
16. q15_t * pSrcA,
17. q15_t * pSrcB,
18. q15_t * pDst,
19. uint32_t blockSize)
20. {
21. uint32_t blkCnt; /* loop counter */
23. #ifndef ARM_MATH_CM0_FAMILY
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
26. q31_t inA1, inA2, inB1, inB2;
28. /*loop Unrolling */
29. blkCnt = blockSize >> 2u;
31. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
32. ** a second loop below computes the remaining 1 to 3 samples. */
33. while(blkCnt > 0u)
34. {
35. /* C = A + B */ (2)
36. /* Add and then store the results in the destination buffer. */
37. inA1 = *__SIMD32(pSrcA)++;
38. inA2 = *__SIMD32(pSrcA)++;
39. inB1 = *__SIMD32(pSrcB)++;
40. inB2 = *__SIMD32(pSrcB)++;
42. *__SIMD32(pDst)++ = __QADD16(inA1, inB1);
43. *__SIMD32(pDst)++ = __QADD16(inA2, inB2);
45. /* Decrement the loop counter */
46. blkCnt--;
47. }
49. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
50. ** No loop unrolling is used. */
51. blkCnt = blockSize % 0x4u;
53. while(blkCnt > 0u)
54. {
55. /* C = A + B */
56. /* Add and then store the results in the destination buffer. */
57. *pDst++ = (q15_t) __QADD16(*pSrcA++, *pSrcB++);
59. /* Decrement the loop counter */
60. blkCnt--;
61. }
63. #else
65. /* Run the below code for Cortex-M0 */
69. /* Initialize blkCnt with number of samples */
70. blkCnt = blockSize;
72. while(blkCnt > 0u)
73. {
74. /* C = A + B */
75. /* Add and then store the results in the destination buffer. */
76. *pDst++ = (q15_t) __SSAT(((q31_t) * pSrcA++ + *pSrcB++), 16); (3)
78. /* Decrement the loop counter */
79. blkCnt--;
80. }
82. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
85. }

复制代码

1. 这个函数也是饱和运算，输出结果的范围[0x8000 0x7FFF]，超出这个结果将产生饱和结果。
2. 函数inA1 = *__SIMD32(pSrcA)++仅需要一条SIMD指令即可完成将两个16位数存到32位的变量inA1中。
3. __SSAT也是SIMD指令，这里是将结果饱和到16位精度。

8.2.4 arm_add_q7

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

1. /**
2. * @brief Q7 vector addition.
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[out] *pDst points to the output vector
6. * @param[in] blockSize number of samples in each vector
7. * @return none.
8. *
9. * <b>Scaling and Overflow Behavior:</b> (1)
10. * par
11. * The function uses saturating arithmetic.
12. * Results outside of the allowable Q7 range [0x80 0x7F] will be saturated.
13. */
15. void arm_add_q7(
16. q7_t * pSrcA,
17. q7_t * pSrcB,
18. q7_t * pDst,
19. uint32_t blockSize)
20. {
21. uint32_t blkCnt; /* loop counter */
23. #ifndef ARM_MATH_CM0_FAMILY
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
28. /*loop Unrolling */
29. blkCnt = blockSize >> 2u;
31. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
32. ** a second loop below computes the remaining 1 to 3 samples. */
33. while(blkCnt > 0u)
34. {
35. /* C = A + B */
36. /* Add and then store the results in the destination buffer. */ (2)
37. *__SIMD32(pDst)++ = __QADD8(*__SIMD32(pSrcA)++, *__SIMD32(pSrcB)++);
39. /* Decrement the loop counter */
40. blkCnt--;
41. }
43. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
44. ** No loop unrolling is used. */
45. blkCnt = blockSize % 0x4u;
47. while(blkCnt > 0u)
48. {
49. /* C = A + B */
50. /* Add and then store the results in the destination buffer. */
51. *pDst++ = (q7_t) __SSAT(*pSrcA++ + *pSrcB++, 8);
53. /* Decrement the loop counter */
54. blkCnt--;
55. }
57. #else
59. /* Run the below code for Cortex-M0 */
63. /* Initialize blkCnt with number of samples */
64. blkCnt = blockSize;
66. while(blkCnt > 0u)
67. {
68. /* C = A + B */
69. /* Add and then store the results in the destination buffer. */
70. *pDst++ = (q7_t) __SSAT((q15_t) * pSrcA++ + *pSrcB++, 8);
72. /* Decrement the loop counter */
73. blkCnt--;
74. }
76. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
79. }

复制代码

1． 这个函数也是饱和运算，输出结果的范围[0x80 0x7F]，超出这个结果将产生饱和。
2． 这里通过SIMD指令实现4组8位数的加法。

8.2.5 实例讲解

实验目的：
    1. 四种类似数据的求和
实验内容：
    1. 按下按键K2, 串口打印输出结果
实验现象：
    通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: DSP_ABS
4. *    功能说明: 加法
5. *    形 参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void DSP_Add(void)
10. {
11. static float32_t pSrcA;
12. static float32_t pSrcB;
13. static float32_t pDst;
14. static q31_t pSrcA1;
15. static q31_t pSrcB1;
16. static q31_t pDst1;
18. static q15_t pSrcA2;
19. static q15_t pSrcB2;
20. static q15_t pDst2;
22. static q7_t pSrcA3;
23. static q7_t pSrcB3;
24. static q7_t pDst3;
26. pSrcA--;
27. arm_add_f32(&pSrcA, &pSrcB, &pDst, 1);
28. printf("arm_add_f32 = %frn", pDst);
30. pSrcA1--;
31. arm_add_q31(&pSrcA1, &pSrcB1, &pDst1, 1);
32. printf("arm_add_q31 = %drn", pDst1);
34. pSrcA2--;
35. arm_add_q15(&pSrcA2, &pSrcB2, &pDst2, 1);
36. printf("arm_add_q15 = %drn", pDst2);
38. pSrcA3--;
39. arm_add_q7(&pSrcA3, &pSrcB3, &pDst3, 1);
40. printf("arm_add_q7 = %drn", pDst3);
41. printf("***********************************rn");
42. }

复制代码

席萌0209

8.3 点乘（Vector Dot Product）

    这部分函数主要用于点乘，公式描述如下：
sum = pSrcA[0]*pSrcB[0] + pSrcA[1]*pSrcB[1] + ... + pSrcA[blockSize-1]*pSrcB[blockSize-1]

8.3.1 arm_dot_prod_f32

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

1. /**
2. * @defgroup dot_prod Vector Dot Product
3. *
4. * Computes the dot product of two vectors.
5. * The vectors are multiplied element-by-element and then summed.
6. *
7. * <pre>
8. * sum = pSrcA[0]*pSrcB[0] + pSrcA[1]*pSrcB[1] + ... + pSrcA[blockSize-1]*pSrcB[blockSize-1]
9. * </pre>
10. *
11. * There are separate functions for floating-point, Q7, Q15, and Q31 data types.
12. */
14. /**
15. * @addtogroup dot_prod
16. * @{
17. */
19. /**
20. * @brief Dot product of floating-point vectors.
21. * @param[in] *pSrcA points to the first input vector
22. * @param[in] *pSrcB points to the second input vector
23. * @param[in] blockSize number of samples in each vector
24. * @param[out] *result output result returned here
25. * @return none.
26. */
29. void arm_dot_prod_f32(
30. float32_t * pSrcA,
31. float32_t * pSrcB,
32. uint32_t blockSize,
33. float32_t * result)
34. {
35. float32_t sum = 0.0f; /* Temporary result storage */ (1)
36. uint32_t blkCnt; /* loop counter */
39. #ifndef ARM_MATH_CM0_FAMILY
41. /* Run the below code for Cortex-M4 and Cortex-M3 */
42. /*loop Unrolling */
43. blkCnt = blockSize >> 2u;
45. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
46. ** a second loop below computes the remaining 1 to 3 samples. */
47. while(blkCnt > 0u)
48. {
49. /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
50. /* Calculate dot product and then store the result in a temporary buffer */
51. sum += (*pSrcA++) * (*pSrcB++); (2)
52. sum += (*pSrcA++) * (*pSrcB++);
53. sum += (*pSrcA++) * (*pSrcB++);
54. sum += (*pSrcA++) * (*pSrcB++);
56. /* Decrement the loop counter */
57. blkCnt--;
58. }
60. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
61. ** No loop unrolling is used. */
62. blkCnt = blockSize % 0x4u;
64. #else
66. /* Run the below code for Cortex-M0 */
68. /* Initialize blkCnt with number of samples */
69. blkCnt = blockSize;
71. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
74. while(blkCnt > 0u)
75. {
76. /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
77. /* Calculate dot product and then store the result in a temporary buffer. */
78. sum += (*pSrcA++) * (*pSrcB++);
80. /* Decrement the loop counter */
81. blkCnt--;
82. }
83. /* Store the result back in the destination buffer */
84. *result = sum;
85. }

复制代码

1. 由于CM4上带的FPU是单精度的，所以初始化float32_t类型的浮点数时需要在数据的末尾加上f。
2. 类似函数sum += (*pSrcA++) * (*pSrcB++)最终会通过浮点的MAC（乘累加）实现，从而加快执行时间。

8.3.2 arm_dot_prod_q31

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

1. /**
2. * @brief Dot product of Q31 vectors.
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[in] blockSize number of samples in each vector
6. * @param[out] *result output result returned here
7. * @return none.
8. *
9. * <b>Scaling and Overflow Behavior:</b> (1)
10. * par
11. * The intermediate multiplications are in 1.31 x 1.31 = 2.62 format and these
12. * are truncated to 2.48 format by discarding the lower 14 bits.
13. * The 2.48 result is then added without saturation to a 64-bit accumulator in 16.48 format.
14. * There are 15 guard bits in the accumulator and there is no risk of overflow as long as
15. * the length of the vectors is less than 2^16 elements.
16. * The return result is in 16.48 format.
17. */
19. void arm_dot_prod_q31(
20. q31_t * pSrcA,
21. q31_t * pSrcB,
22. uint32_t blockSize,
23. q63_t * result)
24. {
25. q63_t sum = 0; /* Temporary result storage */
26. uint32_t blkCnt; /* loop counter */
29. #ifndef ARM_MATH_CM0_FAMILY
31. /* Run the below code for Cortex-M4 and Cortex-M3 */
32. q31_t inA1, inA2, inA3, inA4;
33. q31_t inB1, inB2, inB3, inB4;
35. /*loop Unrolling */
36. blkCnt = blockSize >> 2u;
38. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
39. ** a second loop below computes the remaining 1 to 3 samples. */
40. while(blkCnt > 0u)
41. {
42. /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
43. /* Calculate dot product and then store the result in a temporary buffer. */
44. inA1 = *pSrcA++;
45. inA2 = *pSrcA++;
46. inA3 = *pSrcA++;
47. inA4 = *pSrcA++;
48. inB1 = *pSrcB++;
49. inB2 = *pSrcB++;
50. inB3 = *pSrcB++;
51. inB4 = *pSrcB++;
53. sum += ((q63_t) inA1 * inB1) >> 14u; (2)
54. sum += ((q63_t) inA2 * inB2) >> 14u;
55. sum += ((q63_t) inA3 * inB3) >> 14u;
56. sum += ((q63_t) inA4 * inB4) >> 14u;
58. /* Decrement the loop counter */
59. blkCnt--;
60. }
62. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
63. ** No loop unrolling is used. */
64. blkCnt = blockSize % 0x4u;
66. #else
68. /* Run the below code for Cortex-M0 */
70. /* Initialize blkCnt with number of samples */
71. blkCnt = blockSize;
73. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
76. while(blkCnt > 0u)
77. {
78. /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
79. /* Calculate dot product and then store the result in a temporary buffer. */
80. sum += ((q63_t) * pSrcA++ * *pSrcB++) >> 14u;
82. /* Decrement the loop counter */
83. blkCnt--;
84. }
86. /* Store the result in the destination buffer in 16.48 format */
87. *result = sum;
88. }

复制代码

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

8.3.3 arm_dot_prod_q15

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

1. /**
2. * @brief Dot product of Q15 vectors.
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[in] blockSize number of samples in each vector
6. * @param[out] *result output result returned here
7. * @return none.
8. *
9. * <b>Scaling and Overflow Behavior:</b> (1)
10. * par
11. * The intermediate multiplications are in 1.15 x 1.15 = 2.30 format and these
12. * results are added to a 64-bit accumulator in 34.30 format.
13. * Nonsaturating additions are used and given that there are 33 guard bits in the accumulator
14. * there is no risk of overflow.
15. * The return result is in 34.30 format.
16. */
18. void arm_dot_prod_q15(
19. q15_t * pSrcA,
20. q15_t * pSrcB,
21. uint32_t blockSize,
22. q63_t * result)
23. {
24. q63_t sum = 0; /* Temporary result storage */
25. uint32_t blkCnt; /* loop counter */
27. #ifndef ARM_MATH_CM0_FAMILY
29. /* Run the below code for Cortex-M4 and Cortex-M3 */
32. /*loop Unrolling */
33. blkCnt = blockSize >> 2u;
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. */
37. while(blkCnt > 0u)
38. {
39. /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */ (2)
40. /* Calculate dot product and then store the result in a temporary buffer. */
41. sum = __SMLALD(*__SIMD32(pSrcA)++, *__SIMD32(pSrcB)++, sum);
42. sum = __SMLALD(*__SIMD32(pSrcA)++, *__SIMD32(pSrcB)++, sum);
44. /* Decrement the loop counter */
45. blkCnt--;
46. }
48. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
49. ** No loop unrolling is used. */
50. blkCnt = blockSize % 0x4u;
52. while(blkCnt > 0u)
53. {
54. /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
55. /* Calculate dot product and then store the results in a temporary buffer. */
56. sum = __SMLALD(*pSrcA++, *pSrcB++, sum);
58. /* Decrement the loop counter */
59. blkCnt--;
60. }
63. #else
65. /* Run the below code for Cortex-M0 */
67. /* Initialize blkCnt with number of samples */
68. blkCnt = blockSize;
70. while(blkCnt > 0u)
71. {
72. /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
73. /* Calculate dot product and then store the results in a temporary buffer. */
74. sum += (q63_t) ((q31_t) * pSrcA++ * *pSrcB++);
76. /* Decrement the loop counter */
77. blkCnt--;
78. }
80. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
82. /* Store the result in the destination buffer in 34.30 format */
83. *result = sum;
85. }

复制代码

1． 两个Q15格式的数据相乘，那么输出结果的格式是1.15*1.15 = 2.30，这个函数将输出结果赋值给了64位变量，那么输出结果就是34.30格式。所以基本没有溢出的危险。
2． __SMLALD也是SIMD指令，实现两个16位数相乘，并把结果累加给64位变量。

8.3.4 arm_dot_prod_q7

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

1. /**
2. * @brief Dot product of Q7 vectors.
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[in] blockSize number of samples in each vector
6. * @param[out] *result output result returned here
7. * @return none.
8. *
9. * <b>Scaling and Overflow Behavior:</b> (1)
10. * par
11. * The intermediate multiplications are in 1.7 x 1.7 = 2.14 format and these
12. * results are added to an accumulator in 18.14 format.
13. * Nonsaturating additions are used and there is no danger of wrap around as long as
14. * the vectors are less than 2^18 elements long.
15. * The return result is in 18.14 format.
16. */
18. void arm_dot_prod_q7(
19. q7_t * pSrcA,
20. q7_t * pSrcB,
21. uint32_t blockSize,
22. q31_t * result)
23. {
24. uint32_t blkCnt; /* loop counter */
26. q31_t sum = 0; /* Temporary variables to store output */
28. #ifndef ARM_MATH_CM0_FAMILY
30. /* Run the below code for Cortex-M4 and Cortex-M3 */
32. q31_t input1, input2; /* Temporary variables to store input */
33. q31_t inA1, inA2, inB1, inB2; /* Temporary variables to store input */
37. /*loop Unrolling */
38. blkCnt = blockSize >> 2u;
40. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
41. ** a second loop below computes the remaining 1 to 3 samples. */
42. while(blkCnt > 0u)
43. {
44. /* read 4 samples at a time from sourceA */ (2)
45. input1 = *__SIMD32(pSrcA)++;
46. /* read 4 samples at a time from sourceB */
47. input2 = *__SIMD32(pSrcB)++;
49. /* extract two q7_t samples to q15_t samples */
50. inA1 = __SXTB16(__ROR(input1, 8)); (3)
51. /* extract reminaing two samples */
52. inA2 = __SXTB16(input1);
53. /* extract two q7_t samples to q15_t samples */
54. inB1 = __SXTB16(__ROR(input2, 8));
55. /* extract reminaing two samples */
56. inB2 = __SXTB16(input2);
58. /* multiply and accumulate two samples at a time */
59. sum = __SMLAD(inA1, inB1, sum); (4)
60. sum = __SMLAD(inA2, inB2, sum);
62. /* Decrement the loop counter */
63. blkCnt--;
64. }
66. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
67. ** No loop unrolling is used. */
68. blkCnt = blockSize % 0x4u;
70. while(blkCnt > 0u)
71. {
72. /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
73. /* Dot product and then store the results in a temporary buffer. */
74. sum = __SMLAD(*pSrcA++, *pSrcB++, sum);
76. /* Decrement the loop counter */
77. blkCnt--;
78. }
80. #else
82. /* Run the below code for Cortex-M0 */
86. /* Initialize blkCnt with number of samples */
87. blkCnt = blockSize;
89. while(blkCnt > 0u)
90. {
91. /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
92. /* Dot product and then store the results in a temporary buffer. */
93. sum += (q31_t) ((q15_t) * pSrcA++ * *pSrcB++);
95. /* Decrement the loop counter */
96. blkCnt--;
97. }
99. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
102. /* Store the result in the destination buffer in 18.14 format */
103. *result = sum;
104. }

复制代码

1. 两个Q8格式的数据相乘，那么输出结果就是1.7*1.7 = 2.14格式。这里将最终结果赋值给了32位的变量，那么最终的格式就是18.14。如果乘累加的个数小于2^18那么就不会有溢出的危险（感觉这里应该是2^16）。
2. 一次读取4个8位的数据。
3. __SXTB16也是SIMD指令，用于将两个8位的有符号数扩展成16位。__ROR用于实现数据的循环右移。
4. __SMLAD也是SIMD指令，用于实现如下功能：
    sum = __SMLAD(x, y, z)
    sum = z + ((short)(x>>16) * (short)(y>>16)) + ((short)x * (short)y)

8.3.5 实例讲解

实验目的：
    1. 四种类型数据的点乘。
实验内容：
    1. 按下按键K3, 串口打印输出结果
实验现象：
     通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: DSP_DotProduct
4. *    功能说明: 乘积
5. *    形 参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void DSP_DotProduct(void)
10. {
11. static float32_t pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
12. static float32_t pSrcB[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
13. static float32_t result;
14. static q31_t pSrcA1[5] = {0x7ffffff0,1,1,1,1};
15. static q31_t pSrcB1[5] = {1,1,1,1,1};
16. static q63_t result1;
18. static q15_t pSrcA2[5] = {1,1,1,1,1};
19. static q15_t pSrcB2[5] = {1,1,1,1,1};
20. static q63_t result2;
22. static q7_t pSrcA3[5] = {1,1,1,1,1};
23. static q7_t pSrcB3[5] = {1,1,1,1,1};
24. static q31_t result3;
26. pSrcA[0] -= 1.1f;
27. arm_dot_prod_f32(pSrcA, pSrcB, 5, &result);
28. printf("arm_dot_prod_f32 = %frn", result);
29. pSrcA1[0] -= 0xffff;
30. arm_dot_prod_q31(pSrcA1, pSrcB1, 5, &result1);
31. printf("arm_dot_prod_q31 = %lldrn", result1);
33. pSrcA2[0] -= 1;
34. arm_dot_prod_q15(pSrcA2, pSrcB2, 5, &result2);
35. printf("arm_dot_prod_q15 = %lldrn", result2);
37. pSrcA3[0] -= 1;
38. arm_dot_prod_q7(pSrcA3, pSrcB3, 5, &result3);
39. printf("arm_dot_prod_q7 = %drn", result3);
40. printf("***********************************rn");
41. }

复制代码

席萌0209

8.4 乘法（Vector Multiplication）

    这部分函数主要用于乘法，公式描述如下：
    pDst[n] = pSrcA[n] * pSrcB[n],   0 <= n < blockSize.   

8.4.1 arm_mult_f32

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

1. /**
2. * @brief Floating-point vector multiplication.
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[out] *pDst points to the output vector
6. * @param[in] blockSize number of samples in each vector
7. * @return none.
8. */
10. void arm_mult_f32(
11. float32_t * pSrcA,
12. float32_t * pSrcB,
13. float32_t * pDst,
14. uint32_t blockSize)
15. {
16. uint32_t blkCnt; /* loop counters */
17. #ifndef ARM_MATH_CM0_FAMILY
19. /* Run the below code for Cortex-M4 and Cortex-M3 */
20. float32_t inA1, inA2, inA3, inA4; /* temporary input variables */
21. float32_t inB1, inB2, inB3, inB4; /* temporary input variables */
22. float32_t out1, out2, out3, out4; /* temporary output variables */
24. /* loop Unrolling */
25. blkCnt = blockSize >> 2u;
27. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
28. ** a second loop below computes the remaining 1 to 3 samples. */
29. while(blkCnt > 0u)
30. {
31. /* C = A * B */
32. /* Multiply the inputs and store the results in output buffer */ (1)
33. /* read sample from sourceA */
34. inA1 = *pSrcA;
35. /* read sample from sourceB */
36. inB1 = *pSrcB;
37. /* read sample from sourceA */
38. inA2 = *(pSrcA + 1);
39. /* read sample from sourceB */
40. inB2 = *(pSrcB + 1);
42. /* out = sourceA * sourceB */
43. out1 = inA1 * inB1;
45. /* read sample from sourceA */
46. inA3 = *(pSrcA + 2);
47. /* read sample from sourceB */
48. inB3 = *(pSrcB + 2);
50. /* out = sourceA * sourceB */
51. out2 = inA2 * inB2;
53. /* read sample from sourceA */
54. inA4 = *(pSrcA + 3);
56. /* store result to destination buffer */
57. *pDst = out1;
59. /* read sample from sourceB */
60. inB4 = *(pSrcB + 3);
62. /* out = sourceA * sourceB */
63. out3 = inA3 * inB3;
65. /* store result to destination buffer */
66. *(pDst + 1) = out2;
68. /* out = sourceA * sourceB */
69. out4 = inA4 * inB4;
70. /* store result to destination buffer */
71. *(pDst + 2) = out3;
72. /* store result to destination buffer */
73. *(pDst + 3) = out4;
76. /* update pointers to process next samples */
77. pSrcA += 4u;
78. pSrcB += 4u;
79. pDst += 4u;
81. /* Decrement the blockSize loop counter */
82. blkCnt--;
83. }
85. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
86. ** No loop unrolling is used. */
87. blkCnt = blockSize % 0x4u;
89. #else
91. /* Run the below code for Cortex-M0 */
93. /* Initialize blkCnt with number of samples */
94. blkCnt = blockSize;
96. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
98. while(blkCnt > 0u)
99. {
100. /* C = A * B */
101. /* Multiply the inputs and store the results in output buffer */
102. *pDst++ = (*pSrcA++) * (*pSrcB++);
104. /* Decrement the blockSize loop counter */
105. blkCnt--;
106. }
107. }

复制代码

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

8.4.2 arm_mult_q31

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

1. /**
2. * @brief Q31 vector multiplication.
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[out] *pDst points to the output vector
6. * @param[in] blockSize number of samples in each vector
7. * @return none.
8. *
9. * <b>Scaling and Overflow Behavior:</b> (1)
10. * par
11. * The function uses saturating arithmetic.
12. * Results outside of the allowable Q31 range[0x80000000 0x7FFFFFFF] will be saturated.
13. */
15. void arm_mult_q31(
16. q31_t * pSrcA,
17. q31_t * pSrcB,
18. q31_t * pDst,
19. uint32_t blockSize)
20. {
21. uint32_t blkCnt; /* loop counters */
23. #ifndef ARM_MATH_CM0_FAMILY
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
26. q31_t inA1, inA2, inA3, inA4; /* temporary input variables */
27. q31_t inB1, inB2, inB3, inB4; /* temporary input variables */
28. q31_t out1, out2, out3, out4; /* temporary output variables */
30. /* loop Unrolling */
31. blkCnt = blockSize >> 2u;
33. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
34. ** a second loop below computes the remaining 1 to 3 samples. */
35. while(blkCnt > 0u)
36. {
37. /* C = A * B */
38. /* Multiply the inputs and then store the results in the destination buffer. */
39. inA1 = *pSrcA++;
40. inA2 = *pSrcA++;
41. inA3 = *pSrcA++;
42. inA4 = *pSrcA++;
43. inB1 = *pSrcB++;
44. inB2 = *pSrcB++;
45. inB3 = *pSrcB++;
46. inB4 = *pSrcB++;
48. out1 = ((q63_t) inA1 * inB1) >> 32; (2)
49. out2 = ((q63_t) inA2 * inB2) >> 32;
50. out3 = ((q63_t) inA3 * inB3) >> 32;
51. out4 = ((q63_t) inA4 * inB4) >> 32;
53. out1 = __SSAT(out1, 31); (3)
54. out2 = __SSAT(out2, 31);
55. out3 = __SSAT(out3, 31);
56. out4 = __SSAT(out4, 31);
58. *pDst++ = out1 << 1u; (4)
59. *pDst++ = out2 << 1u;
60. *pDst++ = out3 << 1u;
61. *pDst++ = out4 << 1u;
63. /* Decrement the blockSize loop counter */
64. blkCnt--;
65. }
67. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
68. ** No loop unrolling is used. */
69. blkCnt = blockSize % 0x4u;
71. #else
73. /* Run the below code for Cortex-M0 */
75. /* Initialize blkCnt with number of samples */
76. blkCnt = blockSize;
78. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
80. while(blkCnt > 0u)
81. {
82. /* C = A * B */
83. /* Multiply the inputs and then store the results in the destination buffer. */
84. *pDst++ =
85. (q31_t) clip_q63_to_q31(((q63_t) (*pSrcA++) * (*pSrcB++)) >> 31);
87. /* Decrement the blockSize loop counter */
88. blkCnt--;
89. }
90. }

复制代码

1. 这个函数使用了饱和算法。
    所得结果是Q31格式，范围Q31 range[0x80000000 0x7FFFFFFF]。
2. 所得乘积左移32位。
3. 实现31位精度的饱和运算。
4. 右移一位，保证所得结果是Q31格式。

8.4.3 arm_mult_q15

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

1. /**
2. * @brief Q15 vector multiplication
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[out] *pDst points to the output vector
6. * @param[in] blockSize number of samples in each vector
7. * @return none.
8. *
9. * <b>Scaling and Overflow Behavior:</b> (1)
10. * par
11. * The function uses saturating arithmetic.
12. * Results outside of the allowable Q15 range [0x8000 0x7FFF] will be saturated.
13. */
15. void arm_mult_q15(
16. q15_t * pSrcA,
17. q15_t * pSrcB,
18. q15_t * pDst,
19. uint32_t blockSize)
20. {
21. uint32_t blkCnt; /* loop counters */
23. #ifndef ARM_MATH_CM0_FAMILY
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
26. q31_t inA1, inA2, inB1, inB2; /* temporary input variables */
27. q15_t out1, out2, out3, out4; /* temporary output variables */
28. q31_t mul1, mul2, mul3, mul4; /* temporary variables */
30. /* loop Unrolling */
31. blkCnt = blockSize >> 2u;
33. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
34. ** a second loop below computes the remaining 1 to 3 samples. */
35. while(blkCnt > 0u)
36. {
37. /* read two samples at a time from sourceA */
38. inA1 = *__SIMD32(pSrcA)++; (2)
39. /* read two samples at a time from sourceB */
40. inB1 = *__SIMD32(pSrcB)++;
41. /* read two samples at a time from sourceA */
42. inA2 = *__SIMD32(pSrcA)++;
43. /* read two samples at a time from sourceB */
44. inB2 = *__SIMD32(pSrcB)++;
46. /* multiply mul = sourceA * sourceB */
47. mul1 = (q31_t) ((q15_t) (inA1 >> 16) * (q15_t) (inB1 >> 16)); (3)
48. mul2 = (q31_t) ((q15_t) inA1 * (q15_t) inB1);
49. mul3 = (q31_t) ((q15_t) (inA2 >> 16) * (q15_t) (inB2 >> 16));
50. mul4 = (q31_t) ((q15_t) inA2 * (q15_t) inB2);
52. /* saturate result to 16 bit */
53. out1 = (q15_t) __SSAT(mul1 >> 15, 16); (4)
54. out2 = (q15_t) __SSAT(mul2 >> 15, 16);
55. out3 = (q15_t) __SSAT(mul3 >> 15, 16);
56. out4 = (q15_t) __SSAT(mul4 >> 15, 16);
58. /* store the result */
59. #ifndef ARM_MATH_BIG_ENDIAN
61. *__SIMD32(pDst)++ = __PKHBT(out2, out1, 16); (5)
62. *__SIMD32(pDst)++ = __PKHBT(out4, out3, 16);
64. #else
66. *__SIMD32(pDst)++ = __PKHBT(out2, out1, 16);
67. *__SIMD32(pDst)++ = __PKHBT(out4, out3, 16);
69. #endif // #ifndef ARM_MATH_BIG_ENDIAN
71. /* Decrement the blockSize loop counter */
72. blkCnt--;
73. }
75. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
76. ** No loop unrolling is used. */
77. blkCnt = blockSize % 0x4u;
79. #else
81. /* Run the below code for Cortex-M0 */
83. /* Initialize blkCnt with number of samples */
84. blkCnt = blockSize;
86. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
89. while(blkCnt > 0u)
90. {
91. /* C = A * B */
92. /* Multiply the inputs and store the result in the destination buffer */
93. *pDst++ = (q15_t) __SSAT((((q31_t) (*pSrcA++) * (*pSrcB++)) >> 15), 16);
95. /* Decrement the blockSize loop counter */
96. blkCnt--;
97. }
98. }

复制代码

1. 这个函数使用了饱和算法。
    所得结果是Q15格式，范围 [0x8000 0x7FFF]。
2. 一次读取两个Q15格式的数据。
3. 将四组数的乘积保存到Q31格式的变量mul1，mul2，mul3，mul4。
4. 丢弃32位数据的低15位，并把最终结果饱和到16位精度。
5. 通过SIMD指令__PKHBT将两个Q15格式的数据保存的结果数组中，从而一个指令周期就能完成两个数据的存储。

8.4.4 arm_mult_q7

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

1. /**
2. * @brief Q7 vector multiplication
3. * @param[in] *pSrcA points to the first input vector
4. * @param[in] *pSrcB points to the second input vector
5. * @param[out] *pDst points to the output vector
6. * @param[in] blockSize number of samples in each vector
7. * @return none.
8. *
9. * <b>Scaling and Overflow Behavior:</b> (1)
10. * par
11. * The function uses saturating arithmetic.
12. * Results outside of the allowable Q7 range [0x80 0x7F] will be saturated.
13. */
15. void arm_mult_q7(
16. q7_t * pSrcA,
17. q7_t * pSrcB,
18. q7_t * pDst,
19. uint32_t blockSize)
20. {
21. uint32_t blkCnt; /* loop counters */
23. #ifndef ARM_MATH_CM0_FAMILY
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
26. q7_t out1, out2, out3, out4; /* Temporary variables to store the product */
28. /* loop Unrolling */
29. blkCnt = blockSize >> 2u;
31. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
32. ** a second loop below computes the remaining 1 to 3 samples. */
33. while(blkCnt > 0u)
34. {
35. /* C = A * B */
36. /* Multiply the inputs and store the results in temporary variables */ (2)
37. out1 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
38. out2 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
39. out3 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
40. out4 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
42. /* Store the results of 4 inputs in the destination buffer in single cycle by packing */
43. *__SIMD32(pDst)++ = __PACKq7(out1, out2, out3, out4); (3)
45. /* Decrement the blockSize loop counter */
46. blkCnt--;
47. }
49. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
50. ** No loop unrolling is used. */
51. blkCnt = blockSize % 0x4u;
53. #else
55. /* Run the below code for Cortex-M0 */
57. /* Initialize blkCnt with number of samples */
58. blkCnt = blockSize;
60. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
63. while(blkCnt > 0u)
64. {
65. /* C = A * B */
66. /* Multiply the inputs and store the result in the destination buffer */
67. *pDst++ = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
69. /* Decrement the blockSize loop counter */
70. blkCnt--;
71. }
72. }

复制代码

1. 这个函数使用了饱和算法。
    所得结果是Q7格式，范围 [0x80 0x7F]。
2. 将两个Q7格式的数据乘积左移7位，也就是丢掉低7位的数据，并将所得结果饱和到8位精度。
3. __PACKq7函数可以在一个时钟周期就能完成相应操作。

8.4.5 实例讲解

实验目的：
    1. 四种类型数据的乘法。
实验内容：
    1. 按下摇杆的UP键, 串口打印输出结果
实验现象：
    通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: DSP_Multiplication
4. *    功能说明: 乘法
5. *    形 参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void DSP_Multiplication(void)
10. {
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];
18. static q15_t pSrcA2[5] = {1,1,1,1,1};
19. static q15_t pSrcB2[5] = {1,1,1,1,1};
20. static q15_t pDst2[5];
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];
26. pSrcA[0] += 1.1f;
27. arm_mult_f32(pSrcA, pSrcB, pDst, 5);
28. printf("arm_mult_f32 = %frn", pDst[0]);
29. pSrcA1[0] += 1;
30. arm_mult_q31(pSrcA1, pSrcB1, pDst1, 5);
31. printf("arm_mult_q31 = %drn", pDst1[0]);
33. pSrcA2[0] += 1;
34. arm_mult_q15(pSrcA2, pSrcB2, pDst2, 5);
35. printf("arm_mult_q15 = %drn", pDst2[0]);
37. pSrcA3[0] += 1;
38. arm_mult_q7(pSrcA3, pSrcB3, pDst3, 5);
39. printf("arm_mult_q7 = %drn", pDst3[0]);
40. printf("***********************************rn");
41. }

复制代码

8.5 总结

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