STM32串⼝接收、发送数据实验-程序代码分析
串⼝通信实验
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
bit15bit14bit13~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[R
XBUFFERSIZE]已经在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;模拟串口使用printf函数
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