h743 的spi2 设置成接收数据为DMA方式，为什么不行

wxqhit · 发表于 2024-1-10 18:43:10

版主和各位大牛

   我用的时h743，想把spi2设置为从设备，并启用设置DMA接收数据但是，为什么不行呢？

   我参考了官方的spi dma例程，以及版主@硬汉的裸机spi主从机例程。

   唯一的区别
   spi的数据长度时16bit
   内部memory 时 uint8_t 的数组

   设置好配置后，
   采用官方的函数：
   HAL_SPI_Receive_DMA(&hspi2,(uint8_t *)&video_odd_data,100);


//初始化部分

HAL_DMA_Init(&hdma_spi2_rx);

/* Associate the initialized DMA handle to the the SPI handle */
__HAL_LINKDMA(spiHandle, hdmarx, hdma_spi2_rx);

HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 1, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);

HAL_NVIC_SetPriority(SPI2_IRQn, 1, 0);
HAL_NVIC_EnableIRQ(SPI2_IRQn);

//中断函数
void DMA2_Stream2_IRQHandler(void)
{
HAL_DMA_IRQHandler(hspi2.hdmarx);
}

void SPI1_IRQHandler(void)
{

HAL_SPI_IRQHandler(&hspi2);
}

进不了中断

数据会源源不断的输入，从硬件的引脚也可以看到数据输出了。

eric2013 · 发表于 2024-1-11 10:00:11

贴个完整的代码看下。

wxqhit · 发表于 2024-1-11 12:04:07

代码来了。。
代码1：定时器timer3 启动spi3 主模式，读取ad值。同时，spi3的clock给spi2的时钟，两个spi共用一个clock，这样就可以同一时刻采集模拟量。
//

void TIM3_IRQHandler(void)
{
if( even_tim3_count > 0)
{

//slave

//master
hspi3.State    = HAL_SPI_STATE_BUSY_RX;
hspi3.ErrorCode = HAL_SPI_ERROR_NONE;
hspi3.pRxBuffPtr  = (uint8_t *)&(video_even_data[sampleEvenCnt]);
hspi3.RxXferSize  = 1;
hspi3.RxXferCount = 1;

//Init field not used in handle to zero
hspi3.pTxBuffPtr  = NULL;
hspi3.TxXferSize  = (uint16_t) 0UL;
hspi3.TxXferCount = (uint16_t) 0UL;
hspi3.RxISR    = NULL;
hspi3.TxISR    = NULL;

MODIFY_REG(hspi3.Instance->CR2, SPI_CR2_TSIZE, 1);

hspi3.Lock = HAL_LOCKED;
// Enable SPI peripheral
__HAL_SPI_ENABLE(&hspi3);

//*************cnv plus generate start
EVEN_CNV_EN_GPIO_Port->BSRR = 0x0200;      //set '1' PC_9 spi_convert_pin(AD7980)
//add syn odd============
ODD_CNV_EN_GPIO_Port->BSRR = 0x8000;

HAL_TIM_Base_Stop_IT(&htim3);

clock_even_flag = 0;
clock_odd_flag  = 0;

EVEN_CNV_EN_GPIO_Port->BSRR = 0x02000000; //set'0'  PC_9 spi_convert_pin(AD7980)
ODD_CNV_EN_GPIO_Port->BSRR = 0x80000000; //set'0'  PE_15
//*************cnv plus generate end

SET_BIT(hspi3.Instance->CR1, SPI_CR1_CSTART);

  //wait for data even channle
while (!__HAL_SPI_GET_FLAG(&hspi3, SPI_FLAG_RXP))
{;}

*((uint16_t *)hspi3.pRxBuffPtr) = *((__IO uint16_t *)&hspi3.Instance->RXDR);

hspi3.RxXferCount--;

  SPI_CloseTransfer(&hspi3);

/* Unlock the process */
__HAL_UNLOCK(&hspi3);

}
else
{
HAL_TIM_Base_Stop_IT(&htim3);
}
//even
//HAL_SPI_Transmit(&hspi3,(uint8_t *)&nulldata,1,0); //master

//odd
//HAL_SPI_Transmit(&hspi2,(uint8_t *)&nulldata,1,0);  //slave

HAL_TIM_IRQHandler(&htim3);

}

//第二段代码是，在总体才数据之前，先把spi2 配置为slave模式，然后等待dma终端。

rt_uint8_t video_odd_data[200];

HAL_SPI_Receive_DMA(&hspi2,video_odd_data,100);

//第三段spi2DMA的初始化

/* SPI2 init function */
void MX_SPI2_Init(void) //SPI2 is ODD adc
{

  /* USER CODE BEGIN SPI2_Init 0 */

  /* USER CODE END SPI2_Init 0 */

  /* USER CODE BEGIN SPI2_Init 1 */

  /* USER CODE END SPI2_Init 1 */
  hspi2.Instance = SPI2;
  //hspi2.Init.Mode = SPI_MODE_MASTER;
hspi2.Init.Mode = SPI_MODE_SLAVE;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES_RXONLY;
//hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_16BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi2.Init.CRCPolynomial = 0x0;
  hspi2.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
  hspi2.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
  hspi2.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
  hspi2.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi2.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi2.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_02CYCLE;
  hspi2.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_02CYCLE;
  hspi2.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
  hspi2.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
  hspi2.Init.IOSwap = SPI_IO_SWAP_DISABLE;
  if (HAL_SPI_Init(&hspi2) != HAL_OK)
  {
Error_Handler();
  }
  /* USER CODE BEGIN SPI2_Init 2 */

  /* USER CODE END SPI2_Init 2 */

}

void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(spiHandle->Instance==SPI2)
  {
  /* USER CODE BEGIN SPI2_MspInit 0 */

  /* USER CODE END SPI2_MspInit 0 */
/* SPI2 clock enable */
__HAL_RCC_SPI2_CLK_ENABLE();

__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
/**SPI2 GPIO Configuration
PB14    ------> SPI2_MISO
PA12    ------> SPI2_SCK
*/
GPIO_InitStruct.Pin = GPIO_PIN_14;
//GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
//GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

GPIO_InitStruct.Pin = GPIO_PIN_12;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
//GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

//DMA
//__HAL_RCC_DMA2_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();

hdma_spi2_rx.Instance = DMA1_Stream4;
hdma_spi2_rx.Init.FIFOMode          = DMA_FIFOMODE_DISABLE;
hdma_spi2_rx.Init.FIFOThreshold    = DMA_FIFO_THRESHOLD_FULL;
hdma_spi2_rx.Init.MemBurst          = DMA_MBURST_INC4;
hdma_spi2_rx.Init.PeriphBurst       = DMA_PBURST_INC4;
hdma_spi2_rx.Init.Request          = DMA_REQUEST_SPI2_RX;
hdma_spi2_rx.Init.Direction          = DMA_PERIPH_TO_MEMORY;
hdma_spi2_rx.Init.PeriphInc          = DMA_PINC_DISABLE;
hdma_spi2_rx.Init.MemInc             = DMA_MINC_ENABLE;
//hdma_spi2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_spi2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
hdma_spi2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
//hdma_spi2_rx.Init.MemDataAlignment = DMA_PDATAALIGN_HALFWORD;
hdma_spi2_rx.Init.Mode             = DMA_NORMAL;
hdma_spi2_rx.Init.Priority          = DMA_PRIORITY_HIGH;

if(HAL_DMA_Init(&hdma_spi2_rx) != HAL_OK)
{
Error_Handler();
}
else
{
   __NOP();
}

// Associate the initialized DMA handle to the the SPI handle
__HAL_LINKDMA(spiHandle, hdmarx, hdma_spi2_rx);

HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);

//HAL_NVIC_SetPriority(SPI2_IRQn, 0, 0);
//HAL_NVIC_EnableIRQ(SPI2_IRQn);

  /* USER CODE BEGIN SPI2_MspInit 1 */

  /* USER CODE END SPI2_MspInit 1 */
  }

}

//最后一段代码,发现进不了这两个中断里面

void DMA1_Stream4_IRQHandler(void)
{
HAL_DMA_IRQHandler(&hdma_spi2_rx);
}
uint32_t spi2count=0;
void SPI2_IRQHandler(void)
{
  spi2count++;
  HAL_SPI_IRQHandler(&hspi2);
}

目前的问题是进不了DMA和spi2的中断；

那么我又调整了思路。看看spi2能不能相应中断，就把dma的代码屏蔽掉；
然后改用
HAL_SPI_Receive_IT(&hspi2,video_odd_data,100);函数

这次是进入了中断程序，但是没有看到数据。寄存器接收的数据空的。

特别说明：
spi3，是主模式，借鉴了st的里面
HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)；
的代码，可以正常接收数据。

但是里面有一个，关锁的和开锁的保护。

hspi3.Lock = HAL_LOCKED;
。
。
__HAL_UNLOCK(&hspi3);

这中操作是不是就排斥了其他外设的运行？

感谢大家！！

旮旯旭 · 发表于 2024-1-11 14:33:29

wxqhit 发表于 2024-1-11 12:04
代码来了。。
代码1：定时器timer3 启动spi3 主模式，读取ad值。同时，spi3的clock给spi2的时钟，两个spi ...

我没记错DMA传输 RX TX都要开启，如果只是接收模式，需要设置SPI初始化只接收，不然接收不到。你可以尝试下TX也开启DMA

wxqhit · 发表于 2024-1-12 15:25:33

谢谢@旮旯旭

		自动登录	找回密码
密码			立即注册

[SPI/QSPI] h743 的spi2 设置成接收数据为DMA方式，为什么不行