STM32串口DMA双缓冲，数据接收与发送，HAL库实现

最新推荐文章于 2024-10-08 15:22:14 发布
最新推荐文章于 2024-10-08 15:22:14 发布
阅读量7.9k 收藏 86
点赞数 14
分类专栏： STM32 文章标签： stm32 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Master_0_/article/details/131166263
版权

STM32串口DMA双缓冲

1.简介

STM32F429系列DMA支持双缓冲模式进行数据传输，相当于数字电路设计领域的乒乓操作，但是HAL库并没有实现像单缓冲区一样可以简单使用的函数，有的方法是使用单缓冲的方式，但是通过接收半满的中断控制CPU进行数据处理，相当于是把一个缓冲区拆成两半使用。双缓冲的优势是显而易见的，在将串口数据写入到一个缓冲区时，CPU同时可以进行另一个缓冲区的读取，可以加快数据的处理

HAL库没有实现硬件双缓冲的代码，需要自己实现一下。

2.代码分析

要想自己实现一个双缓冲的接收函数，需要首先看一下HAL库是如何实现单缓冲模式的串口接收的。首先使用STM32CubeMX生成一个正常的开启DMA，串口的工程，先确保单缓冲的串口可以正常收发数据。

开启双缓冲，MDA会强制性切换为循环模式，无法调整。

HAL库启动串口DMA使用函数​HAL_UART_Receive_DMA​

HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
  /* Check that a Rx process is not already ongoing */
  if (huart->RxState == HAL_UART_STATE_READY)
  {
    if ((pData == NULL) || (Size == 0U))
    {
      return HAL_ERROR;
    }

    /* Process Locked */
    __HAL_LOCK(huart);

    /* Set Reception type to Standard reception */
    huart->ReceptionType = HAL_UART_RECEPTION_STANDARD;

    return (UART_Start_Receive_DMA(huart, pData, Size));
  }
  else
  {
    return HAL_BUSY;
  }
}

其中主要功能是UART_Start_Receive_DMA​函数

HAL_StatusTypeDef UART_Start_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
  uint32_t *tmp;

  huart->pRxBuffPtr = pData;
  huart->RxXferSize = Size;

  huart->ErrorCode = HAL_UART_ERROR_NONE;
  huart->RxState = HAL_UART_STATE_BUSY_RX;

  /* Set the UART DMA transfer complete callback */
  huart->hdmarx->XferCpltCallback = UART_DMAReceiveCplt;

  /* Set the UART DMA Half transfer complete callback */
  huart->hdmarx->XferHalfCpltCallback = UART_DMARxHalfCplt;

  /* Set the DMA error callback */
  huart->hdmarx->XferErrorCallback = UART_DMAError;

  /* Set the DMA abort callback */
  huart->hdmarx->XferAbortCallback = NULL;

  /* Enable the DMA stream */
  tmp = (uint32_t *)&pData;
  HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->DR, *(uint32_t *)tmp, Size);

  /* Clear the Overrun flag just before enabling the DMA Rx request: can be mandatory for the second transfer */
  __HAL_UART_CLEAR_OREFLAG(huart);

  /* Process Unlocked */
  __HAL_UNLOCK(huart);

  if (huart->Init.Parity != UART_PARITY_NONE)
  {
    /* Enable the UART Parity Error Interrupt */
    ATOMIC_SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
  }

  /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
  ATOMIC_SET_BIT(huart->Instance->CR3, USART_CR3_EIE);

  /* Enable the DMA transfer for the receiver request by setting the DMAR bit
  in the UART CR3 register */
  ATOMIC_SET_BIT(huart->Instance->CR3, USART_CR3_DMAR);

  return HAL_OK;
}

​UART_Start_Receive_DMA​函数的主要过程是

  • 给DMA传输完成，传输一半，和串口错误设置回调函数
  • 启动中断模式的DMA传输
  • 使能串口的DMA触发

然后再来看一下DMA传输完成的回调函数​UART_DMAReceiveCplt​


/**
  * @brief  DMA UART receive process complete callback.
  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
  *               the configuration information for the specified DMA module.
  * @retval None
  */
static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
{
  UART_HandleTypeDef *huart = (UART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
  /* DMA Normal mode*/
  if ((hdma->Instance->CR & DMA_SxCR_CIRC) == 0U)
  {
    huart->RxXferCount = 0U;

    /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
    ATOMIC_CLEAR_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    ATOMIC_CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);

    /* Disable the DMA transfer for the receiver request by setting the DMAR bit
       in the UART CR3 register */
    ATOMIC_CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);

    /* At end of Rx process, restore huart->RxState to Ready */
    huart->RxState = HAL_UART_STATE_READY;

    /* If Reception till IDLE event has been selected, Disable IDLE Interrupt */
    if (huart->ReceptionType == HAL_UART_RECEPTION_TOIDLE)
    {
      ATOMIC_CLEAR_BIT(huart->Instance->CR1, USART_CR1_IDLEIE);
    }
  }

  /* Check current reception Mode :
     If Reception till IDLE event has been selected : use Rx Event callback */
  if (huart->ReceptionType == HAL_UART_RECEPTION_TOIDLE)
  {
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    /*Call registered Rx Event callback*/
    huart->RxEventCallback(huart, huart->RxXferSize);
#else
    /*Call legacy weak Rx Event callback*/
    HAL_UARTEx_RxEventCallback(huart, huart->RxXferSize);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
  }
  else
  {
    /* In other cases : use Rx Complete callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    /*Call registered Rx complete callback*/
    huart->RxCpltCallback(huart);
#else
    /*Call legacy weak Rx complete callback*/
    HAL_UART_RxCpltCallback(huart);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
  }
}

​UART_DMAReceiveCplt​函数的主要内容是

  • 进行一些状态的更新、对一些中断标志位进行清除
  • 调用HAL开放出来让用户编写的中断服务函数​HAL_UART_RxCpltCallback(huart);​

整体的流程是，HAL_UART_Receive_DMA​->UART_Start_Receive_DMA​->( 回调函数+HAL_DMA_Start_IT​)

‍

要想实现双缓冲，可以仿造HAL库的方式，自己实现一个启动的流程，大体上直接复制HAL库的即可，关键部分进行自己的修改，最好不要直接在HAL库改，在其他的地方重新写。

1.实现HAL_UART_Receive_DMA_double​，主要复制HAL_UART_Receive_DMA​，最后调用的函数改为UART_Start_Receive_DMA_double​


HAL_StatusTypeDef HAL_UART_Receive_DMA_double(UART_HandleTypeDef *huart, uint8_t *pData,uint8_t *pData1 ,uint16_t Size)
{
  /* Check that a Rx process is not already ongoing */
  if (huart->RxState == HAL_UART_STATE_READY)
  {
    if ((pData == NULL) || (Size == 0U))
    {
      return HAL_ERROR;
    }

    /* Process Locked */
    __HAL_LOCK(huart);

    /* Set Reception type to Standard reception */
    huart->ReceptionType = HAL_UART_RECEPTION_STANDARD;

    return (UART_Start_Receive_DMA_double(huart, pData,pData1, Size));
  }
  else
  {
    return HAL_BUSY;
  }
}

2.实现​UART_Start_Receive_DMA_double​

HAL_StatusTypeDef UART_Start_Receive_DMA_double(UART_HandleTypeDef *huart, uint8_t *pData,uint8_t *pData1, uint16_t Size)
{
  uint32_t *tmp;
	uint32_t *tmp1;

  huart->pRxBuffPtr = pData;
  huart->RxXferSize = Size;

  huart->ErrorCode = HAL_UART_ERROR_NONE;
  huart->RxState = HAL_UART_STATE_BUSY_RX;

  /* Set the UART DMA transfer complete callback */
  huart->hdmarx->XferCpltCallback = UART_DMAReceiveCplt_M0;
huart->hdmarx->XferM1CpltCallback = UART_DMAReceiveCplt_M1;
  /* Set the UART DMA Half transfer complete callback */
  huart->hdmarx->XferHalfCpltCallback = NULL;

  /* Set the DMA error callback */
  huart->hdmarx->XferErrorCallback = UART_DMAError;

  /* Set the DMA abort callback */
  huart->hdmarx->XferAbortCallback = NULL;

  /* Enable the DMA stream */
  tmp = (uint32_t *)&pData;
	tmp1 = (uint32_t *)&pData1;
  //HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->DR, *(uint32_t *)tmp, Size);
	HAL_DMAEx_MultiBufferStart_IT(huart->hdmarx, (uint32_t)&huart->Instance->DR, *(uint32_t *)tmp,*(uint32_t *)tmp1 ,Size);
  /* Clear the Overrun flag just before enabling the DMA Rx request: can be mandatory for the second transfer */
  __HAL_UART_CLEAR_OREFLAG(huart);

  /* Process Unlocked */
  __HAL_UNLOCK(huart);

  if (huart->Init.Parity != UART_PARITY_NONE)
  {
    /* Enable the UART Parity Error Interrupt */
    ATOMIC_SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
  }

  /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
  ATOMIC_SET_BIT(huart->Instance->CR3, USART_CR3_EIE);

  /* Enable the DMA transfer for the receiver request by setting the DMAR bit
  in the UART CR3 register */
  ATOMIC_SET_BIT(huart->Instance->CR3, USART_CR3_DMAR);

  return HAL_OK;
}

后面启动DMA传输的函数更改为HAL_DMAEx_MultiBufferStart_IT​，此函数要求必须要有两个缓冲区满的回调函数以及传输错误的回调函数，因此必须实现这三个回调函数。

3.实现回调函数，直接复制HAL库原本的回调函数

/**
  * @brief  DMA UART receive process complete callback.
  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
  *               the configuration information for the specified DMA module.
  * @retval None
  */
static void UART_DMAReceiveCplt_M0(DMA_HandleTypeDef *hdma)
{
  UART_HandleTypeDef *huart = (UART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
  /* DMA Normal mode*/
  if ((hdma->Instance->CR & DMA_SxCR_CIRC) == 0U)
  {
    huart->RxXferCount = 0U;

    /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
    ATOMIC_CLEAR_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    ATOMIC_CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);

    /* Disable the DMA transfer for the receiver request by setting the DMAR bit
       in the UART CR3 register */
    ATOMIC_CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);

    /* At end of Rx process, restore huart->RxState to Ready */
    huart->RxState = HAL_UART_STATE_READY;

    /* If Reception till IDLE event has been selected, Disable IDLE Interrupt */
    if (huart->ReceptionType == HAL_UART_RECEPTION_TOIDLE)
    {
      ATOMIC_CLEAR_BIT(huart->Instance->CR1, USART_CR1_IDLEIE);
    }
  }

  /* Check current reception Mode :
     If Reception till IDLE event has been selected : use Rx Event callback */
  if (huart->ReceptionType == HAL_UART_RECEPTION_TOIDLE)
  {
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    /*Call registered Rx Event callback*/
    huart->RxEventCallback(huart, huart->RxXferSize);
#else
    /*Call legacy weak Rx Event callback*/
    HAL_UARTEx_RxEventCallback(huart, huart->RxXferSize);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
  }
  else
  {
    /* In other cases : use Rx Complete callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    /*Call registered Rx complete callback*/
    huart->RxCpltCallback(huart);
#else
    /*Call legacy weak Rx complete callback*/
    //HAL_UART_RxCpltCallback(huart);
    printf("000\r\n");
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
  }
}

‍


/**
  * @brief  DMA UART receive process complete callback.
  * @param  hdma  Pointer to a DMA_HandleTypeDef structure that contains
  *               the configuration information for the specified DMA module.
  * @retval None
  */
static void UART_DMAReceiveCplt_M1(DMA_HandleTypeDef *hdma)
{
  UART_HandleTypeDef *huart = (UART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;
  /* DMA Normal mode*/
  if ((hdma->Instance->CR & DMA_SxCR_CIRC) == 0U)
  {
    huart->RxXferCount = 0U;

    /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
    ATOMIC_CLEAR_BIT(huart->Instance->CR1, USART_CR1_PEIE);
    ATOMIC_CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);

    /* Disable the DMA transfer for the receiver request by setting the DMAR bit
       in the UART CR3 register */
    ATOMIC_CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);

    /* At end of Rx process, restore huart->RxState to Ready */
    huart->RxState = HAL_UART_STATE_READY;

    /* If Reception till IDLE event has been selected, Disable IDLE Interrupt */
    if (huart->ReceptionType == HAL_UART_RECEPTION_TOIDLE)
    {
      ATOMIC_CLEAR_BIT(huart->Instance->CR1, USART_CR1_IDLEIE);
    }
  }

  /* Check current reception Mode :
     If Reception till IDLE event has been selected : use Rx Event callback */
  if (huart->ReceptionType == HAL_UART_RECEPTION_TOIDLE)
  {
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    /*Call registered Rx Event callback*/
    huart->RxEventCallback(huart, huart->RxXferSize);
#else
    /*Call legacy weak Rx Event callback*/
    HAL_UARTEx_RxEventCallback(huart, huart->RxXferSize);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
  }
  else
  {
    /* In other cases : use Rx Complete callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    /*Call registered Rx complete callback*/
    huart->RxCpltCallback(huart);
#else
    /*Call legacy weak Rx complete callback*/
    //HAL_UART_RxCpltCallback(huart);
    printf("11111\r\n");
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
  }
}

‍

static void UART_DMAError(DMA_HandleTypeDef *hdma)
{
  uint32_t dmarequest = 0x00U;
  UART_HandleTypeDef *huart = (UART_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;

  /* Stop UART DMA Tx request if ongoing */
  dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT);
  if ((huart->gState == HAL_UART_STATE_BUSY_TX) && dmarequest)
  {
    huart->TxXferCount = 0x00U;
    UART_EndTxTransfer(huart);
  }

  /* Stop UART DMA Rx request if ongoing */
  dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
  if ((huart->RxState == HAL_UART_STATE_BUSY_RX) && dmarequest)
  {
    huart->RxXferCount = 0x00U;
    UART_EndRxTransfer(huart);
  }

  huart->ErrorCode |= HAL_UART_ERROR_DMA;
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
  /*Call registered error callback*/
  huart->ErrorCallback(huart);
#else
  /*Call legacy weak error callback*/
  HAL_UART_ErrorCallback(huart);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
}

在这里的回调函数中简单测试，如果第一个缓冲区满就输出0，第二个缓冲区满就输出1，

定义两个缓冲区

uint8_t rx_buf[10];
uint8_t rx_buf1[10];

在主函数中调用

​HAL_UART_Receive_DMA_double(&huart1,rx_buf,rx_buf1,10);​

​[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-70TGixxb-1686544064828)(https://assets.b3logfile.com/siyuan/1675829124924/assets/串口发送-20230610194158-8imrwc7.gif)]​

双缓冲基本实现

‍

3.数据转发实现

在上述简单的接收双缓冲实现的情况下，尝试实现将接收到的数据转发出去，首先将双缓冲区的大小设置为10字节，因为在双缓冲发挥作用的场景下，应该是接收大量的数据，只有将缓冲设置的小一点，才能测试在相对于缓冲区大量的数据接收，如果缓冲区就设置1k字节，那我得发多少才算得上是大量呢？

数据转发的原理如下：

  • 首先设置两个发送缓冲区
  • 接收缓冲区1满就将数据复制到发送缓冲区1，接收缓冲区2满就将数据复制到发送缓冲区2
  • 数据复制完毕后，主函数中根据状态控制将准备好的发送缓冲区1或者2通过串口DMA再发送出去
  while (1)
  {
    if (rx_state == 1)//接收缓冲区1完成
    {
      if (tx_state == 2)//发送缓冲区2发送完成
      {
        tx_state_strat = 1;
        tx_state = 0;
        HAL_UART_Transmit_DMA(&huart1,tx_buf,buf_size);//开始发送 发送缓冲区1的数据
      }
    }
    if (rx_state == 2)//接收缓冲区2完成
    {
      if (tx_state == 1)//发送缓冲区1发送完成
      {
        tx_state_strat = 2;
        tx_state = 0;
        HAL_UART_Transmit_DMA(&huart1,tx_buf1,buf_size);//开始发送 发送缓冲区2的数据
      }
    }
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }

上述原理不难理解，看起来也没什么问题，简单测试也没问题，但是在继续增大数据量的时候数据的转发出现了问题。

​image​

数据出现了丢失！！！！！数据量少一点的时候一切正常，数据量超过某个值之后就会稳定的丢20个字节的数据。

接逻辑分析仪进行观察。

​image​

发现在数据传输中途缺失数据。

为了分析执行过程，在双缓冲切换回调函数以及串口DMA发送完成回调函数进行管脚电平翻转，

​image

在1的位置接收缓冲区1满，2的位置是发送缓冲区1发送完毕，3是接受缓冲区2满，4是发送缓冲区2发送完成

​image​

数据变多之后，二者的相位差越来越大，原因是，接收来的数据每个字节的间隔比较短，而转发之后，由于每个字节之间需要执行程序，就会导致两个发送字节之间的间隔比接收的间隔长，这样一直累计起来就会导致发送和接收的相位差越来越大。

​image

最终发送和接收的时间差累计到一个缓冲区接收的时间后，就会导致数据丢失。

​image​

现在这个情况相当于是对接收到的速度进行处理的速度比接收的速度慢，因为波特率相同，而发送数据还需要一段处理的时间，就导致发送速度慢于接收的速度，这样就会导致数据丢失，如果不从根本上提升数据发送的速度，永远会有数据丢失，所以应该换一个串口以更快的波特率发送数据。

增加一个串口，波特率设置为921600，缓冲区仍然为10字节，一次性发送5760字节，转发也没有问题

​image​

​image​

4.总结

接收使用双缓冲，好处是可以使CPU在处理接收到的数据的同时，新的数据接收还可以正常进行。但是也需要保证对数据的处理速度是要比接收的速度快的，否则一定会导致数据丢失。

如果需要接收的数据长度不可知，还需要结合空闲中断实现数据不定长的接收，可以参考http://t.csdn.cn/vFnt8

工程代码已经上传

https://download.csdn.net/download/Master_0_/87897707

‍

‍

参考链接

https://blog.csdn.net/zhang1079528541/article/details/121049656

https://www.sohu.com/a/260229041_807475

https://blog.csdn.net/qq_51368339/article/details/124439407

https://www.cnblogs.com/puyu9499/archive/2022/02/19/15914090.html

https://blog.csdn.net/qq_20553613/article/details/108367512

https://blog.csdn.net/qq_19999465/article/details/81054680

http://t.csdn.cn/XCan6

‍

小李干净又卫生
关注
专栏目录
STM32F4 DMA双缓冲的正确打开方式
04-28
目前STM32家族中有些系列支持DMA的双缓冲模式，比如STM32F2/STM32F4/STM32F7等系列。尤其随着人们对STM32F4/F7系列应用不断拓宽和加深，在设计中运用到DMA双缓冲的场合也越来越多。STM32芯片中的DMA又可分为两大类，一类是通用DMA，一类是专用DMA,比如用于USB,TFT LCD,ETHERNET等外设应用上的DMA。这里要谈的是基于通用DMA的话题，不妨以STM32F4系列芯片为例
STM32 cubemx+串口空闲中断+DMA双缓冲
02-11 3201
STM32 cubemx+串口空闲中断+DMA双缓冲。 之前做过的项目中涉及到采用最小开销来实时接收遥控器数据、能够准确验证传输过来数据的准确性，减小误差率，要求能稳定适用于不同的环境。
STM32F407寄存器操作（DMA双缓冲模式+SPI）
最新发布
weixin_51686526的博客
10-08 720
双缓冲模式几乎是以空间换时间的代表。大家如有类似的需求可以尝试一下。那么OK，还是老样子，我们下篇文章见。
【STM32标准库】DMA双缓冲模式
目标：MVP
07-08 1586
设置DMA_SxCR寄存器的DBM位为1可启动双缓冲传输模式，并自动激活循环模式，所以设置普通模式或者循环模式都可以。双缓冲不应用与存储器到存储器的传输。可以应用在从存储器到外设或者外设到存储器。双缓冲模式下， 两个存储器地址指针都有效，即DMA_SxM1AR寄存器将被激活使用。
【STM32】串口DMA之双缓冲
weixin_45065888的博客
04-20 4202
【STM32】串口DMA之双缓冲 前言 在前两章节中已经讲述了串口的通常用法， 【STM32】CubeMX+HAL库之串口 以及串口DMA空闲中断不定长接收与发送， 【STM32】串口DMA空闲中断不定长收发配自定义装包与解包 在本章节我们将介绍DMA双缓冲这一技术。在很多时候数据的发送频率与数据接收使用频率并不一致，数据来的太快，接收者还没来得及对其进行处理，下一帧的数据就到了，并将其覆盖，致使信息的有效性大大减弱。这时我们增加一个缓冲区来存放来不及处理的数据，就能更好地完成任务。双缓冲还有一个重要的应用
DMA 双缓冲模式
热门推荐
hello world的博客
07-15 1万+
双缓冲区模式 此模式可用于所有 DMA1 和 DMA2 数据流。 1：除了有两个存储器指针之外，双缓冲区数据流的工作方式与常规（单缓冲区）数据流的一样。 2：使能双缓冲区模式时，将自动使能循环模式，并在每次事务结束时交换存储器指针。 3：每次事务结束时， DMA 控制器都从一个存储器目标交换为另一个存储器目标，软件 在处理一个存储器区域的同时， DMA 传输还可以填充/使用第二个存储器...
STM32串口DMA接收双缓冲
DaveDing888的博客
01-03 7369
STM32高端MCU（F4、F7等）才支持DMA双缓冲，低端MCU（F1）不支持DMA双缓冲，不过有替代方案可实现类型效果。 一、MCU支持ＤＭＡ双缓冲的情形 不再赘述，参见博客 STM32 串口DMA发送+DMA接收+硬件双缓冲区切换功能实现 二、MCU不支持ＤＭＡ双缓冲，但可通过DMA传输半完成中断替代，以下代码已在F103上验证通过。 1.先通过STM32CubeMX生成串口初始化代码 串口接收DMA一定要选择Circular模式，并且使能串口接收中断 2.使能空闲中断，空闲中断中取出接收数据 3
STM32串口DMA模式发送&接收实现，高速串口通信（1.5Mbps）不丢数据
11-05
STM32高速串口通信DMA收发实现 测试平台 平台 主频 BSP库 串口 STM32F030C8T6 48MHz 标准库 UART1、UART2 STM32F103ZET6 72MHz 标准库 UART1、UART2 STM32H743XIH6 400MHz HAL/LL库 UART5 STM32F407VCT6 168MHz HAL...
STM32F4 串口（DMA发送接收方式）代码例程
02-26
本代码例程重点探讨了如何利用STM32F4的串口功能，通过DMA（Direct Memory Access，直接内存访问）进行数据的发送和接收。 首先，我们需要理解串口的基本概念。串口是一种同步串行通信接口，它一次传输一个比特位，...
STM32串口DMA双缓冲
06-12
在STM32的HAL库中，提供了对串口DMA双缓冲的支持。开发者需要配置两个不同的DMA流，分别对应串口的发送和接收，并设定适当的缓冲大小。当一个缓冲区的数据传输完成后，HAL库会自动切换到另一个缓冲区，同时触发回调...
stm32 usart DMA 双缓冲区 发送AT指令
10-30
1.stm32f4用串口usart1+DMA双缓冲区循环发送AT指令然后控制Zigbee组网
STM32F429 ADC 双缓冲DMA 中断
01-29
原子ADC基础上，STM32ADC采集反馈电压，实现通过双缓冲DMA搬运数据。
dma接收双缓存 stm32_利用DMA双缓冲或半完成中断实现串口不定长数据的接收
weixin_39564510的博客
12-19 2483
在《HAL版本DMA循环模式串口数据收发》中介绍了利用DMA循环模式进行串口数据的收发，STM32F4xx的DMA还提供了双缓冲的功能，采用双缓冲模式，可以在一个DMA完成接收后，对其缓冲区内数据进行处理的过程中，将此时接收到的数据放入第二个DMA缓冲区。双缓冲模式尤其对高速数据接收有着明显的优势，本文以上述循环接收方案为基础，提供实现双缓冲接收数据的实现方式。首先，从寄存器的角度讲，要实现双缓冲...
DMA双缓冲
weixin_43527214的博客
03-07 915
举个例子很容易理解： 比如一条流水线上有一个工人在处理产品，正常情况下进来一个产品工人处理一个，没啥问题，但是如果产品进来的速度太快，工人来不及处理，就会导致有很多产品漏处理，会产生很大问题。 现在工人就是CPU, 产品就是要处理的数据，流水线就是DMA, DMA不断的把数据从外设搬到内存供CPU处理，众所周知，DMA的速度是很快的，当外设数据量很大的时候，CPU来不及处理，就会丢失数据， 这时...
stm32f407 6个串口dma_stm32之DMA
weixin_39608457的博客
11-26 1447
　　一. 对于大容量的STM32芯片有2个DMA控制器，控制器1有7个通道，控制器2有5个通道　　每个通道都可以配置一些外设的地址。　　二. 通道的配置过程：　　1. 首先设置CPARx寄存器和CMARx寄存器。　　通过DMA控制器把一个地址的值复制到另外一个地址，通过DMA控制器自动开启一条通道完成。　　CPARx寄存器存放的是外设的地址　　CMARx寄存器存储的是存储器的地址　　2. 设置数据...
stm32f103之DMA双缓冲
maosm007的博客
12-19 5915
出处：http://www.cnblogs.com/polar-lights/p/9211560.html #include "sys.h" #include "usart.h"      #include "string.h" #include "stdio.h" #include "stdlib.h" //蓝牙 ///////////////////////////////////////...
dma接收双缓存 stm32_基于stm32的双缓冲的实现
weixin_39713814的博客
12-19 469
最终编辑405087695终于开荤了~~~DMA先抄一小段DMA的说明。对于没玩过DMA的朋友,这里简单说一下DMA,用自己的语言说吧,那就是,从某个位置传输数据到某个位置,如果不用DMA,那要CPU参与操作,一个字节一个字节地搬,效率高点的,就一个字一个字地搬.但当你用了DMA后,那就是只需要设置:A.从哪里开始搬;B,搬到哪里去;C以字节方式搬还是半字还是字;D:一共搬多少个.之后,启动DM...
HAL_DMAEx_MultiBufferStart_IT
09-16
HAL_DMAEx_MultiBufferStart_IT 是一个双缓冲DMA函数，用于启动多缓冲传输。在使用该函数之前，需要设置相应的回调函数。在代码中，通过调用 HAL_DMA_Abort_IT 函数来停止之前的传输，并重新初始化 DMA。然后，通过调用 HAL_DMAEx_MultiBufferStart_IT 函数来启动多缓冲传输，将数据从 audio_buf 和 audio_buf 传输到 hi2s3 寄存器的 DR 寄存器中。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值