STM32 串口USART DMA方式發送接收數據

原創 小麦大叔 2020-02-21 19:03

硬件：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的基址如下圖所示；
在這裏插入圖片描述
DR寄存器的偏移地址如下圖所示；
在這裏插入圖片描述
所以最終地址爲：0x40004800 + 0x004
#define USART_DR_Base 0x40004804

DMA的通道

因爲有很多外設都可以使用DMA，比如ADC，I2C，SPI等等，所以，不同的外設就要選擇屬於自己的DMA通道，查找參考手冊；
在這裏插入圖片描述
因此USART3_RX在這裏會使用DMA1的通道3，這都是硬件上已經預先分配好的，我們需要遵循這個規則。
所以在代碼中我們做出相應的定義；如下所示；

#define USART_Rx_DMA_Channel    DMA1_Channel3

DMA的中斷

DMA支持三種中斷：傳輸過半，傳輸完成，傳輸出錯；
在這裏插入圖片描述
因此在使用是相當安全也相當靈活，而本文只是用了傳輸完成中斷；如下定義了，傳輸完成中斷的標誌位，DMA1_FLAG_TC3也就對應了圖中的TCIF；

#define USART_Rx_DMA_FLAG       DMA1_FLAG_TC3

USART接收回調函數

在STM32的HAL中封裝了大量外設的回調函數，使用起來十分方便，但是標準庫中則沒有這樣的做法，但是這裏我們可以自己實現，rx_cbk就是回調，即串口數據接收完成就會執行已經註冊的回調函數；

typedef void (*rx_cbk)(void* args);

通過使用接口usart_set_rx_cbk進行回調函數的註冊，pargs爲將傳遞的參數指針；

void usart_set_rx_cbk(uart_mod_t *pmod, rx_cbk pfunc,void *pargs);

頭文件源碼

#ifndef USART_DRIVER_H
#define USART_DRIVER_H
#include <stdio.h>
#include <stdint.h>

/* Private function prototypes -----------------------------------------------*/
#define USE_MICROLIB_USART 1

#if USE_MICROLIB_USART

#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
   set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
//#define GETCHAR_PROTOTYPE int fgetc(FILE *f)

#endif /* __GNUC__ */
extern PUTCHAR_PROTOTYPE;
#else

#endif
 
//default 8N1
#define COM_PORT	USART3
#define TX_PIN		GPIO_Pin_10
#define RX_PIN		GPIO_Pin_11
#define BAUDRATE	115200

#define IRQ_UART_PRE	3
#define IRQ_UART_SUB	3

#define USART_Rx_DMA_Channel    DMA1_Channel3
#define USART_Rx_DMA_FLAG       DMA1_FLAG_TC3
#define USART_DR_Base           0x40004804
#define USART_BUF_SIZE			((uint16_t)16)

typedef void (*rx_cbk)(void* args);
struct uart_mod {
	
	uint8_t rx_buf[USART_BUF_SIZE];
	uint8_t rx_dat_len;
	uint8_t head;
	uint8_t tail;	
	
	void (*init)(void);
	
	void *pargs;
	rx_cbk pfunc_rx_cbk;
};
typedef struct uart_mod uart_mod_t;

extern  uart_mod_t user_uart_mod;
void usart_init(void);
void usart_set_rx_cbk(uart_mod_t *pmod, rx_cbk pfunc,void *pargs);
void usart_send_char(char ch);
void usart_test_echo(void);
uint8_t usart_recv_char(void);
int usart_printf(const char *fmt, ...);

//extern GETCHAR_PROTOTYPE;

#endif

DMA的基本配置

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

static void dma_init(void)

已經定義了數據緩衝區，如下：

uint8_t RxBuffer[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 <stdio.h>
#include <stdarg.h>
#include "stm32f10x_usart.h"
#include "usart_driver.h"

uint8_t RxBuffer[USART_BUF_SIZE] = { 0 };

uart_mod_t user_uart_mod = {
	.rx_dat_len = 0,
	.head = 0,
	.tail = 0,
	.pfunc_rx_cbk = NULL,
	.pargs = NULL
};

static USART_InitTypeDef USART_InitStructure;

static void rcc_init(void){

	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	/* Enable GPIO clock */
	RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB 
							| RCC_APB2Periph_AFIO, ENABLE);
	RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART3, ENABLE);
}

static void gpio_init(void){

  GPIO_InitTypeDef GPIO_InitStructure;
  /* Configure USART Tx as alternate function push-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);

  /* Configure USART Rx as input floating */
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Pin = RX_PIN;
  
  GPIO_Init(GPIOB, &GPIO_InitStructure);

}

static void dma_init(void){

  DMA_InitTypeDef DMA_InitStructure;

  /* USARTy_Tx_DMA_Channel (triggered by USARTy Tx event) 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);

}

static void irq_init(void){

	NVIC_InitTypeDef NVIC_InitStructure;

	/* Enable the USART3_IRQn Interrupt */
	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);
}

void usart_send_char(char ch){

	/* Loop until the end of transmission */
	//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_t usart_recv_char(){
	/* Wait the byte is entirely received by USARTy */
    //while(USART_GetFlagStatus(COM_PORT, USART_FLAG_RXNE) == RESET){}
	while((COM_PORT->SR & USART_FLAG_RXNE) != USART_FLAG_RXNE){
	
	}
	
    /* Store the received byte in the RxBuffer1 */
    return (uint8_t)USART_ReceiveData(COM_PORT);
}

int usart_printf(const char *fmt, ... )
{
    uint8_t i = 0;
    uint8_t usart_tx_buf[128] = { 0 };
    va_list ap;

    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('\0');
	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;
}

void DMA1_Channel3_IRQHandler(void){
     if(DMA_GetITStatus(USART_Rx_DMA_FLAG) == SET){        
        DMA_ClearITPendingBit(USART_Rx_DMA_FLAG);
    }
}

/**
  * @brief  This function handles USART3 global interrupt request.
  * @param  None
  * @retval None
  */
void USART3_IRQHandler(void)
{
	uint8_t buf[USART_BUF_SIZE];
	uint16_t rect_len = 0;
	if(USART_GetITStatus(COM_PORT, USART_IT_IDLE) != RESET)	
	{
		uint8_t i = 0;
		USART_ReceiveData(COM_PORT);
		user_uart_mod.head = USART_BUF_SIZE - DMA_GetCurrDataCounter(USART_Rx_DMA_Channel);		
		//fifo is not full	
		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);
}

#if USE_MICROLIB_USART
/**
  * @brief  Retargets the C library printf function to the USART.
  * @param  None
  * @retval None
  */
PUTCHAR_PROTOTYPE
{
	/* Place your implementation of fputc here */
	/* e.g. write a character to the USART */
	USART_SendData(COM_PORT, (uint8_t) ch);
	/* Loop until the end of transmission */
	while (USART_GetFlagStatus(COM_PORT, USART_FLAG_TC) == RESET)
	{}
	return ch;
}

#else

#pragma import(__use_no_semihosting)                          
struct __FILE 
{ 
	int handle; 

}; 
FILE __stdout;       

int _sys_exit(int x)
{ 
	x = x; 
	return 0;
} 
int fputc(int ch, FILE *f)
{      
	/* Place your implementation of fputc here */
	/* e.g. write a character to the USART */
	USART_SendData(COM_PORT, (uint8_t) ch);
	/* Loop until the end of transmission */
	while (USART_GetFlagStatus(COM_PORT, USART_FLAG_TC) == RESET)
	{}
	return ch;
}
#endif

參考用例

這裏需要調用usart_init，並設置回調函數，如果不設置，則不會執行回調。

void motor_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;	
}

int main(void){
	usart_init();
	usart_set_rx_cbk(&user_uart_mod, motor_get_cmd_from_uart,&user_uart_mod);
}
小麥大叔
發佈了95 篇原創文章 · 獲贊 74 · 訪問量 9萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

STM32F103RC驅動CH375B模塊讀寫優盤扇區數據

之前做畢設買了CH375B模塊，一直沒好好用過。現在想把這個模塊用起來。程序參考的振南的51例程《U盤扇區讀寫[IO方式]》 和正點原子的例程模板，只要把最底層的扇區讀寫測試通過，znFAT文件系統就可以用了。程序用的並口通信控制。先說端

jxw82284134 2020-07-07 04:14:19

STM32 CubeIDE快速創建工程

小麦大叔 2020-03-01 16:24:49

STM32 Cube之旅-嘗試新的開發方式

小麦大叔 2020-03-01 16:24:49

STM32 外部中斷詳解（原理+配置代碼）

小麦大叔 2020-02-28 19:04:44

STM32 TIM高級定時器死區時間的計算

小麦大叔 2020-02-28 07:01:11

STM32項目實戰技術總結匯總（持續更新）

小麦大叔 2020-02-26 05:05:36

hex文件格式總結

小麦大叔 2020-02-21 19:03:39

STM32 TIM 多通道互補PWM波形輸出配置快速入門

小麦大叔 2020-02-21 19:03:39

STM32 TIM1高級定時器配置快速入門

小麦大叔 2020-02-21 19:03:39

STM32 標準庫3.5修改默認外部8M晶振爲16M晶振

小麦大叔 2020-02-21 19:03:39

STM32 使用IQmath實現SVPWM

小麦大叔 2020-02-21 19:03:38

STM32F103RC驅動CH375B模塊讀寫優盤扇區數據

之前做畢設買了CH375B模塊，一直沒好好用過。現在想把這個模塊用起來。程序參考的振南的51例程《U盤扇區讀寫[IO方式]》 和正點原子的例程模板，只要把最底層的扇區讀寫測試通過，znFAT文件系統就可以用了。程序用的並口通信控制。先說端

jxw82284134 2020-07-07 04:14:19

STM32 CubeIDE快速創建工程

小麦大叔 2020-03-01 16:24:49

STM32 Cube之旅-嘗試新的開發方式

小麦大叔 2020-03-01 16:24:49

STM32 外部中斷詳解（原理+配置代碼）

小麦大叔 2020-02-28 19:04:44