STM32串口接收、发送数据实验-程序代码分析

2022-01-12 00:56 jym蒟蒻阅读(2259) 评论(0) 编辑收藏举报

串口通信实验

Printf支持

printf向串口发送一些字符串数据。如果使用串口2，可以修改while((USART1->SR&0X40)==0);和USART1->DR = (u8) ch; 中的USART1为USART2.

//加入以下代码,支持printf函数,而不需要选择use MicroLIB	  
#if 1
#pragma import(__use_no_semihosting)  
//解决HAL库使用时,某些情况可能报错的bug
int _ttywrch(int ch)    
{
    ch=ch;
	return ch;
}
//标准库需要的支持函数                 
struct __FILE 
{ 
	int handle; 
	/* Whatever you require here. If the only file you are using is */ 
	/* standard output using printf() for debugging, no file handling */ 
	/* is required. */ 
}; 
/* FILE is typedef’ d in stdio.h. */ 
FILE __stdout;       
//定义_sys_exit()以避免使用半主机模式    
void _sys_exit(int x) 
{ 
	x = x; 
} 
//重定义fputc函数 
int fputc(int ch, FILE *f)
{      
	while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
	USART1->DR = (u8) ch;      
	return ch;
}
#endif

实验现象

从电脑串口助手发送长度为200以内任意长度的字符串给STM32串口1（字符串以回车换行标识结束），STM32接收到字符串之后，一次性通过串口1把所有数据返回给电脑。

实现过程

把每个接收到的数据保存在一个程序定义的Buffer数组中（数组长度为200），同时把接收到的数据个数保存在定义的变量中。程序通过对接收到的每个数据进行结束判断（接收到回车0x0d之后再接收到换行0x0a），程序接收结束之后，设置相应的标记位，标记结束。。。外部循环通过判断标志位来判断程序结束，然后一次性通过串口1发送出来。发送完成之后，所有标志位和数据量都清零

#define USART_REC_LEN   200  	//定义最大接收字节数 200

 u8  USART_RX_BUF[USART_REC_LEN];
              //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
 
 u16 USART_RX_STA;         		//接收状态标记

USART_RX_STA
bit15	bit14	bit13~0
接收完成标志	接收到0X0D标志	接收到的有效数据个数

程序要求，发送的字符是以回车换行结束（0x0D,0x0A)，windows系统下，回车是由两个字符构成的，“0x0d”和“0x0a”。

ABCDEFGHI…….M(0x0D),(0x0A)，每次接受一个数据，判断是不是0x0d。如果说接收完成，将接收到的数据发出去，同时清零标志位。

代码

main.c

在main里面有HAL_UART_Transmit函数，HAL_UART_Transmit(&UART1_Handler,(uint8_t*)USART_RX_BUF,len,1000); //发送接收到的数据，这个数据是一次性全部发送出去，USART_RX_BUF保存接收到的数据，len是此次接收到的数据长度。

发送完之后清零将USART_RX_STA设置为0

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "key.h"
int main(void)
{
    u8 len;	
	u16 times=0; 
    HAL_Init();                     //初始化HAL库   
    Stm32_Clock_Init(360,25,2,8);   //设置时钟,180Mhz
    delay_init(180);                //初始化延时函数
    uart_init(115200);              //初始化USART
    LED_Init();                     //初始化LED 
    KEY_Init();                     //初始化按键

    while(1)
    {
			
       if(USART_RX_STA&0x8000)
			{							   
				len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
				printf("\r\n您发送的消息为:\r\n");
				HAL_UART_Transmit(&UART1_Handler,(uint8_t*)USART_RX_BUF,len,1000);	//发送接收到的数据
				while(__HAL_UART_GET_FLAG(&UART1_Handler,UART_FLAG_TC)!=SET);		//等待发送结束
				printf("\r\n\r\n");//插入换行
				USART_RX_STA=0;
			}else
			{
				times++;
				if(times%5000==0)
				{
					printf("aaaaaaaaaaaaaaa\r\n\r\n\r\n");
				}
				if(times%200==0)printf("请输入数据,以回车键结束\r\n");  
				if(times%30==0)LED0=!LED0;//闪烁LED,提示系统正在运行.
				delay_ms(10);   
			} 
    } 
}

usart.h

其中有一个extern，c语言中extern可置于变量或者函数之前，以表示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。extern声明变量可以多次，但定义只有一次。

比如usart.h头文件中，extern u8 aRxBuffer[RXBUFFERSIZE];//HAL库USART接收Buffer，aRxBuffer[RXBUFFERSIZE]已经在usart.c定义过了，这样的话，如果在main中引入usart.h头文件，相当于在main里面也用了extern，那么也就可以在main中用usart.c定义过的aRxBuffer[RXBUFFERSIZE]变量。

#ifndef _USART_H
#define _USART_H
#include "sys.h"
#include "stdio.h"	
#define USART_REC_LEN  			200  	//定义最大接收字节数 200
#define EN_USART1_RX 			1		//使能（1）/禁止（0）串口1接收
	  	
extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符 
extern u16 USART_RX_STA;         		//接收状态标记	
extern UART_HandleTypeDef UART1_Handler; //UART句柄

#define RXBUFFERSIZE   1 //缓存大小
extern u8 aRxBuffer[RXBUFFERSIZE];//HAL库USART接收Buffer

//如果想串口中断接收，请不要注释以下宏定义
void uart_init(u32 bound);


#endif

usart.c

以下文字描述配合代码去理解：

对于void uart_init(u32 bound)函数，里面调用了HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer, RXBUFFERSIZE);这里面RXBUFFERSIZE为缓存大小，设置为1，希望在中断服务函数里，每接收到一个字符，都能够进入到回调函数里，方面在回调函数中对数据进行判断。

对于HAL_UART_MspInit函数，里面有一个#if EN_USART1_RX，如果开启接收的话，使能USART1中断通道，设置抢占和响应优先级，usart.h可以找到EN_USART1_RX，他是默认设置为1，也就是开启接收。

然后在USART1_IRQHandler中断服务函数里面，首先调用HAL库中断处理公用函数HAL_UART_IRQHandler(&UART1_Handler)，由于设置RXBUFFERSIZE缓存大小为1，每接收到一个字符都将进入HAL_UART_RxCpltCallback回调函数里面。

在usart.c里面定义了两个重要的变量，u8 USART_RX_BUF[USART_REC_LEN];和u16 USART_RX_STA=0; USART_RX_BUF是一个长度为200的数组，在实验过程里面有做说明，它用来保存接收到的数据。USART_RX_STA是一个十六位的变量，为接收状态标记，bit15，接收完成标志；bit14，接收到0x0d；bit13~0，接收到的有效字节数目；

对于HAL_UART_RxCpltCallback接收完成回调函数，USART_RX_STA&0x8000即bit15位比较，若为1则接受完成。USART_RX_STA&0x4000即与第14位比较，若为1则说明，接收到了0x0d。aRxBuffer[0]指这一次接收到的数据，如果说接收到了0x0d之后又接收到了0x0a，说明程序接收结束，设置标记位最高位为1 。

如果说还没收到0X0D，先判断这次是不是0x0d，如果不是，就把这次接收到的数据保存在USART_RX_BUF里面，其中，USART_RX_STA&0x3fff，0x3fff即0011 1111 1111 1111，bit相同则为1否则为0，便得到已经接收的字符数量。

如果说接收数据量超过200，那么就重新开始处理。

#include "usart.h"
#include "delay.h"
#if 1
#pragma import(__use_no_semihosting)             
//标准库需要的支持函数                 
struct __FILE 
{ 
	int handle; 
}; 

FILE __stdout;       
//定义_sys_exit()以避免使用半主机模式    
void _sys_exit(int x) 
{ 
	x = x; 
} 
//重定义fputc函数 
int fputc(int ch, FILE *f)
{ 	
	while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
	USART1->DR = (u8) ch;      
	return ch;
}
#endif 

#if EN_USART1_RX   //如果使能了接收
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误   	
u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，	接收完成标志
//bit14，	接收到0x0d
//bit13~0，	接收到的有效字节数目
u16 USART_RX_STA=0;       //接收状态标记	

u8 aRxBuffer[RXBUFFERSIZE];//HAL库使用的串口接收缓冲
UART_HandleTypeDef UART1_Handler; //UART句柄

//初始化IO 串口1 
//bound:波特率
void uart_init(u32 bound)
{	
	//UART 初始化设置
	UART1_Handler.Instance=USART1;					    //USART1
	UART1_Handler.Init.BaudRate=bound;				    //波特率
	UART1_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //字长为8位数据格式
	UART1_Handler.Init.StopBits=UART_STOPBITS_1;	    //一个停止位
	UART1_Handler.Init.Parity=UART_PARITY_NONE;		    //无奇偶校验位
	UART1_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //无硬件流控
	UART1_Handler.Init.Mode=UART_MODE_TX_RX;		    //收发模式
	HAL_UART_Init(&UART1_Handler);					    //HAL_UART_Init()会使能UART1
	
	HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer, RXBUFFERSIZE);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量
  
}

//UART底层初始化，时钟使能，引脚配置，中断配置
//此函数会被HAL_UART_Init()调用
//huart:串口句柄

void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
    //GPIO端口设置
	GPIO_InitTypeDef GPIO_Initure;
	
	if(huart->Instance==USART1)//如果是串口1，进行串口1 MSP初始化
	{
		__HAL_RCC_GPIOA_CLK_ENABLE();			//使能GPIOA时钟
		__HAL_RCC_USART1_CLK_ENABLE();			//使能USART1时钟
	
		GPIO_Initure.Pin=GPIO_PIN_9;			//PA9
		GPIO_Initure.Mode=GPIO_MODE_AF_PP;		//复用推挽输出
		GPIO_Initure.Pull=GPIO_PULLUP;			//上拉
		GPIO_Initure.Speed=GPIO_SPEED_FAST;		//高速
		GPIO_Initure.Alternate=GPIO_AF7_USART1;	//复用为USART1
		HAL_GPIO_Init(GPIOA,&GPIO_Initure);	   	//初始化PA9

		GPIO_Initure.Pin=GPIO_PIN_10;			//PA10
		HAL_GPIO_Init(GPIOA,&GPIO_Initure);	   	//初始化PA10
		
#if EN_USART1_RX
		HAL_NVIC_EnableIRQ(USART1_IRQn);		//使能USART1中断通道
		HAL_NVIC_SetPriority(USART1_IRQn,3,3);	//抢占优先级3，子优先级3
#endif	
	}

}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart->Instance==USART1)//如果是串口1
	{
		if((USART_RX_STA&0x8000)==0)//接收未完成，最高位
		{
			if(USART_RX_STA&0x4000)//接收到了0x0d
			{
				if(aRxBuffer[0]!=0x0a)USART_RX_STA=0;//接收错误,重新开始
				else USART_RX_STA|=0x8000;	//接收完成了 
			}
			else //还没收到0X0D
			{	
				if(aRxBuffer[0]==0x0d)USART_RX_STA|=0x4000;
				else
				{
					USART_RX_BUF[USART_RX_STA&0X3FFF]=aRxBuffer[0] ;
					USART_RX_STA++;
					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收	  
				}		 
			}
		}

	}
}
 
//串口1中断服务程序
void USART1_IRQHandler(void)                	
{ 
	u32 timeout=0;
	u32 maxDelay=0x1FFFF;
#if SYSTEM_SUPPORT_OS	 	//使用OS
	OSIntEnter();    
#endif
	
	HAL_UART_IRQHandler(&UART1_Handler);	//调用HAL库中断处理公用函数
	
	timeout=0;
    while (HAL_UART_GetState(&UART1_Handler) != HAL_UART_STATE_READY)//等待就绪
	{
	 timeout++;////超时处理
     if(timeout>maxDelay) break;		
	}
     
	timeout=0;
	while(HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount为1
	{
	 timeout++; //超时处理
	 if(timeout>maxDelay) break;	
	}
#if SYSTEM_SUPPORT_OS	 	//使用OS
	OSIntExit();  											 
#endif
} 
#endif

会员力量，点亮园子希望

刷新页面返回顶部

jym蒟蒻