STM32/STM8技术论坛
直播中

硬汉Eric2013

9年用户 1035经验值
擅长:嵌入式技术
私信 关注
[经验]

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

第8章  BasicMathFunctions的使用（一）
    本期教程开始学习ARM官方的DSP库，这里我们先从基本数学函数开始。本期教程主要讲绝对值，加法，点乘和乘法四种运算。
    8.1 绝对值（VectorAbsolute Value）
    8.2 求和（VectorAddition）
    8.3 点乘（VectorDot Product）
    8.4 乘法（VectorMultiplication）

回帖（5）

硬汉Eric2013

2015-6-4 14:21:12
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. * Scaling and Overflow Behavior:                                                              （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. * Scaling and Overflow Behavior:   
  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. * Scaling and Overflow Behavior:                                                             (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光盘里面有此软件）查看打印信息现象如下：
8.1.png

程序设计：
  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 = %frn", pDst);

  28.      pSrc1 -= 1;
  29.      arm_abs_q31(&pSrc1, &pDst1, 1);                                                                  (2)
  30.      printf("arm_abs_q31 = %drn", pDst1);

  32.      pSrc2 -= 1;
  33.      arm_abs_q15(&pSrc2, &pDst2, 1);                                                                  (3)
  34.      printf("arm_abs_q15 = %drn", pDst2);

  36.      pSrc3 += 1;
  37.      printf("pSrc3 = %drn", pSrc3);
  38.      arm_abs_q7(&pSrc3, &pDst3, 1);                                                                   (4)
  39.      printf("arm_abs_q7 = %drn", pDst3);
  40.      printf("***********************************rn");
  41. }
(1)到(4)实现相应格式下绝对值的求解。这里只求了一个数，大家可以尝试求解一个数组的绝对值。

举报

硬汉Eric2013

2015-6-4 14:25:52
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. * Scaling and Overflow Behavior:                                                             (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. * Scaling and Overflow Behavior:                                                               (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. * Scaling and Overflow Behavior:                                                              (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光盘里面有此软件）查看打印信息现象如下：
8.2.png

程序设计：
  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 = %frn", pDst);

  32.      pSrcA1--;
  33.      arm_add_q31(&pSrcA1, &pSrcB1, &pDst1, 1);
  34.      printf("arm_add_q31 = %drn", pDst1);

  36.      pSrcA2--;
  37.      arm_add_q15(&pSrcA2, &pSrcB2, &pDst2, 1);
  38.      printf("arm_add_q15 = %drn", pDst2);

  40.      pSrcA3--;
  41.      arm_add_q7(&pSrcA3, &pSrcB3, &pDst3, 1);
  42.      printf("arm_add_q7 = %drn", pDst3);
  43.      printf("***********************************rn");
  44. }

举报

硬汉Eric2013

2015-6-4 14:32:38
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. * 

    

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

  9.  *
    10.    
  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. * Scaling and Overflow Behavior:                                                              (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. * Scaling and Overflow Behavior:                                                             (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. * Scaling and Overflow Behavior:                                                              (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光盘里面有此软件）查看打印信息现象如下：
8.3.png

程序设计：
  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.    
  15.      static q31_t  pSrcA1[5] = {0x7ffffff0,1,1,1,1};
  16.      static q31_t  pSrcB1[5] = {1,1,1,1,1};
  17.      static q63_t   result1;  

  19.      static q15_t  pSrcA2[5] = {1,1,1,1,1};
  20.      static q15_t  pSrcB2[5] = {1,1,1,1,1};
  21.      static q63_t  result2;  

  23.      static q7_t  pSrcA3[5] = {1,1,1,1,1};
  24.      static q7_t  pSrcB3[5] = {1,1,1,1,1};
  25.      static q31_t result3;

  27.    
  28.      pSrcA[0] -= 1.1f;
  29.      arm_dot_prod_f32(pSrcA, pSrcB, 5, &result);
  30.      printf("arm_dot_prod_f32 = %frn", result);
  31.    
  32.      pSrcA1[0] -= 0xffff;
  33.      arm_dot_prod_q31(pSrcA1, pSrcB1, 5, &result1);
  34.      printf("arm_dot_prod_q31 = %lldrn", result1);

  36.      pSrcA2[0] -= 1;
  37.      arm_dot_prod_q15(pSrcA2, pSrcB2, 5, &result2);
  38.      printf("arm_dot_prod_q15 = %lldrn", result2);

  40.      pSrcA3[0] -= 1;
  41.      arm_dot_prod_q7(pSrcA3, pSrcB3, 5, &result3);
  42.      printf("arm_dot_prod_q7 = %drn", result3);
  43.      printf("***********************************rn");
  44. }

举报

硬汉Eric2013

2015-6-4 14:36:49
8.4  乘法（Vector Multiplication）
    这部分函数主要用于乘法，公式描述如下：
      pDst[n]= pSrcA[n] * pSrcB[n],   0 <= n
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. * Scaling and Overflow Behavior:                                                             (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格式，范围Q31range[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. * Scaling and Overflow Behavior:                                                              (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. * Scaling and Overflow Behavior:                                                             (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光盘里面有此软件）查看打印信息现象如下：
8.4.png

程序设计：
  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.    
  15.      static q31_t  pSrcA1[5] = {1,1,1,1,1};
  16.      static q31_t  pSrcB1[5] = {1,1,1,1,1};
  17.      static q31_t  pDst1[5];  

  19.      static q15_t  pSrcA2[5] = {1,1,1,1,1};
  20.      static q15_t  pSrcB2[5] = {1,1,1,1,1};
  21.      static q15_t  pDst2[5];  

  23.      static q7_t  pSrcA3[5] = {0x70,1,1,1,1};
  24.      static q7_t  pSrcB3[5] = {0x7f,1,1,1,1};
  25.      static q7_t pDst3[5];

  27.    
  28.      pSrcA[0] += 1.1f;
  29.      arm_mult_f32(pSrcA, pSrcB, pDst, 5);
  30.      printf("arm_mult_f32 = %frn", pDst[0]);
  31.    
  32.      pSrcA1[0] += 1;
  33.      arm_mult_q31(pSrcA1, pSrcB1, pDst1, 5);
  34.      printf("arm_mult_q31 = %drn", pDst1[0]);

  36.      pSrcA2[0] += 1;
  37.      arm_mult_q15(pSrcA2, pSrcB2, pDst2, 5);
  38.      printf("arm_mult_q15 = %drn", pDst2[0]);

  40.      pSrcA3[0] += 1;
  41.      arm_mult_q7(pSrcA3, pSrcB3, pDst3, 5);
  42.      printf("arm_mult_q7 = %drn", pDst3[0]);
  43.      printf("***********************************rn");
  44. }

硬汉Eric2013

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

举报

更多回帖

5 0 0

相关帖子

FIR
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分