gd32 串口DMA发送&双缓冲接收不定长数据例程

于 2024-08-02 21:27:34 发布
阅读量196 收藏
点赞数 3
分类专栏： gd32 文章标签： 嵌入式硬件 单片机 mcu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43026921/article/details/140880636
版权

main.c

/*!
    \file    main.c
    \brief   running LED

    \version 2023-03-31, V1.0.0, firmware for GD32H7xx
*/

/*
    Copyright (c) 2023, GigaDevice Semiconductor Inc.

    Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

    1. Redistributions of source code must retain the above copyright notice, this
       list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright notice,
       this list of conditions and the following disclaimer in the documentation
       and/or other materials provided with the distribution.
    3. Neither the name of the copyright holder nor the names of its contributors
       may be used to endorse or promote products derived from this software without
       specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/

#include "gd32h7xx.h"
#include "systick.h"

#include "string.h"
#include "stdio.h"
#include "circular_buffer.h"


#define USART_DMA_TRANSFER_SIZE 4096

__attribute__ ((aligned(32))) uint8_t usart_rx_buff0[USART_DMA_TRANSFER_SIZE] = {0};
__attribute__ ((aligned(32))) uint8_t usart_rx_buff1[USART_DMA_TRANSFER_SIZE] = {0};
__attribute__ ((aligned(32))) uint8_t circular_buffer_data[USART_DMA_TRANSFER_SIZE] = {0};


struct circular_buffer_t circular_buffer;


volatile static int rx_buff_select = 0;

uint8_t* get_rx_buff()
{
    if (rx_buff_select) return usart_rx_buff0;
    else return usart_rx_buff1;
}

uint8_t* get_next_rx_buff()
{
    rx_buff_select = !rx_buff_select;
    return get_rx_buff();
}


/*!
    \brief      enable the CPU Chache
    \param[in]  none
    \param[out] none
    \retval     none
*/
static void cache_enable(void)
{
    /* Enable I-Cache */
    SCB_EnableICache();

    /* Enable D-Cache */
//    SCB_EnableDCache();
}

void led_config()
{
    rcu_periph_clock_enable(RCU_GPIOJ);

    gpio_mode_set(GPIOJ, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_8);
    gpio_output_options_set(GPIOJ, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_8);

    gpio_mode_set(GPIOJ, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_9);
    gpio_output_options_set(GPIOJ, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_9);

    gpio_bit_set(GPIOJ, GPIO_PIN_8);
    gpio_bit_set(GPIOJ, GPIO_PIN_9);

}

void clock_config()
{
    rcu_system_clock_source_config(RCU_CKSYSSRC_IRC64MDIV);
    rcu_deinit();

    rcu_osci_on(RCU_HXTAL); //开启外部时钟
    rcu_osci_stab_wait(RCU_HXTAL); //等待外部时钟稳定 25MHZ

    rcu_ahb_clock_config(RCU_AHB_CKSYS_DIV2); //AHB 300MHz
    rcu_apb1_clock_config(RCU_APB1_CKAHB_DIV2); //APB1 150MHz
    rcu_apb2_clock_config(RCU_APB2_CKAHB_DIV1); //APB2 300MHz
    rcu_apb3_clock_config(RCU_APB3_CKAHB_DIV2); //APB3 150MHz
    rcu_apb4_clock_config(RCU_APB4_CKAHB_DIV2); //APB4 150MHz

    rcu_pll_source_config(RCU_PLLSRC_HXTAL); //选择外部高速时钟源 25MHz

    rcu_pll0_config(1, 24, 1, 1, 1); //PLL0P 600MHz
    rcu_pll_clock_output_enable(RCU_PLL0P | RCU_PLL0Q | RCU_PLL0R); //PLL0输出使能

    RCU_CTL |= RCU_CTL_PLL0EN; //PLL0 使能

    rcu_osci_stab_wait(RCU_PLL0_CK); //等待PLL0稳定

    rcu_system_clock_source_config(RCU_CKSYSSRC_PLL0P); //CK_SYS 600MHz
    SystemCoreClock = 600 * 1000 * 1000; //600MHz
}

void usart_config()
{
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_USART0);

    nvic_irq_enable(USART0_IRQn, 2, 2);

    gpio_af_set(GPIOB, GPIO_AF_7, GPIO_PIN_6);
    gpio_af_set(GPIOB, GPIO_AF_7, GPIO_PIN_7);

    gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_6);
    gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_6);

    gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_7);
    gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_7);

    usart_deinit(USART0);
    usart_word_length_set(USART0, USART_WL_8BIT);
    usart_stop_bit_set(USART0, USART_STB_1BIT);
    usart_parity_config(USART0, USART_PM_NONE);
    usart_baudrate_set(USART0, 921600U);
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
    usart_interrupt_enable(USART0, USART_INT_IDLE);
    usart_enable(USART0);
}

void usart_transmit(char* buff, int size)
{
    for (int i = 0; i < size; ++i) {
        usart_data_transmit(USART0, buff[i]);
        while (RESET == usart_flag_get(USART0, USART_FLAG_TBE)) {}
    }
}


void usart_transmit_dma(char* buff, int size)
{
    dma_memory_address_config(DMA0, DMA_CH0, DMA_MEMORY_0, buff);
    dma_transfer_number_config(DMA0, DMA_CH0, size);
    dma_channel_enable(DMA0, DMA_CH0);
}


void dma_config()
{
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMAMUX);
    nvic_irq_enable(DMA0_Channel0_IRQn, 2, 1);
    nvic_irq_enable(DMA0_Channel1_IRQn, 2, 0);

    dma_single_data_parameter_struct dma_init_struct;

    //TX
    dma_deinit(DMA0, DMA_CH0);
    dma_single_data_para_struct_init(&dma_init_struct);
    dma_init_struct.request      = DMA_REQUEST_USART0_TX;
    dma_init_struct.direction    = DMA_MEMORY_TO_PERIPH;
    dma_init_struct.memory0_addr  = (uint32_t)0;
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;
    dma_init_struct.number       = 0;
    dma_init_struct.periph_addr  = (uint32_t)(&USART_TDATA(USART0));
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
    dma_single_data_mode_init(DMA0, DMA_CH0, &dma_init_struct);

    dma_circulation_disable(DMA0, DMA_CH0);
    usart_dma_transmit_config(USART0, USART_TRANSMIT_DMA_ENABLE);
    dma_interrupt_enable(DMA0, DMA_CH0, DMA_INT_FTF);
//    dma_channel_enable(DMA0, DMA_CH0);

    //RX
    dma_deinit(DMA0, DMA_CH1);
    dma_single_data_para_struct_init(&dma_init_struct);
    dma_init_struct.request      = DMA_REQUEST_USART0_RX;
    dma_init_struct.direction    = DMA_PERIPH_TO_MEMORY;
    dma_init_struct.memory0_addr  = (uint32_t)get_next_rx_buff();
    dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;
    dma_init_struct.number       = USART_DMA_TRANSFER_SIZE;
    dma_init_struct.periph_addr  = (uint32_t)(&USART_RDATA(USART0));
    dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
    dma_single_data_mode_init(DMA0, DMA_CH1, &dma_init_struct);

    dma_circulation_disable(DMA0, DMA_CH1);
    usart_dma_receive_config(USART0, USART_RECEIVE_DMA_ENABLE);
    dma_interrupt_enable(DMA0, DMA_CH1, DMA_INT_FTF);
    dma_channel_enable(DMA0, DMA_CH1);
}

void DMA0_Channel0_IRQHandler()
{
    if (RESET != dma_interrupt_flag_get(DMA0, DMA_CH0, DMA_INT_FLAG_FTF)) {
        dma_interrupt_flag_clear(DMA0, DMA_CH0, DMA_INT_FLAG_FTF);


        gpio_bit_toggle(GPIOJ, GPIO_PIN_8);
    }
}

void DMA0_Channel1_IRQHandler()
{
    if (RESET != dma_interrupt_flag_get(DMA0, DMA_CH1, DMA_INT_FLAG_FTF)) { //传输完成
        dma_interrupt_flag_clear(DMA0, DMA_CH1, DMA_INT_FLAG_FTF);

        uint8_t* rx_buff = get_rx_buff();

        dma_single_data_parameter_struct dma_init_struct;
        dma_deinit(DMA0, DMA_CH1);
        dma_single_data_para_struct_init(&dma_init_struct);
        dma_init_struct.request      = DMA_REQUEST_USART0_RX;
        dma_init_struct.direction    = DMA_PERIPH_TO_MEMORY;
        dma_init_struct.memory0_addr  = (uint32_t)get_next_rx_buff();
        dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
        dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;
        dma_init_struct.number       = USART_DMA_TRANSFER_SIZE;
        dma_init_struct.periph_addr  = (uint32_t)(&USART_RDATA(USART0));
        dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
        dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
        dma_single_data_mode_init(DMA0, DMA_CH1, &dma_init_struct);

        dma_circulation_disable(DMA0, DMA_CH1);
        usart_dma_receive_config(USART0, USART_RECEIVE_DMA_ENABLE);
        dma_interrupt_enable(DMA0, DMA_CH1, DMA_INT_FTF);
        dma_channel_enable(DMA0, DMA_CH1);

        for (int i = 0; i < USART_DMA_TRANSFER_SIZE; ++i) circular_buffer_push_back(&circular_buffer, rx_buff[i]);

        gpio_bit_toggle(GPIOJ, GPIO_PIN_9);
    }
}

void USART0_IRQHandler()
{
    if (RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE)) {
        usart_interrupt_flag_clear(USART0, USART_INT_FLAG_IDLE);


        uint32_t size = USART_DMA_TRANSFER_SIZE - dma_transfer_number_get(DMA0, DMA_CH1);
        uint8_t* rx_buff = get_rx_buff();

        dma_single_data_parameter_struct dma_init_struct;
        dma_deinit(DMA0, DMA_CH1);
        dma_single_data_para_struct_init(&dma_init_struct);
        dma_init_struct.request      = DMA_REQUEST_USART0_RX;
        dma_init_struct.direction    = DMA_PERIPH_TO_MEMORY;
        dma_init_struct.memory0_addr  = (uint32_t)get_next_rx_buff();
        dma_init_struct.memory_inc   = DMA_MEMORY_INCREASE_ENABLE;
        dma_init_struct.periph_memory_width = DMA_PERIPH_WIDTH_8BIT;
        dma_init_struct.number       = USART_DMA_TRANSFER_SIZE;
        dma_init_struct.periph_addr  = (uint32_t)(&USART_RDATA(USART0));
        dma_init_struct.periph_inc   = DMA_PERIPH_INCREASE_DISABLE;
        dma_init_struct.priority     = DMA_PRIORITY_ULTRA_HIGH;
        dma_single_data_mode_init(DMA0, DMA_CH1, &dma_init_struct);

        dma_circulation_disable(DMA0, DMA_CH1);
        usart_dma_receive_config(USART0, USART_RECEIVE_DMA_ENABLE);
        dma_interrupt_enable(DMA0, DMA_CH1, DMA_INT_FTF);
        dma_channel_enable(DMA0, DMA_CH1);

        for (int i = 0; i < size; ++i) circular_buffer_push_back(&circular_buffer, rx_buff[i]);

        gpio_bit_toggle(GPIOJ, GPIO_PIN_9);
    }
}

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* enable the CPU Cache */
    cache_enable();

    clock_config(); //使用外部时钟

    /* configure systick */
    systick_config();

    create_circular_buffer(&circular_buffer, circular_buffer_data, USART_DMA_TRANSFER_SIZE);

    led_config();
    usart_config();
    dma_config();


    char msg[] = "Hello World\r\n";
    usart_transmit_dma(msg, strlen(msg));


    while(1) {
        while (circular_buffer_available(&circular_buffer)) {
            char ch;
            circular_buffer_pop_front(&circular_buffer, &ch);
            usart_transmit(&ch, 1);
        }
        delay_1ms(1);
    }
}
BusyBox0
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一个严谨的STM32串口DMA发送&接收（1.5Mbps波特率）机制
只要思想不滑坡，想法总比问题多。
09-03 4万+
本文描述串口DMA收/发机制设计，及STM32串口DMA收/发实现。
【GD32】从0开始学GD32单片机（7）—— DMA直接存储器访问控制器详解+DMA串口发送和接收例程
JackieCoo的博客
09-22 4756
介绍了GD32的DMA外设，包含DMA串口发送和DMA串口接收例程
dma接收双缓存 stm32_STM32的串口DMA收发以及双缓冲区的实现
weixin_39725594的博客
12-19 735
在使用STM32的UART的DMA功能总结如下：首先上代码，这里采用STM32 的USART1作为Demo，RX的DMA为DMA1_Channel5，TX的DMA为DMA1_Channel4.初始化如下，红色的标记需要注意：RX-DMA初始化1 //DMA Rx2 USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);3 DMA_Cmd(DMA1_Channel5...
dma接收双缓存 stm32_STM32串口接收使用DMA双缓冲
weixin_39802519的博客
12-19 504
#define IMAGE_BUFFER_SIZE 100 //以字为单位 经试验，增大这个数值速度并未提升u32 Image_Buffer1[IMAGE_BUFFER_SIZE]={0};u32 Image_Buffer2[IMAGE_BUFFER_SIZE]={0};//OV2640 JPEG模式接口配置void OV2640_JpegDcmiInit(void){DCMI_InitTyp...
STM32串口不定长度传输策略
qq_42357877的博客
02-28 912
STM32串口不定长度传输策略梳理
DMA+USART双缓冲区收发,妈妈再也不用担心丢包（附GD32L233源码）
yybyg的博客
11-30 887
自己写了个类似printf的串口发送，在Xcom里换行尾部加 \ r\ n。以及printf重定向。
GD32F303固件库开发（9）----USART通过DMA收发
热门推荐
xh1479的博客
07-08 2万+
本章主要配置printf进行打印。 查阅手册可以得知，PA9、PA10为串口0的输出和输入口。
STM32F407 DMA+串口接收不定长数据程序
05-04
在提供的压缩包文件"DMA+串口接收不定长数据"中，应该包含实现这一功能的C代码文件，如`main.c`、`stm32f4xx_hal_msp.c`、`stm32f4xx_it.c`等，以及相应的头文件。这些文件包含了初始化串口、DMA、中断服务程序以及...
GD32F405RGT6串口接收发送DMA
03-11
本文将深入探讨如何利用GD32F405RGT6的串行通信接口（UART）进行数据的接收与发送，并结合DMA（Direct Memory Access，直接存储器访问）技术，实现高效的数据传输。 首先，串口是设备间进行通信的一种常见接口，...
STM32_HAL+串口+DMA发送和不定长度数据接收
08-15
对于发送，`HAL_UART_Transmit_DMA()`函数启动一个DMA传输，将内存中的数据缓冲区发送到串口。一旦传输完成，HAL库会触发一个中断，通知CPU任务完成。对于接收，`HAL_UART_Receive_DMA()`函数设置接收过程，当串口...
STM32F1串口DMA与空闲中断接收不定长数据.zip
07-18
本例程实现STM32F103ZET6的串口DMA发送与串口DMA接收，配合串口空闲中断可以接收不定长数据。可以参照本人的文章：https://blog.csdn.net/qq_30267617/article/details/118877845。
GD32f103系列教程—(SPI DMA方式软件实现篇)
最新发布
m0_37755481的博客
12-15 1923
项目中需要采用DMA方式传输数据的原因：如果仅仅采用SPI接口进行寄存器通信，那么大可不必采用DMA通信，直接让CPU利用SPI接口通信即可。但是项目中往往会出现传输大量的数据包的情况，此时直接传输和以DMA传输的时间上的差异就体现出来了，并且采用直接传输的时候由于MCU需要不停的搬运数据，因此在传输的两帧数据中间会有很大的延时，导致传输效率极低。所以，首先，配置DMA的时钟，然后配置DMA的一些功能，比如存储器的宽度，传输方向，内存的宽度等。该图为SPI采用DMA通信方式的SPI的波形图。
了解DMA
weixin_60713230的博客
01-25 2221
版权声明：本文为CSDN博主「Z小旋」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/as480133937/article/details/104927922 DMA的基本介绍 什么是DMA (DMA的基本定义) DMA，全称Direct Memory Access，即直接存储器访问。 DMA传输将数据从一个地址空间复制到另一个地址空间，提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。
GD32F303RET6 串口空闲中断+DMA数据发送接收+环形缓冲区方式保存数据
Car12
09-13 1998
使用dma发送结束数据，保存数据使用环形缓冲区
STM32F407学习之DMA双缓冲模式HAL库实现
qq_51368339的博客
04-27 6265
本学期第一次培训要求用单片机实现1到40KHz的单步进变频正弦波输出，本菜鸡一开始用了通过修改定时器预分频系数和自动重装载值改变输出波表频率、修改定时器 + DDS两种方法，但实现的效果不太理想，不仅波形不好看，如37KHz的频率也不大准。后边查阅资料、与朋友们探讨，最终决定尝试用DMA双缓冲+DDS实现波形发生器，实现效果不仅波形好看，频率也相对准确。 网上关于stm32的DMA双缓冲实现资料不多，在这里写下自己实现的两种方法，一方面是为了以后用到时候自己能够很快找到，一方面是希望可以帮助一下也想用双缓
dma接收双缓存 stm32_干货---stm32f103之DMA双缓冲__也算我为网络贡献的微薄之力
weixin_39602615的博客
12-19 672
#include "sys.h"#include"usart.h"#include"string.h"#include"stdio.h"#include"stdlib.h"//蓝牙//////////////////////////////////////////////////////////////////////////////////uart_find uart1s;//定义串口一的接受处...
STM32的DMA双缓冲模式详解
xqhrs232的专栏
06-24 1348
原文地址::STM32的DMA双缓冲模式详解_水木皆Ming的博客-CSDN博客_dma双缓冲相关文章1、STM32F4-DISCO 学习之DMA双缓冲机制----STM32F4-DISCO 学习之DMA双缓冲机制 - JavaShuo 2、STM32串口接收使用DMA双缓冲----https://news.eda365.com/tech/cxsheji/12009720041528.html............
【GD32】GD32 DMA+ADC多通道扫描
xxdx_admin的博客
03-02 1万+
芯片:GD32F350 运行在8M 目标:每10ms读取三个adc通道,并且通过DMA传输 流程 1.配置DMA传输 2.配置ADC模式和通道 3.配置定时器定时触发 4.中断函数和获取足够数据后进行数据处理 说明:本次使用ADC的定时扫描模式,由定时器触发ADC采集转换 ADC扫描模式预先设定好读取的通达,比如ch1 ch3 ch5,当触发adc时候就会连续采集三个通道的数据,通过dma传输到内存,过程(触发->4->5->8->触发->4->5->8->触
GD32E320 SPI+DMA收发
ic2121的博客
07-28 2984
之前发表了STM32F0->GD32E230的串口移植，这里加一个SPI的配置，会介绍SPI在使用DMA和不使用DMA的代码讲解。同时会对自己开发过程中遇到的问题进行说明。
串口DMA方式接收不定长数据，事例程序
06-07
以下是基于STM32Cube HAL库的串口DMA方式接收不定长数据的例程： ``` #define RX_BUFFER_SIZE 256 uint8_t rx_buffer[RX_BUFFER_SIZE]; volatile uint16_t rx_buffer_head = 0; volatile uint16_t rx_buffer_tail = 0; UART_HandleTypeDef huart; void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if (huart == &huart1) { rx_buffer_head = (rx_buffer_head + 1) % RX_BUFFER_SIZE; if (rx_buffer_head == rx_buffer_tail) { // buffer overflow, handle error here } } } void init_uart() { huart.Instance = USART1; huart.Init.BaudRate = 115200; huart.Init.WordLength = UART_WORDLENGTH_8B; huart.Init.StopBits = UART_STOPBITS_1; huart.Init.Parity = UART_PARITY_NONE; huart.Init.Mode = UART_MODE_TX_RX; huart.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&huart); // enable DMA mode for receiving __HAL_UART_ENABLE_IT(&huart, UART_IT_IDLE); HAL_UART_Receive_DMA(&huart, rx_buffer, RX_BUFFER_SIZE); } void handle_data() { while (rx_buffer_head != rx_buffer_tail) { uint8_t data = rx_buffer[rx_buffer_tail]; rx_buffer_tail = (rx_buffer_tail + 1) % RX_BUFFER_SIZE; // do something with data } } int main() { init_uart(); while (1) { handle_data(); } } ``` 在此例程中，我们使用了DMA方式接收UART数据，当串口接收到数据时，会触发HAL_UART_RxCpltCallback回调函数，我们在这个回调函数中处理接收到的数据，并将数据存储到一个环形缓冲区中。在主函数中，我们不断调用handle_data函数来处理接收到的数据。需要注意的是，当环形缓冲区满了之后，我们需要进行错误处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值