硬件平台：H750-ART-Pi
软件平台：CubeMX+HAL库 V1.12.1版本

问题背景：需要使用定时器触发DMA-SPI向外部DAC发送数据，由于需要向外部发送的数据量较大且配置SPI总线的多通道，当前需要使用DMA双缓冲配置（从SD卡中读取BIN文件依次填充PingPong-FIFO，使用外扩SDRAM作为DMA-BUF）
遇到的问题：当前已经能够使用单缓冲+定时器触发的方式来向外发送数据，使用双缓冲时，无反应（定时器在工作，当前网络上的一些例程都是基于标准库的，参考作用有限），想求助下HAL库DMA双缓冲案例或者函数调用顺序。
详情参考gitee链接：GIt-CubeMX配置
启动定时器部分代码：HAL_DMAEx_MultiBufferStart_IT这个函数应该是DMA双缓冲的关键 但是开启后无效，即使单缓冲正常工作下也无法看到SPI_TXDR更新，很奇怪

1. void BSP_DAC_SPI_DMA_Start()
   
2. {
   
3.         LookUP_BUF_INIT();
   
4. //        HAL_DMAEx_MultiBufferStart(&hspi2.hdmatx, LookUP_PingPongBufer.activeBuffer, &hspi2.Instance->TXDR,LookUP_PingPongBufer.readyBuffer,BUFFER_SIZE/4);
   
5.         HAL_DMAEx_MultiBufferStart_IT(&hdma_spi2_tx, LookUP_PingPongBufer.activeBuffer, &hspi2.Instance->TXDR, LookUP_PingPongBufer.readyBuffer,BUFFER_SIZE/4);
   
6. 
   
7. //        if(HAL_SPI_Transmit_DMA(&hspi2, (uint8_t*)LookUP_PingPongBufer.activeBuffer, BUFFER_SIZE/4)!= HAL_OK)       
   
8. //        {
   
9. //                printf("BSP_DAC_SPI_DMA_Start  HAL_SPI_Transmit_DMA ERROR !!! \r\n");                  
   
10. //        }
    
11. 
    
12.         if(HAL_TIM_OC_Start(&htim12, TIM_CHANNEL_1) != HAL_OK)
    
13.         {
    
14.                 printf("BSP_DAC_SPI_DMA_Start HAL_TIM_OC_Start ERROR !!! \r\n");                  
    
15.         }       
    
16. }
    
17. void LookUP_BUF_INIT(void)
    
18. {
    
19.         FRESULT result;
    
20.         uint32_t bw;
    
21.         char path[64];
    
22.        
    
23.         PingPong_Init(&LookUP_PingPongBufer,LOOKUP_BUF1_ADDR,LOOKUP_BUF2_ADDR);
    
24.        
    
25. 
    
26.         result = f_mount(&fs, DiskPath, 0);                        /* Mount a logical drive */
    
27.         if (result != FR_OK)
    
28.         {
    
29.                 printf("mount fs failed !!\r\n", FR_Table[result]);
    
30.         }
    
31. 
    
32.         sprintf(path, "%sTable_hex.bin", DiskPath);
    
33.         result = f_open(&file, path, FA_OPEN_EXISTING | FA_READ);
    
34.         if (result !=  FR_OK)
    
35.         {
    
36.                 printf("Don't Find File : Table_hex\r\n");
    
37.                 return;
    
38.         }
    
39. 
    
40.         result = f_read(&file, LookUP_PingPongBufer.activeBuffer , BUFFER_SIZE, &bw);
    
41.         if (bw > 0)
    
42.         {
    
43.                 FsReadBuf[bw] = 0;
    
44.         }
    
45.        
    
46.         result = f_read(&file, LookUP_PingPongBufer.readyBuffer , BUFFER_SIZE, &bw);
    
47.         if (bw > 0)
    
48.         {
    
49.                 FsReadBuf[bw] = 0;
    
50.         }
    
51. 
    
52. 
    
53. //        f_close(&file);
    
54. 
    
55. //        f_mount(NULL, DiskPath, 0);
    
56. }

复制代码

定时器初始化部分代码：

1. void MX_SPI2_Init(void)
   
2. {
   
3. 
   
4.   /* USER CODE BEGIN SPI2_Init 0 */
   
5. 
   
6.   /* USER CODE END SPI2_Init 0 */
   
7. 
   
8.   /* USER CODE BEGIN SPI2_Init 1 */
   
9. 
   
10.   /* USER CODE END SPI2_Init 1 */
    
11.   hspi2.Instance = SPI2;
    
12.   hspi2.Init.Mode = SPI_MODE_MASTER;
    
13.   hspi2.Init.Direction = SPI_DIRECTION_2LINES;
    
14.   hspi2.Init.DataSize = SPI_DATASIZE_32BIT;
    
15.   hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
    
16.   hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
    
17.   hspi2.Init.NSS = SPI_NSS_SOFT;
    
18.   hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
    
19.   hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
    
20.   hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
    
21.   hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    
22.   hspi2.Init.CRCPolynomial = 0x0;
    
23.   hspi2.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
    
24.   hspi2.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
    
25.   hspi2.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
    
26.   hspi2.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
    
27.   hspi2.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
    
28.   hspi2.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
    
29.   hspi2.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
    
30.   hspi2.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
    
31.   hspi2.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
    
32.   hspi2.Init.IOSwap = SPI_IO_SWAP_DISABLE;
    
33.   if (HAL_SPI_Init(&hspi2) != HAL_OK)
    
34.   {
    
35.     Error_Handler();
    
36.   }
    
37.   /* USER CODE BEGIN SPI2_Init 2 */
    
38. 
    
39.   /* USER CODE END SPI2_Init 2 */
    
40. 
    
41. }
    
42. 
    
43. void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
    
44. {
    
45. 
    
46.   GPIO_InitTypeDef GPIO_InitStruct = {0};
    
47.   HAL_DMA_MuxSyncConfigTypeDef pSyncConfig= {0};
    
48.   RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
    
49.   if(spiHandle->Instance==SPI2)
    
50.   {
    
51.   /* USER CODE BEGIN SPI2_MspInit 0 */
    
52. 
    
53.   /* USER CODE END SPI2_MspInit 0 */
    
54. 
    
55.   /** Initializes the peripherals clock
    
56.   */
    
57.     PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_SPI2;
    
58.     PeriphClkInitStruct.Spi123ClockSelection = RCC_SPI123CLKSOURCE_CLKP;
    
59.     if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
    
60.     {
    
61.       Error_Handler();
    
62.     }
    
63. 
    
64.     /* SPI2 clock enable */
    
65.     __HAL_RCC_SPI2_CLK_ENABLE();
    
66. 
    
67.     __HAL_RCC_GPIOI_CLK_ENABLE();
    
68.     /**SPI2 GPIO Configuration
    
69.     PI1     ------> SPI2_SCK
    
70.     PI2     ------> SPI2_MISO
    
71.     PI3     ------> SPI2_MOSI
    
72.     */
    
73.     GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3;
    
74.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
75.     GPIO_InitStruct.Pull = GPIO_NOPULL;
    
76.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
77.     GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
    
78.     HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);
    
79. 
    
80.     /* SPI2 DMA Init */
    
81.     /* SPI2_TX Init */
    
82.     hdma_spi2_tx.Instance = DMA1_Stream0;
    
83.     hdma_spi2_tx.Init.Request = DMA_REQUEST_SPI2_TX;
    
84.     hdma_spi2_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    
85.     hdma_spi2_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    
86.     hdma_spi2_tx.Init.MemInc = DMA_MINC_ENABLE;
    
87.     hdma_spi2_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
    
88.     hdma_spi2_tx.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
    
89.     hdma_spi2_tx.Init.Mode = DMA_CIRCULAR;
    
90.     hdma_spi2_tx.Init.Priority = DMA_PRIORITY_LOW;
    
91.     hdma_spi2_tx.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
    
92.     hdma_spi2_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
    
93.     hdma_spi2_tx.Init.MemBurst = DMA_MBURST_SINGLE;
    
94.     hdma_spi2_tx.Init.PeriphBurst = DMA_PBURST_SINGLE;
    
95.     if (HAL_DMA_Init(&hdma_spi2_tx) != HAL_OK)
    
96.     {
    
97.       Error_Handler();
    
98.     }
    
99. 
    
100.     pSyncConfig.SyncSignalID = HAL_DMAMUX1_SYNC_TIM12_TRGO;
     
101.     pSyncConfig.SyncPolarity = HAL_DMAMUX_SYNC_RISING;
     
102.     pSyncConfig.SyncEnable = ENABLE;
     
103.     pSyncConfig.EventEnable = ENABLE;
     
104.     pSyncConfig.RequestNumber = 1;
     
105.     if (HAL_DMAEx_ConfigMuxSync(&hdma_spi2_tx, &pSyncConfig) != HAL_OK)
     
106.     {
     
107.       Error_Handler();
     
108.     }
     
109. 
     
110.     __HAL_LINKDMA(spiHandle,hdmatx,hdma_spi2_tx);
     
111. 
     
112.     /* SPI2 interrupt Init */
     
113.     HAL_NVIC_SetPriority(SPI2_IRQn, 0, 0);
     
114.     HAL_NVIC_EnableIRQ(SPI2_IRQn);
     
115.   /* USER CODE BEGIN SPI2_MspInit 1 */
     
116. 
     
117. //                HAL_DMAEx_MultiBufferStart_IT(&hdma_spi2_tx, (uint8_t*)LookUP_PingPongBufer.activeBuffer, (uint32_t)hspi2.Instance->TXDR, (uint8_t*)LookUP_PingPongBufer.readyBuffer,1000);
     
118.                
     
119.   /* USER CODE END SPI2_MspInit 1 */
     
120.   }
     
121. }

复制代码

SPI初始化部分代码：

1. 
   
2. /* TIM12 init function */
   
3. void MX_TIM12_Init(void)
   
4. {
   
5. 
   
6.   /* USER CODE BEGIN TIM12_Init 0 */
   
7. 
   
8.   /* USER CODE END TIM12_Init 0 */
   
9. 
   
10.   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
    
11.   TIM_MasterConfigTypeDef sMasterConfig = {0};
    
12.   TIM_OC_InitTypeDef sConfigOC = {0};
    
13. 
    
14.   /* USER CODE BEGIN TIM12_Init 1 */
    
15. 
    
16.   /* USER CODE END TIM12_Init 1 */
    
17.   htim12.Instance = TIM12;
    
18.   htim12.Init.Prescaler = 240-1;
    
19.   htim12.Init.CounterMode = TIM_COUNTERMODE_UP;
    
20.   htim12.Init.Period = 1000-1;
    
21.   htim12.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
22.   htim12.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
    
23.   if (HAL_TIM_Base_Init(&htim12) != HAL_OK)
    
24.   {
    
25.     Error_Handler();
    
26.   }
    
27.   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    
28.   if (HAL_TIM_ConfigClockSource(&htim12, &sClockSourceConfig) != HAL_OK)
    
29.   {
    
30.     Error_Handler();
    
31.   }
    
32.   if (HAL_TIM_PWM_Init(&htim12) != HAL_OK)
    
33.   {
    
34.     Error_Handler();
    
35.   }
    
36.   sMasterConfig.MasterOutputTrigger = TIM_TRGO_OC1REF;
    
37.   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    
38.   if (HAL_TIMEx_MasterConfigSynchronization(&htim12, &sMasterConfig) != HAL_OK)
    
39.   {
    
40.     Error_Handler();
    
41.   }
    
42.   sConfigOC.OCMode = TIM_OCMODE_PWM1;
    
43.   sConfigOC.Pulse = (1000)/2-1;
    
44.   sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
    
45.   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    
46.   if (HAL_TIM_PWM_ConfigChannel(&htim12, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
    
47.   {
    
48.     Error_Handler();
    
49.   }
    
50.   /* USER CODE BEGIN TIM12_Init 2 */
    
51. 
    
52.   /* USER CODE END TIM12_Init 2 */
    
53. 
    
54. }
    
55. 
    
56. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
    
57. {
    
58. 
    
59.   if(tim_baseHandle->Instance==TIM12)
    
60.   {
    
61.   /* USER CODE BEGIN TIM12_MspInit 0 */
    
62. 
    
63.   /* USER CODE END TIM12_MspInit 0 */
    
64.     /* TIM12 clock enable */
    
65.     __HAL_RCC_TIM12_CLK_ENABLE();
    
66. 
    
67.     /* TIM12 interrupt Init */
    
68.     HAL_NVIC_SetPriority(TIM8_BRK_TIM12_IRQn, 0, 0);
    
69.     HAL_NVIC_EnableIRQ(TIM8_BRK_TIM12_IRQn);
    
70.   /* USER CODE BEGIN TIM12_MspInit 1 */
    
71. 
    
72.   /* USER CODE END TIM12_MspInit 1 */
    
73.   }
    
74. }

复制代码

图为使用逻辑分析仪抓取单缓冲数据时刻，SPI总线数据

你可以参考下这篇文章。

基于STM32H7 DMA 双缓冲实现SPI逐个数据输出

xmshao 发表于 2025-8-17 08:00
你可以参考下这篇文章。</p>
<p>[基于STM32H7 DMA 双缓冲实现SPI逐个数据输出](<a href="https://mp.weixin.qq.com/s/u">https://mp.weixin.qq.com/s/u</a> ...

[md]您好 我仔细看了下 微信公众号文章和参考手册 似乎没有区别 1.我测试了HAL_DMAEx_EnableMuxRequestGenerator(&hdma_dma_generator0);函数对当前双缓冲无法启动的问题也没有改善 2.为避免变量RAM所属区域的影响，我还变更了变量存储区域到SRAM4（D3区域），也是没有作用 我还是无法理解为什么我的代码在单缓冲的情况下是能正常工作，双缓冲下异常😕 双缓冲情况下我只修改这个函数