STM32如何高效接收串口数据？

硬件：stm32f103cbt6
软件：STM32F10x_StdPeriph_Lib_V3.5.0

DMA，直接内存存取，可以用它的双手释放CPU的灵魂，所以，本文通过USART3进行串口收发，接受使用DMA的方式，无需CPU进行干预，当接受完成之后，数据可以直接从内存的缓冲区读取，从而减少了CPU的压力。

具体的代码实现如下：

usart_driver.h 封装了接口，数据接收回调函数类型，基本数据结构等；

usart_driver.c 函数原型实现，中断服务函数实现等；

拷贝这两个文件即可，可以根据目录下的参考用例，进行初始化。

头文件usart_driver.h已经声明了外部函数可能用到的接口；

USART3_DR的地址

因为USART3接收到数据会存在DR寄存器中，而DMA控制器则负责将该寄存器中的内容一一搬运到内存的缓冲区中（比如你定义的某个数组中），所以这里需要告诉DMA控制去哪里搬运，因此需要设置USART3_DR的总线地址。

USART3的基址如下图所示；

USART3的基址

DR寄存器的偏移地址如下图所示；

DR偏移地址

所以最终地址为：0x40004800 + 0x004#define USART_DR_Base 0x40004804

DMA的通道

因为有很多外设都可以使用DMA，比如ADC，I2C，SPI等等，所以，不同的外设就要选择属于自己的DMA通道，查找参考手册；

DMA通道

因此USART3_RX在这里会使用DMA1的通道3，这都是硬件上已经预先分配好的，我们需要遵循这个规则。所以在代码中我们做出相应的定义；如下所示；

#defineUSART_Rx_DMA_ChannelDMA1_Channel3

DMA的中断

DMA支持三种中断：传输过半，传输完成，传输出错；

DMA中断

因此在使用是相当安全也相当灵活，而本文只是用了传输完成中断；如下定义了，传输完成中断的标志位，DMA1_FLAG_TC3也就对应了图中的TCIF；

#defineUSART_Rx_DMA_FLAGDMA1_FLAG_TC3

USART接收回调函数

在STM32的HAL中封装了大量外设的回调函数，使用起来十分方便，但是标准库中则没有这样的做法，但是这里我们可以自己实现，rx_cbk就是回调，即串口数据接收完成就会执行已经注册的回调函数；

typedefvoid(*rx_cbk)(void*args);

通过使用接口usart_set_rx_cbk进行回调函数的注册，pargs为将传递的参数指针；

voidusart_set_rx_cbk(uart_mod_t*pmod,rx_cbkpfunc,void*pargs);

头文件源码

#ifndefUSART_DRIVER_H #defineUSART_DRIVER_H #include #include /*Privatefunctionprototypes-----------------------------------------------*/ #defineUSE_MICROLIB_USART1 #ifUSE_MICROLIB_USART #ifdef__GNUC__ /*WithGCC/RAISONANCE,smallprintf(optionLDLinker->Libraries->Smallprintf setto'Yes')calls__io_putchar()*/ #definePUTCHAR_PROTOTYPEint__io_putchar(intch) #else #definePUTCHAR_PROTOTYPEintfputc(intch,FILE*f) //#defineGETCHAR_PROTOTYPEintfgetc(FILE*f) #endif/*__GNUC__*/ externPUTCHAR_PROTOTYPE; #else #endif //default8N1 #defineCOM_PORTUSART3 #defineTX_PINGPIO_Pin_10 #defineRX_PINGPIO_Pin_11 #defineBAUDRATE115200 #defineIRQ_UART_PRE3 #defineIRQ_UART_SUB3 #defineUSART_Rx_DMA_ChannelDMA1_Channel3 #defineUSART_Rx_DMA_FLAGDMA1_FLAG_TC3 #defineUSART_DR_Base0x40004804 #defineUSART_BUF_SIZE((uint16_t)16) typedefvoid(*rx_cbk)(void*args); structuart_mod{ uint8_trx_buf[USART_BUF_SIZE]; uint8_trx_dat_len; uint8_thead; uint8_ttail; void(*init)(void); void*pargs; rx_cbkpfunc_rx_cbk; }; typedefstructuart_moduart_mod_t; externuart_mod_tuser_uart_mod; voidusart_init(void); voidusart_set_rx_cbk(uart_mod_t*pmod,rx_cbkpfunc,void*pargs); voidusart_send_char(charch); voidusart_test_echo(void); uint8_tusart_recv_char(void); intusart_printf(constchar*fmt,...); //externGETCHAR_PROTOTYPE; #endif

DMA的基本配置

串口接收DMA的配置在函数dma_init中；

staticvoiddma_init(void)

已经定义了数据缓冲区，如下：

uint8_tRxBuffer[USART_BUF_SIZE]={0};

因此需要在DMA的配置中设置USART_DR的地址，和数据缓冲区的地址，以及两者的大小；还有就是数据流向；

寄存器流向内存；

内存流向寄存器；这个需要搞清楚；相关配置如下所示；

DMA_InitStructure.DMA_PeripheralBaseAddr=USART_DR_Base; DMA_InitStructure.DMA_MemoryBaseAddr=(uint32_t)RxBuffer; DMA_InitStructure.DMA_BufferSize=USART_BUF_SIZE; DMA_InitStructure.DMA_DIR=DMA_DIR_PeripheralSRC;

注意：DMA_DIR_PeripheralSRC表示，外设作为源地址，数据是从外设寄存器流向内存，即DMA会把数据从地址USART_DR_Base搬运到RxBuffer去。如果这个地方搞错，会导致RxBuffer始终没有你想要的数据。

环形队列接收数据

线性缓冲区会因为缓冲器接收数据已满导致无法继续接收的问题；而环形队列进行接收的话，会自动进行覆盖，这样一来，在读取数据的时候，也要配置一个环形队列进行数据处理，下面的配置是把DMA配置为循环模式；

DMA_InitStructure.DMA_Mode=DMA_Mode_Circular;

在结构体user_uart_mod中，则用两个变量分别指向队首head和队尾tail；具体数据的读取在函数USART3_IRQHandler中，会把数据从内存的RxBuffer读取到结构体user_uart_mod的成员变量rx_buf中；最终调用回调函数。

函数原型

usart_driver.c

#include #include #include"stm32f10x_usart.h" #include"usart_driver.h" uint8_tRxBuffer[USART_BUF_SIZE]={0}; uart_mod_tuser_uart_mod={ .rx_dat_len=0, .head=0, .tail=0, .pfunc_rx_cbk=NULL, .pargs=NULL }; staticUSART_InitTypeDefUSART_InitStructure; staticvoidrcc_init(void){ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE); /*EnableGPIOclock*/ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB |RCC_APB2Periph_AFIO,ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE); } staticvoidgpio_init(void){ GPIO_InitTypeDefGPIO_InitStructure; /*ConfigureUSARTTxasalternatefunctionpush-pull*/ GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP; GPIO_InitStructure.GPIO_Pin=TX_PIN; GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz; GPIO_Init(GPIOB,&GPIO_InitStructure); /*ConfigureUSARTRxasinputfloating*/ GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING; GPIO_InitStructure.GPIO_Pin=RX_PIN; GPIO_Init(GPIOB,&GPIO_InitStructure); } staticvoiddma_init(void){ DMA_InitTypeDefDMA_InitStructure; /*USARTy_Tx_DMA_Channel(triggeredbyUSARTyTxevent)Config*/ DMA_DeInit(USART_Rx_DMA_Channel); DMA_InitStructure.DMA_PeripheralBaseAddr=USART_DR_Base; DMA_InitStructure.DMA_MemoryBaseAddr=(uint32_t)RxBuffer; //DMA_InitStructure.DMA_DIR=DMA_DIR_PeripheralDST; DMA_InitStructure.DMA_DIR=DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_BufferSize=USART_BUF_SIZE; DMA_InitStructure.DMA_PeripheralInc=DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc=DMA_MemoryInc_Enable; DMA_InitStructure.DMA_PeripheralDataSize=DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize=DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_Mode=DMA_Mode_Circular; DMA_InitStructure.DMA_Priority=DMA_Priority_VeryHigh; DMA_InitStructure.DMA_M2M=DMA_M2M_Disable; DMA_Init(USART_Rx_DMA_Channel,&DMA_InitStructure); } staticvoidirq_init(void){ NVIC_InitTypeDefNVIC_InitStructure; /*EnabletheUSART3_IRQnInterrupt*/ NVIC_InitStructure.NVIC_IRQChannel=USART3_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=IRQ_UART_PRE; NVIC_InitStructure.NVIC_IRQChannelSubPriority=IRQ_UART_SUB; NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE; NVIC_Init(&NVIC_InitStructure); } voidusart_send_char(charch){ /*Loopuntiltheendoftransmission*/ //while(USART_GetFlagStatus(COM_PORT,USART_FLAG_TC)==RESET){} while((COM_PORT->SR&USART_FLAG_TC)!=USART_FLAG_TC){ } USART_SendData(COM_PORT,(uint8_t)ch); } uint8_tusart_recv_char(){ /*WaitthebyteisentirelyreceivedbyUSARTy*/ //while(USART_GetFlagStatus(COM_PORT,USART_FLAG_RXNE)==RESET){} while((COM_PORT->SR&USART_FLAG_RXNE)!=USART_FLAG_RXNE){ } /*StorethereceivedbyteintheRxBuffer1*/ return(uint8_t)USART_ReceiveData(COM_PORT); } intusart_printf(constchar*fmt,...) { uint8_ti=0; uint8_tusart_tx_buf[128]={0}; va_listap; va_start(ap,fmt); vsprintf((char*)usart_tx_buf,fmt,ap); va_end(ap); while(usart_tx_buf[i]&&i< 128){   usart_send_char(usart_tx_buf[i]);      i++;  }      usart_send_char('');  return 0; } void usart_test_echo(){  uint8_t tmp_dat = 0xff;  tmp_dat = usart_recv_char();  usart_send_char(tmp_dat); } void usart_init(void){  rcc_init ();  gpio_init ();  irq_init();    /* USARTx configured as follow:   - BaudRate = 115200 baud     - Word Length = 8 Bits   - One Stop Bit   - No parity   - Hardware flow control disabled (RTS and CTS signals)   - Receive and transmit enabled  */  USART_InitStructure.USART_BaudRate = BAUDRATE;  USART_InitStructure.USART_WordLength = USART_WordLength_8b;  USART_InitStructure.USART_StopBits = USART_StopBits_1;  USART_InitStructure.USART_Parity = USART_Parity_No;  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;  /* USART configuration */  USART_Init(COM_PORT, &USART_InitStructure);  USART_ITConfig(COM_PORT, USART_IT_IDLE, ENABLE);  //USART_ITConfig(COM_PORT, USART_IT_RXNE, ENABLE);  /* Enable USART */  USART_Cmd(COM_PORT, ENABLE);    USART_DMACmd(COM_PORT,USART_DMAReq_Rx, ENABLE);  dma_init();  DMA_ITConfig(USART_Rx_DMA_Channel, DMA_IT_TC, ENABLE);   DMA_ITConfig(USART_Rx_DMA_Channel, DMA_IT_TE, ENABLE);  DMA_Cmd(USART_Rx_DMA_Channel, ENABLE);  } void usart_set_rx_cbk(uart_mod_t *pmod, rx_cbk pfunc,void *pargs){  pmod->pargs=pargs; pmod->pfunc_rx_cbk=pfunc; } voidDMA1_Channel3_IRQHandler(void){ if(DMA_GetITStatus(USART_Rx_DMA_FLAG)==SET){ DMA_ClearITPendingBit(USART_Rx_DMA_FLAG); } } /** *@briefThisfunctionhandlesUSART3globalinterruptrequest. *@paramNone *@retvalNone */ voidUSART3_IRQHandler(void) { uint8_tbuf[USART_BUF_SIZE]; uint16_trect_len=0; if(USART_GetITStatus(COM_PORT,USART_IT_IDLE)!=RESET) { uint8_ti=0; USART_ReceiveData(COM_PORT); user_uart_mod.head=USART_BUF_SIZE-DMA_GetCurrDataCounter(USART_Rx_DMA_Channel); //fifoisnotfull while(user_uart_mod.head%USART_BUF_SIZE!=user_uart_mod.tail%USART_BUF_SIZE){ user_uart_mod.rx_buf[i++]=RxBuffer[user_uart_mod.tail++%USART_BUF_SIZE]; } user_uart_mod.rx_dat_len=i; //DMA_Cmd(USART_Rx_DMA_Channel,ENABLE); if(user_uart_mod.pfunc_rx_cbk!=NULL){ user_uart_mod.pfunc_rx_cbk(user_uart_mod.pargs); } } USART_ClearITPendingBit(COM_PORT,USART_IT_IDLE); //USART_ClearITPendingBit(COM_PORT,USART_IT_RXNE); } #ifUSE_MICROLIB_USART /** *@briefRetargetstheClibraryprintffunctiontotheUSART. *@paramNone *@retvalNone */ PUTCHAR_PROTOTYPE { /*Placeyourimplementationoffputchere*/ /*e.g.writeacharactertotheUSART*/ USART_SendData(COM_PORT,(uint8_t)ch); /*Loopuntiltheendoftransmission*/ while(USART_GetFlagStatus(COM_PORT,USART_FLAG_TC)==RESET) {} returnch; } #else #pragmaimport(__use_no_semihosting) struct__FILE { inthandle; }; FILE__stdout; int_sys_exit(intx) { x=x; return0; } intfputc(intch,FILE*f) { /*Placeyourimplementationoffputchere*/ /*e.g.writeacharactertotheUSART*/ USART_SendData(COM_PORT,(uint8_t)ch); /*Loopuntiltheendoftransmission*/ while(USART_GetFlagStatus(COM_PORT,USART_FLAG_TC)==RESET) {} returnch; } #endif

参考用例

这里需要调用usart_init，并设置回调函数，如果不设置，则不会执行回调。

voidmotor_get_cmd_from_uart(void*pargs){ if(pargs==NULL){ return; } uart_mod_t*p=pargs; if(p->rx_dat_len>0&&p->rx_dat_len==PACKAGE_SIZE){ if(p->rx_buf[0]==PACKAGE_HEAD &&p->rx_buf[PACKAGE_SIZE-1]==PACKAGE_TAIL){ user_cmd_mod.head=p->rx_buf[0]; user_cmd_mod.cmd.value_n[0]=p->rx_buf[1]; user_cmd_mod.cmd.value_n[1]=p->rx_buf[2]; user_cmd_mod.option=p->rx_buf[3]; user_cmd_mod.data.value_n[0]=p->rx_buf[4]; user_cmd_mod.data.value_n[1]=p->rx_buf[5]; user_cmd_mod.data.value_n[2]=p->rx_buf[6]; user_cmd_mod.data.value_n[3]=p->rx_buf[7]; user_cmd_mod.tail=p->rx_buf[PACKAGE_SIZE-1]; user_cmd_mod.process_flag=1; } } p->rx_dat_len=0; } intmain(void){ usart_init(); usart_set_rx_cbk(&user_uart_mod,motor_get_cmd_from_uart,&user_uart_mod); }

总结

本文简单介绍了基于STM32基于DMA，利用串口空闲中断进行串口数据接收的具体配置和实现方法，代码基于标准库3.5版本；
因为标准库ST目前已经不再更新，并且ST提供了cubemx工具可以进行基于HAL库和LL库的外设快速配置，从而简化大量工作；当然为了不掉头发感觉撸寄存器也不错，最终适合自己的才是最好的。

责任编辑：lq