stm32串口+DMA环形缓冲收发保姆级

已于 2023-04-09 12:48:17 修改
阅读量4.2k 收藏 68
点赞数 16
分类专栏： STM32cubeMX+HAL库 文章标签： stm32 单片机 vscode c语言
于 2023-04-09 12:42:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Porter_007/article/details/130040455
版权

基于HAL库的STM32串口DMA环形缓冲收发实例

首先在此感谢开源项目，以及大佬们的无私奉献，让每一个逐梦人能够免费学习，再次感谢！
发布只为记录，记性不够，笔记来凑。记得点赞哦
具体实现原理讲起来确实挺复杂，不过用起来还是很NICE的！可以直接移植！

1、STM32CubeMax配置

1.1、选择单片机型号
在这里插入图片描述

2、配置时钟和串口

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

或者直接在HCLK位置输入72，点击OK自动配置

在这里插入图片描述
在这里插入图片描述

这个地方第四步，模式选择MODE。发送选择正常NOMAL.接收RX选择循环模式，第五步，外设地址不自增，存储器地址自增勾选

数字长度选择字节模式byte

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

此处必须使能UART，原因后面会提到

然后点击生成文件就行。如果用的keil，则直接点击Open Project，如果用的VSCODE，选择打开文件夹Open folder

在这里插入图片描述

在这里插入图片描述

到这个页面后点击MDK_ARM,就是生成的文件

然后返回上一层，右击，选择打开方式，为通过code打开，


在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
右击，选择新建文件夹在这里插入图片描述

新建文件夹BSP 和bsp_usart.h和bsp_usart.c

将文件夹拖到目录栏

在这里插入图片描述

在这里插入图片描述

将刚才的两个文件夹路径放进来在这里插入图片描述

至此，所有的构建操作已经全部完成，剩下的就是程序编辑

为了方便打印调试，引用printf打印输出，引入fputc,添加头文件#include “stdio.h”

#include "stdio.h"
int fputc(int ch, FILE *f)
{
    // while((USART1->SR&0X40)==0);//循环发送,直到发送完毕
    // USART1->DR = (unsigned char) ch;
    HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 100);
    return ch;
}

huart1结构体句柄由系统自动生成


保姆级的提示到这一步结束，要是不会用就直接调用吧，下来可能就是关键步骤，不会这么详细的讲，至于如何使用这些引入的函数，点击这个链接

定义数组，用来存放发送的数据

#define UART1_RX_RB_LEN (128u)

uint8_t usart1_tx_rb_data[128];
uint8_t usart1_rx_rb_data[UART1_RX_RB_LEN];

绑定结构体指针BUFF和定义的实体数组

lwrb_init(&usart1_tx_rb, usart1_tx_rb_data, ARRAY_LEN(usart1_tx_rb_data));
lwrb_init(&usart1_rx_rb, usart1_rx_rb_data, ARRAY_LEN(usart1_rx_rb_data));

2、发送环节

​ 为了移植方便，使底层逻辑不暴露，引入发送函数，方便外部调用

void USART1_SendData(const uint8_t *p_data, uint16_t len)
{
    lwrb_write(&usart1_tx_rb, p_data, len); /* Write data to TX buffer for loopback */
    USART1_Start_DmaTx();
}

void USART1_Sendstring(const char *str)
{
    lwrb_write(&usart1_tx_rb, str, strlen(str)); /* Write data to TX buffer for loopback */
    USART1_Start_DmaTx();

}

真正的发送函数处理

uint8_t USART1_Start_DmaTx(void)
{
    uint32_t primask;
    uint8_t started = 0;

    primask = __get_PRIMASK();
    __disable_irq();
    if (usart1_tx_dma_current_len == 0
            && (usart1_tx_dma_current_len = lwrb_get_linear_block_read_length(&usart1_tx_rb)) > 0) 
    {
        __HAL_DMA_DISABLE(&hdma_usart1_tx);
         
        __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx
            , __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_usart1_tx));
        __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx
            , __HAL_DMA_GET_HT_FLAG_INDEX(&hdma_usart1_tx));
        __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx
            , __HAL_DMA_GET_TE_FLAG_INDEX(&hdma_usart1_tx));
        __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx
            , __HAL_DMA_GET_GI_FLAG_INDEX(&hdma_usart1_tx));

        HAL_UART_Transmit_DMA(&huart1
            , (uint8_t*)lwrb_get_linear_block_read_address(&usart1_tx_rb)
            , (uint16_t)usart1_tx_dma_current_len);
        started = 1;
    }
    __set_PRIMASK(primask);
    
    return started;
}

发送完成后触发中断,跳过当前已经有的长度，然后再次进入发送状态，判断缓冲区中是否还存在数据，如果有进入IF语句，如果没有，返回started = 0;此时发送形成一个循环发送和检测

void USART1_TxTcCb(UART_HandleTypeDef *huart)
{
        lwrb_skip(&usart1_tx_rb, usart1_tx_dma_current_len);/* Skip sent data, mark as read */
        usart1_tx_dma_current_len = 0;           /* Clear length variable */
        USART1_Start_DmaTx();          /* Start sending more data */
}

3、接收环节

HAL_UARTEx_ReceiveToIdle_DMA(&huart1, usart1_rx_dma_buffer, ARRAY_LEN(usart1_rx_dma_buffer));

利用此函数可以接受数据，直至触发IDLE空闲中断，具体细节点击函数查看，不在此赘述

此时会产生三种情况，接受一半中断。接受溢出中断和接收完成后空闲中断

如果自己注册回调函数则，会调用自己的回调函数，不然则为系统默认回调函数

不会的可以参考此篇注册串口回调函数

//注册回调事件
HAL_UART_RegisterRxEventCallback(&huart1, USART1_RxEventCb);

HAL_UART_RegisterCallback(&huart1, HAL_UART_TX_COMPLETE_CB_ID, USART1_TxTcCb);

产生回调后，进入回调函数，可以自定义一些回调处理和动作

//接受半个缓冲区完成回调函数
void USART1_DMA_RxHtCb( DMA_HandleTypeDef * p_hdma)
{
    UNUSED(p_hdma);

    USART1_RxEventCheck();
}

//接收完成回调函数
void USART1_DMA_RxTcCb( DMA_HandleTypeDef * p_hdma)
{
    UNUSED(p_hdma);
    
    USART1_RxEventCheck();
	usart1_rx_flag = 1;
}

/*!< UART Reception Event Callback     */
void USART1_RxEventCb(struct __UART_HandleTypeDef *huart, uint16_t pos)
{
    UNUSED(huart);
    UNUSED(pos);
    
    USART1_RxEventCheck();
}

对回调事件进行检查分析，看是那种情况，具体参考大佬文章

在这里插入图片描述

共有这么几种情况：

  • 情况A：缓冲区为空W == R = 0 == 0

  • 情况B：缓冲区将字节保存为W - R = 4 - 0 = 4``W > R

  • Case C : 缓冲区已满or orW == R - 1``7 == 0 - 1``7 = (0 - 1 + S) % S = (0 - 1 + 8) % 8 = (-1 + 8) % 8 = 7

    • R并且W可以保存S不同的值，从0到，即模数S - 1``S
    • 缓冲区将字节保存为W - R = 7 - 0 = 7``W > R

  • 情况D：缓冲区将字节保存为S - (R - W) = 8 - (5 - 3) = 6``R > W

  • 情况E：缓冲区已满为( ) 并保存字节W == R - 1``4 = 5 - 1``S - (R - W) = 8 - (5 - 4) ) = 7}

void USART1_RxEventCheck(void)
{
    static uint16_t old_pos;
    uint16_t pos;
    
    /* Calculate current position in buffer and check for new data available */
    //检查缓冲区中已用长度
    pos = ARRAY_LEN(usart1_rx_dma_buffer) - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
    if (pos != old_pos) 
    {    /* Check change in received data */
        if (pos > old_pos) 
        { /* Current position is over previous one */
            /*
             * Processing is done in "linear" mode.
             *
             * Application processing is fast with single data block,
             * length is simply calculated by subtracting pointers
             *
             * [   0   ]
             * [   1   ] <- old_pos |------------------------------------|
             * [   2   ]            |                                    |
             * [   3   ]            | Single block (len = pos - old_pos) |
             * [   4   ]            |                                    |
             * [   5   ]            |------------------------------------|
             * [   6   ] <- pos
             * [   7   ]
             * [ N - 1 ]
             */

            lwrb_write(&usart1_rx_rb, &usart1_rx_dma_buffer[old_pos], pos - old_pos);
        } 
        else 
        {
            /*
             * Processing is done in "overflow" mode..
             *
             * Application must process data twice,
             * since there are 2 linear memory blocks to handle
             *
             * [   0   ]            |---------------------------------|
             * [   1   ]            | Second block (len = pos)        |
             * [   2   ]            |---------------------------------|
             * [   3   ] <- pos
             * [   4   ] <- old_pos |---------------------------------|
             * [   5   ]            |                                 |
             * [   6   ]            | First block (len = N - old_pos) |
             * [   7   ]            |                                 |
             * [ N - 1 ]            |---------------------------------|
             */
            lwrb_write(&usart1_rx_rb, &usart1_rx_dma_buffer[old_pos], ARRAY_LEN(usart1_rx_dma_buffer) - old_pos);
            
            if (pos > 0) 
            {
                lwrb_write(&usart1_rx_rb, &usart1_rx_dma_buffer[0], pos);
            }
        }
         old_pos = pos; /* Save current position as old for next transfers */
		usart1_rx_flag = 1;

    }
}

当标志位置一后，对读取到的数据进行处理,此时传进来的数据需要我们自行进行拼接，比如上述情况E，发送的数据存到了两端，这样需要先将后面的读出来，再加上前面的

void USART1_ProcessData(void)
{
    uint8_t data[UART1_RX_RB_LEN];
    uint16_t len1 = lwrb_get_linear_block_read_length(&usart1_rx_rb);
    printf("len1 = %d\r\n", len1);
    if (len1 > 0) 
    {
        printf("lwrb_read(&usart1_tx_rb, data, len1) = %d\r\n"
            , lwrb_read(&usart1_rx_rb, data, len1));
        uint16_t len2 = lwrb_get_linear_block_read_length(&usart1_rx_rb);
        printf("len2 = %d\r\n", len2);
        if (len2 > 0)
        {
            printf("lwrb_read(&usart1_tx_rb, &data[len1], len2) = %d\r\n"
                , lwrb_read(&usart1_rx_rb, &data[len1], len2));
        }
        // 进行data进行处理

        // 处理usart1_rx_rb的一些东西
        lwrb_write(&usart1_tx_rb
            , data
            , len1 + len2); /* Write data to TX buffer for loopback */  

        USART1_Start_DmaTx();
    }
}

再main函数中对标志位进行处理，

int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  HAL_Delay(50);
  USART1_Init();
  printf("stm32f103rct6_uart_dma_loopback_test!\r\n");
  // uint8_t str[] = "USART1_Init\r\n";
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    if (usart1_rx_flag == 1)
    {
      usart1_rx_flag = 0;
      // printf("usart1_rx_flag = 1\r\n");
      USART1_ProcessData();
    }
    HAL_Delay(1000);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

下面附上BSP_USART.c完整代码，


#include "bsp_usart.h"
#include "usart.h"
#include "dma.h"

#define UART1_RX_DMA_BUFFER_LEN (20u)
#define UART1_RX_RB_LEN (128u)

lwrb_t usart1_rx_rb;// Ring buffer instance for TX data
lwrb_t usart1_tx_rb;// Ring buffer instance for TX data

uint8_t usart1_rx_dma_buffer[UART1_RX_DMA_BUFFER_LEN];
uint8_t usart1_rx_rb_data[UART1_RX_RB_LEN];// Ring buffer data array for RX DMA
uint8_t usart1_tx_rb_data[128];// Ring buffer data array for TX DMA

volatile size_t usart1_tx_dma_current_len;// Length of currently active TX DMA transfer
volatile uint8_t usart1_rx_flag;

int fputc(int ch, FILE *f)
{

    HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 100);

    return ch;
}

uint8_t USART1_Start_DmaTx(void)
{
    uint32_t primask;
    uint8_t started = 0;
    
    primask = __get_PRIMASK();
    __disable_irq();

    if (usart1_tx_dma_current_len == 0
            && (usart1_tx_dma_current_len = lwrb_get_linear_block_read_length(&usart1_tx_rb)) > 0) 
    {
        __HAL_DMA_DISABLE(&hdma_usart1_tx);

        __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx
            , __HAL_DMA_GET_TC_FLAG_INDEX(&hdma_usart1_tx));
        __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx
            , __HAL_DMA_GET_HT_FLAG_INDEX(&hdma_usart1_tx));
        __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx
            , __HAL_DMA_GET_TE_FLAG_INDEX(&hdma_usart1_tx));
        __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx
            , __HAL_DMA_GET_GI_FLAG_INDEX(&hdma_usart1_tx));

        HAL_UART_Transmit_DMA(&huart1
            , (uint8_t*)lwrb_get_linear_block_read_address(&usart1_tx_rb)
            , (uint16_t)usart1_tx_dma_current_len);

        started = 1;
    }
    __set_PRIMASK(primask);
    
    return started;
}

void USART1_DMA_RxHtCb( DMA_HandleTypeDef * p_hdma)
{
    UNUSED(p_hdma);
    
    USART1_RxEventCheck();
}

//接收完成回调函数
void USART1_DMA_RxTcCb( DMA_HandleTypeDef * p_hdma)
{
    UNUSED(p_hdma);
    
    USART1_RxEventCheck();
	usart1_rx_flag = 1;
}

void USART1_RxEventCb(struct __UART_HandleTypeDef *huart, uint16_t pos)
{
    UNUSED(huart);
    UNUSED(pos);

    USART1_RxEventCheck();
}

// 串口1发送完成回调
void USART1_TxTcCb(UART_HandleTypeDef *huart)
{
        lwrb_skip(&usart1_tx_rb, usart1_tx_dma_current_len);	/* Skip sent data, mark as read */
        usart1_tx_dma_current_len = 0;          			   /* Clear length variable */
        USART1_Start_DmaTx();         					       /* Start sending more data */
}

void USART1_Init(void)
{
    lwrb_init(&usart1_tx_rb, usart1_tx_rb_data, ARRAY_LEN(usart1_tx_rb_data));
    lwrb_init(&usart1_rx_rb, usart1_rx_rb_data, ARRAY_LEN(usart1_rx_rb_data));

    HAL_UARTEx_ReceiveToIdle_DMA(&huart1, usart1_rx_dma_buffer, ARRAY_LEN(usart1_rx_dma_buffer));
    HAL_UART_RegisterRxEventCallback(&huart1, USART1_RxEventCb);
    HAL_UART_RegisterCallback(&huart1, HAL_UART_TX_COMPLETE_CB_ID, USART1_TxTcCb);
}

// void USART1_RxEventCheck(uint16_t pos)
void USART1_RxEventCheck(void)
{
    static uint16_t old_pos;
    uint16_t pos;
    
    /* Calculate current position in buffer and check for new data available */
    //检查缓冲区中已用长度
    pos = ARRAY_LEN(usart1_rx_dma_buffer) - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
    // printf("old_pos = %d, pos = %d\r\n", old_pos, pos);
    if (pos != old_pos) 
    {    /* Check change in received data */
        if (pos > old_pos) 
        { /* Current position is over previous one */
            /*
             * Processing is done in "linear" mode.
             *
             * Application processing is fast with single data block,
             * length is simply calculated by subtracting pointers
             *
             * [   0   ]
             * [   1   ] <- old_pos |------------------------------------|
             * [   2   ]            |                                    |
             * [   3   ]            | Single block (len = pos - old_pos) |
             * [   4   ]            |                                    |
             * [   5   ]            |------------------------------------|
             * [   6   ] <- pos
             * [   7   ]
             * [ N - 1 ]
             */

            lwrb_write(&usart1_rx_rb, &usart1_rx_dma_buffer[old_pos], pos - old_pos);
        } 
        else 
        {
            /*
             * Processing is done in "overflow" mode..
             *
             * Application must process data twice,
             * since there are 2 linear memory blocks to handle
             *
             * [   0   ]            |---------------------------------|
             * [   1   ]            | Second block (len = pos)        |
             * [   2   ]            |---------------------------------|
             * [   3   ] <- pos
             * [   4   ] <- old_pos |---------------------------------|
             * [   5   ]            |                                 |
             * [   6   ]            | First block (len = N - old_pos) |
             * [   7   ]            |                                 |
             * [ N - 1 ]            |---------------------------------|
             */

            lwrb_write(&usart1_rx_rb, &usart1_rx_dma_buffer[old_pos], ARRAY_LEN(usart1_rx_dma_buffer) - old_pos);
            
            if (pos > 0) 
            {
            
                lwrb_write(&usart1_rx_rb, &usart1_rx_dma_buffer[0], pos);
            }
        }
        old_pos = pos; /* Save current position as old for next transfers */
	    usart1_rx_flag = 1;
    }
}

void USART1_ProcessData(void)
{
    uint8_t data[UART1_RX_RB_LEN];
    uint16_t len1 = lwrb_get_linear_block_read_length(&usart1_rx_rb);
    printf("len1 = %d\r\n", len1);
    if (len1 > 0) 
    {
        printf("lwrb_read(&usart1_tx_rb, data, len1) = %d\r\n"
            , lwrb_read(&usart1_rx_rb, data, len1));
        uint16_t len2 = lwrb_get_linear_block_read_length(&usart1_rx_rb);
        printf("len2 = %d\r\n", len2);
        if (len2 > 0)
        {
            printf("lwrb_read(&usart1_tx_rb, &data[len1], len2) = %d\r\n"
                , lwrb_read(&usart1_rx_rb, &data[len1], len2));
        }
        // 进行data进行处理

        // 处理usart1_rx_rb的一些东西
        lwrb_write(&usart1_tx_rb
            , data
            , len1 + len2); /* Write data to TX buffer for loopback */  

        USART1_Start_DmaTx();
    }
}

void USART1_SendData(const uint8_t *p_data, uint16_t len)
{
    lwrb_write(&usart1_tx_rb, p_data, len); /* Write data to TX buffer for loopback */
    USART1_Start_DmaTx();
}

void USART1_Sendstring(const char *str)
{

    lwrb_write(&usart1_tx_rb, str, strlen(str)); /* Write data to TX buffer for loopback */
    USART1_Start_DmaTx();

}

BSP_USART_H文件

#ifndef __BSP_USART_H__
#define __BSP_USART_H__

#include "main.h"
#include "stdio.h"
#include "lwrb.h"

#define ARRAY_LEN(x)            (sizeof(x) / sizeof((x)[0]))


extern UART_HandleTypeDef huart1;
extern DMA_HandleTypeDef hdma_usart1_rx;
extern DMA_HandleTypeDef hdma_usart1_tx;
extern volatile size_t usart1_tx_dma_current_len;
extern volatile uint8_t usart1_rx_flag;

void USART1_Init(void);
void USART1_ProcessData(void);
void USART1_SendData(const uint8_t *p_data, uint16_t len);
void USART1_Sendstring(const char* str);










#endif // ! __BSP_USART_H__

lwrb文件链接

#ifndef __BSP_USART_H__
#define __BSP_USART_H__

#include "main.h"
#include "stdio.h"
#include "lwrb.h"

#define ARRAY_LEN(x)            (sizeof(x) / sizeof((x)[0]))


extern UART_HandleTypeDef huart1;
extern DMA_HandleTypeDef hdma_usart1_rx;
extern DMA_HandleTypeDef hdma_usart1_tx;
extern volatile size_t usart1_tx_dma_current_len;
extern volatile uint8_t usart1_rx_flag;

void USART1_Init(void);
void USART1_ProcessData(void);
void USART1_SendData(const uint8_t *p_data, uint16_t len);
void USART1_Sendstring(const char* str);


#endif // ! __BSP_USART_H__


lwrb文件[链接](https://github.com/MaJerle/lwrb)

git[下载链接](https://github.com/MaJerle/lwrb.git)
小马_666
关注
  • 16
    点赞
  • 踩
  • 68
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
STM32环形串口队列程序 大数据串口收发 实时不丢包
sFakAKfmo的博客
01-04 1532
摘要：本文介绍了一种基于STM32的环形串口队列程序，该程序能够实现大数据量的串口收发，采用中断接收、边收边发的方式，并采用大数据环形队列来处理数据，保证了处理过程的高效性和数据的完整性。为了解决这些问题，本文提出了一种基于STM32的环形串口队列程序，通过充分利用中断接收和大数据环形队列，实现了大数据量的串口收发，并保证了实时性和数据的完整性。同时，通过使用大数据环形队列，可在保证数据实时性的前提下，避免数据丢失的问题，提高了数据的可靠性。该队列采用循环的方式存储数据，在读写数据时避免了数据覆盖的问题。
STM32+RS485+DMA+modbus协议
01-29
STM32F103zet6芯片 进行modbus协议代码的编写 使用DMA进行数据发送和接收 主机读取多个从机的n个寄存器数据 主机向从机的1个寄存器中写入数据
STM32串口接收不定长数据（空闲中断+DMA）
码到成功
12-04 4293
前文已经提到，当接收到一字节数据时，会触发接收中断，对应串口状态寄存器第 5 位被置 1；如果串口在空闲时，则会触发空闲中断，第 4 位被置 1 ，如下图所示：在中断服务函数里，记得一定要清除 IDLE 位，否则将一直触发空闲中断，影响后续的业务处理。令人头秃的描述：DMA（Direct Memory Access，直接存储器访问）提供在外设与内存存储器和存储器外设与外设之间的高速数据传输使用。它允许不同速度的硬件装置来沟通，而不需要依赖于 CPU ，在这个时间中，CPU 对于内存的工作来说就无法使用。
【STM32+HAL+Proteus】系列学习教程---串口USART（DMA 方式）定长，不定长收发。
最新发布
面包板扎的专栏
04-16 1303
DMA（Direct Memory Access）直接内存访问。
STM32速成笔记—DMA
qq_45217381的博客
06-22 4588
本文介绍了DMA的概念，用途。对于STM32F103ZET6的DMA做出了详细地介绍，给出了DMA配置步骤。最后，以配置DMA搬运ADC转换结果为例，给出了DMA的配置和使用方法。
STM32串口通信DMA方式
weixin_51002159的博客
09-02 2756
STM32串口通信DMA方式
STM32—DMA使用
自我升级中
01-23 1343
DMA是指外部设备不通过CPU而直接与系统内存交换数据的接口技术。为了好理解，可以称之为只能传输数据的CPU。
65 STM32F0系列 串口DMA循环接收实验记录
Chasing_Chasing的博客
04-01 3585
1.引言 最近因为中断冲突问题，导致串口接收数据时随机丢失一两个字节。无奈串口的中断优先级不能是最高的，所以中断冲突问题明显存在，因此需要串口使用DMA方式来接收数据，从而规避串口接收数据丢失问题。 2.DMA配置经验 首次使用dma，需要了解一下dma的知识。 1.首先最重要要了解的一点就是，dma接收数据一定要接收到指定长度的数据，或指定长度的一半数据才能产生接收中断，如果数据没有达到一半或指定长度，就无法产生dma接收数据通知。 ...
【STM32笔记】STM32的串口数据收发基础（四）（USART DMA模式）
m0_49126759的博客
10-10 3284
在STM32中编写串口通信数据收发有三种方式：轮询模式（阻塞方式），中断模式（非阻塞方式）以及DMA模式。
STM32串口+DMA+环形FIFO例程 freertos.rar
08-10
stm32 串口+DMA+环形FIFO缓存收发数基本例程， 仅供参考 freertos环境，其他环境类推
STM32H7串口+DMA双缓存配置文件
04-13
基于STM32H7的双缓存配置方案，串口+DMA，该方法可以用作其他的方式加DMA，同时配合本人写的博客可以更加容易理解如何配置，该文档为单纯的串口+DMA双缓存配置，用户可以自己加上一个任务进行测试。
STM32开发项目：处理串口溢出中断(ORE)
01-06
问题表现 在MCU系统负载较重、串口收发数据频率很高、多个中断存在（如同时有定时器更新中断、外部中断、DMA中断、串口接收中断）的情况下，容易出现串口溢出错误（ORE）。该错误的主要显现形式是：程序莫名卡死在串口中断之中（单片机失去响应）。 解决方法 ORE标志位在USART_SR寄存器，当我们打开串口接收中断时，同时也就打开了ORE中断，串口的overload错误会导致程序反复进入串口中断服务程序。在中断服务程序中增加处理overload的处理，顺序执行对USART_SR和USART_DR寄存器的读操作可以复位ORE位，以防止程序反复进入串口中断服务程序。示例代码如下： 在STM32中断函数
STM32_HAL+串口+DMA发送和不定长度数据接收
08-15
STM32_HAL+串口+DMA发送和接收,可做项目研发，串口用DMA发送和接收，减轻CPU负担。
stm32+adc+dma+独立模式+双重模式+内部通道获取温度
01-08
共包含STM32的6个程序文件 1-stm32+ADC电压采集-...2-stm32+ADC采集电压-DMA形式读取 3-stm32+ADC+独立模式+DMA+6通道 4-STM32+ADC+DMA+双重模式 5-STM32+ADC+DMA+双重模式-多通道 6-STM32+ADC+DMA+内部通道获取温度
七、Stm32学习-DMA-循环模式与非循环模式
Xia996的博客
01-03 2700
DMA是可以直接访问stm32的所有存储器，例如Flash，SRAM等。所以你通过CPU配置了DMA，它就可以自动去各个外设搬运数据到指定的地方，CPU就不用来做这搬运数据的活了，只需要在指定的地方读取CPU所需要的数据即可。Flash一般是只读，如果要将程序写入Flash，还需要先擦除页，再写入，这是另外一部分内容。然后还要将Boot引脚置对应的高低电平。这些在手册中都能找到。
在STM32F4上使用串口DMA接收的配置
csaaa2005的专栏
06-01 1206
由于发——收——发——收的方式一般都是不定长的数据，所以使用DMA的定长接收并不合适。上述方法适用于，接收的字符在发送方能确保不会超时的场合，比如不使用操作系统的单片机等。有个项目使用到了STM32F4的DMA，我从F1的代码移植过来做了一些修改，以适配F4对应函数的一些差异。2.发送使用原库函数，未使用DMA，接收过程为了减少对中断的调用，使用了DMA向缓冲区写数据，并在接收时使用空闲中断来判断接收帧的结束。1.使用F4的串口1 和其他设备进行1发1收的异步通信，即发——收——发——收这种形式的通信。
【嵌入式学习-STM32F103-DMA】
weixin_43251807的博客
03-15 2598
参考爱上半导体和江科大视频资料学习DMA
基于STM32L431+Liteos的串口空闲中断加DMA循环接收
狂想家
02-17 1179
串口空闲中断加DMA循环接收。
STM32F103 USART1串口使用DMA接收不定长数据和DMA中断发送
ba_wang_mao的专栏
11-09 5120
STM32F103 USART1串口使用DMA接收不定长数据和DMA中断发送
stm32 rs485+dma软件收发
06-06
STM32是一种高性能的32位微控制器，拥有丰富的外设资源和DMA技术，适合于各种应用场合。RS485是一种串行通信协议，可以用于远距离传输数据。在STM32上使用RS485协议进行通信，通常需要使用软件实现收发。而利用DMA技术可以提高数据传输效率，减轻CPU负担。 STM32提供了丰富的串口外设资源，包括USART、UART、SPI等。其中，USART支持RS485模式，可以方便地实现RS485通信，而UART则需要通过软件实现。在软件实现RS485收发时，通常采用半双工方式，即同一时刻只能进行发送或接收。为了实现快速、可靠的数据传输，可以使用DMA技术。 DMA（Direct Memory Access）直接存储器访问技术是一种硬件加速技术，可以使外设在不经过CPU的干预下将数据直接传输到内存中，或者将内存中的数据直接传输到外设中。在RS485通信中，可以使用DMA技术来实现数据缓存、数据收发等功能，从而提高数据传输效率和CPU利用率。 使用STM32进行RS485 DMA软件收发，通常需要完成以下步骤： 1.配置串口外设资源，包括USART或UART的初始化，波特率、数据位、停止位、校验位等设置。 2.配置DMA外设资源，包括DMA通道、数据传输方向、数据长度、传输模式（单次传输或循环传输）、中断控制器等设置。 3.实现DMA传输完成中断处理函数，以便在数据传输完成后对数据进行处理或者进行下一步操作。 4.在应用程序中实现接收数据和发送数据的功能，包括数据的缓存、传输、校验和处理等。 5.使用半双工模式进行数据收发，以避免数据冲突和数据丢失等问题。 以上就是STM32 RS485 DMA软件收发的基本实现方法。使用DMA技术可以有效地提高数据传输效率，减轻CPU负担，避免数据丢失和冲突等问题，适用于对数据传输效率有较高要求的应用场合。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值