完整版教程下載地址：http://www.armbbs.cn/forum.php?mod=viewthread&tid=94547
第11章 DSP基礎函數-絕對值，求和，乘法和點乘
本期教程開始學習ARM官方的DSP庫，這裏我們先從基本數學函數開始。本期教程主要講絕對值，加法，點乘和乘法四種運算。
目錄
11.3 絕對值（Vector Absolute Value）
11.6 乘法（Vector Multiplication）
11.1 初學者重要提示
在這裏簡單的跟大家介紹一下DSP庫中函數的通用格式，後面就不再贅述了。
- 基本所有的函數都是可重入的。
- 大部分函數都支持批量計算，比如求絕對值函數arm_abs_f32。所以如果只是就幾個數的絕對值，用這個庫函數就沒有什麼優勢了。
- 庫函數基本是CM0，CM0+，CM3，CM4和CM7內核都是支持的，不限制廠家。
- 每組數據基本上都是以4個數爲一個單位進行計算，不夠四個再單獨計算。大部分函數都是配有f32，Q31，Q15和Q7四種格式。
- 爲什麼定點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基礎運算（絕對值，求和，乘法和點乘）
實驗目的：
- 學習基礎運算（絕對值，求和，乘法和點乘）。
實驗內容：
- 啓動一個自動重裝軟件定時器，每100ms翻轉一次LED2。
- 按下按鍵K1, DSP求絕對值運算。
- 按下按鍵K2, DSP求和運算。
- 按下按鍵K3, DSP求點乘運算。
- 按下搖桿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基礎運算（絕對值，求和，乘法和點乘）
實驗目的：
- 學習基礎運算（絕對值，求和，乘法和點乘）。
實驗內容：
- 啓動一個自動重裝軟件定時器，每100ms翻轉一次LED2。
- 按下按鍵K1, DSP求絕對值運算。
- 按下按鍵K2, DSP求和運算。
- 按下按鍵K3, DSP求點乘運算。
- 按下搖桿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指令。