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

第9章 BasicMathFunctions的使用（二）

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

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

    9.1 相反数（VectorNegate）

    9.2 求和（VectorOffset）

    9.3 点乘（VectorShift）

    9.4 减法（VectorSub）

    9.5 比例因子（VectorScale）

    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. * [url=home.php?mod=space&uid=1141835]@Return[/url] 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光盘里面有此软件）查看打印信息现象如下：




程序设计：

  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.    
  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_negate_f32(&pSrc, &pDst, 1);
  26.      printf("arm_negate_f32 = %f\r\n", pDst);

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

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

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

复制代码



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光盘里面有此软件）查看打印信息现象如下：




程序设计：

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

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

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

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

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

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

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

复制代码



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

上一篇：求助 51单片机串口问题
下一篇：请教大神，学习中
栏目分类
热门文章

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

网站地图

Top