发新帖本帖赏金 50.00元(功能说明)我要提问
123下一页
返回列表
打印
[STM32F0]

寄存器才是YYDS,冲破HAL库的累赘臃肿!!![SPI+DMA的应用]

[复制链接]
6521|50
手机看帖
扫描二维码
随时随地手机跟帖
跳转到指定楼层
楼主
chenyuanjiyi|  楼主 | 2021-12-3 16:59 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
本帖最后由 chenyuanjiyi 于 2021-12-9 17:47 编辑

#申请原创#

>关于SPI+DMA的使用,进行了两次测试了,之前测试过一次,结果一直没找到问题,现在明白该如何使用了,特此记录。

一、自身SPI时间

主芯片:STM32F072CBT6(48M)
RF芯片:SX1280(通过SPI通讯)
环境:cubemx生成+MDKV5
关于SPI的通常的应用很简单,特别是通过cubemx自动生成的代码,这里就不过多介绍,可自行百度搜索关于SPI的教程及相关资料

这张图片是通过cubemx生成的SPI代码的一个效果(NSS软件控制+SPI传输),上述是仿照
HAL_SPI_TransmitReceive()
此函数又重新修改创建了一个
BSP_SPI_TransmitReceive()
函数,通过调用BSP_SPI_TransmitReceive()函数,然后测出的波形(关于函数修改的,见下面的工程路径链接)。

至于为啥不用HAL自身提供的HAL_SPI_TransmitReceive()的函数,是因为我发现调用这个函数的时候会造成,每两个字节后的间距会比较远,例:字节0和字节1相隔比较近,但是字节1和字节2隔得挺远的。

说远了,回到主题,通过上面图片,可知字节与字节间距离大概为1.0us左右,并且NSS拉低拉高与数据传输的时间也大概1us,发送5个字节的数据,SPI至少需要9.46us。
二、对比SPI时间这个数据说实话我觉的也还挺不错的,直到我突然发现样机SPI的速度,两字节间距控制在ns级别,如图


上图同样是发送5字节的数据,字节间距控制在832ns,下拉NSS到数据输出248ns,数据输出完到上拉560ns,整体发送5字节需要5.7us。
对比我之前的参数,一个是字节间距一个是纳秒一个是毫秒,还有总的发送时间,样子发送时间大概就我的1/2。
因为我这个传输对时间要求较高,所以想着也将时间尽量减少。

三、尝试减少字节间距时间
1.初步测试思路
通过对比样机SPI的速度,发现最主要的是字节间距较短,那么缩短这个时间,我首先想到了的是SPI+DMA进行传输,然后就通过cubemx直接生成了一个SPI+DMA的配置,然后通过软件控制,具体测试代码如下:


 while (1)
  {
    /* USER CODE END WHILE */
        HAL_GPIO_WritePin(GPIOA,GPIO_PIN_15,GPIO_PIN_RESET);
    HAL_SPI_TransmitReceive_DMA(&hspi1,txbuff,rxbuff,8);
    HAL_GPIO_WritePin(GPIOA,GPIO_PIN_15,GPIO_PIN_SET);
   
    HAL_GPIO_TogglePin(LED_Red_GPIO_Port,LED_Red_Pin);
    HAL_Delay(50);
    /* USER CODE BEGIN 3 */
  }



在while中周期进行读写SPI数据,但是发现数据不对,测试现象如下


在上图的测试现象中,NSS已经拉低了,但是要等一段时间才会进行数据传输,而且数据还未传输完成,NSS就拉高了,这个现象就有问题了。
针对NSS引脚和数据传输错开的现象,增加了一个等待传输完再拉高的代码,
while (1)
  {
    /* USER CODE END WHILE */
        HAL_GPIO_WritePin(GPIOA,GPIO_PIN_15,GPIO_PIN_RESET);
    HAL_SPI_TransmitReceive_DMA(&hspi1,txbuff,rxbuff,8);
    while(__HAL_DMA_GET_COUNTER(&hdma_spi1_rx)!=0);
    HAL_GPIO_WritePin(GPIOA,GPIO_PIN_15,GPIO_PIN_SET);
   
    HAL_GPIO_TogglePin(LED_Red_GPIO_Port,LED_Red_Pin);
    HAL_Delay(50);
    /* USER CODE BEGIN 3 */
  }

结果如下:


现在数据传输是在NSS拉低范围内了,但是NSS拉低到数据传输有9.96us,数据传输完到NSS拉高也有11.312us,字节间距倒是减少了不少,至少证明SPI+DMA这条路应该是没问题的,可以减少数据传输的时间。

2.再次测试
针对上一次测试,发现NSS的拉高拉低到数据传输需要较长的时间,我就想会不会是软件控制NSS太慢了,另外由于SPI是DMA进行传输的,就有可能导致SPI传输和控制NSS的操作没达到同步,所以就将SPI+DMA的软件控制NSS  改成了  硬件控制NSS 。
/* SPI1 init function */
void MX_SPI1_Init(void)
{

        hspi1.Instance = SPI1;
        hspi1.Init.Mode = SPI_MODE_MASTER;                        //设置SPI工作模式,设置为主模式
        hspi1.Init.Direction = SPI_DIRECTION_2LINES;              //设置SPI单向或者双向的数据模式:SPI设置为双线模式
        hspi1.Init.DataSize = SPI_DATASIZE_8BIT;                  //设置SPI的数据大小:SPI发送接收8位帧结构
        hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;                //串行同步时钟的空闲状态为低电平
        hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;                    //串行同步时钟的第一个跳变沿(上升或下降)数据被采样
         hspi1.Init.NSS = SPI_NSS_HARD_INPUT;                            //NSS信号由软件控制    SPI_NSS_HARD_OUTPUT   SPI_NSS_SOFT
        hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;   //定义波特率预分频的值:波特率预分频值为4
        hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;                   //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
       hspi1.Init.TIMode = SPI_TIMODE_DISABLE;                   //关闭TI模式
       hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;   //关闭硬件CRC校验
       hspi1.Init.CRCPolynomial = 7;                             //CRC值计算的多项式
       hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
       hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;//SPI_NSS_PULSE_DISABLE;             //
   
        if (HAL_SPI_Init(&hspi1) != HAL_OK)
       {
                 _Error_Handler(__FILE__, __LINE__);
       }
}


void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct;
  if(spiHandle->Instance==SPI1)
  {
  /* USER CODE BEGIN SPI1_MspInit 0 */

  /* USER CODE END SPI1_MspInit 0 */
    /* SPI1 clock enable */
    __HAL_RCC_SPI1_CLK_ENABLE();
  
    /**SPI1 GPIO Configuration   
    PB3     ------> SPI1_SCK
    PB4     ------> SPI1_MISO
    PB5     ------> SPI1_MOSI
    */
GPIO_InitStruct.Pin = GPIO_PIN_15;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
      
    GPIO_InitStruct.Pin = A7106_SCK_Pin|A7106_MISO_Pin|A7106_MOSI_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    /* SPI1 DMA Init */
    /* SPI1_TX Init */
    hdma_spi1_tx.Instance = DMA1_Channel3;                          //通道选择
    hdma_spi1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;             //存储器到外设
    hdma_spi1_tx.Init.PeriphInc = DMA_PINC_DISABLE;                 //外设非增量模式
    hdma_spi1_tx.Init.MemInc = DMA_MINC_ENABLE;                     //存储器增量模式
    hdma_spi1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    //外设数据长度:8位
    hdma_spi1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;       //存储器数据长度:8位
    hdma_spi1_tx.Init.Mode = DMA_NORMAL;                            //DMA普通模式
    hdma_spi1_tx.Init.Priority = DMA_PRIORITY_HIGH;
    if (HAL_DMA_Init(&hdma_spi1_tx) != HAL_OK)
    {
      _Error_Handler(__FILE__, __LINE__);
    }

    __HAL_LINKDMA(spiHandle,hdmatx,hdma_spi1_tx);

    /* SPI1_RX Init */
    hdma_spi1_rx.Instance = DMA1_Channel2;
    hdma_spi1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_spi1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi1_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_spi1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_spi1_rx.Init.Mode = DMA_NORMAL;
    hdma_spi1_rx.Init.Priority = DMA_PRIORITY_HIGH;
    if (HAL_DMA_Init(&hdma_spi1_rx) != HAL_OK)
    {
      _Error_Handler(__FILE__, __LINE__);
    }

    __HAL_LINKDMA(spiHandle,hdmarx,hdma_spi1_rx);

  /* USER CODE BEGIN SPI1_MspInit 1 */

  /* USER CODE END SPI1_MspInit 1 */
  }
}

硬件控制NSS,想着让其自动拉高拉低
但是测试发现,每发一个字节NSS引脚就自动拉高了,这就导致了读取的数据是有问题的,具体现象如下:

上图的现象,每个字节都进行拉高了,那对于一包数据大于1字节的话,那么就会有问题的,
SPI的数据 = 外设地址 + 该地址的命令(我的理解)
所以针对上图,我想着就如何让NSS拉高的操作和发送的数据相关联,即不让他每个字节都自动拉高
为此,研究了好久,同时也发过好几个帖子,都没有找到相关的资料

-------------------------------卡主了---------------------------------------------------------------------------------------------
在这个阶段卡了挺久的,后面也就没管SPI+DMA的应用了,直到后面空闲了在接着重新拿起这个SPI+DMA的操作。

3.间隔两个月后的再次尝试
在我发的关于SPI+DMA的求助帖子上,我看到推荐说用软件NSS,同时我也仔细研究了下样机的SPI波形,发现他有两路SPI数据,


如图,可以得知他采用的是软件控制NSS,因为有两个NSS引脚,并且公用同一路数据引脚,
那么样机采用的是软件控制,达到的SPI数据的速度提升,那么照理来说我们也能通过软件控制NSS,实现SPI+DMA的操作。

但是在初步测试时,软件控制NSS,出现错位问题,所以对软件控制还是有些怀疑的,直到我在帖子上看到   正常来讲,那个NSS每个字节抬高一个时钟时间是正常的操作,每个字节NSS抬高是正常操作,那么我想用硬件控制NSS,让其跟随传输的数据进行自动拉高拉低就行不通了,思路有问题了。

现在开始专研软件控制NSS,达到SPI+DMA的操作了,在测试1中,暴露的问题是NSS拉高的太快了,那么换个思路,能不能让他传输完成就自动拉高呢,这是可以的,DMA中断中正好就有一个传输完成的标志,那我就利用上这个标志,在中断中让其拉高NSS,
void DMA1_Channel2_3_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel2_3_IRQn 0 */

  /* USER CODE END DMA1_Channel2_3_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_spi1_rx);
  HAL_DMA_IRQHandler(&hdma_spi1_tx);
  
  /* USER CODE BEGIN DMA1_Channel2_3_IRQn 1 */
if(__HAL_DMA_GET_IT_SOURCE(&hdma_spi1_rx, DMA_IT_TC)){
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);
  }
  /* USER CODE END DMA1_Channel2_3_IRQn 1 */
}

在调用HAL_SPI_TransmitReceive_DMA()函数前,拉低NSS,在DMA的传输完成中断进行拉高NSS,然后测试,效果是可以的,数据传输完后就立刻拉高了,就是NSS拉低到数据传输的时间较长,那么都可以在中断里拉高NSS了,那么在开启DMA传输前,拉低NSS不也是可以的吗。。。。

所以我跳到HAL_SPI_TransmitReceive_DMA()函数里,在开启DMA前,增加了拉低NSS的操作
HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,uint16_t Size)
{
******************省略***********
  /* Enable the SPI Error Interrupt Bit */
  __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_ERR));
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET);
  /* Enable Tx DMA Request */
  SET_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN);

error :
  /* Process Unlocked */
  __HAL_UNLOCK(hspi);
  return errorcode;
}

现在NSS拉低的操作,放到HAL提供的HAL_SPI_TransmitReceive_DMA()函数里;
NSS拉高的操作,在DMA传输完成中断中;
测试效果:


这个效果是不错的,字节间距是208ns,拉低到数据传输656ns,数据传输完到拉高1.328us,发送5个字节需要5.952us的时间,这个时间相比于之前已经提升挺多的了,就是数据传输完到拉高时间稍微有点长。

四、实现SPI+DMA传输(减少传输时间)
在最后一次测试中,时间已经不错了,就是稍微有点瑕疵,于是在进行修改,在
HAL_DMA_IRQHandler(&hdma_spi1_tx);
里面对NSS进行拉高
void HAL_DMA_IRQHandler(DMA_HandleTypeDef *hdma)
{

***************省略**************
/* Transfer Complete Interrupt management ***********************************/
  else if ((RESET != (flag_it & (DMA_FLAG_TC1 << hdma->ChannelIndex))) && (RESET != (source_it & DMA_IT_TC)))
  {
          if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
          {
                  /* Disable the transfer complete  & transfer error interrupts */
                  /* if the DMA mode is not CIRCULAR */
                  hdma->Instance->CCR &= ~(DMA_IT_TC | DMA_IT_TE);
                  
                  /* Change the DMA state */
                  hdma->State = HAL_DMA_STATE_READY;
          }
         
          /* Clear the transfer complete flag */
          hdma->DmaBaseAddress->IFCR = DMA_FLAG_TC1 << hdma->ChannelIndex;
   
    /*nss up*/
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);
   
          /* Process Unlocked */
          __HAL_UNLOCK(hdma);
         
          if(hdma->XferCpltCallback != NULL)
          {
                  /* Transfer complete callback */
                  hdma->XferCpltCallback(hdma);
          }
  }
  ***************省略**************
  }

发现将NSS放在这里,时间是更短的


数据传输完到拉高NSS,已经降低到560ns了,为了适配其他的DMA中断,本想在HAL_DMA_IRQHandler()里面增加 if 判断,再拉高NSS,但是发现增加了判断,数据传输完到拉高NSS这里的时间又变成了us,于是索性复制HAL_DMA_IRQHandler()这个函数,在里面进行拉高NSS的操作,并对函数重命名,只能SPI_DMA调用。

实现步骤一
创建属于自己的HAL_DMA_SPI读写函数
/*
* 复制HAL_SPI_TransmitReceive_DMA()函数,在开启DMA前,拉低NSS引脚
*/
HAL_StatusTypeDef HAL_SPI_MY_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,uint16_t Size)
{
***************************
******************省略**************
  /* Set the SPI Tx DMA transfer complete callback as NULL because the communication closing is performed in DMA reception complete callback  */

  hspi->hdmatx->XferHalfCpltCallback = NULL;
  hspi->hdmatx->XferCpltCallback     = NULL;
  hspi->hdmatx->XferErrorCallback    = NULL;
  hspi->hdmatx->XferAbortCallback    = NULL;


  /* Enable the Tx DMA Stream/Channel  */
  HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)hspi->pTxBuffPtr, (uint32_t)&hspi->Instance->DR, hspi->TxXferCount);
  
/* Check if the SPI is already enabled */
  if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)
  {
    /* Enable SPI peripheral */
    __HAL_SPI_ENABLE(hspi);
  }
  /* Enable the SPI Error Interrupt Bit */
  __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_ERR));

HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET);

  /* Enable Tx DMA Request */
  SET_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN);

error :
  /* Process Unlocked */
  __HAL_UNLOCK(hspi);
  return errorcode;
}

这个函数只是单纯复制HAL_SPI_TransmitReceive_DMA()函数,然后在开启DMA前,拉低NSS引脚,这样就能尽量减少对库的修改,同时在NSS更换引脚后,也可以更方便修改NSS引脚

实现步骤二
创建属于自己的HAL_DMA_SPI中断函数
/*
* 在it.c中,要先调用
  HAL_DMA_IRQHandler(&hdma_spi1_rx);
  HAL_SPI1_TX_DMA_IRQHandler(&hdma_spi1_tx);//在此函数中会对NSS引脚拉高
*/
void HAL_SPI1_TX_DMA_IRQHandler(DMA_HandleTypeDef *hdma)
{
*****************省略*************
  /* Transfer Complete Interrupt management ***********************************/
  else if ((RESET != (flag_it & (DMA_FLAG_TC1 << hdma->ChannelIndex))) && (RESET != (source_it & DMA_IT_TC)))
  {
          if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
          {
                  /* Disable the transfer complete  & transfer error interrupts */
                  /* if the DMA mode is not CIRCULAR */
                  hdma->Instance->CCR &= ~(DMA_IT_TC | DMA_IT_TE);
      
                  /* Change the DMA state */
                  hdma->State = HAL_DMA_STATE_READY;
          }
        
          /* Clear the transfer complete flag */
          hdma->DmaBaseAddress->IFCR = DMA_FLAG_TC1 << hdma->ChannelIndex;

    /*nss up*/
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);

          /* Process Unlocked */
          __HAL_UNLOCK(hdma);

          if(hdma->XferCpltCallback != NULL)
          {
                  /* Transfer complete callback */
                  hdma->XferCpltCallback(hdma);
          }
  }
*****************省略

}  

这个函数是复制 HAL_DMA_IRQHandler()函数,然后增加NSS的操作。
【注意】:

  • 在void DMA1_Channel2_3_IRQHandler(void)中,要先调
    HAL_DMA_IRQHandler(&hdma_spi1_rx); 再调用HAL_SPI1_TX_DMA_IRQHandler(&hdma_spi1_tx);函数
    (调换位置时会出现数据还没传输完,NSS就拉高的操作)
  • 对于SPI_DMA的通道优先级尽量设置高点,这样可以更好的保证SPI传输时间短

实现效果


发送5个字节大概需要5.16us,NSS上下拉时间在600ns左右:
----------------时间:2021.12.02
五、关于上述实现的出现的bug
1.读取出现数据错误问题

在while中正常应该是读出0xA9B7为SX1280的ID,但是实际读出的却是0xB7A9;
主要是SPI的波形没问题,也确实是先读到的0xA9,再读的0xB7;有些奇怪,于是想会不会是DMA太快了,导致单片机读取数据有问题??
于是我在调用SPI_DMA的读写函数后加上个等待,如下
#define SX1280_SPI_WR(pTxData, pRxData, Size)        HAL_SPI_MY_TransmitReceive_DMA(&hspi1, pTxData,pRxData,Size)
/*
函数功能:读字节
参数:写入的数据  读取的数据 大小
*/
void SpiInOut( uint8_t *txBuffer, uint8_t *rxBuffer, uint16_t size )
{
    SX1280_SPI_WR(txBuffer,rxBuffer,size);
while(__HAL_DMA_GET_COUNTER(&hdma_spi1_rx)!=0)  
}

最终测试发现数据是正确的,读到的SX1280_ID=0xA9B7

2.两包数据之间的间距太长
刚开始也有说到,此次主要是为了减短时间,而在 一、自身SPI的图里,字节间距是比较长的,现在两个字节间的时间是缩短了,但是我发现在使用SPI_DMA读写两包数据间的时间还是比较长的,并且比采用BSP_SPI读写函数的时间还要长,那不是没缩短什么时间吗?


可以看到两包数据间隔27.5us,这时间未免有点长了
于是我就开始研究,如何缩短两包数据间的时间

六、研究如何缩短时间
关于这个时间,我猜测很可能是HAL引起的,因为我代码上就跑了个SPI_DMA的读写函数,并且HAL的执行效率较低,所以怀疑是不是HAL执行的东西太多了导致的。

1.对HAL_SPI_MY_TransmitReceive_DMA()函数初步优化
因为HAL_SPI_MY_TransmitReceive_DMA()这个函数我是直接挪用的HAL的,然后在开启DMA前,拉低了下NSS引脚而已,所以我就想着能不能对此函数进行精简。
于是我对这个函数进行删除操作,因为里面有许多的一些判断,我根据我SPI_DMA的配置,将我没设置到代码都给删掉,最终变成了这样
HAL_StatusTypeDef HAL_SPI_MY_TransmitReceive_DMA0(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,uint16_t Size)
{
  HAL_StatusTypeDef errorcode = HAL_OK;

  /* Reset the threshold bit */
  CLEAR_BIT(hspi->Instance->CR2, SPI_CR2_LDMATX | SPI_CR2_LDMARX);

  /* Set fiforxthresold according the reception data length: 8bit */
  SET_BIT(hspi->Instance->CR2, SPI_RXFIFO_THRESHOLD);

  /* Enable the Rx DMA Stream/Channel  */
//  HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->DR, (uint32_t)pRxData, Size);
{
    /* Disable the peripheral */
    hdma_spi1_rx.Instance->CCR &= ~DMA_CCR_EN;

    /* Configure the source, destination address and the data length */  
    //DMA_SetConfig(hdma_spi1_rx, (uint32_t)&hspi->Instance->DR, (uint32_t)pRxData, Size);
{
  /* Clear all flags */
  hdma_spi1_rx.DmaBaseAddress->IFCR  = (DMA_FLAG_GL1 << hdma_spi1_rx.ChannelIndex);

  /* Configure DMA Channel data length */
  hdma_spi1_rx.Instance->CNDTR = Size;
  
  /* Peripheral to Memory */
  {
    /* Configure DMA Channel source address */
    hdma_spi1_rx.Instance->CPAR = (uint32_t)&hspi->Instance->DR;
    /* Configure DMA Channel destination address */
    hdma_spi1_rx.Instance->CMAR = (uint32_t)pRxData;
  }
}
    /* Enable the transfer complete, & transfer error interrupts */
    /* Half transfer interrupt is optional: enable it only if associated callback is available */
    hdma_spi1_rx.Instance->CCR |= (DMA_IT_TC | DMA_IT_HT | DMA_IT_TE);

   /* Enable the Peripheral */
   hdma_spi1_rx.Instance->CCR |= DMA_CCR_EN;
}

  /* Enable Rx DMA Request */
  SET_BIT(hspi->Instance->CR2, SPI_CR2_RXDMAEN);


  /* Enable the Tx DMA Stream/Channel  */
//  HAL_DMA_Start_IT(hspi->hdmatx, (uint32_t)pTxData, (uint32_t)&hspi->Instance->DR,Size);
{
    /* Disable the peripheral */
    hdma_spi1_tx.Instance->CCR &= ~DMA_CCR_EN;

    /* Configure the source, destination address and the data length */  
// DMA_SetConfig(hdma_spi1_rx, (uint32_t)&hspi->Instance->DR, (uint32_t)pRxData, Size);
{
  /* Clear all flags */
  hdma_spi1_tx.DmaBaseAddress->IFCR  = (DMA_FLAG_GL1 << hdma_spi1_rx.ChannelIndex);

  /* Configure DMA Channel data length */
  hdma_spi1_tx.Instance->CNDTR = Size;
  /* Memory to Peripheral */
  {   
    /* Configure DMA Channel destination address */
    hdma_spi1_tx.Instance->CPAR = (uint32_t)&hspi->Instance->DR;
    /* Configure DMA Channel source address */
    hdma_spi1_tx.Instance->CMAR = (uint32_t)pTxData;
  }
}
      /* Enable the transfer complete, & transfer error interrupts */
      /* Half transfer interrupt is optional: enable it only if associated callback is available */
      hdma_spi1_tx.Instance->CCR |= (DMA_IT_TC | DMA_IT_HT | DMA_IT_TE);

      HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET);
      /* Enable the Peripheral */
      hdma_spi1_tx.Instance->CCR |= DMA_CCR_EN;
}
  /* Check if the SPI is already enabled */
  if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)
  {
    /* Enable SPI peripheral */
    __HAL_SPI_ENABLE(hspi);
  }
  /* Enable the SPI Error Interrupt Bit */
  __HAL_SPI_ENABLE_IT(hspi, (SPI_IT_ERR));

  /* Enable Tx DMA Request */
  SET_BIT(hspi->Instance->CR2, SPI_CR2_TXDMAEN);

  return errorcode;
}

然后进行测试,测试结果如下,可以看到虽然两包数据间的时间减少了,但还是有个16.48us,这个时间对于我还是太长了,因为我采用BSP_SPI读写函数时,两包数据间也就2-3us左右,这个时间还是明显偏长。


2.进一步优化
如何在进一步,缩短时间,再对此函数进行优化? 将其改成直接操作寄存器?

在此需特别感谢 21ic论坛的版主 @呐咯密密
在我调试过程中给予我特别多的帮助。

在他的帮助下,将上述的读写函数,再进一步优化,
HAL_StatusTypeDef HAL_SPI_MY_TransmitReceive_DMA0(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,uint16_t Size)
{
  HAL_StatusTypeDef errorcode = HAL_OK;
  
          hspi->Instance->CR2 |= SPI_CR2_TXDMAEN;
        hspi->Instance->CR2 |= SPI_CR2_RXDMAEN;
        hdma_spi1_tx.Instance->CCR &= ~DMA_CCR_EN;
    hdma_spi1_tx.Instance->CPAR = (uint32_t)&hspi->Instance->DR;
    hdma_spi1_tx.Instance->CMAR = (uint32_t)pTxData;        
        hdma_spi1_tx.Instance->CNDTR = Size;
hdma_spi1_tx.Instance->CCR |= (DMA_IT_TC | DMA_IT_HT | DMA_IT_TE);
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET);
        hdma_spi1_tx.Instance->CCR |= DMA_CCR_EN;
        hdma_spi1_rx.Instance->CCR &= ~DMA_CCR_EN;
    hdma_spi1_rx.Instance->CPAR = (uint32_t)&hspi->Instance->DR;
    hdma_spi1_rx.Instance->CMAR = (uint32_t)pRxData;        
        hdma_spi1_rx.Instance->CNDTR = Size;
  hdma_spi1_rx.Instance->CCR |= (DMA_IT_TC | DMA_IT_HT | DMA_IT_TE);
        hdma_spi1_rx.Instance->CCR |= DMA_CCR_EN;
  

    /* Enable SPI peripheral */
//    __HAL_SPI_ENABLE(hspi);
  hspi->Instance->CR1 |= SPI_CR1_SPE;
  return errorcode;
}

现在已经全改成寄存器操作了,进行测试



结果还有16us的时间????
啥情况,读写函数已经删减到寄存了,还这么多时间???

3.对中断进行优化
这时听大哥说,他用的SPI+DMA不带中断的,这时我才突然反应过来,在中断里也是用的HAL调用的呀,这里也要进行优化!!!
/*while中操作,只执行读写函数*/
uint8_t txbuff[5]={0x19,0x01,0x53,0x00,0x00};
uint8_t rxbuff[5];
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    HAL_SPI_MY_TransmitReceive_DMA0(&hspi1, txbuff,rxbuff,5);
    HAL_SPI_MY_TransmitReceive_DMA0(&hspi1, txbuff,rxbuff,5);
//    SX1280_ID = Radio.GetFirmwareVersion();//获取芯片信息 0xA9B7 可用于测试SPI的读写情况
   
    HAL_GPIO_TogglePin(LED_Red_GPIO_Port,LED_Red_Pin);
      HAL_Delay(50);
    /* USER CODE END WHILE */
   
    /* USER CODE BEGIN 3 */
  }
/*SPI_DMA的读写函数*/
HAL_StatusTypeDef HAL_SPI_MY_TransmitReceive_DMA0(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,uint16_t Size)
{
  hspi->Instance->CR2 |= SPI_CR2_TXDMAEN;
        hspi->Instance->CR2 |= SPI_CR2_RXDMAEN;
        hdma_spi1_tx.Instance->CCR &= ~DMA_CCR_EN;
    hdma_spi1_tx.Instance->CPAR = (uint32_t)&hspi->Instance->DR;
    hdma_spi1_tx.Instance->CMAR = (uint32_t)pTxData;        
        hdma_spi1_tx.Instance->CNDTR = Size;
//hdma_spi1_tx.Instance->CCR |= (DMA_IT_TC | DMA_IT_HT | DMA_IT_TE);
  
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET);
        hdma_spi1_tx.Instance->CCR |= DMA_CCR_EN;
        hdma_spi1_rx.Instance->CCR &= ~DMA_CCR_EN;
    hdma_spi1_rx.Instance->CPAR = (uint32_t)&hspi->Instance->DR;
    hdma_spi1_rx.Instance->CMAR = (uint32_t)pRxData;        
        hdma_spi1_rx.Instance->CNDTR = Size;
  hdma_spi1_rx.Instance->CCR |= (DMA_IT_TC);//| DMA_IT_HT | DMA_IT_TE);
        hdma_spi1_rx.Instance->CCR |= DMA_CCR_EN;

  hspi->Instance->CR1 |= SPI_CR1_SPE;
  }
/*DMA中断*/
void DMA1_Channel2_3_IRQHandler(void)
{
  /* USER CODE BEGIN DMA1_Channel2_3_IRQn 0 */

  /* USER CODE END DMA1_Channel2_3_IRQn 0 */
//  HAL_DMA_IRQHandler(&hdma_spi1_rx);
//  HAL_DMA_IRQHandler(&hdma_spi1_tx);
  /* USER CODE BEGIN DMA1_Channel2_3_IRQn 1 */
if(__HAL_DMA_GET_IT_SOURCE(&hdma_spi1_rx, DMA_IT_TC)){
  hdma_spi1_rx.Instance->CCR &= ~(DMA_IT_TC );
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);
  }
  /* USER CODE END DMA1_Channel2_3_IRQn 1 */
}

现在对上述进行优化了,然后进行测试


可以看到两包数据间的间距是1.16us了,虽然说现在数据错误,但是至少说明,修改中断里的操作是没问题的。

4.最终优化结果
现在再进一步测试,去掉中断(我本想是数据传输完后,立刻拉高NSS引脚,但是现在看来是我对TC中断有误解了,因为上图的测试现象说明,触发了TC中断,但是数据并没有传输完)


现在关闭中断,等待传输完后在拉高NSS,将读写函数进行如下修改
void HAL_SPI_MY_TransmitReceive_DMA0(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,uint16_t Size)
{

  hspi->Instance->CR2 |= SPI_CR2_TXDMAEN;
        hspi->Instance->CR2 |= SPI_CR2_RXDMAEN;
        hdma_spi1_tx.Instance->CCR &= ~DMA_CCR_EN;
    hdma_spi1_tx.Instance->CPAR = (uint32_t)&hspi->Instance->DR;
    hdma_spi1_tx.Instance->CMAR = (uint32_t)pTxData;        
        hdma_spi1_tx.Instance->CNDTR = Size;
//hdma_spi1_tx.Instance->CCR |= (DMA_IT_TC | DMA_IT_HT | DMA_IT_TE);
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET);
  
        hdma_spi1_tx.Instance->CCR |= DMA_CCR_EN;
        hdma_spi1_rx.Instance->CCR &= ~DMA_CCR_EN;
    hdma_spi1_rx.Instance->CPAR = (uint32_t)&hspi->Instance->DR;
    hdma_spi1_rx.Instance->CMAR = (uint32_t)pRxData;        
        hdma_spi1_rx.Instance->CNDTR = Size;
  
//  hdma_spi1_rx.Instance->CCR |= (DMA_IT_TC);//| DMA_IT_HT | DMA_IT_TE);
  
        hdma_spi1_rx.Instance->CCR |= DMA_CCR_EN;
  

  hspi->Instance->CR1 |= SPI_CR1_SPE;

  while((hspi->Instance->SR & SPI_SR_RXNE)!=RESET);
  while((hspi->Instance->SR & SPI_SR_BSY)!=RESET);
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);
  }

只对SPI_DMA读写函数进行修改,在while中还是发送那些指令,在读写函数中不开启中断,增加等待

while((hspi->Instance->SR & SPI_SR_RXNE)!=RESET);while((hspi->Instance->SR & SPI_SR_BSY)!=RESET);HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);
测试结果:


上图中NSS拉低到开始传输数据560ns,数据传输完成到NSS拉高432ns,两包数据间隔是2.09us

七、最终测试数据及配置
1.测试数据
在这可以将我第 五.1中数据错误的修改去掉






#define SX1280_SPI_WR(pTxData, pRxData, Size)        HAL_SPI_MY_TransmitReceive_DMA(&hspi1, pTxData,pRxData,Size)
/*
函数功能:读字节
参数:写入的数据  读取的数据 大小
*/
void SpiInOut( uint8_t *txBuffer, uint8_t *rxBuffer, uint16_t size )
{
    SX1280_SPI_WR(txBuffer,rxBuffer,size);
//while(__HAL_DMA_GET_COUNTER(&hdma_spi1_rx)!=0)  
}
同时配置成上述读取的数据正确的
while (1)
  {
    HAL_SPI_MY_TransmitReceive_DMA0(&hspi1, txbuff,rxbuff,5);
    HAL_SPI_MY_TransmitReceive_DMA0(&hspi1, txbuff,rxbuff,5);
    /*这里发送了两包数据,正常返回 0xA9B7*/
    SX1280_ID = Radio.GetFirmwareVersion();//获取芯片信息 0xA9B7 可用于测试SPI的读写情况
   
    HAL_GPIO_TogglePin(LED_Red_GPIO_Port,LED_Red_Pin);
      HAL_Delay(50);
    /* USER CODE END WHILE */
   
    /* USER CODE BEGIN 3 */
  }

关于上述while中的测试现象如下


前两包数据间距是2.08us,后面两包数据间距是6.8us,这是因为读取SX1280_ID是通过调用SX1280自身的库,然后再调用我封装的那个SPI_DMA读写函数。

2.配置
/*main函数*/
int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_SPI1_Init();

  Radio.Init( &Callbacks );//初始化回调函数
  Radio.SetRegulatorMode( USE_DCDC ); // 也可以设置为LDO模式但消耗更多功率 USE_DCDC  USE_LDO
uint8_t txbuff[5]={0x19,0x01,0x53,0x00,0x00};
uint8_t rxbuff[5];
  while (1)
  {
    HAL_SPI_MY_TransmitReceive_DMA(&hspi1, txbuff,rxbuff,5);
    HAL_SPI_MY_TransmitReceive_DMA(&hspi1, txbuff,rxbuff,5);
   
    SX1280_ID = Radio.GetFirmwareVersion();//获取芯片信息 0xA9B7 可用于测试SPI的读写情况
   
    HAL_GPIO_TogglePin(LED_Red_GPIO_Port,LED_Red_Pin);
    HAL_Delay(50);
  }
}
/*DMA配置*/
void MX_DMA_Init(void)
{
  __HAL_RCC_DMA1_CLK_ENABLE();//开启DMA时钟即可

  /* 不需要配置DMA的优先级,因为没用到DMA中断 */
//  HAL_NVIC_SetPriority(DMA1_Channel2_3_IRQn, 0, 0);
//  HAL_NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);
}
/*SPI配置*/
void MX_SPI1_Init(void)
{

  hspi1.Instance = SPI1;
  hspi1.Init.Mode = SPI_MODE_MASTER;
  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi1.Init.NSS = SPI_NSS_SOFT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi1.Init.CRCPolynomial = 7;
  hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
  hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
  if (HAL_SPI_Init(&hspi1) != HAL_OK)
  {
    Error_Handler();
  }

}

void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(spiHandle->Instance==SPI1)
  {
    /* SPI1 clock enable */
    __HAL_RCC_SPI1_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**SPI1 GPIO Configuration   
    PB3     ------> SPI1_SCK
    PB4     ------> SPI1_MISO
    PB5     ------> SPI1_MOSI
    */
  
    GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    /* SPI1 DMA Init */
    /* SPI1_TX Init */
    hdma_spi1_tx.Instance = DMA1_Channel3;
    hdma_spi1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    hdma_spi1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi1_tx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_spi1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_spi1_tx.Init.Mode = DMA_NORMAL;
    hdma_spi1_tx.Init.Priority = DMA_PRIORITY_MEDIUM;
    if (HAL_DMA_Init(&hdma_spi1_tx) != HAL_OK)
    {
      Error_Handler();
    }
    __HAL_LINKDMA(spiHandle,hdmatx,hdma_spi1_tx);

    /* SPI1_RX Init */
    hdma_spi1_rx.Instance = DMA1_Channel2;
    hdma_spi1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_spi1_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_spi1_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_spi1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_spi1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_spi1_rx.Init.Mode = DMA_NORMAL;
    hdma_spi1_rx.Init.Priority = DMA_PRIORITY_MEDIUM;
    if (HAL_DMA_Init(&hdma_spi1_rx) != HAL_OK)
    {
      Error_Handler();
    }
    __HAL_LINKDMA(spiHandle,hdmarx,hdma_spi1_rx);

    /* 未用到SPI中断,也可不用配置 */
//    HAL_NVIC_SetPriority(SPI1_IRQn, 0, 0);
//    HAL_NVIC_EnableIRQ(SPI1_IRQn);
  }
}
/*SPI_DMA读写函数*/
void HAL_SPI_MY_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,uint16_t Size)
{
  hspi->Instance->CR2 |= SPI_CR2_TXDMAEN;
        hspi->Instance->CR2 |= SPI_CR2_RXDMAEN;
        hdma_spi1_tx.Instance->CCR &= ~DMA_CCR_EN;
  hdma_spi1_tx.Instance->CPAR = (uint32_t)&hspi->Instance->DR;
  hdma_spi1_tx.Instance->CMAR = (uint32_t)pTxData;        
        hdma_spi1_tx.Instance->CNDTR = Size;

  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET);
  
        hdma_spi1_tx.Instance->CCR |= DMA_CCR_EN;
        hdma_spi1_rx.Instance->CCR &= ~DMA_CCR_EN;
  hdma_spi1_rx.Instance->CPAR = (uint32_t)&hspi->Instance->DR;
  hdma_spi1_rx.Instance->CMAR = (uint32_t)pRxData;        
        hdma_spi1_rx.Instance->CNDTR = Size;
        hdma_spi1_rx.Instance->CCR |= DMA_CCR_EN;
  
  hspi->Instance->CR1 |= SPI_CR1_SPE;

  while((hspi->Instance->SR & SPI_SR_RXNE)!=RESET);
  while((hspi->Instance->SR & SPI_SR_BSY)!=RESET);
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET);
}

关于具体代码,稍后放到github上(附件上传不了)
关于如何减少时间,大家有更好的方法,欢迎讨论联系,谢谢!
最后再次感谢 21ic论坛的版主 @呐咯密密
----------------时间:2021.12.03
关于测试工程,github链接:https://github.com/Gu-Yue-Hu/SPI_DMA_HAL.git














   

使用特权

评论回复

打赏榜单

21小跑堂 打赏了 50.00 元 2021-12-03
理由:恭喜通过原创文章审核!请多多加油哦!

来自 2楼
chenyuanjiyi|  楼主 | 2021-12-17 09:38 | 只看该作者
本帖最后由 chenyuanjiyi 于 2022-2-23 09:15 编辑

补充一点:针对ST不同系列芯片,上面的SPI读写函数不能直接使用,有一些区别

今天在对F4系列芯片采用上述SPI读写函数是有问题的,后经修改,如下,才能正常使用
void HAL_SPI_MY_TransmitReceive_DMA0(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,uint16_t Size)
{
SPI_DMA_Base_Registers *regs = (SPI_DMA_Base_Registers *)hdma_spi2_rx.StreamBaseAddress;

hdma_spi2_rx.Instance->CR &=  ~DMA_SxCR_EN;
hdma_spi2_rx.Instance->PAR = (uint32_t)&hspi->Instance->DR;
hdma_spi2_rx.Instance->M0AR = (uint32_t)pRxData;
hdma_spi2_rx.Instance->NDTR = Size;
  regs->IFCR = 0x3FU << hdma_spi2_rx.StreamIndex;
hdma_spi2_rx.Instance->CR |= DMA_SxCR_EN;
hspi->Instance->CR2 |= SPI_CR2_RXDMAEN;
  

SPI_DMA_Base_Registers *regs1 = (SPI_DMA_Base_Registers *)hdma_spi2_tx.StreamBaseAddress;

hdma_spi2_tx.Instance->CR &= ~DMA_SxCR_EN;
hdma_spi2_tx.Instance->PAR = (uint32_t)&hspi->Instance->DR;
hdma_spi2_tx.Instance->M0AR = (uint32_t)pTxData;
hdma_spi2_tx.Instance->NDTR = Size;
regs1->IFCR = 0x3FU << hdma_spi2_tx.StreamIndex;
// hdma_spi2_tx.Instance->CR  |= DMA_IT_TC ;
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET);  
hdma_spi2_tx.Instance->CR |= DMA_SxCR_EN;


hspi->Instance->CR1 |= SPI_CR1_SPE;
hspi->Instance->CR2 |= SPI_CR2_TXDMAEN;

regs->IFCR = DMA_FLAG_TCIF0_4 << hdma_spi2_rx.StreamIndex;
regs->IFCR = 0x3FU << hdma_spi2_rx.StreamIndex;
regs1->IFCR = DMA_FLAG_TCIF0_4 << hdma_spi2_tx.StreamIndex;
regs1->IFCR = 0x3FU << hdma_spi2_tx.StreamIndex;

while((hspi->Instance->SR & SPI_SR_RXNE)!=RESET);
while((hspi->Instance->SR & SPI_SR_BSY)!=RESET);


HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_SET);   
}
对比F0系列的,增加了
egs->IFCR = DMA_FLAG_TCIF0_4 << hdma_spi2_rx.StreamIndex;
regs->IFCR = 0x3FU << hdma_spi2_rx.StreamIndex;
regs1->IFCR = DMA_FLAG_TCIF0_4 << hdma_spi2_tx.StreamIndex;
regs1->IFCR = 0x3FU << hdma_spi2_tx.StreamIndex;

这些操作。

总结:
对于HAL上使用SPI_DMA读写函数时,按照帖子上思路来进行修改是没问题的,测试时,首先对HAL_SPI_TransmitReceive_DMA()函数做减法操作,再对HAL_DMA_IRQHandler();做减法操作,最终根据帖子中F0系列修改后的SPI_DMA读写函数格式进行修改,记得使用时先对函数进行读写验证,不仅要看他的波形,还要看他实际的读写的数据是否正确,才能最终使用!!

关于采用HAL还是寄存器,我的想法是通过cubemx(HAL库),自动生成相关的配置,然后在需要高速、效率的时候,将部分HAL库的内容改成使用寄存器操作,这样是相对简单点的,当然改完需要测试有没有问题。



使用特权

评论回复
板凳
香水城| | 2021-12-3 17:10 | 只看该作者
总结后更有收获!

使用特权

评论回复
地板
香水城| | 2021-12-3 17:11 | 只看该作者
本帖最后由 香水城 于 2021-12-3 17:32 编辑

总结后更有收获!


关于SPI+DMA的使用问题

使用特权

评论回复
5
呐咯密密| | 2021-12-3 17:16 | 只看该作者
寄存器永远的神!哈哈哈

使用特权

评论回复
6
chenyuanjiyi|  楼主 | 2021-12-3 17:23 | 只看该作者
呐咯密密 发表于 2021-12-3 17:16
寄存器永远的神!哈哈哈

哈哈  感谢大佬的帮助

使用特权

评论回复
7
andreilei| | 2021-12-4 15:55 | 只看该作者
公开课《电子的奇妙世界》用定格动画的方式讲述发生在电子世界的故事,呈现元器件们的奇妙冒险!
整容二极管
晶振的噩梦
谁杀死了LED
保险丝的葬礼
妄自尊大的发光二极管
————
电子的奇妙世界,视频公开课
https://open.21ic.com/open/lesson/5766

使用特权

评论回复
8
6552918| | 2021-12-4 22:14 | 只看该作者
讲解的很细致,nice!

使用特权

评论回复
9
liaojihua2010| | 2021-12-6 08:47 | 只看该作者
一早就认真看完了你的帖子,不错的总结,这个习惯很好的。

使用特权

评论回复
10
hi0712| | 2021-12-10 08:49 | 只看该作者
哎 从汇编过来 一直到hal库的飘过

使用特权

评论回复
11
Gavin3389| | 2021-12-10 09:00 | 只看该作者
写的真好,这种实验的思路很值得学习
不过,看倒后面,有点跟不上了,
我可能只适合软件NSS

使用特权

评论回复
12
laocuo1142| | 2021-12-13 08:21 | 只看该作者
哈哈,我最近也在调SX1280,现在HAL库是主流啊

使用特权

评论回复
13
tpgf| | 2022-1-3 16:31 | 只看该作者
有的缩写我看不懂啊

使用特权

评论回复
14
磨砂| | 2022-1-3 16:33 | 只看该作者
我 还是喜欢用hal库

使用特权

评论回复
15
晓伍| | 2022-1-3 16:34 | 只看该作者
看个人习惯了

使用特权

评论回复
16
八层楼| | 2022-1-3 16:37 | 只看该作者
YYDS是什么意思啊

使用特权

评论回复
17
观海| | 2022-1-3 16:38 | 只看该作者
各有各的有点吧

使用特权

评论回复
18
chenyuanjiyi|  楼主 | 2022-1-4 09:18 | 只看该作者
HAL确实要方便,在加上cubemx,点几下就配置好了,要是寄存器的话,单纯配置就要耗费比较多的时间了;
根据需求来,像上面那个DMA_SPI的,HAL的运行时间就相对慢点,所以就直接对HAL提供的SPI_DMA读写函数进行删减优化了,逐渐减成寄存器操作了

使用特权

评论回复
19
122541325| | 2022-1-4 15:19 | 只看该作者
用寄存器肯定是比库的效率高了,我之前的公司还不准用寄存器,只是前期开发慢了点,我还是比较喜欢用库,库函数解决不了了,然后会从寄存器上想办法

使用特权

评论回复
20
kiwis66| | 2022-1-5 09:13 | 只看该作者
离开寄存器已经好久~

使用特权

评论回复
发新帖 本帖赏金 50.00元(功能说明)我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则

16

主题

134

帖子

3

粉丝