h743 的spi2 设置成接收数据为DMA方式，为什么不行
版主和各位大牛我用的时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);
}
进不了中断
数据会源源不断的输入，从硬件的引脚也可以看到数据输出了。
贴个完整的代码看下。 代码来了。。
代码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);
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;
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);
这中操作是不是就排斥了其他外设的运行？
感谢大家！！
wxqhit 发表于 2024-1-11 12:04
代码来了。。
代码1：定时器timer3 启动spi3 主模式，读取ad值。同时，spi3的clock给spi2的时钟，两个spi ...
我没记错DMA传输 RX TX都要开启，如果只是接收模式，需要设置SPI初始化只接收，不然接收不到。你可以尝试下TX也开启DMA 谢谢@旮旯旭
页:
[1]