微波EDA网，见证研发工程师的成长！
首页 > 研发问答 > 嵌入式设计讨论 > MCU和单片机设计讨论 > 第8章 BasicMathFunctions的使用（一）

第8章 BasicMathFunctions的使用（一）

时间：10-02 整理：3721RD 点击：
第8章  BasicMathFunctions的使用（一）

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

    8.1 绝对值（VectorAbsolute Value）

    8.2 求和（VectorAddition）

    8.3 点乘（VectorDot Product）

    8.4 乘法（VectorMultiplication）


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. * [url=home.php?mod=space&uid=1141835]@Return[/url] 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.    
  83.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  84.    ** No loop unrolling is used. */
  85.   blkCnt = blockSize % 0x4u;

  87.   while(blkCnt > 0u)
  88.   {
  89.     /* C = |A| */
  90.     /* Read the input */
  91.     in1 = *pSrc++;

  93.     /* Calculate absolute value of input and then store the result in the destination buffer. */
  94.     *pDst++ = (in1 > 0) ? in1 : (q15_t)__QSUB16(0, in1);

  96.     /* Decrement the loop counter */
  97.     blkCnt--;
  98.   }

  100. #else

  102.   /* Run the below code for Cortex-M0 */

  104.   q15_t in;                                      /* Temporary input variable */

  106.   /* Initialize blkCnt with number of samples */
  107.   blkCnt = blockSize;

  109.   while(blkCnt > 0u)
  110.   {
  111.     /* C = |A| */
  112.     /* Read the input */
  113.     in = *pSrc++;

  115.     /* Calculate absolute value of input and then store the result in the destination buffer. */
  116.     *pDst++ = (in > 0) ? in : ((in == (q15_t) 0x8000) ? 0x7fff : -in);

  118.     /* Decrement the loop counter */
  119.     blkCnt--;
  120.   }

  122. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  124. }

复制代码

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.    
  14.      static q31_t pSrc1;
  15.      static q31_t pDst1;
  16.    
  17.      static q15_t pSrc2;
  18.      static q15_t pDst2;
  19.    
  20.      static q7_t pSrc3 = 127; /* 为了说明问题，在这里设置初始值为127，然后查看0x80是否饱和为0x7F */
  21.      static q7_t pDst3;
  22.    
  23.    
  24.      pSrc -= 1.23f;
  25.      arm_abs_f32(&pSrc, &pDst, 1);                                                                    (1)
  26.      printf("arm_abs_f32 = %f\r\n", pDst);

  28.      pSrc1 -= 1;
  29.      arm_abs_q31(&pSrc1, &pDst1, 1);                                                                  (2)
  30.      printf("arm_abs_q31 = %d\r\n", pDst1);

  32.      pSrc2 -= 1;
  33.      arm_abs_q15(&pSrc2, &pDst2, 1);                                                                  (3)
  34.      printf("arm_abs_q15 = %d\r\n", pDst2);

  36.      pSrc3 += 1;
  37.      printf("pSrc3 = %d\r\n", pSrc3);
  38.      arm_abs_q7(&pSrc3, &pDst3, 1);                                                                   (4)
  39.      printf("arm_abs_q7 = %d\r\n", pDst3);
  40.      printf("***********************************\r\n");
  41. }

复制代码

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


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.     这个函数也是饱和运算，输出结果的范围[0x800000000x7FFFFFFF]，超出这个结果将产生饱和结果。

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.     这个函数也是饱和运算，输出结果的范围[0x80000x7FFF]，超出这个结果将产生饱和结果。

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． 这个函数也是饱和运算，输出结果的范围[0x800x7F]，超出这个结果将产生饱和。

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.    
  15.      static q31_t  pSrcA1;
  16.      static q31_t  pSrcB1;
  17.      static q31_t  pDst1;

  19.      static q15_t  pSrcA2;
  20.      static q15_t  pSrcB2;
  21.      static q15_t  pDst2;

  23.      static q7_t  pSrcA3;
  24.      static q7_t  pSrcB3;
  25.      static q7_t  pDst3;

  27.    
  28.      pSrcA--;
  29.      arm_add_f32(&pSrcA, &pSrcB, &pDst, 1);
  30.      printf("arm_add_f32 = %f\r\n", pDst);

  32.      pSrcA1--;
  33.      arm_add_q31(&pSrcA1, &pSrcB1, &pDst1, 1);
  34.      printf("arm_add_q31 = %d\r\n", pDst1);

  36.      pSrcA2--;
  37.      arm_add_q15(&pSrcA2, &pSrcB2, &pDst2, 1);
  38.      printf("arm_add_q15 = %d\r\n", pDst2);

  40.      pSrcA3--;
  41.      arm_add_q7(&pSrcA3, &pSrcB3, &pDst3, 1);
  42.      printf("arm_add_q7 = %d\r\n", pDst3);
  43.      printf("***********************************\r\n");
  44. }

复制代码


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.   whil
上一篇：如何快速学习单片机
下一篇：求助 刚接触单片机 求帮忙做一个课程设计

dsp iir fir 相关文章：

栏目分类
热门文章

Copyright © 2017-2020 微波EDA网 版权所有

网站地图

Top