【STM32H7的DSP教程】第11章 DSP基礎函數-絕對值，求和，乘法和點乘

完整版教程下載地址：http://www.armbbs.cn/forum.php?mod=viewthread&tid=94547

第11章       DSP基礎函數-絕對值，求和，乘法和點乘

本期教程開始學習ARM官方的DSP庫，這里我們先從基本數學函數開始。本期教程主要講絕對值，加法，點乘和乘法四種運算。

11.1 初學者重要提示

11.2 DSP基礎運算指令

11.3 絕對值（Vector Absolute Value）

11.4 求和（Vector Addition）

11.5 點乘（Vector Dot Product）

11.6 乘法（Vector Multiplication）

11.7 實驗例程說明（MDK）

11.8 實驗例程說明（IAR）

 

 

11.1 初學者重要提示

在這里簡單的跟大家介紹一下DSP庫中函數的通用格式，后面就不再贅述了。

1.   基本所有的函數都是可重入的。
2.   大部分函數都支持批量計算，比如求絕對值函數arm_abs_f32。所以如果只是就幾個數的絕對值，用這個庫函數就沒有什么優勢了。
3.   庫函數基本是CM0，CM0+，CM3，CM4和CM7內核都是支持的，不限制廠家。
4.   每組數據基本上都是以4個數為一個單位進行計算，不夠四個再單獨計算。大部分函數都是配有f32，Q31，Q15和Q7四種格式。
5.   為什么定點DSP運算輸出的時候容易出現結果為0的情況：http://www.armbbs.cn/forum.php?mod=viewthread&tid=95194 。

11.2 DSP基礎運算指令

本章用到基礎運算指令：

•   絕對值函數用到QSUB，QSUB16和QSUB8。
•   求和函數用到QADD，QADD16和QADD8。
•   點乘函數用到SMLALD和SMLAD。
•   乘法用到__PKHBT和__SSAT。

用到的這幾個指令，在本章講解具體函數時都有專門的講解說明。這里重點說一下飽和運算的問題，字母Q打頭的指令是飽和運算指令，飽和的意思超過所能表示的數值范圍時，將直接取最大值，比如QSUB16減法指令，如果是正數，那么最大值是0x7FFF（32767），大於這個值將直接取0x7FFF，如果是負數，那么最小值是0x8000（-32768），比這個值還小將直接取值0x8000。

反應到實際應用中就是下面這種效果：

 

11.3 絕對值（Vector Absolute Value）

這部分函數主要用於求絕對值，公式描述如下：

pDst[n] = abs(pSrc[n]),   0 <= n < blockSize.

特別注意，這部分函數支持目標指針和源指針指向相同的緩沖區。

11.3.1        函數arm_abs_f32

函數原型：

1.    void arm_abs_f32(
2.      const float32_t * pSrc,
3.            float32_t * pDst,
4.            uint32_t blockSize)
5.    {
6.            uint32_t blkCnt;                               /* Loop counter */
7.    
8.    #if defined(ARM_MATH_NEON)
9.        float32x4_t vec1;
10.        float32x4_t res;
11.    
12.        /* Compute 4 outputs at a time */
13.        blkCnt = blockSize >> 2U;
14.    
15.        while (blkCnt > 0U)
16.        {
17.            /* C = |A| */
18.    
19.            /* Calculate absolute values and then store the results in the destination buffer. */
20.            vec1 = vld1q_f32(pSrc);
21.            res = vabsq_f32(vec1);
22.            vst1q_f32(pDst, res);
23.    
24.            /* Increment pointers */
25.            pSrc += 4;
26.            pDst += 4;
27.            
28.            /* Decrement the loop counter */
29.            blkCnt--;
30.        }
31.    
32.        /* Tail */
33.        blkCnt = blockSize & 0x3;
34.    
35.    #else
36.    #if defined (ARM_MATH_LOOPUNROLL)
37.    
38.      /* Loop unrolling: Compute 4 outputs at a time */
39.      blkCnt = blockSize >> 2U;
40.    
41.      while (blkCnt > 0U)
42.      {
43.        /* C = |A| */
44.    
45.        /* Calculate absolute and store result in destination buffer. */
46.        *pDst++ = fabsf(*pSrc++);
47.    
48.        *pDst++ = fabsf(*pSrc++);
49.    
50.        *pDst++ = fabsf(*pSrc++);
51.    
52.        *pDst++ = fabsf(*pSrc++);
53.    
54.        /* Decrement loop counter */
55.        blkCnt--;
56.      }
57.    
58.      /* Loop unrolling: Compute remaining outputs */
59.      blkCnt = blockSize % 0x4U;
60.    
61.    #else
62.    
63.      /* Initialize blkCnt with number of samples */
64.      blkCnt = blockSize;
65.    
66.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
67.    #endif /* #if defined(ARM_MATH_NEON) */
68.    
69.      while (blkCnt > 0U)
70.      {
71.        /* C = |A| */
72.    
73.        /* Calculate absolute and store result in destination buffer. */
74.        *pDst++ = fabsf(*pSrc++);
75.    
76.        /* Decrement loop counter */
77.        blkCnt--;
78.      }
79.    
80.    }

 

函數描述：

這個函數用於求32位浮點數的絕對值。

函數解析：

•   第8到35行，用於NEON指令集，當前的CM內核不支持。
•   第36到66行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   函數fabsf不是用Cortex-M內核支持的DSP指令實現的，而是用C庫函數實現的，這個函數是被MDK封裝了起來。
•  第69到78行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。

函數參數：

•   第1個參數是原數據地址。
•   第2個參數是求絕對值后目的數據地址。
•   第3個參數轉換的數據個數，這里是指的浮點數個數。

函數描述：

函數形參的源地址和目的地址可以使用同一個緩沖。

11.3.2        函數arm_abs_q31

函數原型：

1.    void arm_abs_q31(
2.      const q31_t * pSrc,
3.            q31_t * pDst,
4.            uint32_t blockSize)
5.    {
6.            uint32_t blkCnt;                               /* Loop counter */
7.            q31_t in;                                      /* Temporary variable */
8.    
9.    #if defined (ARM_MATH_LOOPUNROLL)
10.    
11.      /* Loop unrolling: Compute 4 outputs at a time */
12.      blkCnt = blockSize >> 2U;
13.    
14.      while (blkCnt > 0U)
15.      {
16.        /* C = |A| */
17.    
18.        /* Calculate absolute of input (if -1 then saturated to 0x7fffffff) and store result in destination
19.          buffer. */
20.        in = *pSrc++;
21.    #if defined (ARM_MATH_DSP)
22.        *pDst++ = (in > 0) ? in : (q31_t)__QSUB(0, in);
23.    #else
24.        *pDst++ = (in > 0) ? in : ((in == INT32_MIN) ? INT32_MAX : -in);
25.    #endif
26.    
27.        in = *pSrc++;
28.    #if defined (ARM_MATH_DSP)
29.        *pDst++ = (in > 0) ? in : (q31_t)__QSUB(0, in);
30.    #else
31.        *pDst++ = (in > 0) ? in : ((in == INT32_MIN) ? INT32_MAX : -in);
32.    #endif
33.    
34.        in = *pSrc++;
35.    #if defined (ARM_MATH_DSP)
36.        *pDst++ = (in > 0) ? in : (q31_t)__QSUB(0, in);
37.    #else
38.        *pDst++ = (in > 0) ? in : ((in == INT32_MIN) ? INT32_MAX : -in);
39.    #endif
40.    
41.        in = *pSrc++;
42.    #if defined (ARM_MATH_DSP)
43.        *pDst++ = (in > 0) ? in : (q31_t)__QSUB(0, in);
44.    #else
45.        *pDst++ = (in > 0) ? in : ((in == INT32_MIN) ? INT32_MAX : -in);
46.    #endif
47.    
48.        /* Decrement loop counter */
49.        blkCnt--;
50.      }
51.    
52.      /* Loop unrolling: Compute remaining outputs */
53.      blkCnt = blockSize % 0x4U;
54.    
55.    #else
56.    
57.      /* Initialize blkCnt with number of samples */
58.      blkCnt = blockSize;
59.    
60.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
61.    
62.      while (blkCnt > 0U)
63.      {
64.        /* C = |A| */
65.    
66.        /* Calculate absolute of input (if -1 then saturated to 0x7fffffff) and store result in destination
67.           buffer. */
68.        in = *pSrc++;
69.    #if defined (ARM_MATH_DSP)
70.        *pDst++ = (in > 0) ? in : (q31_t)__QSUB(0, in);
71.    #else
72.        *pDst++ = (in > 0) ? in : ((in == INT32_MIN) ? INT32_MAX : -in);
73.    #endif
74.    
75.        /* Decrement loop counter */
76.        blkCnt--;
77.      }
78.    
79.    }

 

函數描述：

用於求32位定點數的絕對值。

函數解析：

•   第9到60行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第69到78行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•  這個函數使用了飽和運算，其實不光這個函數，后面很多函數都是使用了飽和運算的，關於什么是飽和運算，大家看Cortex-M3權威指南中文版的4.3.6 小節：匯編語言：飽和運算即可。
•   對於Q31格式的數據，飽和運算會使得數據0x80000000變成0x7fffffff（這個數比較特殊，算是特殊處理，記住即可）。
•   這里重點說一下函數__QSUB，其實這個函數算是Cortex-M7，M4/M3的一個指令，用於實現飽和減法。比如函數：__QSUB(0, in1) 的作用就是實現0 – in1並返回結果。這里__QSUB實現的是32位數的飽和減法。還有__QSUB16和__QSUB8實現的是16位和8位數的減法。

函數參數：

•   第1個參數是原數據地址。
•   第2個參數是求絕對值后目的數據地址。
•   第3個參數轉換的數據個數，這里是指的定點數個數。

函數描述：

函數形參的源地址和目的地址可以使用同一個緩沖。

11.3.3        函數arm_abs_q15

函數原型：

1.    void arm_abs_q15(
2.      const q15_t * pSrc,
3.            q15_t * pDst,
4.            uint32_t blockSize)
5.    {
6.            uint32_t blkCnt;                               /* Loop counter */
7.            q15_t in;                                      /* Temporary input variable */
8.    
9.    #if defined (ARM_MATH_LOOPUNROLL)
10.    
11.      /* Loop unrolling: Compute 4 outputs at a time */
12.      blkCnt = blockSize >> 2U;
13.    
14.      while (blkCnt > 0U)
15.      {
16.        /* C = |A| */
17.    
18.        /* Calculate absolute of input (if -1 then saturated to 0x7fff) and store result in destination buffer.
19.         */
20.        in = *pSrc++;
21.    #if defined (ARM_MATH_DSP)
22.        *pDst++ = (in > 0) ? in : (q15_t)__QSUB16(0, in);
23.    #else
24.        *pDst++ = (in > 0) ? in : ((in == (q15_t) 0x8000) ? 0x7fff : -in);
25.    #endif
26.    
27.        in = *pSrc++;
28.    #if defined (ARM_MATH_DSP)
29.        *pDst++ = (in > 0) ? in : (q15_t)__QSUB16(0, in);
30.    #else
31.        *pDst++ = (in > 0) ? in : ((in == (q15_t) 0x8000) ? 0x7fff : -in);
32.    #endif
33.    
34.        in = *pSrc++;
35.    #if defined (ARM_MATH_DSP)
36.        *pDst++ = (in > 0) ? in : (q15_t)__QSUB16(0, in);
37.    #else
38.        *pDst++ = (in > 0) ? in : ((in == (q15_t) 0x8000) ? 0x7fff : -in);
39.    #endif
40.    
41.        in = *pSrc++;
42.    #if defined (ARM_MATH_DSP)
43.        *pDst++ = (in > 0) ? in : (q15_t)__QSUB16(0, in);
44.    #else
45.        *pDst++ = (in > 0) ? in : ((in == (q15_t) 0x8000) ? 0x7fff : -in);
46.    #endif
47.    
48.        /* Decrement loop counter */
49.        blkCnt--;
50.      }
51.    
52.      /* Loop unrolling: Compute remaining outputs */
53.      blkCnt = blockSize % 0x4U;
54.    
55.    #else
56.    
57.      /* Initialize blkCnt with number of samples */
58.      blkCnt = blockSize;
59.    
60.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
61.    
62.      while (blkCnt > 0U)
63.      {
64.        /* C = |A| */
65.    
66.        /* Calculate absolute of input (if -1 then saturated to 0x7fff) and store result in destination buffer.
67.         */
68.        in = *pSrc++;
69.    #if defined (ARM_MATH_DSP)
70.        *pDst++ = (in > 0) ? in : (q15_t)__QSUB16(0, in);
71.    #else
72.        *pDst++ = (in > 0) ? in : ((in == (q15_t) 0x8000) ? 0x7fff : -in);
73.    #endif
74.    
75.        /* Decrement loop counter */
76.        blkCnt--;
77.      }
78.    
79.    }

 

函數描述：

用於求16位定點數的絕對值。

函數解析：

•   第9到55行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第62到77行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   對於Q15格式的數據，飽和運算會使得數據0x8000變成0x7fff。
•   __QSUB16用於實現16位數據的飽和減法。

函數參數：

•   第1個參數是原數據地址。
•   第2個參數是求絕對值后目的數據地址。
•   第3個參數轉換的數據個數，這里是指的定點數個數。

函數描述：

函數形參的源地址和目的地址可以使用同一個緩沖。

11.3.4        函數arm_abs_q7

函數原型：

1.    void arm_abs_q7(
2.      const q7_t * pSrc,
3.            q7_t * pDst,
4.            uint32_t blockSize)
5.    {
6.            uint32_t blkCnt;                               /* Loop counter */
7.            q7_t in;                                       /* Temporary input variable */
8.    
9.    #if defined (ARM_MATH_LOOPUNROLL)
10.    
11.      /* Loop unrolling: Compute 4 outputs at a time */
12.      blkCnt = blockSize >> 2U;
13.    
14.      while (blkCnt > 0U)
15.      {
16.        /* C = |A| */
17.    
18.        /* Calculate absolute of input (if -1 then saturated to 0x7f) and store result in destination buffer.
19.         */
20.        in = *pSrc++;
21.    #if defined (ARM_MATH_DSP)
22.        *pDst++ = (in > 0) ? in : (q7_t)__QSUB(0, in);
23.    #else
24.        *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? (q7_t) 0x7f : -in);
25.    #endif
26.    
27.        in = *pSrc++;
28.    #if defined (ARM_MATH_DSP)
29.        *pDst++ = (in > 0) ? in : (q7_t)__QSUB(0, in);
30.    #else
31.        *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? (q7_t) 0x7f : -in);
32.    #endif
33.    
34.        in = *pSrc++;
35.    #if defined (ARM_MATH_DSP)
36.        *pDst++ = (in > 0) ? in : (q7_t)__QSUB(0, in);
37.    #else
38.        *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? (q7_t) 0x7f : -in);
39.    #endif
40.    
41.        in = *pSrc++;ezi le mexia 
42.    #if defined (ARM_MATH_DSP)
43.        *pDst++ = (in > 0) ? in : (q7_t)__QSUB(0, in);
44.    #else
45.        *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? (q7_t) 0x7f : -in);
46.    #endif
47.    
48.        /* Decrement loop counter */
49.        blkCnt--;
50.      }
51.    
52.      /* Loop unrolling: Compute remaining outputs */
53.      blkCnt = blockSize % 0x4U;
54.    
55.    #else
56.    
57.      /* Initialize blkCnt with number of samples */
58.      blkCnt = blockSize;
59.    
60.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
61.    
62.      while (blkCnt > 0U)
63.      {
64.        /* C = |A| */
65.    
66.        /* Calculate absolute of input (if -1 then saturated to 0x7f) and store result in destination buffer.
67.         */
68.        in = *pSrc++;
69.    #if defined (ARM_MATH_DSP)
70.        *pDst++ = (in > 0) ? in : (q7_t) __QSUB(0, in);
71.    #else
72.        *pDst++ = (in > 0) ? in : ((in == (q7_t) 0x80) ? (q7_t) 0x7f : -in);
73.    #endif
74.    
75.        /* Decrement loop counter */
76.        blkCnt--;
77.      }
78.    
79.    }

 

函數描述：

用於求8位定點數的絕對值。

函數解析：

•   第9到55行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第62到77行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   對於Q7格式的數據，飽和運算會使得數據0x80變成0x7f。
•   __QSUB用於實現32位數據的飽和減法。而當前的DSP庫版本卻將其用到了Q7函數中，導致0x80的飽和出錯。詳情看此貼：http://www.armbbs.cn/forum.php?mod=viewthread&tid=95152 。

函數參數：

•   第1個參數是原數據地址。
•   第2個參數是求絕對值后目的數據地址。
•   第3個參數轉換的數據個數，這里是指的定點數個數。

函數描述：

函數形參的源地址和目的地址可以使用同一個緩沖。

11.3.5        使用舉例

程序設計：

/*
*********************************************************************************************************
*    函 數 名: DSP_ABS
*    功能說明: 求絕對值
*    形    參: 無
*    返 回 值: 無
*********************************************************************************************************
*/
static void DSP_ABS(void)
{
    float32_t pSrc;
    float32_t pDst;

    q31_t pSrc1;
    q31_t pDst1;

    q15_t pSrc2;
    q15_t pDst2;

    q7_t pSrc3; 
    q7_t pDst3;
    
    
    /*求絕對值*********************************/
    pSrc -= 1.23f;
    arm_abs_f32(&pSrc, &pDst, 1);
    printf("arm_abs_f32 = %f\r\n", pDst);

    pSrc1 -= 1;
    arm_abs_q31(&pSrc1, &pDst1, 1);
    printf("arm_abs_q31 = %d\r\n", pDst1);

    pSrc2 = -32768;
    arm_abs_q15(&pSrc2, &pDst2, 1);
    printf("arm_abs_q15 = %d\r\n", pDst2);

    pSrc3 = 127; 
    arm_abs_q7(&pSrc3, &pDst3, 1);
    printf("arm_abs_q7 = %d\r\n", pDst3);
    printf("***********************************\r\n");
}

 

實驗現象：

 

這里特別注意Q15的計算，數值-32768被飽和處理到32767，即0 - （-32768）= 32768，超出了正數所能表示的最大值，經過飽和后，輸出為32767。

11.4 求和（Vector Addition）

這部分函數主要用於求和，公式描述如下：

pDst[n] = pSrcA[n] + pSrcB[n],   0 <= n < blockSize.

11.4.1        函數arm_add_f32

函數原型：

1.    void arm_add_f32(
2.      const float32_t * pSrcA,
3.      const float32_t * pSrcB,
4.            float32_t * pDst,
5.            uint32_t blockSize)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.    
9.    #if defined(ARM_MATH_NEON)
10.        float32x4_t vec1;
11.        float32x4_t vec2;
12.        float32x4_t res;
13.    
14.        /* Compute 4 outputs at a time */
15.        blkCnt = blockSize >> 2U;
16.    
17.        while (blkCnt > 0U)
18.        {
19.            /* C = A + B */
20.    
21.            /* Add and then store the results in the destination buffer. */
22.            vec1 = vld1q_f32(pSrcA);
23.            vec2 = vld1q_f32(pSrcB);
24.            res = vaddq_f32(vec1, vec2);
25.            vst1q_f32(pDst, res);
26.    
27.            /* Increment pointers */
28.            pSrcA += 4;
29.            pSrcB += 4; 
30.            pDst += 4;
31.            
32.            /* Decrement the loop counter */
33.            blkCnt--;
34.        }
35.    
36.        /* Tail */
37.        blkCnt = blockSize & 0x3;
38.    
39.    #else
40.    #if defined (ARM_MATH_LOOPUNROLL)
41.    
42.      /* Loop unrolling: Compute 4 outputs at a time */
43.      blkCnt = blockSize >> 2U;
44.    
45.      while (blkCnt > 0U)
46.      {
47.        /* C = A + B */
48.    
49.        /* Add and store result in destination buffer. */
50.        *pDst++ = (*pSrcA++) + (*pSrcB++);
51.        *pDst++ = (*pSrcA++) + (*pSrcB++);
52.        *pDst++ = (*pSrcA++) + (*pSrcB++);
53.        *pDst++ = (*pSrcA++) + (*pSrcB++);
54.    
55.        /* Decrement loop counter */
56.        blkCnt--;
57.      }
58.    
59.      /* Loop unrolling: Compute remaining outputs */
60.      blkCnt = blockSize % 0x4U;
61.    
62.    #else
63.    
64.      /* Initialize blkCnt with number of samples */
65.      blkCnt = blockSize;
66.    
67.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
68.    #endif /* #if defined(ARM_MATH_NEON) */
69.    
70.      while (blkCnt > 0U)
71.      {
72.        /* C = A + B */
73.    
74.        /* Add and store result in destination buffer. */
75.        *pDst++ = (*pSrcA++) + (*pSrcB++);
76.    
77.        /* Decrement loop counter */
78.        blkCnt--;
79.      }
80.    
81.    }

 

函數描述：

這個函數用於求兩個32位浮點數的和。

函數解析：

•   第8到35行，用於NEON指令集，當前的CM內核不支持。
•   第40到62行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第70到79行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。

函數參數：

•   第1個參數是加數地址。
•   第2個參數是被加數地址。
•   第3個參數是和地址。
•   第4個參數是浮點數個數，其實就是執行加法的次數。

11.4.2        函數arm_add_q31

函數原型：

1.    void arm_add_q31(
2.      const q31_t * pSrcA,
3.      const q31_t * pSrcB,
4.            q31_t * pDst,
5.            uint32_t blockSize)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.    
9.    #if defined (ARM_MATH_LOOPUNROLL)
10.    
11.      /* Loop unrolling: Compute 4 outputs at a time */
12.      blkCnt = blockSize >> 2U;
13.    
14.      while (blkCnt > 0U)
15.      {
16.        /* C = A + B */
17.    
18.        /* Add and store result in destination buffer. */
19.        *pDst++ = __QADD(*pSrcA++, *pSrcB++);
20.    
21.        *pDst++ = __QADD(*pSrcA++, *pSrcB++);
22.    
23.        *pDst++ = __QADD(*pSrcA++, *pSrcB++);
24.    
25.        *pDst++ = __QADD(*pSrcA++, *pSrcB++);
26.    
27.        /* Decrement loop counter */
28.        blkCnt--;
29.      }
30.    
31.      /* Loop unrolling: Compute remaining outputs */
32.      blkCnt = blockSize % 0x4U;
33.    
34.    #else
35.    
36.      /* Initialize blkCnt with number of samples */
37.      blkCnt = blockSize;
38.    
39.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
40.    
41.      while (blkCnt > 0U)
42.      {
43.        /* C = A + B */
44.    
45.        /* Add and store result in destination buffer. */
46.        *pDst++ = __QADD(*pSrcA++, *pSrcB++);
47.    
48.        /* Decrement loop counter */
49.        blkCnt--;
50.      }
51.    
52.    }

 

函數描述：

這個函數用於求兩個32位定點數的和。

函數解析：

•   第9到34行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第41到50行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   __QADD實現32位數的加法飽和運算。輸出結果的范圍[0x80000000 0x7FFFFFFF]，超出這個結果將產生飽和結果，負數飽和到0x80000000，正數飽和到0x7FFFFFFF。

函數參數：

•   第1個參數是加數地址。
•   第2個參數是被加數地址。
•   第3個參數是和地址。
•   第4個參數是定點數個數，其實就是執行加法的次數。

11.4.3        函數arm_add_q15

函數原型：

1.    void arm_add_q15(
2.      const q15_t * pSrcA,
3.      const q15_t * pSrcB,
4.            q15_t * pDst,
5.            uint32_t blockSize)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.    
9.    #if defined (ARM_MATH_LOOPUNROLL)
10.    
11.    #if defined (ARM_MATH_DSP)
12.      q31_t inA1, inA2;
13.      q31_t inB1, inB2;
14.    #endif
15.    
16.      /* Loop unrolling: Compute 4 outputs at a time */
17.      blkCnt = blockSize >> 2U;
18.    
19.      while (blkCnt > 0U)
20.      {
21.        /* C = A + B */
22.    
23.    #if defined (ARM_MATH_DSP)
24.        /* read 2 times 2 samples at a time from sourceA */
25.        inA1 = read_q15x2_ia ((q15_t **) &pSrcA);
26.        inA2 = read_q15x2_ia ((q15_t **) &pSrcA);
27.        /* read 2 times 2 samples at a time from sourceB */
28.        inB1 = read_q15x2_ia ((q15_t **) &pSrcB);
29.        inB2 = read_q15x2_ia ((q15_t **) &pSrcB);
30.    
31.        /* Add and store 2 times 2 samples at a time */
32.        write_q15x2_ia (&pDst, __QADD16(inA1, inB1));
33.        write_q15x2_ia (&pDst, __QADD16(inA2, inB2));
34.    #else
35.        *pDst++ = (q15_t) __SSAT(((q31_t) *pSrcA++ + *pSrcB++), 16);
36.        *pDst++ = (q15_t) __SSAT(((q31_t) *pSrcA++ + *pSrcB++), 16);
37.        *pDst++ = (q15_t) __SSAT(((q31_t) *pSrcA++ + *pSrcB++), 16);
38.        *pDst++ = (q15_t) __SSAT(((q31_t) *pSrcA++ + *pSrcB++), 16);
39.    #endif
40.    
41.        /* Decrement loop counter */
42.        blkCnt--;
43.      }
44.    
45.      /* Loop unrolling: Compute remaining outputs */
46.      blkCnt = blockSize % 0x4U;
47.    
48.    #else
49.    
50.      /* Initialize blkCnt with number of samples */
51.      blkCnt = blockSize;
52.    
53.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
54.    
55.      while (blkCnt > 0U)
56.      {
57.        /* C = A + B */
58.    
59.        /* Add and store result in destination buffer. */
60.    #if defined (ARM_MATH_DSP)
61.        *pDst++ = (q15_t) __QADD16(*pSrcA++, *pSrcB++);
62.    #else
63.        *pDst++ = (q15_t) __SSAT(((q31_t) *pSrcA++ + *pSrcB++), 16);
64.    #endif
65.    
66.        /* Decrement loop counter */
67.        blkCnt--;
68.      }
69.    
70.    }

 

函數描述：

這個函數用於求兩個16位定點數的和。

函數解析：

•   第23到34行，對於M4和M7帶DSP單元的芯片使用。
•   第35到38行，對於不帶DSP單元的M0，M0+和M3使用。
•   第55到68行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   函數read_q15x2_ia的原型如下：

__STATIC_FORCEINLINE q31_t read_q15x2_ia (
  q15_t ** pQ15)
{
  q31_t val;

  memcpy (&val, *pQ15, 4);
  *pQ15 += 2;

  return (val);
}

 

作用是讀取兩次16位數據，返回一個32位數據，並將數據地址遞增，方便下次讀取。

•   __QADD16實現兩次16位數的加法飽和運算。輸出結果的范圍[0x8000 0x7FFF]，超出這個結果將產生飽和結果，負數飽和到0x8000，正數飽和到0x7FFF。
•   __SSAT也是SIMD指令，這里是將結果飽和到16位精度。

函數參數：

•   第1個參數是加數地址。
•   第2個參數是被加數地址。
•   第3個參數是和地址。
•   第4個參數是定點數個數，其實就是執行加法的次數。

11.4.4        函數arm_add_q7

函數原型：

1.    void arm_add_q7(
2.      const q7_t * pSrcA,
3.      const q7_t * pSrcB,
4.            q7_t * pDst,
5.            uint32_t blockSize)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.    
9.    #if defined (ARM_MATH_LOOPUNROLL)
10.    
11.      /* Loop unrolling: Compute 4 outputs at a time */
12.      blkCnt = blockSize >> 2U;
13.    
14.      while (blkCnt > 0U)
15.      {
16.        /* C = A + B */
17.    
18.    #if defined (ARM_MATH_DSP)
19.        /* Add and store result in destination buffer (4 samples at a time). */
20.        write_q7x4_ia (&pDst, __QADD8 (read_q7x4_ia ((q7_t **) &pSrcA), read_q7x4_ia ((q7_t **) &pSrcB)));
21.    #else
22.        *pDst++ = (q7_t) __SSAT ((q15_t) *pSrcA++ + *pSrcB++, 8);
23.        *pDst++ = (q7_t) __SSAT ((q15_t) *pSrcA++ + *pSrcB++, 8);
24.        *pDst++ = (q7_t) __SSAT ((q15_t) *pSrcA++ + *pSrcB++, 8);
25.        *pDst++ = (q7_t) __SSAT ((q15_t) *pSrcA++ + *pSrcB++, 8);
26.    #endif
27.    
28.        /* Decrement loop counter */
29.        blkCnt--;
30.      }
31.    
32.      /* Loop unrolling: Compute remaining outputs */
33.      blkCnt = blockSize % 0x4U;
34.    
35.    #else
36.    
37.      /* Initialize blkCnt with number of samples */
38.      blkCnt = blockSize;
39.    
40.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
41.    
42.      while (blkCnt > 0U)
43.      {
44.        /* C = A + B */
45.    
46.        /* Add and store result in destination buffer. */
47.        *pDst++ = (q7_t) __SSAT((q15_t) *pSrcA++ + *pSrcB++, 8);
48.    
49.        /* Decrement loop counter */
50.        blkCnt--;
51.      }
52.    
53.    }

 

函數描述：

這個函數用於求兩個8位定點數的和。

函數解析：

•   第18到21行，對於M4和M7帶DSP單元的芯片使用。
•   第22到25行，對於不帶DSP單元的M0，M0+和M3使用。
•   第42到51行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   函數read_q15x2_ia的原型如下：

__STATIC_FORCEINLINE void write_q7x4_ia (
  q7_t ** pQ7,
  q31_t   value)
{
  q31_t val = value;

  memcpy (*pQ7, &val, 4);
  *pQ7 += 4;
}

 

作用是讀取4次8位數據，返回一個32位數據，並將數據地址遞增，方便下次讀取。

•   __QADD8實現四次8位數的加法飽和運算。輸出結果的范圍[0x80 0x7F]，超出這個結果將產生飽和結果，負數飽和到0x80，正數飽和到0x7F。

函數參數：

•   第1個參數是加數地址。
•   第2個參數是被加數地址。
•   第3個參數是和地址。
•   第4個參數是定點數個數，其實就是執行加法的次數。

11.4.5        使用舉例

程序設計：

/*
*********************************************************************************************************
*    函 數 名: DSP_Add
*    功能說明: 加法
*    形    參: 無
*    返 回 值: 無
*********************************************************************************************************
*/
static void DSP_Add(void)
{
    float32_t   pSrcA;
    float32_t   pSrcB;  
    float32_t   pDst;  
    
    q31_t  pSrcA1;  
    q31_t  pSrcB1;  
    q31_t  pDst1;  

    q15_t  pSrcA2;  
    q15_t  pSrcB2;  
    q15_t  pDst2; 

    q7_t  pSrcA3; 
    q7_t  pSrcB3;  
    q7_t  pDst3;  

    
    /*求和*********************************/
    pSrcA = 0.1f;
    pSrcB = 0.2f;
    arm_add_f32(&pSrcA, &pSrcB, &pDst, 1);
    printf("arm_add_f32 = %f\r\n", pDst);

    pSrcA1 = 1;
    pSrcB1 = 1;
    arm_add_q31(&pSrcA1, &pSrcB1, &pDst1, 1);
    printf("arm_add_q31 = %d\r\n", pDst1);

    pSrcA2 = 2;
    pSrcB2 = 2;
    arm_add_q15(&pSrcA2, &pSrcB2, &pDst2, 1);
    printf("arm_add_q15 = %d\r\n", pDst2);

    pSrcA3 = 30;
    pSrcB3 = 120;
    arm_add_q7(&pSrcA3, &pSrcB3, &pDst3, 1);
    printf("arm_add_q7 = %d\r\n", pDst3);
    printf("***********************************\r\n");
}

 

實驗現象：

 

這里特別注意Q7的計算處理，30+120已經超出了Q7所能表示的最大值127，經過飽和處理后，經過飽和后，輸出為127。

11.5 點乘（Vector Dot Product）

這部分函數主要用於點乘，公式描述如下：

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

11.5.1        函數arm_dot_prod_f32

函數原型：

1.    void arm_dot_prod_f32(
2.      const float32_t * pSrcA,
3.      const float32_t * pSrcB,
4.            uint32_t blockSize,
5.            float32_t * result)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.            float32_t sum = 0.0f;                          /* Temporary return variable */
9.    
10.    #if defined(ARM_MATH_NEON)
11.        float32x4_t vec1;
12.        float32x4_t vec2;
13.        float32x4_t res;
14.        float32x4_t accum = vdupq_n_f32(0);    
15.    
16.        /* Compute 4 outputs at a time */
17.        blkCnt = blockSize >> 2U;
18.    
19.        vec1 = vld1q_f32(pSrcA);
20.        vec2 = vld1q_f32(pSrcB);
21.    
22.        while (blkCnt > 0U)
23.        {
24.            /* C = A[0]*B[0] + A[1]*B[1] + A[2]*B[2] + ... + A[blockSize-1]*B[blockSize-1] */
25.            /* Calculate dot product and then store the result in a temporary buffer. */
26.            
27.        accum = vmlaq_f32(accum, vec1, vec2);
28.        
29.            /* Increment pointers */
30.            pSrcA += 4;
31.            pSrcB += 4; 
32.    
33.            vec1 = vld1q_f32(pSrcA);
34.            vec2 = vld1q_f32(pSrcB);
35.            
36.            /* Decrement the loop counter */
37.            blkCnt--;
38.        }
39.        
40.    #if __aarch64__
41.        sum = vpadds_f32(vpadd_f32(vget_low_f32(accum), vget_high_f32(accum)));
42.    #else
43.        sum = (vpadd_f32(vget_low_f32(accum), vget_high_f32(accum)))[0] + (vpadd_f32(vget_low_f32(accum), 
44.              vget_high_f32(accum)))[1];
45.    #endif    
46.    
47.        /* Tail */
48.        blkCnt = blockSize & 0x3;
49.    
50.    #else
51.    #if defined (ARM_MATH_LOOPUNROLL)
52.    
53.      /* Loop unrolling: Compute 4 outputs at a time */
54.      blkCnt = blockSize >> 2U;
55.    
56.      /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
57.       ** a second loop below computes the remaining 1 to 3 samples. */
58.      while (blkCnt > 0U)
59.      {
60.        /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
61.    
62.        /* Calculate dot product and store result in a temporary buffer. */
63.        sum += (*pSrcA++) * (*pSrcB++);
64.    
65.        sum += (*pSrcA++) * (*pSrcB++);
66.    
67.        sum += (*pSrcA++) * (*pSrcB++);
68.    
69.        sum += (*pSrcA++) * (*pSrcB++);
70.    
71.        /* Decrement loop counter */
72.        blkCnt--;
73.      }
74.    
75.      /* Loop unrolling: Compute remaining outputs */
76.      blkCnt = blockSize % 0x4U;
77.    
78.    #else
79.    
80.      /* Initialize blkCnt with number of samples */
81.      blkCnt = blockSize;
82.    
83.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
84.    #endif /* #if defined(ARM_MATH_NEON) */
85.    
86.      while (blkCnt > 0U)
87.      {
88.        /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
89.    
90.        /* Calculate dot product and store result in a temporary buffer. */
91.        sum += (*pSrcA++) * (*pSrcB++);
92.    
93.        /* Decrement loop counter */
94.        blkCnt--;
95.      }
96.    
97.      /* Store result in destination buffer */
98.      *result = sum;
99.    }

 

函數描述：

這個函數用於求32位浮點數的點乘。

函數解析：

•   第10到50行，用於NEON指令集，當前的CM內核不支持。
•   第51到78行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第86到95行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。

函數參數：

•   第1個參數是乘數地址。
•   第2個參數是被乘數地址。
•   第3個參數是浮點數個數，其實就是執行點乘的次數。
•   第4個參數是結果地址。

11.5.2        函數arm_dot_prod_q31

函數原型：

1.    void arm_dot_prod_q31(
2.      const q31_t * pSrcA,
3.      const q31_t * pSrcB,
4.            uint32_t blockSize,
5.            q63_t * result)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.            q63_t sum = 0;                                 /* Temporary return variable */
9.    
10.    #if defined (ARM_MATH_LOOPUNROLL)
11.    
12.      /* Loop unrolling: Compute 4 outputs at a time */
13.      blkCnt = blockSize >> 2U;
14.    
15.      while (blkCnt > 0U)
16.      {
17.        /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
18.    
19.        /* Calculate dot product and store result in a temporary buffer. */
20.        sum += ((q63_t) *pSrcA++ * *pSrcB++) >> 14U;
21.    
22.        sum += ((q63_t) *pSrcA++ * *pSrcB++) >> 14U;
23.    
24.        sum += ((q63_t) *pSrcA++ * *pSrcB++) >> 14U;
25.    
26.        sum += ((q63_t) *pSrcA++ * *pSrcB++) >> 14U;
27.    
28.        /* Decrement loop counter */
29.        blkCnt--;
30.      }
31.    
32.      /* Loop unrolling: Compute remaining outputs */
33.      blkCnt = blockSize % 0x4U;
34.    
35.    #else
36.    
37.      /* Initialize blkCnt with number of samples */
38.      blkCnt = blockSize;
39.    
40.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
41.    
42.      while (blkCnt > 0U)
43.      {
44.        /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
45.    
46.        /* Calculate dot product and store result in a temporary buffer. */
47.        sum += ((q63_t) *pSrcA++ * *pSrcB++) >> 14U;
48.    
49.        /* Decrement loop counter */
50.        blkCnt--;
51.      }
52.    
53.      /* Store result in destination buffer in 16.48 format */
54.      *result = sum;
55.    }

 

函數描述：

這個函數用於求32位定點數的點乘。

函數解析：

•   第10到35行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第42到51行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   兩個Q31格式的32位數相乘，那么輸出結果的格式是1.31*1.31 = 2.62。實際應用中基本不需要這么高的精度，這個函數將低14位的數據截取掉，反應在函數中就是兩個數的乘積左移14位，也就是定點數的小數點也左移14位，那么最終的結果的格式是16.48。所以只要乘累加的個數小於2^16就沒有輸出結果溢出的危險。

函數參數：

•   第1個參數是乘數地址。
•   第2個參數是被乘數地址。
•   第3個參數是定點數個數，其實就是執行點乘的次數。
•   第4個參數是結果地址。

11.5.3        函數arm_dot_prod_q15

函數原型：

1.    void arm_dot_prod_q15(
2.      const q15_t * pSrcA,
3.      const q15_t * pSrcB,
4.            uint32_t blockSize,
5.            q63_t * result)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.            q63_t sum = 0;                                 /* Temporary return variable */
9.    
10.    #if defined (ARM_MATH_LOOPUNROLL)
11.    
12.      /* Loop unrolling: Compute 4 outputs at a time */
13.      blkCnt = blockSize >> 2U;
14.    
15.      while (blkCnt > 0U)
16.      {
17.        /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
18.    
19.    #if defined (ARM_MATH_DSP)
20.        /* Calculate dot product and store result in a temporary buffer. */
21.        sum = __SMLALD(read_q15x2_ia ((q15_t **) &pSrcA), read_q15x2_ia ((q15_t **) &pSrcB), sum);
22.        sum = __SMLALD(read_q15x2_ia ((q15_t **) &pSrcA), read_q15x2_ia ((q15_t **) &pSrcB), sum);
23.    #else
24.        sum += (q63_t)((q31_t) *pSrcA++ * *pSrcB++);
25.        sum += (q63_t)((q31_t) *pSrcA++ * *pSrcB++);
26.        sum += (q63_t)((q31_t) *pSrcA++ * *pSrcB++);
27.        sum += (q63_t)((q31_t) *pSrcA++ * *pSrcB++);
28.    #endif
29.    
30.        /* Decrement loop counter */
31.        blkCnt--;
32.      }
33.    
34.      /* Loop unrolling: Compute remaining outputs */
35.      blkCnt = blockSize % 0x4U;
36.    
37.    #else
38.    
39.      /* Initialize blkCnt with number of samples */
40.      blkCnt = blockSize;
41.    
42.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
43.    
44.      while (blkCnt > 0U)
45.      {
46.        /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
47.    
48.        /* Calculate dot product and store result in a temporary buffer. */
49.    //#if defined (ARM_MATH_DSP)
50.    //    sum  = __SMLALD(*pSrcA++, *pSrcB++, sum);
51.    //#else
52.        sum += (q63_t)((q31_t) *pSrcA++ * *pSrcB++);
53.    //#endif
54.    
55.        /* Decrement loop counter */
56.        blkCnt--;
57.      }
58.    
59.      /* Store result in destination buffer in 34.30 format */
60.      *result = sum;
61.    }

 

函數描述：

這個函數用於求32位定點數的點乘。

函數解析：

•   第10到37行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第44到57行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   兩個Q15格式的數據相乘，那么輸出結果的格式是1.15*1.15 = 2.30，這個函數將輸出結果賦值給了64位變量，那么輸出結果就是34.30格式。所以基本沒有溢出的危險。
•   __SMLALD也是SIMD指令，實現兩個16位數相乘，並把結果累加給64位變量。

函數參數：

•   第1個參數是乘數地址。
•   第2個參數是被乘數地址。
•   第3個參數是定點數個數，其實就是執行點乘的次數。
•   第4個參數是結果地址。

11.5.4        函數arm_dot_prod_q7

函數原型：

1.    void arm_dot_prod_q7(
2.      const q7_t * pSrcA,
3.      const q7_t * pSrcB,
4.            uint32_t blockSize,
5.            q31_t * result)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.            q31_t sum = 0;                                 /* Temporary return variable */
9.    
10.    #if defined (ARM_MATH_LOOPUNROLL)
11.    
12.    #if defined (ARM_MATH_DSP)
13.      q31_t input1, input2;                          /* Temporary variables */
14.      q31_t inA1, inA2, inB1, inB2;                  /* Temporary variables */
15.    #endif
16.    
17.      /* Loop unrolling: Compute 4 outputs at a time */
18.      blkCnt = blockSize >> 2U;
19.    
20.      while (blkCnt > 0U)
21.      {
22.        /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
23.    
24.    #if defined (ARM_MATH_DSP)
25.        /* read 4 samples at a time from sourceA */
26.        input1 = read_q7x4_ia ((q7_t **) &pSrcA);
27.        /* read 4 samples at a time from sourceB */
28.        input2 = read_q7x4_ia ((q7_t **) &pSrcB);
29.    
30.        /* extract two q7_t samples to q15_t samples */
31.        inA1 = __SXTB16(__ROR(input1, 8));
32.        /* extract reminaing two samples */
33.        inA2 = __SXTB16(input1);
34.        /* extract two q7_t samples to q15_t samples */
35.        inB1 = __SXTB16(__ROR(input2, 8));
36.        /* extract reminaing two samples */
37.        inB2 = __SXTB16(input2);
38.    
39.        /* multiply and accumulate two samples at a time */
40.        sum = __SMLAD(inA1, inB1, sum);
41.        sum = __SMLAD(inA2, inB2, sum);
42.    #else
43.        sum += (q31_t) ((q15_t) *pSrcA++ * *pSrcB++);
44.        sum += (q31_t) ((q15_t) *pSrcA++ * *pSrcB++);
45.        sum += (q31_t) ((q15_t) *pSrcA++ * *pSrcB++);
46.        sum += (q31_t) ((q15_t) *pSrcA++ * *pSrcB++);
47.    #endif
48.    
49.        /* Decrement loop counter */
50.        blkCnt--;
51.      }
52.    
53.      /* Loop unrolling: Compute remaining outputs */
54.      blkCnt = blockSize % 0x4U;
55.    
56.    #else
57.    
58.      /* Initialize blkCnt with number of samples */
59.      blkCnt = blockSize;
60.    
61.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
62.    
63.      while (blkCnt > 0U)
64.      {
65.        /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
66.    
67.        /* Calculate dot product and store result in a temporary buffer. */
68.    //#if defined (ARM_MATH_DSP)
69.    //    sum  = __SMLAD(*pSrcA++, *pSrcB++, sum);
70.    //#else
71.        sum += (q31_t) ((q15_t) *pSrcA++ * *pSrcB++);
72.    //#endif
73.    
74.        /* Decrement loop counter */
75.        blkCnt--;
76.      }
77.    
78.      /* Store result in destination buffer in 18.14 format */
79.      *result = sum;
80.    }

 

函數描述：

這個函數用於求8位定點數的點乘。

函數解析：

•   第10到56行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第63到76行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   兩個Q8格式的數據相乘，那么輸出結果就是1.7*1.7 = 2.14格式。這里將最終結果賦值給了32位的變量，那么最終的格式就是18.14。如果乘累加的個數小於2^18那么就不會有溢出的危險。
•   __SXTB16也是SIMD指令，用於將兩個8位的有符號數擴展成16位。__ROR用於實現數據的循環右移。
•   __SMLAD也是SIMD指令，用於實現如下功能：

sum = __SMLAD(x, y, z)

sum = z + ((short)(x>>16) * (short)(y>>16)) + ((short)x * (short)y)

函數參數：

•   第1個參數是乘數地址。
•   第2個參數是被乘數地址。
•   第3個參數是定點數個數，其實就是執行點乘的次數。
•   第4個參數是結果地址。

11.5.5        使用舉例

程序設計：

/*
*********************************************************************************************************
*    函 數 名: DSP_DotProduct
*    功能說明: 點乘
*    形    參: 無
*    返 回 值: 無
*********************************************************************************************************
*/
static void DSP_DotProduct(void)
{
    float32_t   pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
    float32_t   pSrcB[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};  
    float32_t   result;  
    
    q31_t  pSrcA1[5] = {0x7ffffff0,1,1,1,1};  
    q31_t  pSrcB1[5] = {1,1,1,1,1};  
    q63_t  result1;   

    q15_t  pSrcA2[5] = {1,1,1,1,1};  
    q15_t  pSrcB2[5] = {1,1,1,1,1};  
    q63_t  result2;   

    q7_t  pSrcA3[5] = {1,1,1,1,1}; 
    q7_t  pSrcB3[5] = {1,1,1,1,1};  
    q31_t result3;  

    
    /*求點乘*********************************/
    arm_dot_prod_f32(pSrcA, pSrcB, 5, &result);
    printf("arm_dot_prod_f32 = %f\r\n", result);
    
    arm_dot_prod_q31(pSrcA1, pSrcB1, 5, &result1);
    printf("arm_dot_prod_q31 = %lld\r\n", result1);

    arm_dot_prod_q15(pSrcA2, pSrcB2, 5, &result2);
    printf("arm_dot_prod_q15 = %lld\r\n", result2);

    arm_dot_prod_q7(pSrcA3, pSrcB3, 5, &result3);
    printf("arm_dot_prod_q7 = %d\r\n", result3);
    printf("***********************************\r\n");
}

 

實驗現象：

 

11.6 乘法（Vector Multiplication）

這部分函數主要用於乘法，公式描述如下：

pDst[n] = pSrcA[n] * pSrcB[n],   0 <= n < blockSize.    

11.6.1        函數arm_mult_f32

函數原型：

1.    void arm_mult_f32(
2.      const float32_t * pSrcA,
3.      const float32_t * pSrcB,
4.            float32_t * pDst,
5.            uint32_t blockSize)
6.    {
7.        uint32_t blkCnt;                               /* Loop counter */
8.    
9.    #if defined(ARM_MATH_NEON)
10.        float32x4_t vec1;
11.        float32x4_t vec2;
12.        float32x4_t res;
13.    
14.        /* Compute 4 outputs at a time */
15.        blkCnt = blockSize >> 2U;
16.    
17.        while (blkCnt > 0U)
18.        {
19.            /* C = A * B */
20.    
21.            /* Multiply the inputs and then store the results in the destination buffer. */
22.            vec1 = vld1q_f32(pSrcA);
23.            vec2 = vld1q_f32(pSrcB);
24.            res = vmulq_f32(vec1, vec2);
25.            vst1q_f32(pDst, res);
26.    
27.            /* Increment pointers */
28.            pSrcA += 4;
29.            pSrcB += 4; 
30.            pDst += 4;
31.            
32.            /* Decrement the loop counter */
33.            blkCnt--;
34.        }
35.    
36.        /* Tail */
37.        blkCnt = blockSize & 0x3;
38.    
39.    #else
40.    #if defined (ARM_MATH_LOOPUNROLL)
41.    
42.      /* Loop unrolling: Compute 4 outputs at a time */
43.      blkCnt = blockSize >> 2U;
44.    
45.      while (blkCnt > 0U)
46.      {
47.        /* C = A * B */
48.    
49.        /* Multiply inputs and store result in destination buffer. */
50.        *pDst++ = (*pSrcA++) * (*pSrcB++);
51.    
52.        *pDst++ = (*pSrcA++) * (*pSrcB++);
53.    
54.        *pDst++ = (*pSrcA++) * (*pSrcB++);
55.    
56.        *pDst++ = (*pSrcA++) * (*pSrcB++);
57.    
58.        /* Decrement loop counter */
59.        blkCnt--;
60.      }
61.    
62.      /* Loop unrolling: Compute remaining outputs */
63.      blkCnt = blockSize % 0x4U;
64.    
65.    #else
66.    
67.      /* Initialize blkCnt with number of samples */
68.      blkCnt = blockSize;
69.    
70.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
71.    #endif /* #if defined(ARM_MATH_NEON) */
72.    
73.      while (blkCnt > 0U)
74.      {
75.        /* C = A * B */
76.    
77.        /* Multiply input and store result in destination buffer. */
78.        *pDst++ = (*pSrcA++) * (*pSrcB++);
79.    
80.        /* Decrement loop counter */
81.        blkCnt--;
82.      }
83.    
84.    }

 

函數描述：

這個函數用於求32位浮點數的乘法。

函數解析：

•   第9到39行，用於NEON指令集，當前的CM內核不支持。
•   第40到65行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第73到82行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。

函數參數：

•   第1個參數是乘數地址。
•   第2個參數是被乘數地址。
•   第3個參數是結果地址。
•   第4個參數是數據塊大小，其實就是執行乘法的次數。

11.6.2        函數arm_mult_q31

函數原型：

1.    void arm_mult_q31(
2.      const q31_t * pSrcA,
3.      const q31_t * pSrcB,
4.            q31_t * pDst,
5.            uint32_t blockSize)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.            q31_t out;                                     /* Temporary output variable */
9.    
10.    #if defined (ARM_MATH_LOOPUNROLL)
11.    
12.      /* Loop unrolling: Compute 4 outputs at a time */
13.      blkCnt = blockSize >> 2U;
14.    
15.      while (blkCnt > 0U)
16.      {
17.        /* C = A * B */
18.    
19.        /* Multiply inputs and store result in destination buffer. */
20.        out = ((q63_t) *pSrcA++ * *pSrcB++) >> 32;
21.        out = __SSAT(out, 31);
22.        *pDst++ = out << 1U;
23.    
24.        out = ((q63_t) *pSrcA++ * *pSrcB++) >> 32;
25.        out = __SSAT(out, 31);
26.        *pDst++ = out << 1U;
27.    
28.        out = ((q63_t) *pSrcA++ * *pSrcB++) >> 32;
29.        out = __SSAT(out, 31);
30.        *pDst++ = out << 1U;
31.    
32.        out = ((q63_t) *pSrcA++ * *pSrcB++) >> 32;
33.        out = __SSAT(out, 31);
34.        *pDst++ = out << 1U;
35.    
36.        /* Decrement loop counter */
37.        blkCnt--;
38.      }
39.    
40.      /* Loop unrolling: Compute remaining outputs */
41.      blkCnt = blockSize % 0x4U;
42.    
43.    #else
44.    
45.      /* Initialize blkCnt with number of samples */
46.      blkCnt = blockSize;
47.    
48.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
49.    
50.      while (blkCnt > 0U)
51.      {
52.        /* C = A * B */
53.    
54.        /* Multiply inputs and store result in destination buffer. */
55.        out = ((q63_t) *pSrcA++ * *pSrcB++) >> 32;
56.        out = __SSAT(out, 31);
57.        *pDst++ = out << 1U;
58.    
59.        /* Decrement loop counter */
60.        blkCnt--;
61.      }
62.    
63.    }

 

函數描述：

這個函數用於求32位定點數的乘法。

函數解析：

•   這個函數使用了飽和運算__SSAT,所得結果是Q31格式，范圍Q31 range[0x80000000 0x7FFFFFFF]
•   第10到43行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第50到61行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   第20行，所得乘積左移32位。
•   第21行，實現31位精度的飽和運算。
•   第22行，右移一位，保證所得結果是Q31格式。

函數參數：

•   第1個參數是乘數地址。
•   第2個參數是被乘數地址。
•   第3個參數是結果地址。
•   第4個參數是數據塊大小，其實就是執行乘法的次數。

11.6.3        函數arm_mult_q15

函數原型：

1.    void arm_mult_q15(
2.      const q15_t * pSrcA,
3.      const q15_t * pSrcB,
4.            q15_t * pDst,
5.            uint32_t blockSize)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.    
9.    #if defined (ARM_MATH_LOOPUNROLL)
10.    
11.    #if defined (ARM_MATH_DSP)
12.      q31_t inA1, inA2, inB1, inB2;                  /* Temporary input variables */
13.      q15_t out1, out2, out3, out4;                  /* Temporary output variables */
14.      q31_t mul1, mul2, mul3, mul4;                  /* Temporary variables */
15.    #endif
16.    
17.      /* Loop unrolling: Compute 4 outputs at a time */
18.      blkCnt = blockSize >> 2U;
19.    
20.      while (blkCnt > 0U)
21.      {
22.        /* C = A * B */
23.    
24.    #if defined (ARM_MATH_DSP)
25.        /* read 2 samples at a time from sourceA */
26.        inA1 = read_q15x2_ia ((q15_t **) &pSrcA);
27.        /* read 2 samples at a time from sourceB */
28.        inB1 = read_q15x2_ia ((q15_t **) &pSrcB);
29.        /* read 2 samples at a time from sourceA */
30.        inA2 = read_q15x2_ia ((q15_t **) &pSrcA);
31.        /* read 2 samples at a time from sourceB */
32.        inB2 = read_q15x2_ia ((q15_t **) &pSrcB);
33.    
34.        /* multiply mul = sourceA * sourceB */
35.        mul1 = (q31_t) ((q15_t) (inA1 >> 16) * (q15_t) (inB1 >> 16));
36.        mul2 = (q31_t) ((q15_t) (inA1      ) * (q15_t) (inB1      ));
37.        mul3 = (q31_t) ((q15_t) (inA2 >> 16) * (q15_t) (inB2 >> 16));
38.        mul4 = (q31_t) ((q15_t) (inA2      ) * (q15_t) (inB2      ));
39.    
40.        /* saturate result to 16 bit */
41.        out1 = (q15_t) __SSAT(mul1 >> 15, 16);
42.        out2 = (q15_t) __SSAT(mul2 >> 15, 16);
43.        out3 = (q15_t) __SSAT(mul3 >> 15, 16);
44.        out4 = (q15_t) __SSAT(mul4 >> 15, 16);
45.    
46.        /* store result to destination */
47.    #ifndef ARM_MATH_BIG_ENDIAN
48.        write_q15x2_ia (&pDst, __PKHBT(out2, out1, 16));
49.        write_q15x2_ia (&pDst, __PKHBT(out4, out3, 16));
50.    #else
51.        write_q15x2_ia (&pDst, __PKHBT(out1, out2, 16));
52.        write_q15x2_ia (&pDst, __PKHBT(out3, out4, 16));
53.    #endif /* #ifndef ARM_MATH_BIG_ENDIAN */
54.    
55.    #else
56.        *pDst++ = (q15_t) __SSAT((((q31_t) (*pSrcA++) * (*pSrcB++)) >> 15), 16);
57.        *pDst++ = (q15_t) __SSAT((((q31_t) (*pSrcA++) * (*pSrcB++)) >> 15), 16);
58.        *pDst++ = (q15_t) __SSAT((((q31_t) (*pSrcA++) * (*pSrcB++)) >> 15), 16);
59.        *pDst++ = (q15_t) __SSAT((((q31_t) (*pSrcA++) * (*pSrcB++)) >> 15), 16);
60.    #endif
61.    
62.        /* Decrement loop counter */
63.        blkCnt--;
64.      }
65.    
66.      /* Loop unrolling: Compute remaining outputs */
67.      blkCnt = blockSize % 0x4U;
68.    
69.    #else
70.    
71.      /* Initialize blkCnt with number of samples */
72.      blkCnt = blockSize;
73.    
74.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
75.    
76.      while (blkCnt > 0U)
77.      {
78.        /* C = A * B */
79.    
80.        /* Multiply inputs and store result in destination buffer. */
81.        *pDst++ = (q15_t) __SSAT((((q31_t) (*pSrcA++) * (*pSrcB++)) >> 15), 16);
82.    
83.        /* Decrement loop counter */
84.        blkCnt--;
85.      }
86.    
87.    }

 

函數描述：

這個函數用於求16位定點數的乘法。

函數解析：

•   這個函數使用了飽和運算__SSAT,所得結果是Q31格式，范圍Q31 range[0x80000000 0x7FFFFFFF]。
•   第9到69行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第79到85行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   第26行，一次讀取兩個Q15格式的數據。
•   第35到38行，將四組數的乘積保存到Q31格式的變量mul1，mul2，mul3，mul4。
•   第41到44行，丟棄32位數據的低15位，並把最終結果飽和到16位精度。
•   第51到52行的SIMD指令__PKHBT，將兩個Q15格式的數據保存的結果數組中，從而一個指令周期就能完成兩個數據的存儲。

函數參數：

•   第1個參數是乘數地址。
•   第2個參數是被乘數地址。
•   第3個參數是結果地址。
•   第4個參數是數據塊大小，其實就是執行乘法的次數。

11.6.4        函數arm_mult_q7

函數原型：

1.    void arm_mult_q7(
2.      const q7_t * pSrcA,
3.      const q7_t * pSrcB,
4.            q7_t * pDst,
5.            uint32_t blockSize)
6.    {
7.            uint32_t blkCnt;                               /* Loop counter */
8.    
9.    #if defined (ARM_MATH_LOOPUNROLL)
10.    
11.    #if defined (ARM_MATH_DSP)
12.      q7_t out1, out2, out3, out4;                   /* Temporary output variables */
13.    #endif
14.    
15.      /* Loop unrolling: Compute 4 outputs at a time */
16.      blkCnt = blockSize >> 2U;
17.    
18.      while (blkCnt > 0U)
19.      {
20.        /* C = A * B */
21.    
22.    #if defined (ARM_MATH_DSP)
23.        /* Multiply inputs and store results in temporary variables */
24.        out1 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
25.        out2 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
26.        out3 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
27.        out4 = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
28.    
29.        /* Pack and store result in destination buffer (in single write) */
30.        write_q7x4_ia (&pDst, __PACKq7(out1, out2, out3, out4));
31.    #else
32.        *pDst++ = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
33.        *pDst++ = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
34.        *pDst++ = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
35.        *pDst++ = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
36.    #endif
37.    
38.        /* Decrement loop counter */
39.        blkCnt--;
40.      }
41.    
42.      /* Loop unrolling: Compute remaining outputs */
43.      blkCnt = blockSize % 0x4U;
44.    
45.    #else
46.    
47.      /* Initialize blkCnt with number of samples */
48.      blkCnt = blockSize;
49.    
50.    #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
51.    
52.      while (blkCnt > 0U)
53.      {
54.        /* C = A * B */
55.    
56.        /* Multiply input and store result in destination buffer. */
57.        *pDst++ = (q7_t) __SSAT((((q15_t) (*pSrcA++) * (*pSrcB++)) >> 7), 8);
58.    
59.        /* Decrement loop counter */
60.        blkCnt--;
61.      }
62.    
63.    }

 

函數描述：

這個函數用於求8位定點數的乘法。

函數解析：

•   這個函數使用了飽和算法__SSAT，所得結果是Q7格式，范圍 [0x80  0x7F]
•   第9到45行，實現四個為一組進行計數，好處是加快執行速度，降低while循環占用時間。
•   第52到61行，四個為一組剩余數據的處理或者不采用四個為一組時數據處理。
•   第24到27行，將兩個Q7格式的數據乘積左移7位，也就是丟掉低7位的數據，並將所得結果飽和到8位精度。
•   第30行，__PACKq7函數可以在一個時鍾周期就能完成相應操作。

函數參數：

•   第1個參數是乘數地址。
•   第2個參數是被乘數地址。
•   第3個參數是結果地址。
•   第4個參數是數據塊大小，其實就是執行乘法的次數。

11.6.5        使用舉例

程序設計：

/*
*********************************************************************************************************
*    函 數 名: DSP_Multiplication
*    功能說明: 乘法
*    形    參: 無
*    返 回 值: 無
*********************************************************************************************************
*/
static void DSP_Multiplication(void)
{
    float32_t   pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
    float32_t   pSrcB[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};  
    float32_t   pDst[5];  
    
    q31_t  pSrcA1[5] = {1,1,1,1,1};  
    q31_t  pSrcB1[5] = {1,1,1,1,1};  
    q31_t  pDst1[5];   

    q15_t  pSrcA2[5] = {1,1,1,1,1};  
    q15_t  pSrcB2[5] = {1,1,1,1,1};  
    q15_t  pDst2[5];   

    q7_t  pSrcA3[5] = {0x70,1,1,1,1}; 
    q7_t  pSrcB3[5] = {0x7f,1,1,1,1};  
    q7_t pDst3[5];  

    
    /*求乘積*********************************/
    pSrcA[0] += 1.1f;
    arm_mult_f32(pSrcA, pSrcB, pDst, 5);
    printf("arm_mult_f32 = %f\r\n", pDst[0]);
    
    pSrcA1[0] += 1;
    arm_mult_q31(pSrcA1, pSrcB1, pDst1, 5);
    printf("arm_mult_q31 = %d\r\n", pDst1[0]);

    pSrcA2[0] += 1;
    arm_mult_q15(pSrcA2, pSrcB2, pDst2, 5);
    printf("arm_mult_q15 = %d\r\n", pDst2[0]);

    pSrcA3[0] += 1;
    arm_mult_q7(pSrcA3, pSrcB3, pDst3, 5);
    printf("arm_mult_q7 = %d\r\n", pDst3[0]);
    printf("***********************************\r\n");
}

 

實驗現象：

 

這里特別注意為什么Q31和Q15結算的輸出結果會有0，關於這個問題，在此貼進行了詳細說明：

http://www.armbbs.cn/forum.php?mod=viewthread&tid=95194。

11.7 實驗例程說明（MDK）

配套例子：

V7-206_DSP基礎運算（絕對值，求和，乘法和點乘）

實驗目的：

1. 學習基礎運算（絕對值，求和，乘法和點乘）。

實驗內容：

1. 啟動一個自動重裝軟件定時器，每100ms翻轉一次LED2。
2. 按下按鍵K1, DSP求絕對值運算。
3. 按下按鍵K2, DSP求和運算。
4. 按下按鍵K3, DSP求點乘運算。
5. 按下搖桿OK鍵, DSP求乘積運算。 

使用AC6注意事項

特別注意附件章節C的問題

上電后串口打印的信息：

波特率 115200，數據位 8，奇偶校驗位無，停止位 1。

詳見本章的4.5，5.5和6.5小節。

程序設計：

  系統棧大小分配：

 

  RAM空間用的DTCM：

 

  硬件外設初始化

硬件外設的初始化是在 bsp.c 文件實現：

/*
*********************************************************************************************************
*    函 數 名: bsp_Init
*    功能說明: 初始化所有的硬件設備。該函數配置CPU寄存器和外設的寄存器並初始化一些全局變量。只需要調用一次
*    形    參：無
*    返 回 值: 無
*********************************************************************************************************
*/
void bsp_Init(void)
{
    /* 配置MPU */
    MPU_Config();
    
    /* 使能L1 Cache */
    CPU_CACHE_Enable();

    /* 
       STM32H7xx HAL 庫初始化，此時系統用的還是H7自帶的64MHz，HSI時鍾:
       - 調用函數HAL_InitTick，初始化滴答時鍾中斷1ms。
       - 設置NVIV優先級分組為4。
     */
    HAL_Init();

    /* 
       配置系統時鍾到400MHz
       - 切換使用HSE。
       - 此函數會更新全局變量SystemCoreClock，並重新配置HAL_InitTick。
    */
    SystemClock_Config();

    /* 
       Event Recorder：
       - 可用於代碼執行時間測量，MDK5.25及其以上版本才支持，IAR不支持。
       - 默認不開啟，如果要使能此選項，務必看V7開發板用戶手冊第8章
    */    
#if Enable_EventRecorder == 1  
    /* 初始化EventRecorder並開啟 */
    EventRecorderInitialize(EventRecordAll, 1U);
    EventRecorderStart();
#endif
    
    bsp_InitKey();        /* 按鍵初始化，要放在滴答定時器之前，因為按鈕檢測是通過滴答定時器掃描 */
    bsp_InitTimer();      /* 初始化滴答定時器 */
    bsp_InitUart();    /* 初始化串口 */
    bsp_InitExtIO();    /* 初始化FMC總線74HC574擴展IO. 必須在 bsp_InitLed()前執行 */    
    bsp_InitLed();        /* 初始化LED */    
}

 

  MPU配置和Cache配置：

數據Cache和指令Cache都開啟。配置了AXI SRAM區（本例子未用到AXI SRAM），FMC的擴展IO區。

/*
*********************************************************************************************************
*    函 數 名: MPU_Config
*    功能說明: 配置MPU
*    形    參: 無
*    返 回 值: 無
*********************************************************************************************************
*/
static void MPU_Config( void )
{
    MPU_Region_InitTypeDef MPU_InitStruct;

    /* 禁止 MPU */
    HAL_MPU_Disable();

    /* 配置AXI SRAM的MPU屬性為Write back, Read allocate，Write allocate */
    MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    MPU_InitStruct.BaseAddress      = 0x24000000;
    MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    MPU_InitStruct.SubRegionDisable = 0x00;
    MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;

    HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
    
    /* 配置FMC擴展IO的MPU屬性為Device或者Strongly Ordered */
    MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    MPU_InitStruct.BaseAddress      = 0x60000000;
    MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;    
    MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;    
    MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    MPU_InitStruct.SubRegionDisable = 0x00;
    MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
    HAL_MPU_ConfigRegion(&MPU_InitStruct);

    /*使能 MPU */
    HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
}

/*
*********************************************************************************************************
*    函 數 名: CPU_CACHE_Enable
*    功能說明: 使能L1 Cache
*    形    參: 無
*    返 回 值: 無
*********************************************************************************************************
*/
static void CPU_CACHE_Enable(void)
{
    /* 使能 I-Cache */
    SCB_EnableICache();

    /* 使能 D-Cache */
    SCB_EnableDCache();
}

 

  主功能：

主程序實現如下操作：

•  按下按鍵K1, DSP求絕對值運算。
•  按下按鍵K2, DSP求和運算。
•  按下按鍵K3, DSP求點乘運算。
•  按下搖桿OK鍵, DSP求乘積運算。 

/*
*********************************************************************************************************
*    函 數 名: main
*    功能說明: c程序入口
*    形    參: 無
*    返 回 值: 錯誤代碼(無需處理)
*********************************************************************************************************
*/
int main(void)
{
    uint8_t ucKeyCode;        /* 按鍵代碼 */
    uint8_t ucValue;
    

    bsp_Init();    /* 硬件初始化 */
    PrintfLogo();    /* 打印例程信息到串口1 */

    PrintfHelp();    /* 打印操作提示信息 */
    

    bsp_StartAutoTimer(0, 100);    /* 啟動1個100ms的自動重裝的定時器 */

    /* 進入主程序循環體 */
    while (1)
    {
        bsp_Idle();        /* 這個函數在bsp.c文件。用戶可以修改這個函數實現CPU休眠和喂狗 */

        /* 判斷定時器超時時間 */
        if (bsp_CheckTimer(0))    
        {
            /* 每隔100ms 進來一次 */  
            bsp_LedToggle(2);
        }

        ucKeyCode = bsp_GetKey();    /* 讀取鍵值, 無鍵按下時返回 KEY_NONE = 0 */
        if (ucKeyCode != KEY_NONE)
        {
            switch (ucKeyCode)
            {
                case KEY_DOWN_K1:            /* K1鍵按下，求絕對值 */
                    DSP_ABS();
                    break;

                case KEY_DOWN_K2:            /* K2鍵按下, 求和 */
                    DSP_Add();
                    break;

                case KEY_DOWN_K3:            /* K3鍵按下，求點乘 */
                    DSP_DotProduct();
                    break;
    
                case JOY_DOWN_OK:            /* 搖桿OK鍵按下，求乘積 */
                    DSP_Multiplication();
                    break;

                default:
                    /* 其他的鍵值不處理 */
                    break;
            }
        }
    }
}

 

11.8 實驗例程說明（IAR）

配套例子：

V7-206_DSP基礎運算（絕對值，求和，乘法和點乘）

實驗目的：

1. 學習基礎運算（絕對值，求和，乘法和點乘）。

實驗內容：

1. 啟動一個自動重裝軟件定時器，每100ms翻轉一次LED2。
2. 按下按鍵K1, DSP求絕對值運算。
3. 按下按鍵K2, DSP求和運算。
4. 按下按鍵K3, DSP求點乘運算。
5. 按下搖桿OK鍵, DSP求乘積運算。 

上電后串口打印的信息：

波特率 115200，數據位 8，奇偶校驗位無，停止位 1。

詳見本章的4.5，5.5和6.5小節。

程序設計：

  系統棧大小分配：

 

  RAM空間用的DTCM：

 

  硬件外設初始化

硬件外設的初始化是在 bsp.c 文件實現：

/*
*********************************************************************************************************
*    函 數 名: bsp_Init
*    功能說明: 初始化所有的硬件設備。該函數配置CPU寄存器和外設的寄存器並初始化一些全局變量。只需要調用一次
*    形    參：無
*    返 回 值: 無
*********************************************************************************************************
*/
void bsp_Init(void)
{
    /* 配置MPU */
    MPU_Config();
    
    /* 使能L1 Cache */
    CPU_CACHE_Enable();

    /* 
       STM32H7xx HAL 庫初始化，此時系統用的還是H7自帶的64MHz，HSI時鍾:
       - 調用函數HAL_InitTick，初始化滴答時鍾中斷1ms。
       - 設置NVIV優先級分組為4。
     */
    HAL_Init();

    /* 
       配置系統時鍾到400MHz
       - 切換使用HSE。
       - 此函數會更新全局變量SystemCoreClock，並重新配置HAL_InitTick。
    */
    SystemClock_Config();

    /* 
       Event Recorder：
       - 可用於代碼執行時間測量，MDK5.25及其以上版本才支持，IAR不支持。
       - 默認不開啟，如果要使能此選項，務必看V7開發板用戶手冊第8章
    */    
#if Enable_EventRecorder == 1  
    /* 初始化EventRecorder並開啟 */
    EventRecorderInitialize(EventRecordAll, 1U);
    EventRecorderStart();
#endif
    
    bsp_InitKey();        /* 按鍵初始化，要放在滴答定時器之前，因為按鈕檢測是通過滴答定時器掃描 */
    bsp_InitTimer();      /* 初始化滴答定時器 */
    bsp_InitUart();    /* 初始化串口 */
    bsp_InitExtIO();    /* 初始化FMC總線74HC574擴展IO. 必須在 bsp_InitLed()前執行 */    
    bsp_InitLed();        /* 初始化LED */    
}

 

  MPU配置和Cache配置：

數據Cache和指令Cache都開啟。配置了AXI SRAM區（本例子未用到AXI SRAM），FMC的擴展IO區。

/*
*********************************************************************************************************
*    函 數 名: MPU_Config
*    功能說明: 配置MPU
*    形    參: 無
*    返 回 值: 無
*********************************************************************************************************
*/
static void MPU_Config( void )
{
    MPU_Region_InitTypeDef MPU_InitStruct;

    /* 禁止 MPU */
    HAL_MPU_Disable();

    /* 配置AXI SRAM的MPU屬性為Write back, Read allocate，Write allocate */
    MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    MPU_InitStruct.BaseAddress      = 0x24000000;
    MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    MPU_InitStruct.SubRegionDisable = 0x00;
    MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;

    HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
    
    /* 配置FMC擴展IO的MPU屬性為Device或者Strongly Ordered */
    MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    MPU_InitStruct.BaseAddress      = 0x60000000;
    MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;    
    MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;    
    MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    MPU_InitStruct.SubRegionDisable = 0x00;
    MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
    HAL_MPU_ConfigRegion(&MPU_InitStruct);

    /*使能 MPU */
    HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
}

/*
*********************************************************************************************************
*    函 數 名: CPU_CACHE_Enable
*    功能說明: 使能L1 Cache
*    形    參: 無
*    返 回 值: 無
*********************************************************************************************************
*/
static void CPU_CACHE_Enable(void)
{
    /* 使能 I-Cache */
    SCB_EnableICache();

    /* 使能 D-Cache */
    SCB_EnableDCache();
}

 

  主功能：

主程序實現如下操作：

•   按下按鍵K1, DSP求絕對值運算。
•   按下按鍵K2, DSP求和運算。
•   按下按鍵K3, DSP求點乘運算。
•   按下搖桿OK鍵, DSP求乘積運算。 

/*
*********************************************************************************************************
*    函 數 名: main
*    功能說明: c程序入口
*    形    參: 無
*    返 回 值: 錯誤代碼(無需處理)
*********************************************************************************************************
*/
int main(void)
{
    uint8_t ucKeyCode;        /* 按鍵代碼 */
    uint8_t ucValue;
    

    bsp_Init();    /* 硬件初始化 */
    PrintfLogo();    /* 打印例程信息到串口1 */

    PrintfHelp();    /* 打印操作提示信息 */
    

    bsp_StartAutoTimer(0, 100);    /* 啟動1個100ms的自動重裝的定時器 */

    /* 進入主程序循環體 */
    while (1)
    {
        bsp_Idle();        /* 這個函數在bsp.c文件。用戶可以修改這個函數實現CPU休眠和喂狗 */

        /* 判斷定時器超時時間 */
        if (bsp_CheckTimer(0))    
        {
            /* 每隔100ms 進來一次 */  
            bsp_LedToggle(2);
        }

        ucKeyCode = bsp_GetKey();    /* 讀取鍵值, 無鍵按下時返回 KEY_NONE = 0 */
        if (ucKeyCode != KEY_NONE)
        {
            switch (ucKeyCode)
            {
                case KEY_DOWN_K1:            /* K1鍵按下，求絕對值 */
                    DSP_ABS();
                    break;

                case KEY_DOWN_K2:            /* K2鍵按下, 求和 */
                    DSP_Add();
                    break;

                case KEY_DOWN_K3:            /* K3鍵按下，求點乘 */
                    DSP_DotProduct();
                    break;
    
                case JOY_DOWN_OK:            /* 搖桿OK鍵按下，求乘積 */
                    DSP_Multiplication();
                    break;

                default:
                    /* 其他的鍵值不處理 */
                    break;
            }
        }
    }
}

 

11.9 總結

本期教程就跟大家講這么多，還是那句話，可以自己寫些代碼調用本期教程中講的這幾個函數，如果可以的話，可以自己嘗試直接調用這些DSP指令。