你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

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

[复制链接]
baiyongbin2009 发布时间：2015-3-19 11:05
特别说明：完整45期数字信号处理教程，原创高性能示波器代码全开源地址：链接
第9章 BasicMathFunctions的使用（二）

    本期教程主要讲基本函数中的相反数，偏移，位移，减法和比例因子。
    9.1 相反数（Vector Negate）
    9.2 求和（Vector Offset）
    9.3 点乘（Vector Shift）
    9.4 减法（Vector Sub）
    9.5 比例因子（Vector Scale）
    9.6 BasicMathFunctions的重要说明
    9.7 总结

9.1 相反数（Vector Negate）
    这部分函数主要用于求相反数，公式描述如下：
     pDst[n] = -pSrc[n],   0 <= n < blockSize.   
    特别注意，这部分函数支持目标指针和源指针指向相同的缓冲区。
9.1.1 arm_negate_f32
    这个函数用于求32位浮点数的相反数，源代码分析如下：
  1. /**        
  2. * @brief  Negates the elements of a floating-point vector.        
  3. * @param[in]  *pSrc points to the input vector        
  4. * @param[out]  *pDst points to the output vector        
  5. * @param[in]  blockSize number of samples in the vector        
  6. * @return none.        
  7. */

  9. void arm_negate_f32(
  10.   float32_t * pSrc,
  11.   float32_t * pDst,
  12.   uint32_t blockSize)
  13. {
  14.   uint32_t blkCnt;                               /* loop counter */


  17. #ifndef ARM_MATH_CM0_FAMILY

  19. /* Run the below code for Cortex-M4 and Cortex-M3 */
  20.   float32_t in1, in2, in3, in4;                  /* temporary variables */

  22.   /*loop Unrolling */
  23.   blkCnt = blockSize >> 2u;

  25.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
  26.    ** a second loop below computes the remaining 1 to 3 samples. */
  27.   while(blkCnt > 0u)
  28.   {
  29.     /* read inputs from source */
  30.     in1 = *pSrc;
  31.     in2 = *(pSrc + 1);
  32.     in3 = *(pSrc + 2);
  33.     in4 = *(pSrc + 3);

  35.     /* negate the input */                                                                            (1)
  36.     in1 = -in1;
  37.     in2 = -in2;
  38.     in3 = -in3;
  39.     in4 = -in4;

  41.     /* store the result to destination */
  42.     *pDst = in1;
  43.     *(pDst + 1) = in2;
  44.     *(pDst + 2) = in3;
  45.     *(pDst + 3) = in4;

  47.     /* update pointers to process next samples */
  48.     pSrc += 4u;
  49.     pDst += 4u;

  51.     /* Decrement the loop counter */
  52.     blkCnt--;
  53.   }

  55.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
  56.    ** No loop unrolling is used. */
  57.   blkCnt = blockSize % 0x4u;

  59. #else

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

  63.   /* Initialize blkCnt with number of samples */
  64.   blkCnt = blockSize;

  66. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  68.   while(blkCnt > 0u)
  69.   {
  70.     /* C = -A */
  71.     /* Negate and then store the results in the destination buffer. */
  72.     *pDst++ = -*pSrc++;

  74.     /* Decrement the loop counter */
  75.     blkCnt--;
  76.   }
  77. }
复制代码
1. 浮点数的相反数求解比较简单，直接在相应的变量前加上负号即可。

9.1.2 arm_negate_q31
    这个函数用于求32位定点数的相反数，源代码分析如下：
  1. /**   
  2. * @brief  Negates the elements of a Q31 vector.   
  3. * @param[in]  *pSrc points to the input vector   
  4. * @param[out]  *pDst points to the output vector   
  5. * @param[in]  blockSize number of samples in the vector   
  6. * @return none.   
  7. *   
  8. * <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_negate_q31(
  15.   q31_t * pSrc,
  16.   q31_t * pDst,
  17.   uint32_t blockSize)
  18. {
  19.   q31_t in;                                      /* Temporary variable */
  20.   uint32_t blkCnt;                               /* loop counter */

  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.     /* Negate and then store the results in the destination buffer. */
  36.     in1 = *pSrc++;
  37.     in2 = *pSrc++;
  38.     in3 = *pSrc++;
  39.     in4 = *pSrc++;

  41.     *pDst++ = __QSUB(0, in1);                                                                      (2)
  42.     *pDst++ = __QSUB(0, in2);
  43.     *pDst++ = __QSUB(0, in3);
  44.     *pDst++ = __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 */


  64.   while(blkCnt > 0u)
  65.   {
  66.     /* C = -A */
  67.     /* Negate and then store the result in the destination buffer. */
  68.     in = *pSrc++;
  69.     *pDst++ = (in == INT32_MIN) ? INT32_MAX : -in;

  71.     /* Decrement the loop counter */
  72.     blkCnt--;
  73.   }
  74. }
复制代码
1. 这个函数使用了饱和运算。
    饱和运算数值0x80000000将变成0x7FFFFFFF。
2. 饱和运算__QSUB我们在上一章已经详细讲述了，这就就是实现数值0减去相应的参数变量。

9.1.3 arm_negate_q15
    这个函数用于求16位定点数的相反数，源代码分析如下：
  1. /**        
  2. * @brief  Negates the elements of a Q15 vector.        
  3. * @param[in]  *pSrc points to the input vector        
  4. * @param[out]  *pDst points to the output vector        
  5. * @param[in]  blockSize number of samples in the vector        
  6. * @return none.        
  7. *   
  8. * \par Conditions for optimum performance   
  9. *  Input and output buffers should be aligned by 32-bit   
  10. *   
  11. *        
  12. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
  13. * \par        
  14. * The function uses saturating arithmetic.        
  15. * The Q15 value -1 (0x8000) will be saturated to the maximum allowable positive value 0x7FFF.        
  16. */

  18. void arm_negate_q15(
  19.   q15_t * pSrc,
  20.   q15_t * pDst,
  21.   uint32_t blockSize)
  22. {
  23.   uint32_t blkCnt;                               /* loop counter */
  24.   q15_t in;

  26. #ifndef ARM_MATH_CM0_FAMILY

  28. /* Run the below code for Cortex-M4 and Cortex-M3 */

  30.   q31_t in1, in2;                                /* Temporary variables */


  33.   /*loop Unrolling */
  34.   blkCnt = blockSize >> 2u;

  36.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
  37.    ** a second loop below computes the remaining 1 to 3 samples. */
  38.   while(blkCnt > 0u)
  39.   {
  40.     /* C = -A */
  41.     /* Read two inputs at a time */                                                                  (2)
  42.     in1 = _SIMD32_OFFSET(pSrc);
  43.     in2 = _SIMD32_OFFSET(pSrc + 2);

  45.     /* negate two samples at a time */                                                               (3)
  46.     in1 = __QSUB16(0, in1);

  48.     /* negate two samples at a time */
  49.     in2 = __QSUB16(0, in2);

  51.     /* store the result to destination 2 samples at a time */                                        (4)
  52.     _SIMD32_OFFSET(pDst) = in1;
  53.     /* store the result to destination 2 samples at a time */
  54.     _SIMD32_OFFSET(pDst + 2) = in2;


  57.     /* update pointers to process next samples */
  58.     pSrc += 4u;
  59.     pDst += 4u;

  61.     /* Decrement the loop counter */
  62.     blkCnt--;
  63.   }

  65.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
  66.    ** No loop unrolling is used. */
  67.   blkCnt = blockSize % 0x4u;

  69. #else

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

  73.   /* Initialize blkCnt with number of samples */
  74.   blkCnt = blockSize;

  76. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  78.   while(blkCnt > 0u)
  79.   {
  80.     /* C = -A */
  81.     /* Negate and then store the result in the destination buffer. */
  82.     in = *pSrc++;
  83.     *pDst++ = (in == (q15_t) 0x8000) ? 0x7fff : -in;

  85.     /* Decrement the loop counter */
  86.     blkCnt--;
  87.   }
  88. }
复制代码
1. 这个函数使用了饱和运算。
    饱和运算数值0x8000将变成0x7FFF。
2. 一次读取两个Q15格式的数据。
3. 由于__QSUB是SIMD指令，这里可以实现一次计算两个Q15数据的相反数。
4. 这里实现一次赋值两个Q15数据。

9.1.4 arm_negate_q7
    这个函数用于求8位定点数的相反数，源代码分析如下：
  1. /**   
  2. * @brief  Negates the elements of a Q7 vector.   
  3. * @param[in]  *pSrc points to the input vector   
  4. * @param[out]  *pDst points to the output vector   
  5. * @param[in]  blockSize number of samples in the vector   
  6. * @return none.   
  7. *   
  8. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
  9. * \par   
  10. * The function uses saturating arithmetic.   
  11. * The Q7 value -1 (0x80) will be saturated to the maximum allowable positive value 0x7F.   
  12. */

  14. void arm_negate_q7(
  15.   q7_t * pSrc,
  16.   q7_t * pDst,
  17.   uint32_t blockSize)
  18. {
  19.   uint32_t blkCnt;                               /* loop counter */
  20.   q7_t in;

  22. #ifndef ARM_MATH_CM0_FAMILY

  24. /* Run the below code for Cortex-M4 and Cortex-M3 */
  25.   q31_t input;                                   /* Input values1-4 */
  26.   q31_t zero = 0x00000000;                                                                           (2)


  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 */
  37.     /* Read four inputs */
  38.     input = *__SIMD32(pSrc)++;                                                                        (3)

  40.     /* Store the Negated results in the destination buffer in a single cycle by packing the results */
  41.     *__SIMD32(pDst)++ = __QSUB8(zero, input);                                                         (4)

  43.     /* Decrement the loop counter */
  44.     blkCnt--;
  45.   }

  47.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  48.    ** No loop unrolling is used. */
  49.   blkCnt = blockSize % 0x4u;

  51. #else

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

  55.   /* Initialize blkCnt with number of samples */
  56.   blkCnt = blockSize;

  58. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  60.   while(blkCnt > 0u)
  61.   {
  62.     /* C = -A */
  63.     /* Negate and then store the results in the destination buffer. */ \
  64.       in = *pSrc++;
  65.     *pDst++ = (in == (q7_t) 0x80) ? 0x7f : -in;

  67.     /* Decrement the loop counter */
  68.     blkCnt--;
  69.   }
  70. }
复制代码
1. 这个函数使用了饱和运算。
    饱和运算数值0x80将变成0x7F。
2. 给局部变量赋初值，防止默认初始值不是0，所以从某种意义上来说，给变量赋初值是很有必要的。
3. 一次读取4个Q7格式的数据到input里面。
4. 通过__QSUB8实现一次计算四个Q7格式数据的相反数。

9.1.5 实例讲解
实验目的：
    1. 四种类型数据的相反数。
实验内容：
    1. 按下K1键, 串口打印输出结果
实验现象：
        通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：
9.1.png
程序设计：
  1. /*
  2. *********************************************************************************************************
  3. *        函 数 名: DSP_Negate
  4. *        功能说明: 求相反数
  5. *        形    参：无
  6. *        返 回 值: 无
  7. *********************************************************************************************************
  8. */
  9. static void DSP_Negate(void)
  10. {
  11. static float32_t pSrc;
  12.     static float32_t pDst;
  13. static q31_t pSrc1;
  14. static q31_t pDst1;
  15. static q15_t pSrc2;
  16. static q15_t pDst2;
  17. static q7_t pSrc3 = 127; /* 为了说明问题，在这里设置初始值为127，然后查看0x80是否饱和为0x7F */
  18. static q7_t pDst3;
  19. pSrc -= 1.23f;
  20. arm_negate_f32(&pSrc, &pDst, 1);
  21. printf("arm_negate_f32 = %f\r\n", pDst);

  23. pSrc1 -= 1;
  24. arm_negate_q31(&pSrc1, &pDst1, 1);
  25. printf("arm_negate_q31 = %d\r\n", pDst1);

  27. pSrc2 -= 1;
  28. arm_negate_q15(&pSrc2, &pDst2, 1);
  29. printf("arm_negate_q15 = %d\r\n", pDst2);

  31. pSrc3 += 1;
  32. arm_negate_q7(&pSrc3, &pDst3, 1);
  33. printf("arm_negate_q7 = %d\r\n", pDst3);
  34. printf("***********************************\r\n");
  35. }
复制代码

赞 收藏 评论10 发布时间：2015-3-19 11:05

举报

10个回答
baiyongbin2009 回答时间：2015-3-19 11:09:29
9.2 偏移（Vector Offset）
    这部分函数主要用于求相反数，公式描述如下：
     pDst[n] = pSrc[n] + offset,   0 <= n < blockSize.
        注意，这部分函数支持目标指针和源指针指向相同的缓冲区。
9.2.1 arm_offset_f32
    这个函数用于求32位浮点数的偏移，源代码分析如下：
  1. /**        
  2. * @brief  Adds a constant offset to a floating-point vector.        
  3. * @param[in]  *pSrc points to the input vector        
  4. * @param[in]  offset is the offset to be added        
  5. * @param[out]  *pDst points to the output vector        
  6. * @param[in]  blockSize number of samples in the vector        
  7. * @return none.        
  8. */
  9. void arm_offset_f32(
  10.   float32_t * pSrc,
  11.   float32_t offset,
  12.   float32_t * pDst,
  13.   uint32_t blockSize)
  14. {
  15.   uint32_t blkCnt;                               /* loop counter */

  17. #ifndef ARM_MATH_CM0_FAMILY

  19. /* Run the below code for Cortex-M4 and Cortex-M3 */
  20.   float32_t in1, in2, in3, in4;

  22.   /*loop Unrolling */
  23.   blkCnt = blockSize >> 2u;

  25.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
  26.    ** a second loop below computes the remaining 1 to 3 samples. */
  27.   while(blkCnt > 0u)
  28.   {
  29.     /* C = A + offset */                                                                            (1)
  30.     /* Add offset and then store the results in the destination buffer. */
  31.     /* read samples from source */
  32.     in1 = *pSrc;
  33.     in2 = *(pSrc + 1);

  35.     /* add offset to input */
  36.     in1 = in1 + offset;

  38.     /* read samples from source */
  39.     in3 = *(pSrc + 2);

  41.     /* add offset to input */
  42.     in2 = in2 + offset;

  44.     /* read samples from source */
  45.     in4 = *(pSrc + 3);

  47.     /* add offset to input */
  48.     in3 = in3 + offset;

  50.     /* store result to destination */
  51.     *pDst = in1;

  53.     /* add offset to input */
  54.     in4 = in4 + offset;

  56.     /* store result to destination */
  57.     *(pDst + 1) = in2;

  59.     /* store result to destination */
  60.     *(pDst + 2) = in3;

  62.     /* store result to destination */
  63.     *(pDst + 3) = in4;

  65.     /* update pointers to process next samples */
  66.     pSrc += 4u;
  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

  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)
  87.   {
  88.     /* C = A + offset */
  89.     /* Add offset and then store the result in the destination buffer. */
  90.     *pDst++ = (*pSrc++) + offset;

  92.     /* Decrement the loop counter */
  93.     blkCnt--;
  94.   }
  95. }
复制代码
1. 浮点数的偏移值求解比较简单，加上相应的偏移值并赋值给目标变量即可。

9.2.2 arm_offset_q31
    这个函数用于求32位定点数的偏移值，源代码分析如下：
  1. /**   
  2. * @brief  Adds a constant offset to a Q31 vector.   
  3. * @param[in]  *pSrc points to the input vector   
  4. * @param[in]  offset is the offset to be added   
  5. * @param[out]  *pDst points to the output vector   
  6. * @param[in]  blockSize number of samples in the 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] are saturated.   
  13. */

  15. void arm_offset_q31(
  16.   q31_t * pSrc,
  17.   q31_t offset,
  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 in1, in2, in3, in4;


  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 + offset */
  37.     /* Add offset and then store the results in the destination buffer. */
  38.     in1 = *pSrc++;
  39.     in2 = *pSrc++;
  40.     in3 = *pSrc++;
  41.     in4 = *pSrc++;

  43.     *pDst++ = __QADD(in1, offset);                                                                   (2)
  44.     *pDst++ = __QADD(in2, offset);
  45.     *pDst++ = __QADD(in3, offset);
  46.     *pDst++ = __QADD(in4, offset);

  48.     /* Decrement the loop counter */
  49.     blkCnt--;
  50.   }

  52.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  53.    ** No loop unrolling is used. */
  54.   blkCnt = blockSize % 0x4u;

  56.   while(blkCnt > 0u)
  57.   {
  58.     /* C = A + offset */
  59.     /* Add offset and then store the result in the destination buffer. */
  60.     *pDst++ = __QADD(*pSrc++, offset);

  62.     /* Decrement the loop counter */
  63.     blkCnt--;
  64.   }

  66. #else

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

  70.   /* Initialize blkCnt with number of samples */
  71.   blkCnt = blockSize;

  73.   while(blkCnt > 0u)
  74.   {
  75.     /* C = A + offset */
  76.     /* Add offset and then store the result in the destination buffer. */
  77.     *pDst++ = (q31_t) clip_q63_to_q31((q63_t) * pSrc++ + offset);

  79.     /* Decrement the loop counter */
  80.     blkCnt--;
  81.   }

  83. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  85. }
复制代码
1. 这个函数使用了饱和运算。
    饱和运算数值0x80000000将变成0x7FFFFFFF。
2. 指令__QADD我们在上章教程中已经讲解过，这里是实现两个参数相加。

9.2.3 arm_offset_q15
    这个函数用于求16位定点数的偏移，源代码分析如下：
  1. /**   
  2. * @brief  Adds a constant offset to a Q15 vector.   
  3. * @param[in]  *pSrc points to the input vector   
  4. * @param[in]  offset is the offset to be added   
  5. * @param[out]  *pDst points to the output vector   
  6. * @param[in]  blockSize number of samples in the 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] are saturated.   
  13. */

  15. void arm_offset_q15(
  16.   q15_t * pSrc,
  17.   q15_t offset,
  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 offset_packed;                           /* Offset packed to 32 bit */


  29.   /*loop Unrolling */
  30.   blkCnt = blockSize >> 2u;

  32.   /* Offset is packed to 32 bit in order to use SIMD32 for addition */
  33.   offset_packed = __PKHBT(offset, offset, 16);                                                       (2)

  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 + offset */
  40.     /* Add offset and then store the results in the destination buffer, 2 samples at a time. */
  41.     *__SIMD32(pDst)++ = __QADD16(*__SIMD32(pSrc)++, offset_packed);                                  (3)
  42.     *__SIMD32(pDst)++ = __QADD16(*__SIMD32(pSrc)++, offset_packed);

  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 + offset */
  55.     /* Add offset and then store the results in the destination buffer. */
  56.     *pDst++ = (q15_t) __QADD16(*pSrc++, offset);

  58.     /* Decrement the loop counter */
  59.     blkCnt--;
  60.   }

  62. #else

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

  66.   /* Initialize blkCnt with number of samples */
  67.   blkCnt = blockSize;

  69.   while(blkCnt > 0u)
  70.   {
  71.     /* C = A + offset */
  72.     /* Add offset and then store the results in the destination buffer. */
  73.     *pDst++ = (q15_t) __SSAT(((q31_t) * pSrc++ + offset), 16);

  75.     /* Decrement the loop counter */
  76.     blkCnt--;
  77.   }

  79. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  81. }
复制代码
1. 这个函数使用了饱和运算。
    饱和运算数值0x8000将变成0x7FFF。
2. 将两个Q15格式的变量合并成一个Q31格式的数据，方便指令__QADD16的调用。
3. 由于__QADD16是SIMD指令，这里调用一次就能实现两个Q15格式数据的计算。

9.2.4 arm_offset_q7
    这个函数用于求8位定点数的偏移，源代码分析如下：
  1. /**   
  2. * @brief  Adds a constant offset to a Q7 vector.   
  3. * @param[in]  *pSrc points to the input vector   
  4. * @param[in]  offset is the offset to be added   
  5. * @param[out]  *pDst points to the output vector   
  6. * @param[in]  blockSize number of samples in the vector   
  7. * @return none.   
  8. *   
  9. * <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] are saturated.   
  13. */

  15. void arm_offset_q7(
  16.   q7_t * pSrc,
  17.   q7_t offset,
  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 */
  26.   q31_t offset_packed;                           /* Offset packed to 32 bit */


  29.   /*loop Unrolling */
  30.   blkCnt = blockSize >> 2u;

  32.   /* Offset is packed to 32 bit in order to use SIMD32 for addition */                               (2)
  33.   offset_packed = __PACKq7(offset, offset, offset, offset);

  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 + offset */
  40.     /* Add offset and then store the results in the destination bufferfor 4 samples at a time. */
  41.     *__SIMD32(pDst)++ = __QADD8(*__SIMD32(pSrc)++, offset_packed);                                   (3)

  43.     /* Decrement the loop counter */
  44.     blkCnt--;
  45.   }

  47.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  48.    ** No loop unrolling is used. */
  49.   blkCnt = blockSize % 0x4u;

  51.   while(blkCnt > 0u)
  52.   {
  53.     /* C = A + offset */
  54.     /* Add offset and then store the result in the destination buffer. */
  55.     *pDst++ = (q7_t) __SSAT(*pSrc++ + offset, 8);

  57.     /* Decrement the loop counter */
  58.     blkCnt--;
  59.   }

  61. #else

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

  65.   /* Initialize blkCnt with number of samples */
  66.   blkCnt = blockSize;

  68.   while(blkCnt > 0u)
  69.   {
  70.     /* C = A + offset */
  71.     /* Add offset and then store the result in the destination buffer. */
  72.     *pDst++ = (q7_t) __SSAT((q15_t) * pSrc++ + offset, 8);

  74.     /* Decrement the loop counter */
  75.     blkCnt--;
  76.   }

  78. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  80. }
复制代码
1. 这个函数使用了饱和运算。
    饱和运算数值0x80将变成0x7F。
2. 通过__PACKq7将4个Q7格式的数据合并成一个Q31格式的数据。
3. 由于__QADD8是SIMD指令，这里调用一次就能实现四个Q8格式数据的计算。

9.2.5 实例讲解
实验目的：
    1. 四种类型数据的相反数。
实验内容：
    1. 按下K2键, 串口打印输出结果
实验现象：
        通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：
9.2.png
程序设计：
  1. /*
  2. *********************************************************************************************************
  3. *        函 数 名: DSP_Offset
  4. *        功能说明: 偏移
  5. *        形    参：无
  6. *        返 回 值: 无
  7. *********************************************************************************************************
  8. */
  9. static void DSP_Offset(void)
  10. {
  11. static float32_t   pSrcA;
  12. static float32_t   Offset = 0.0f;  
  13. static float32_t   pDst;  
  14. static q31_t  pSrcA1;  
  15. static q31_t  Offset1 = 0;  
  16. static q31_t  pDst1;  

  18. static q15_t  pSrcA2;  
  19. static q15_t  Offset2 = 0;  
  20. static q15_t  pDst2;

  22. static q7_t  pSrcA3;
  23. static q7_t  Offset3 = 0;  
  24. static q7_t  pDst3;  

  26. Offset--;
  27. arm_offset_f32(&pSrcA, Offset, &pDst, 1);
  28. printf("arm_add_f32 = %f\r\n", pDst);

  30. Offset1--;
  31. arm_offset_q31(&pSrcA1, Offset1, &pDst1, 1);
  32. printf("arm_add_q31 = %d\r\n", pDst1);

  34. Offset2--;
  35. arm_offset_q15(&pSrcA2, Offset2, &pDst2, 1);
  36. printf("arm_add_q15 = %d\r\n", pDst2);

  38. Offset3--;
  39. arm_offset_q7(&pSrcA3, Offset3, &pDst3, 1);
  40. printf("arm_add_q7 = %d\r\n", pDst3);
  41. printf("***********************************\r\n");
  42. }
复制代码

赞 评论
baiyongbin2009 回答时间：2015-3-19 11:23:02
9.3 位移（Vector Shift）
    这部分函数主要用于实现位移，公式描述如下：
    pDst[n] = pSrc[n] << shift,   0 <= n < blockSize.  
    注意，这部分函数支持目标指针和源指针指向相同的缓冲区。
9.3.1 arm_shift_q31
    这个函数用于求32位定点数的位移，源代码分析如下：
  1. /**        
  2. * @brief  Shifts the elements of a Q31 vector a specified number of bits.        
  3. * @param[in]  *pSrc points to the input vector        
  4. * @param[in]  shiftBits number of bits to shift.  
  5. *              A positive value shifts left; a negative value shifts right.                           (1)
  6. * @param[out]  *pDst points to the output vector        
  7. * @param[in]  blockSize number of samples in the vector        
  8. * @return none.        
  9. *        
  10. *        
  11. * <b>Scaling and Overflow Behavior:</b>                                                              (2)
  12. * \par        
  13. * The function uses saturating arithmetic.        
  14. * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] will be saturated.        
  15. */

  17. void arm_shift_q31(
  18.   q31_t * pSrc,
  19.   int8_t shiftBits,
  20.   q31_t * pDst,
  21.   uint32_t blockSize)
  22. {
  23.   uint32_t blkCnt;                               /* loop counter */
  24.   uint8_t sign = (shiftBits & 0x80);             /* Sign of shiftBits */                              (3)

  26. #ifndef ARM_MATH_CM0_FAMILY

  28.   q31_t in1, in2, in3, in4;                      /* Temporary input variables */
  29.   q31_t out1, out2, out3, out4;                  /* Temporary output variables */

  31.   /*loop Unrolling */
  32.   blkCnt = blockSize >> 2u;


  35.   if(sign == 0u)                                                                                     (4)
  36.   {
  37.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
  38.      ** a second loop below computes the remaining 1 to 3 samples. */
  39.     while(blkCnt > 0u)
  40.     {
  41.       /* C = A  << shiftBits */
  42.       /* Shift the input and then store the results in the destination buffer. */
  43.       in1 = *pSrc;
  44.       in2 = *(pSrc + 1);
  45.       out1 = in1 << shiftBits;
  46.       in3 = *(pSrc + 2);
  47.       out2 = in2 << shiftBits;
  48.       in4 = *(pSrc + 3);
  49.       if(in1 != (out1 >> shiftBits))                                                                (5)
  50.         out1 = 0x7FFFFFFF ^ (in1 >> 31);

  52.       if(in2 != (out2 >> shiftBits))
  53.         out2 = 0x7FFFFFFF ^ (in2 >> 31);

  55.       *pDst = out1;
  56.       out3 = in3 << shiftBits;
  57.       *(pDst + 1) = out2;
  58.       out4 = in4 << shiftBits;

  60.       if(in3 != (out3 >> shiftBits))
  61.         out3 = 0x7FFFFFFF ^ (in3 >> 31);

  63.       if(in4 != (out4 >> shiftBits))
  64.         out4 = 0x7FFFFFFF ^ (in4 >> 31);

  66.       *(pDst + 2) = out3;
  67.       *(pDst + 3) = out4;

  69.       /* Update destination pointer to process next sampels */
  70.       pSrc += 4u;
  71.       pDst += 4u;

  73.       /* Decrement the loop counter */
  74.       blkCnt--;
  75.     }
  76.   }
  77.   else                                                                                              (6)
  78.   {

  80.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
  81.      ** a second loop below computes the remaining 1 to 3 samples. */
  82.     while(blkCnt > 0u)
  83.     {
  84.       /* C = A >>  shiftBits */
  85.       /* Shift the input and then store the results in the destination buffer. */
  86.       in1 = *pSrc;
  87.       in2 = *(pSrc + 1);
  88.       in3 = *(pSrc + 2);
  89.       in4 = *(pSrc + 3);

  91.       *pDst = (in1 >> -shiftBits);                                                                  (7)
  92.       *(pDst + 1) = (in2 >> -shiftBits);
  93.       *(pDst + 2) = (in3 >> -shiftBits);
  94.       *(pDst + 3) = (in4 >> -shiftBits);


  97.       pSrc += 4u;
  98.       pDst += 4u;

  100.       blkCnt--;
  101.     }

  103.   }

  105.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  106.    ** No loop unrolling is used. */
  107.   blkCnt = blockSize % 0x4u;

  109. #else

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


  114.   /* Initialize blkCnt with number of samples */
  115.   blkCnt = blockSize;

  117. #endif /* #ifndef ARM_MATH_CM0_FAMILY */


  120.   while(blkCnt > 0u)
  121.   {
  122.     /* C = A (>> or <<) shiftBits */
  123.     /* Shift the input and then store the result in the destination buffer. */                       (8)
  124.     *pDst++ = (sign == 0u) ? clip_q63_to_q31((q63_t) * pSrc++ << shiftBits) :
  125.       (*pSrc++ >> -shiftBits);

  127.     /* Decrement the loop counter */
  128.     blkCnt--;
  129.   }


  132. }
复制代码
1. 如果函数的参数shiftBits是正数那么表示左移，如果参数shiftBits是负数那么就是右移。
2. 这个函数使用了饱和运算。
    饱和运算数值0x80000000将变成0x7FFFFFFF。
3. 获取偏移值shiftBits是正数还是负数。
4. 如果移位值是正数，那么就是左移。
5. 数值的左移仅支持将其左移后再右移相应的位数后数值不变的情况，如果不满足这个条件，那么输出结果只有两种结果（这里就是实现输出结果的饱和运算）。
    out = 0x7FFFFFFF & 0xFFFFFFFF =0x80000000
    out = 0x7FFFFFFF & 0x0000000 =0x7FFFFFFF
6. 如果移位值是负数，那么就是右移。
7. 将偏移值取反然后左移即可。
8. 用于实现剩余数值偏移的计算。

9.3.2 arm_shift_q15
    这个函数用于求16位定点数的位移，源代码分析如下：
  1. /**   
  2. * @brief  Shifts the elements of a Q15 vector a specified number of bits.   
  3. * @param[in]  *pSrc points to the input vector   
  4. * @param[in]  shiftBits number of bits to shift.  
  5. *            A positive value shifts left; a negative value shifts right.                           (1)
  6. * @param[out]  *pDst points to the output vector   
  7. * @param[in]  blockSize number of samples in the vector   
  8. * @return none.   
  9. *   
  10. * <b>Scaling and Overflow Behavior:</b>                                                             (2)
  11. * \par   
  12. * The function uses saturating arithmetic.   
  13. * Results outside of the allowable Q15 range [0x8000 0x7FFF] will be saturated.   
  14. */

  16. void arm_shift_q15(
  17.   q15_t * pSrc,
  18.   int8_t shiftBits,
  19.   q15_t * pDst,
  20.   uint32_t blockSize)
  21. {
  22.   uint32_t blkCnt;                               /* loop counter */
  23.   uint8_t sign;                                  /* Sign of shiftBits */

  25. #ifndef ARM_MATH_CM0_FAMILY

  27. /* Run the below code for Cortex-M4 and Cortex-M3 */

  29.   q15_t in1, in2;                                /* Temporary variables */


  32.   /*loop Unrolling */
  33.   blkCnt = blockSize >> 2u;

  35.   /* Getting the sign of shiftBits */
  36.   sign = (shiftBits & 0x80);                                                                        (3)

  38.   /* If the shift value is positive then do right shift else left shift */
  39.   if(sign == 0u)
  40.   {
  41.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
  42.      ** a second loop below computes the remaining 1 to 3 samples. */
  43.     while(blkCnt > 0u)
  44.     {
  45.       /* Read 2 inputs */
  46.       in1 = *pSrc++;
  47.       in2 = *pSrc++;
  48.       /* C = A << shiftBits */
  49.       /* Shift the inputs and then store the results in the destination buffer. */
  50. #ifndef  ARM_MATH_BIG_ENDIAN

  52.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in1 << shiftBits), 16),
  53.                                   __SSAT((in2 << shiftBits), 16), 16);

  55. #else

  57.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in2 << shiftBits), 16),                                   (4)
  58.                                   __SSAT((in1 << shiftBits), 16), 16);

  60. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */

  62.       in1 = *pSrc++;
  63.       in2 = *pSrc++;

  65. #ifndef  ARM_MATH_BIG_ENDIAN

  67.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in1 << shiftBits), 16),
  68.                                   __SSAT((in2 << shiftBits), 16), 16);

  70. #else

  72.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in2 << shiftBits), 16),                                 
  73.                                   __SSAT((in1 << shiftBits), 16), 16);

  75. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */

  77.       /* Decrement the loop counter */
  78.       blkCnt--;
  79.     }

  81.     /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  82.      ** No loop unrolling is used. */
  83.     blkCnt = blockSize % 0x4u;

  85.     while(blkCnt > 0u)
  86.     {
  87.       /* C = A << shiftBits */
  88.       /* Shift and then store the results in the destination buffer. */
  89.       *pDst++ = __SSAT((*pSrc++ << shiftBits), 16);                                                 (5)

  91.       /* Decrement the loop counter */
  92.       blkCnt--;
  93.     }
  94.   }
  95.   else                                                                                              (6)
  96.   {
  97.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
  98.      ** a second loop below computes the remaining 1 to 3 samples. */
  99.     while(blkCnt > 0u)
  100.     {
  101.       /* Read 2 inputs */
  102.       in1 = *pSrc++;
  103.       in2 = *pSrc++;

  105.       /* C = A >> shiftBits */
  106.       /* Shift the inputs and then store the results in the destination buffer. */
  107. #ifndef  ARM_MATH_BIG_ENDIAN

  109.       *__SIMD32(pDst)++ = __PKHBT((in1 >> -shiftBits),
  110.                                   (in2 >> -shiftBits), 16);

  112. #else

  114.       *__SIMD32(pDst)++ = __PKHBT((in2 >> -shiftBits),                                              (7)
  115.                                   (in1 >> -shiftBits), 16);

  117. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */

  119.       in1 = *pSrc++;
  120.       in2 = *pSrc++;

  122. #ifndef  ARM_MATH_BIG_ENDIAN

  124.       *__SIMD32(pDst)++ = __PKHBT((in1 >> -shiftBits),
  125.                                   (in2 >> -shiftBits), 16);

  127. #else

  129.       *__SIMD32(pDst)++ = __PKHBT((in2 >> -shiftBits),                                             
  130.                                   (in1 >> -shiftBits), 16);

  132. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */

  134.       /* Decrement the loop counter */
  135.       blkCnt--;
  136.     }

  138.     /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  139.      ** No loop unrolling is used. */
  140.     blkCnt = blockSize % 0x4u;

  142.     while(blkCnt > 0u)
  143.     {
  144.       /* C = A >> shiftBits */
  145.       /* Shift the inputs and then store the results in the destination buffer. */
  146.       *pDst++ = (*pSrc++ >> -shiftBits);

  148.       /* Decrement the loop counter */
  149.       blkCnt--;
  150.     }
  151.   }

  153. #else

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

  157.   /* Getting the sign of shiftBits */
  158.   sign = (shiftBits & 0x80);

  160.   /* If the shift value is positive then do right shift else left shift */
  161.   if(sign == 0u)
  162.   {
  163.     /* Initialize blkCnt with number of samples */
  164.     blkCnt = blockSize;

  166.     while(blkCnt > 0u)
  167.     {
  168.       /* C = A << shiftBits */
  169.       /* Shift and then store the results in the destination buffer. */
  170.       *pDst++ = __SSAT(((q31_t) * pSrc++ << shiftBits), 16);

  172.       /* Decrement the loop counter */
  173.       blkCnt--;
  174.     }
  175.   }
  176.   else
  177.   {
  178.     /* Initialize blkCnt with number of samples */
  179.     blkCnt = blockSize;

  181.     while(blkCnt > 0u)
  182.     {
  183.       /* C = A >> shiftBits */
  184.       /* Shift the inputs and then store the results in the destination buffer. */
  185.       *pDst++ = (*pSrc++ >> -shiftBits);

  187.       /* Decrement the loop counter */
  188.       blkCnt--;
  189.     }
  190.   }

  192. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  194. }
复制代码
1. 如果函数的参数shiftBits是正数那么表示左移，如果参数shiftBits是负数那么就是右移。
2. 这个函数使用了饱和运算。
    饱和运算数值0x8000将变成0x7FFF。
3. 获取偏移值是正数还是负数。
4. 通过调用一次__PKHBT实现两个Q15格式数据的计算。
5. 剩余几个数值的计算。
6. 如果位移值为负数，那么就是右移。
7. 将位移值取反以后，通过调用一次__PKHBT实现两个Q15格式数据的计算。


赞 评论
baiyongbin2009 回答时间：2015-3-19 11:23:36
9.3.3 arm_shift_q7
    这个函数用于求8位定点数的位移，源代码分析如下：
  1. /**
  2. * @brief Shifts the elements of a Q7 vector a specified number of bits.
  3. * @param[in] *pSrc points to the input vector
  4. * @param[in] shiftBits number of bits to shift.
  5. * A positive value shifts left; a negative value shifts right. (1)
  6. * @param[out] *pDst points to the output vector
  7. * @param[in] blockSize number of samples in the vector
  8. * @return none.
  9. *
  10. * \par Conditions for optimum performance
  11. * Input and output buffers should be aligned by 32-bit
  12. *
  13. *
  14. * <b>Scaling and Overflow Behavior:</b> (2)
  15. * \par
  16. * The function uses saturating arithmetic.
  17. * Results outside of the allowable Q7 range [0x8 0x7F] will be saturated.
  18. */

  20. void arm_shift_q7(
  21. q7_t * pSrc,
  22. int8_t shiftBits,
  23. q7_t * pDst,
  24. uint32_t blockSize)
  25. {
  26. uint32_t blkCnt; /* loop counter */
  27. uint8_t sign; /* Sign of shiftBits */

  29. #ifndef ARM_MATH_CM0_FAMILY

  31. /* Run the below code for Cortex-M4 and Cortex-M3 */
  32. q7_t in1; /* Input value1 */
  33. q7_t in2; /* Input value2 */
  34. q7_t in3; /* Input value3 */
  35. q7_t in4; /* Input value4 */


  38. /*loop Unrolling */
  39. blkCnt = blockSize >> 2u;

  41. /* Getting the sign of shiftBits */
  42. sign = (shiftBits & 0x80); (3)

  44. /* If the shift value is positive then do right shift else left shift */
  45. if(sign == 0u)
  46. {
  47. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
  48. ** a second loop below computes the remaining 1 to 3 samples. */
  49. while(blkCnt > 0u)
  50. {
  51. /* C = A << shiftBits */
  52. /* Read 4 inputs */
  53. in1 = *pSrc;
  54. in2 = *(pSrc + 1);
  55. in3 = *(pSrc + 2);
  56. in4 = *(pSrc + 3);
  57. (4)
  58. /* Store the Shifted result in the destination buffer in single cycle by packing the outputs */
  59. *__SIMD32(pDst)++ = __PACKq7(__SSAT((in1 << shiftBits), 8),
  60. __SSAT((in2 << shiftBits), 8),
  61. __SSAT((in3 << shiftBits), 8),
  62. __SSAT((in4 << shiftBits), 8));
  63. /* Update source pointer to process next sampels */
  64. pSrc += 4u;

  66. /* Decrement the loop counter */
  67. blkCnt--;
  68. }

  70. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
  71. ** No loop unrolling is used. */
  72. blkCnt = blockSize % 0x4u;

  74. while(blkCnt > 0u)
  75. {
  76. /* C = A << shiftBits */ (5)
  77. /* Shift the input and then store the result in the destination buffer. */
  78. *pDst++ = (q7_t) __SSAT((*pSrc++ << shiftBits), 8);

  80. /* Decrement the loop counter */
  81. blkCnt--;
  82. }
  83. }
  84. else (6)
  85. {
  86. shiftBits = -shiftBits;
  87. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
  88. ** a second loop below computes the remaining 1 to 3 samples. */
  89. while(blkCnt > 0u)
  90. {
  91. /* C = A >> shiftBits */
  92. /* Read 4 inputs */
  93. in1 = *pSrc;
  94. in2 = *(pSrc + 1);
  95. in3 = *(pSrc + 2);
  96. in4 = *(pSrc + 3);

  98. /* Store the Shifted result in the destination buffer in single cycle by packing the outputs */
  99. *__SIMD32(pDst)++ = __PACKq7((in1 >> shiftBits), (in2 >> shiftBits),
  100. (in3 >> shiftBits), (in4 >> shiftBits));


  103. pSrc += 4u;

  105. /* Decrement the loop counter */
  106. blkCnt--;
  107. }

  109. /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
  110. ** No loop unrolling is used. */
  111. blkCnt = blockSize % 0x4u;

  113. while(blkCnt > 0u)
  114. {
  115. /* C = A >> shiftBits */
  116. /* Shift the input and then store the result in the destination buffer. */
  117. in1 = *pSrc++;
  118. *pDst++ = (in1 >> shiftBits);

  120. /* Decrement the loop counter */
  121. blkCnt--;
  122. }
  123. }

  125. #else

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

  129. /* Getting the sign of shiftBits */
  130. sign = (shiftBits & 0x80);

  132. /* If the shift value is positive then do right shift else left shift */
  133. if(sign == 0u)
  134. {
  135. /* Initialize blkCnt with number of samples */
  136. blkCnt = blockSize;

  138. while(blkCnt > 0u)
  139. {
  140. /* C = A << shiftBits */
  141. /* Shift the input and then store the result in the destination buffer. */
  142. *pDst++ = (q7_t) __SSAT(((q15_t) * pSrc++ << shiftBits), 8);

  144. /* Decrement the loop counter */
  145. blkCnt--;
  146. }
  147. }
  148. else
  149. {
  150. /* Initialize blkCnt with number of samples */
  151. blkCnt = blockSize;

  153. while(blkCnt > 0u)
  154. {
  155. /* C = A >> shiftBits */
  156. /* Shift the input and then store the result in the destination buffer. */
  157. *pDst++ = (*pSrc++ >> -shiftBits);

  159. /* Decrement the loop counter */
  160. blkCnt--;
  161. }
  162. }

  164. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
  165. }
复制代码
1. 如果函数的参数shiftBits是正数那么表示左移，如果参数shiftBits是负数那么就是右移。
2. 这个函数使用了饱和运算。
    饱和运算数值0x80将变成0x7F。
3. 获取偏移值是正数还是负数。
4. 通过调用一次__PACKq7实现四个Q7格式数据的位移。
5. 剩余几不足4个数据的位移求解。
6. 如果移位值是负数，那么就是右移。

9.3.4 实例讲解
实验目的：
    1. 三种类型数据的位移。
实验内容：
    1. 按下K3键, 串口打印输出结果
实验现象：
通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：
9.3.png
程序设计：
  1. /*
  2. *********************************************************************************************************
  3. *        函 数 名: DSP_Shift
  4. *        功能说明: 位移
  5. *        形 参：无
  6. *        返 回 值: 无
  7. *********************************************************************************************************
  8. */
  9. static void DSP_Shift(void)
  10. {
  11. static q31_t pSrcA1 = 0x88886666;
  12. static q31_t pDst1;

  14. static q15_t pSrcA2 = 0x8866;
  15. static q15_t pDst2;

  17. static q7_t pSrcA3 = 0x86;
  18. static q7_t pDst3;


  21. arm_shift_q31(&pSrcA1, 3, &pDst1, 1);
  22. printf("arm_shift_q31 = %8x\r\n", pDst1);

  24. arm_shift_q15(&pSrcA2, -3, &pDst2, 1);
  25. printf("arm_shift_q15 = %4x\r\n", pDst2);

  27. arm_shift_q7(&pSrcA3, 3, &pDst3, 1);
  28. printf("arm_shift_q7 = %2x\r\n", pDst3);
  29. printf("***********************************\r\n");
  30. }
复制代码

赞 评论
baiyongbin2009 回答时间：2015-3-19 11:26:56
9.4 减法（Vector Sub）
    这部分函数主要用于实现减法，公式描述如下：
    pDst[n] = pSrcA[n] - pSrcB[n],   0 <= n < blockSize.     
9.4.1 arm_sub_f32
    这个函数用于求32位浮点数的减法，源代码分析如下：
  1. /**        
  2. * @brief Floating-point vector subtraction.        
  3. * @param[in]       *pSrcA points to the first input vector        
  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_sub_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 variables */
  22.   float32_t inB1, inB2, inB3, inB4;              /* temporary 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.     /* Subtract and then store the results in the destination buffer. */
  33.     /* Read 4 input samples from sourceA and sourceB */
  34.     inA1 = *pSrcA;
  35.     inB1 = *pSrcB;
  36.     inA2 = *(pSrcA + 1);
  37.     inB2 = *(pSrcB + 1);
  38.     inA3 = *(pSrcA + 2);
  39.     inB3 = *(pSrcB + 2);
  40.     inA4 = *(pSrcA + 3);
  41.     inB4 = *(pSrcB + 3);

  43.     /* dst = srcA - srcB */
  44.     /* subtract and store the result */                                                              (1)
  45.     *pDst = inA1 - inB1;
  46.     *(pDst + 1) = inA2 - inB2;
  47.     *(pDst + 2) = inA3 - inB3;
  48.     *(pDst + 3) = inA4 - inB4;


  51.     /* Update pointers to process next sampels */
  52.     pSrcA += 4u;
  53.     pSrcB += 4u;
  54.     pDst += 4u;

  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 */

  73.   while(blkCnt > 0u)
  74.   {
  75.     /* C = A - B */
  76.     /* Subtract and then store the results in the destination buffer. */
  77.     *pDst++ = (*pSrcA++) - (*pSrcB++);

  79.     /* Decrement the loop counter */
  80.     blkCnt--;
  81.   }
  82. }
复制代码
1. 浮点数的减法运算比较简单，直接两个数值相减即可。

9.4.2 arm_sub_q31
    这个函数用于求32位定点数的减法，源代码分析如下：
  1. /**   
  2. * @brief Q31 vector subtraction.   
  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_sub_q31(
  16.   q31_t * pSrcA,
  17.   q31_t * pSrcB,
  18.   q31_t * pDst,
  19.   uint32_t blockSize)
  20. {
  21.   uint32_t blkCnt;                               /* loop counter */


  24. #ifndef ARM_MATH_CM0_FAMILY

  26. /* Run the below code for Cortex-M4 and Cortex-M3 */
  27.   q31_t inA1, inA2, inA3, inA4;
  28.   q31_t inB1, inB2, inB3, inB4;

  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.     /* Subtract and then store the results in the destination buffer. */
  39.     inA1 = *pSrcA++;
  40.     inA2 = *pSrcA++;
  41.     inB1 = *pSrcB++;
  42.     inB2 = *pSrcB++;

  44.     inA3 = *pSrcA++;
  45.     inA4 = *pSrcA++;
  46.     inB3 = *pSrcB++;
  47.     inB4 = *pSrcB++;

  49.     *pDst++ = __QSUB(inA1, inB1);                                                                    (2)
  50.     *pDst++ = __QSUB(inA2, inB2);
  51.     *pDst++ = __QSUB(inA3, inB3);
  52.     *pDst++ = __QSUB(inA4, inB4);

  54.     /* Decrement the loop counter */
  55.     blkCnt--;
  56.   }

  58.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  59.    ** No loop unrolling is used. */
  60.   blkCnt = blockSize % 0x4u;

  62.   while(blkCnt > 0u)
  63.   {
  64.     /* C = A - B */
  65.     /* Subtract and then store the result in the destination buffer. */
  66.     *pDst++ = __QSUB(*pSrcA++, *pSrcB++);

  68.     /* Decrement the loop counter */
  69.     blkCnt--;
  70.   }

  72. #else

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

  76.   /* Initialize blkCnt with number of samples */
  77.   blkCnt = blockSize;

  79.   while(blkCnt > 0u)
  80.   {
  81.     /* C = A - B */
  82.     /* Subtract and then store the result in the destination buffer. */
  83.     *pDst++ = (q31_t) clip_q63_to_q31((q63_t) * pSrcA++ - *pSrcB++);

  85.     /* Decrement the loop counter */
  86.     blkCnt--;
  87.   }

  89. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  91. }
复制代码
1. 这个函数使用了饱和运算。
    饱和运算数值0x80000000将变成0x7FFFFFFF。
2. __QSUB也是SIMD指令，这里可以用这个指令实现两个Q31格式数据的饱和减法。

9.4.3 arm_sub_q15
    这个函数用于求16位定点数的减法，源代码分析如下：
  1. /**   
  2. * @brief Q15 vector subtraction.   
  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>   
  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_sub_q15(
  16.   q15_t * pSrcA,
  17.   q15_t * pSrcB,
  18.   q15_t * pDst,
  19.   uint32_t blockSize)
  20. {
  21.   uint32_t blkCnt;                               /* loop counter */


  24. #ifndef ARM_MATH_CM0_FAMILY

  26. /* Run the below code for Cortex-M4 and Cortex-M3 */
  27.   q31_t inA1, inA2;
  28.   q31_t inB1, inB2;

  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.     /* Subtract and then store the results in the destination buffer two samples at a time. */
  39.     inA1 = *__SIMD32(pSrcA)++;                                                                      (1)
  40.     inA2 = *__SIMD32(pSrcA)++;
  41.     inB1 = *__SIMD32(pSrcB)++;
  42.     inB2 = *__SIMD32(pSrcB)++;

  44.     *__SIMD32(pDst)++ = __QSUB16(inA1, inB1);                                                       (2)
  45.     *__SIMD32(pDst)++ = __QSUB16(inA2, inB2);

  47.     /* Decrement the loop counter */
  48.     blkCnt--;
  49.   }

  51.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  52.    ** No loop unrolling is used. */
  53.   blkCnt = blockSize % 0x4u;

  55.   while(blkCnt > 0u)
  56.   {
  57.     /* C = A - B */
  58.     /* Subtract and then store the result in the destination buffer. */
  59.     *pDst++ = (q15_t) __QSUB16(*pSrcA++, *pSrcB++);

  61.     /* Decrement the loop counter */
  62.     blkCnt--;
  63.   }

  65. #else

  67.   /* 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.     /* Subtract and then store the result in the destination buffer. */
  76.     *pDst++ = (q15_t) __SSAT(((q31_t) * pSrcA++ - *pSrcB++), 16);

  78.     /* Decrement the loop counter */
  79.     blkCnt--;
  80.   }

  82. #endif /* #ifndef ARM_MATH_CM0_FAMILY */


  85. }
复制代码
1. 这里一次读取两个Q15格式的数据。
2. 由于__QSUB16是SIMD指令，在这里调用一次__QSUB16可以实现两次减法运算。

9.4.4 arm_sub_q7
    这个函数用于求8位定点数的减法，源代码分析如下：
  1. /**   
  2. * @brief Q7 vector subtraction.   
  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>   
  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_sub_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 */

  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 - B */
  35.     /* Subtract and then store the results in the destination buffer 4 samples at a time. */
  36.     *__SIMD32(pDst)++ = __QSUB8(*__SIMD32(pSrcA)++, *__SIMD32(pSrcB)++);                              (1)

  38.     /* Decrement the loop counter */
  39.     blkCnt--;
  40.   }

  42.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  43.    ** No loop unrolling is used. */
  44.   blkCnt = blockSize % 0x4u;

  46.   while(blkCnt > 0u)
  47.   {
  48.     /* C = A - B */
  49.     /* Subtract and then store the result in the destination buffer. */
  50.     *pDst++ = __SSAT(*pSrcA++ - *pSrcB++, 8);

  52.     /* Decrement the loop counter */
  53.     blkCnt--;
  54.   }

  56. #else

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

  60.   /* Initialize blkCnt with number of samples */
  61.   blkCnt = blockSize;

  63.   while(blkCnt > 0u)
  64.   {
  65.     /* C = A - B */
  66.     /* Subtract and then store the result in the destination buffer. */
  67.     *pDst++ = (q7_t) __SSAT((q15_t) * pSrcA++ - *pSrcB++, 8);

  69.     /* Decrement the loop counter */
  70.     blkCnt--;
  71.   }

  73. #endif /* #ifndef ARM_MATH_CM0_FAMILY */


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

9.4.5 实例讲解
实验目的：
    1. 四种种类型数据的减法。
实验内容：
    1. 按下按键UP, 串口打印输出结果
实验现象：
        通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：
9.4.png
程序设计：
  1. /*
  2. *********************************************************************************************************
  3. *        函 数 名: DSP_Sub
  4. *        功能说明: 减法
  5. *        形    参：无
  6. *        返 回 值: 无
  7. *********************************************************************************************************
  8. */
  9. static void DSP_Sub(void)
  10. {
  11. static float32_t   pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
  12. static float32_t   pSrcB[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};  
  13. static float32_t   pDst[5];  
  14. static q31_t  pSrcA1[5] = {1,1,1,1,1};  
  15. static q31_t  pSrcB1[5] = {1,1,1,1,1};  
  16. static q31_t  pDst1[5];   

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

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

  26. pSrcA[0] += 1.1f;
  27. arm_sub_f32(pSrcA, pSrcB, pDst, 5);
  28. printf("arm_sub_f32 = %f\r\n", pDst[0]);
  29. pSrcA1[0] += 1;
  30. arm_sub_q31(pSrcA1, pSrcB1, pDst1, 5);
  31. printf("arm_sub_q31 = %d\r\n", pDst1[0]);

  33. pSrcA2[0] += 1;
  34. arm_sub_q15(pSrcA2, pSrcB2, pDst2, 5);
  35. printf("arm_sub_q15 = %d\r\n", pDst2[0]);

  37. pSrcA3[0] += 1;
  38. arm_sub_q7(pSrcA3, pSrcB3, pDst3, 5);
  39. printf("arm_sub_q7 = %d\r\n", pDst3[0]);
  40. printf("***********************************\r\n");
  41. }
复制代码

赞 评论
baiyongbin2009 回答时间：2015-3-19 11:30:19
9.5 比例因子（Vector Scale）
    这部分函数主要用于实现数据的比例放大和缩小，浮点数据公式描述如下：
      pDst[n] = pSrc[n] * scale,   0 <= n < blockSize.        
    如果是Q31，Q15，Q7格式的数据，公式描述如下：
      pDst[n] = (pSrc[n] * scaleFract) << shift,   0 <= n < blockSize.   
    这种情况下，比例因子就是：
      scale = scaleFract * 2^shift.      
          注意，这部分函数支持目标指针和源指针指向相同的缓冲区。
9.5.1 arm_scale_f32
    这个函数用于求32位浮点数的比例放缩，源代码分析如下：
  1. /**        
  2. * @brief Multiplies a floating-point vector by a scalar.        
  3. * @param[in]       *pSrc points to the input vector        
  4. * @param[in]       scale scale factor to be applied        
  5. * @param[out]      *pDst points to the output vector        
  6. * @param[in]       blockSize number of samples in the vector        
  7. * @return none.        
  8. */


  11. void arm_scale_f32(
  12.   float32_t * pSrc,
  13.   float32_t scale,
  14.   float32_t * pDst,
  15.   uint32_t blockSize)
  16. {
  17.   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 in1, in2, in3, in4;                  /* temporary variabels */

  23.   /*loop Unrolling */
  24.   blkCnt = blockSize >> 2u;

  26.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
  27.    ** a second loop below computes the remaining 1 to 3 samples. */
  28.   while(blkCnt > 0u)
  29.   {
  30.     /* C = A * scale */
  31.     /* Scale the input and then store the results in the destination buffer. */
  32.     /* read input samples from source */
  33.     in1 = *pSrc;
  34.     in2 = *(pSrc + 1);

  36.     /* multiply with scaling factor */                                                               (1)
  37.     in1 = in1 * scale;

  39.     /* read input sample from source */
  40.     in3 = *(pSrc + 2);

  42.     /* multiply with scaling factor */
  43.     in2 = in2 * scale;

  45.     /* read input sample from source */
  46.     in4 = *(pSrc + 3);

  48.     /* multiply with scaling factor */
  49.     in3 = in3 * scale;
  50.     in4 = in4 * scale;
  51.     /* store the result to destination */
  52.     *pDst = in1;
  53.     *(pDst + 1) = in2;
  54.     *(pDst + 2) = in3;
  55.     *(pDst + 3) = in4;

  57.     /* update pointers to process next samples */
  58.     pSrc += 4u;
  59.     pDst += 4u;

  61.     /* Decrement the loop counter */
  62.     blkCnt--;
  63.   }

  65.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
  66.    ** No loop unrolling is used. */
  67.   blkCnt = blockSize % 0x4u;

  69. #else

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

  73.   /* Initialize blkCnt with number of samples */
  74.   blkCnt = blockSize;

  76. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  78.   while(blkCnt > 0u)
  79.   {
  80.     /* C = A * scale */
  81.     /* Scale the input and then store the result in the destination buffer. */
  82.     *pDst++ = (*pSrc++) * scale;

  84.     /* Decrement the loop counter */
  85.     blkCnt--;
  86.   }
  87. }
复制代码
1. 浮点数据的比例因子计算比较简单，源浮点数相应相应的比例因子即可。

9.5.2 arm_scale_q31
    这个函数用于求32位定点数的比例放缩，源代码分析如下：
  1. /**      
  2. * @brief Multiplies a Q31 vector by a scalar.      
  3. * @param[in]       *pSrc points to the input vector      
  4. * @param[in]       scaleFract fractional portion of the scale value      
  5. * @param[in]       shift number of bits to shift the result by      
  6. * @param[out]      *pDst points to the output vector      
  7. * @param[in]       blockSize number of samples in the vector      
  8. * @return none.      
  9. *      
  10. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
  11. * \par      
  12. * The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.31 format.      
  13. * These are multiplied to yield a 2.62 intermediate result and this is shifted with saturation to 1.31 format.      
  14. */

  16. void arm_scale_q31(
  17.   q31_t * pSrc,
  18.   q31_t scaleFract,
  19.   int8_t shift,
  20.   q31_t * pDst,
  21.   uint32_t blockSize)
  22. {
  23.   int8_t kShift = shift + 1;                     /* Shift to apply after scaling */                 (2)
  24.   int8_t sign = (kShift & 0x80);
  25.   uint32_t blkCnt;                               /* loop counter */
  26.   q31_t in, out;

  28. #ifndef ARM_MATH_CM0_FAMILY

  30. /* Run the below code for Cortex-M4 and Cortex-M3 */

  32.   q31_t in1, in2, in3, in4;                      /* temporary input variables */
  33.   q31_t out1, out2, out3, out4;                  /* temporary output variabels */


  36.   /*loop Unrolling */
  37.   blkCnt = blockSize >> 2u;

  39.   if(sign == 0u)                                                                                    (3)
  40.   {
  41.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.      
  42.      ** a second loop below computes the remaining 1 to 3 samples. */
  43.     while(blkCnt > 0u)
  44.     {
  45.       /* read four inputs from source */
  46.       in1 = *pSrc;
  47.       in2 = *(pSrc + 1);
  48.       in3 = *(pSrc + 2);
  49.       in4 = *(pSrc + 3);

  51.       /* multiply input with scaler value */                                                        (4)
  52.       in1 = ((q63_t) in1 * scaleFract) >> 32;
  53.       in2 = ((q63_t) in2 * scaleFract) >> 32;
  54.       in3 = ((q63_t) in3 * scaleFract) >> 32;
  55.       in4 = ((q63_t) in4 * scaleFract) >> 32;

  57.       /* apply shifting */
  58.       out1 = in1 << kShift;
  59.       out2 = in2 << kShift;

  61.       /* saturate the results. */
  62.       if(in1 != (out1 >> kShift))                                                                   (5)
  63.         out1 = 0x7FFFFFFF ^ (in1 >> 31);

  65.       if(in2 != (out2 >> kShift))
  66.         out2 = 0x7FFFFFFF ^ (in2 >> 31);

  68.       out3 = in3 << kShift;
  69.       out4 = in4 << kShift;

  71.       *pDst = out1;
  72.       *(pDst + 1) = out2;

  74.       if(in3 != (out3 >> kShift))
  75.         out3 = 0x7FFFFFFF ^ (in3 >> 31);

  77.       if(in4 != (out4 >> kShift))
  78.         out4 = 0x7FFFFFFF ^ (in4 >> 31);

  80.       /* Store result destination */
  81.       *(pDst + 2) = out3;
  82.       *(pDst + 3) = out4;

  84.       /* Update pointers to process next sampels */
  85.       pSrc += 4u;
  86.       pDst += 4u;

  88.       /* Decrement the loop counter */
  89.       blkCnt--;
  90.     }

  92.   }
  93.   else                                                                                               {
  94.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.      
  95.      ** a second loop below computes the remaining 1 to 3 samples. */
  96.     while(blkCnt > 0u)
  97.     {
  98.       /* read four inputs from source */
  99.       in1 = *pSrc;
  100.       in2 = *(pSrc + 1);
  101.       in3 = *(pSrc + 2);
  102.       in4 = *(pSrc + 3);

  104.       /* multiply input with scaler value */
  105.       in1 = ((q63_t) in1 * scaleFract) >> 32;
  106.       in2 = ((q63_t) in2 * scaleFract) >> 32;
  107.       in3 = ((q63_t) in3 * scaleFract) >> 32;
  108.       in4 = ((q63_t) in4 * scaleFract) >> 32;

  110.       /* apply shifting */                                                                           (6)
  111.       out1 = in1 >> -kShift;
  112.       out2 = in2 >> -kShift;

  114.       out3 = in3 >> -kShift;
  115.       out4 = in4 >> -kShift;

  117.       /* Store result destination */
  118.       *pDst = out1;
  119.       *(pDst + 1) = out2;

  121.       *(pDst + 2) = out3;
  122.       *(pDst + 3) = out4;

  124.       /* Update pointers to process next sampels */
  125.       pSrc += 4u;
  126.       pDst += 4u;

  128.       /* Decrement the loop counter */
  129.       blkCnt--;
  130.     }
  131.   }
  132.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.      
  133.    ** No loop unrolling is used. */
  134.   blkCnt = blockSize % 0x4u;

  136. #else

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

  140.   /* Initialize blkCnt with number of samples */
  141.   blkCnt = blockSize;

  143. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  145.   if(sign == 0)
  146.   {
  147.   while(blkCnt > 0u)
  148.   {
  149. /* C = A * scale */
  150. /* Scale the input and then store the result in the destination buffer. */
  151. in = *pSrc++;
  152. in = ((q63_t) in * scaleFract) >> 32;

  154. out = in << kShift;
  155. if(in != (out >> kShift))
  156. out = 0x7FFFFFFF ^ (in >> 31);

  158. *pDst++ = out;

  160. /* Decrement the loop counter */
  161. blkCnt--;
  162.   }
  163.   }
  164.   else
  165.   {
  166.   while(blkCnt > 0u)
  167.   {
  168. /* C = A * scale */
  169. /* Scale the input and then store the result in the destination buffer. */
  170. in = *pSrc++;
  171. in = ((q63_t) in * scaleFract) >> 32;

  173. out = in >> -kShift;

  175. *pDst++ = out;

  177. /* Decrement the loop counter */
  178. blkCnt--;
  179.   }
  180.   
  181.   }
  182. }
复制代码
1. 源数据和比例因子都是Q31格式。这样他们的乘积就是1.31 * 1.31 = 2.62格式。由于输出结果也是Q31格式，那么源数据和比例因子的乘积需要右移32位，并且输出结果需要饱和处理。
2. 这里不清楚为什么要加1操作，留作以后解决。
3. 如果位移是正值，那么就是左移位，否则就是右移位。
4. 将源数据和比例因子的乘积左移32位，保证结果也是Q31格式。
5. 这里是对结果的饱和处理。
6. 数值的右移不存在饱和问题，这里直接取反即可。

9.5.3 arm_scale_q15
    这个函数用于求16位定点数的比例放缩，源代码分析如下：
  1. /**   
  2. * @brief Multiplies a Q15 vector by a scalar.   
  3. * @param[in]       *pSrc points to the input vector   
  4. * @param[in]       scaleFract fractional portion of the scale value   
  5. * @param[in]       shift number of bits to shift the result by   
  6. * @param[out]      *pDst points to the output vector   
  7. * @param[in]       blockSize number of samples in the vector   
  8. * @return none.   
  9. *   
  10. * <b>Scaling and Overflow Behavior:</b>                                                               (1)
  11. * \par   
  12. * The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.15 format.   
  13. * These are multiplied to yield a 2.30 intermediate result and this is shifted with saturation to 1.15 format.   
  14. */


  17. void arm_scale_q15(
  18.   q15_t * pSrc,
  19.   q15_t scaleFract,
  20.   int8_t shift,
  21.   q15_t * pDst,
  22.   uint32_t blockSize)
  23. {
  24.   int8_t kShift = 15 - shift;                    /* shift to apply after scaling */                   (2)
  25.   uint32_t blkCnt;                               /* loop counter */

  27. #ifndef ARM_MATH_CM0_FAMILY

  29. /* Run the below code for Cortex-M4 and Cortex-M3 */
  30.   q15_t in1, in2, in3, in4;
  31.   q31_t inA1, inA2;                              /* Temporary variables */
  32.   q31_t out1, out2, out3, out4;


  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.     /* Reading 2 inputs from memory */
  43.     inA1 = *__SIMD32(pSrc)++;                                                                       (3)
  44.     inA2 = *__SIMD32(pSrc)++;

  46.     /* C = A * scale */
  47.     /* Scale the inputs and then store the 2 results in the destination buffer        
  48.      * in single cycle by packing the outputs */
  49.     out1 = (q31_t) ((q15_t) (inA1 >> 16) * scaleFract);                                             (4)
  50.     out2 = (q31_t) ((q15_t) inA1 * scaleFract);
  51.     out3 = (q31_t) ((q15_t) (inA2 >> 16) * scaleFract);
  52.     out4 = (q31_t) ((q15_t) inA2 * scaleFract);

  54.     /* apply shifting */
  55.     out1 = out1 >> kShift;
  56.     out2 = out2 >> kShift;
  57.     out3 = out3 >> kShift;
  58.     out4 = out4 >> kShift;

  60.     /* saturate the output */
  61.     in1 = (q15_t) (__SSAT(out1, 16));                                                               (5)
  62.     in2 = (q15_t) (__SSAT(out2, 16));
  63.     in3 = (q15_t) (__SSAT(out3, 16));
  64.     in4 = (q15_t) (__SSAT(out4, 16));

  66.     /* store the result to destination */                                                           (6)
  67.     *__SIMD32(pDst)++ = __PKHBT(in2, in1, 16);
  68.     *__SIMD32(pDst)++ = __PKHBT(in4, in3, 16);

  70.     /* Decrement the loop counter */
  71.     blkCnt--;
  72.   }

  74.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
  75.    ** No loop unrolling is used. */
  76.   blkCnt = blockSize % 0x4u;

  78.   while(blkCnt > 0u)
  79.   {
  80.     /* C = A * scale */
  81.     /* Scale the input and then store the result in the destination buffer. */
  82.     *pDst++ = (q15_t) (__SSAT(((*pSrc++) * scaleFract) >> kShift, 16));

  84.     /* Decrement the loop counter */
  85.     blkCnt--;
  86.   }

  88. #else

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

  92.   /* Initialize blkCnt with number of samples */
  93.   blkCnt = blockSize;

  95.   while(blkCnt > 0u)
  96.   {
  97.     /* C = A * scale */
  98.     /* Scale the input and then store the result in the destination buffer. */
  99.     *pDst++ = (q15_t) (__SSAT(((q31_t) * pSrc++ * scaleFract) >> kShift, 16));

  101.     /* Decrement the loop counter */
  102.     blkCnt--;
  103.   }

  105. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  107. }
复制代码
1. 源数据和比例因子的数据格式都是Q15，这样的话，输出结果就是1.15 * 1.15 = 2.30格式，由于输出结果也是Q15格式，所以输出结果需要饱和处理。
2. 这个变量设计很巧妙，这样下面处理正数左移和负数右移就很方面了，可以直接使用一个右移就可以实现。
3. 读取两个Q15格式的数据。
4. 将源数据乘以比例因子后赋值给Q31格式的变量。
5. 对输出结果做饱和处理。
6. 通过调用一次__PKHBT指令，将两个Q15格式的数据都赋值给目的变量。


赞 评论
baiyongbin2009 回答时间：2015-3-19 11:31:11
9.5.4 arm_scale_q7
    这个函数用于求8位定点数的比例放缩，源代码分析如下：
  1. /**
  2. * @brief Multiplies a Q7 vector by a scalar.
  3. * @param[in] *pSrc points to the input vector
  4. * @param[in] scaleFract fractional portion of the scale value
  5. * @param[in] shift number of bits to shift the result by
  6. * @param[out] *pDst points to the output vector
  7. * @param[in] blockSize number of samples in the vector
  8. * @return none.
  9. *
  10. * <b>Scaling and Overflow Behavior:</b> (1)
  11. * \par
  12. * The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.7 format.
  13. * These are multiplied to yield a 2.14 intermediate result and this is shifted with saturation to 1.7 format.
  14. */

  16. void arm_scale_q7(
  17. q7_t * pSrc,
  18. q7_t scaleFract,
  19. int8_t shift,
  20. q7_t * pDst,
  21. uint32_t blockSize)
  22. {
  23. int8_t kShift = 7 - shift; /* shift to apply after scaling */ (2)
  24. uint32_t blkCnt; /* loop counter */

  26. #ifndef ARM_MATH_CM0_FAMILY

  28. /* Run the below code for Cortex-M4 and Cortex-M3 */
  29. q7_t in1, in2, in3, in4, out1, out2, out3, out4; /* Temporary variables to store input & output */


  32. /*loop Unrolling */
  33. blkCnt = blockSize >> 2u;


  36. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
  37. ** a second loop below computes the remaining 1 to 3 samples. */
  38. while(blkCnt > 0u)
  39. {
  40. /* Reading 4 inputs from memory */
  41. in1 = *pSrc++;
  42. in2 = *pSrc++;
  43. in3 = *pSrc++;
  44. in4 = *pSrc++;

  46. /* C = A * scale */
  47. /* Scale the inputs and then store the results in the temporary variables. */
  48. out1 = (q7_t) (__SSAT(((in1) * scaleFract) >> kShift, 8)); (3)
  49. out2 = (q7_t) (__SSAT(((in2) * scaleFract) >> kShift, 8));
  50. out3 = (q7_t) (__SSAT(((in3) * scaleFract) >> kShift, 8));
  51. out4 = (q7_t) (__SSAT(((in4) * scaleFract) >> kShift, 8));

  53. /* Packing the individual outputs into 32bit and storing in
  54. * destination buffer in single write */
  55. *__SIMD32(pDst)++ = __PACKq7(out1, out2, out3, out4); (4)

  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. while(blkCnt > 0u)
  66. {
  67. /* C = A * scale */
  68. /* Scale the input and then store the result in the destination buffer. */
  69. *pDst++ = (q7_t) (__SSAT(((*pSrc++) * scaleFract) >> kShift, 8));

  71. /* Decrement the loop counter */
  72. blkCnt--;
  73. }

  75. #else

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

  79. /* Initialize blkCnt with number of samples */
  80. blkCnt = blockSize;

  82. while(blkCnt > 0u)
  83. {
  84. /* C = A * scale */
  85. /* Scale the input and then store the result in the destination buffer. */
  86. *pDst++ = (q7_t) (__SSAT((((q15_t) * pSrc++ * scaleFract) >> kShift), 8));

  88. /* Decrement the loop counter */
  89. blkCnt--;
  90. }

  92. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  94. }
复制代码
1. 源数据和比例因子的数据格式都是Q7，这样的话，输出结果就是1.7 * 1.7 = 2.14格式，由于输出结果也是Q7格式，所以输出结果需要饱和处理。
2. 这个变量设计很巧妙，这样下面处理正数左移和负数右移就很方面了，可以直接使用一个右移就可以实现。
3. 对源数据和比例因子的输出结果做8位精度的饱和处理。

9.5.5 实例讲解
实验目的：
    1. 四种种类型数据的比例放缩。
实验内容：
    1. 按下按键DOWN 串口打印输出结果
实验现象：
    通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：
9.5.png
程序设计：
  1. /*
  2. *********************************************************************************************************
  3. *        函 数 名: DSP_Scale
  4. *        功能说明: 比例因子
  5. *        形 参：无
  6. *        返 回 值: 无
  7. *********************************************************************************************************
  8. */
  9. static void DSP_Scale(void)
  10. {
  11. static float32_t pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
  12. static float32_t scale = 0.0f;
  13. static float32_t pDst[5];
  14. static q31_t pSrcA1[5] = {0x6fffffff,1,1,1,1};
  15. static q31_t scale1 = 0x6fffffff;
  16. static q31_t pDst1[5];

  18. static q15_t pSrcA2[5] = {0x6fff,1,1,1,1};
  19. static q15_t scale2 = 0x6fff;
  20. static q15_t pDst2[5];

  22. static q7_t pSrcA3[5] = {0x70,1,1,1,1};
  23. static q7_t scale3 = 0x6f;
  24. static q7_t pDst3[5];

  26. scale += 0.1f;
  27. arm_scale_f32(pSrcA, scale, pDst, 5);
  28. printf("arm_sub_f32 = %f\r\n", pDst[0]);
  29. scale1 += 1;
  30. arm_scale_q31(pSrcA1, scale1, 0, pDst1, 5);
  31. printf("arm_scale_q31 = %x\r\n", pDst1[0]);

  33. scale2 += 1;
  34. arm_scale_q15(pSrcA2, scale2, 0, pDst2, 5);
  35. printf("arm_scale_q15 = %x\r\n", pDst2[0]);

  37. scale3 += 1;
  38. arm_scale_q7(pSrcA3, scale3, 0, pDst3, 5);
  39. printf("arm_scale_q7 = %x\r\n", pDst3[0]);
  40. printf("***********************************\r\n");
  41. }
复制代码

赞 评论
baiyongbin2009 回答时间：2015-3-19 11:32:14
9.6 BasicMathFunctions的重要说明
    截至到这里，BasicMathFunctions函数已经讲解完了，也许大家也发现了这些函数的一些共同点，在前面第8章的时候我们简单的阐述过，这里再进一步的阐述一下：
l 这些函数基本都是支持重入的。
l 基本每个函数都有四种数据类型，F32，Q31，Q15，Q7。
l 函数中数值的处理基本都是4个为一组，这么做的原因是F32，Q31，Q15，Q7就可以统一采用一个程序设计架构，便于管理。更重要的是可以在Q15和Q7数据处理中很好的发挥SIMD指令的作用（因为4个为一组的话，可以用SIMD指令正好处理2个Q15数据或者4个Q7数据）。
l 部分函数是支持目标指针和源指针指向相同的缓冲区。
    关于这个的使用，我们没有在前面的讲解中举例子，下面举一个简单的例子进行说明，这里就以9.5小节中scale函数进行说明：
  1. static void DSP_Scale(void)
  2. {
  3. static float32_t   pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
  4. static float32_t   scale = 0.0f;  
  5. static q31_t  pSrcA1[5] = {0x6fffffff,1,1,1,1};  
  6. static q31_t  scale1 = 0x6fffffff;  

  8. static q15_t  pSrcA2[5] = {0x6fff,1,1,1,1};  
  9. static q15_t  scale2 = 0x6fff;  
  10. static q7_t  pSrcA3[5] = {0x70,1,1,1,1};
  11. static q7_t  scale3 = 0x6f;  

  13. scale += 0.1f;
  14. arm_scale_f32(pSrcA, scale, pSrcA, 5);              (1)
  15. printf("arm_sub_f32 = %f\r\n", pSrcA[0]);
  16. scale1 += 1;
  17. arm_scale_q31(pSrcA1, scale1, 0, pSrcA1, 5);        (2)
  18. printf("arm_scale_q31 = %x\r\n", pSrcA1[0]);

  20. scale2 += 1;
  21. arm_scale_q15(pSrcA2, scale2, 0, pSrcA2, 5);        (3)
  22. printf("arm_scale_q15 = %x\r\n", pSrcA2[0]);

  24. scale3 += 1;
  25. arm_scale_q7(pSrcA3, scale3, 0, pSrcA3, 5);         (4)
  26. printf("arm_scale_q7 = %x\r\n", pSrcA3[0]);
  27. printf("***********************************\r\n");
  28. }
复制代码
上面代码的（1）至（4）目标指针和源指针指向相同的缓冲区。


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

赞 评论
_ilikerome_ 回答时间：2015-3-20 07:04:13
学习一下。。。
赞 评论
eurphan 回答时间：2015-3-20 09:19:06
不懂帮顶      
赞 评论
wyxy163@126.com 回答时间：2015-3-21 16:06:00
提示: 作者被禁止或删除 内容自动屏蔽
赞 评论

所属标签

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
st-img 微信公众号
st-img 手机版