USART串口协议——串口发送接收以及串口收发数据包

一、通信接口

1、通信的目的：将一个设备的数据传送到另一个设备，扩展硬件系统

2、通信协议：制定通信的规则，通信双方按照协议规则进行数据收发

二、串口通信

1、串口是一种应用十分广泛的通讯接口，串口成本低、容易使用、通信线路简单，可实现两个设备的互相通信

2、单片机的串口可以使单片机与单片机、单片机与电脑、单片机与各式各样的模块互相通信，极大地扩展了单片机的应用范围，增强了单片机系统的硬件实力

3、硬件电路

（1）简单双向串口通信有两根通信线（发送端TX和接收端RX）

（2）TX与RX要交叉连接

（3）当只需单向的数据传输时，可以只接一根通信线

（4）当电平标准不一致时，需要加电平转换芯片

4、电平标准

        电平标准是数据1和数据0的表达方式，是传输线缆中人为规定的电压与数据的对应关系，串口常用的电平标准有如下三种：

        TTL电平：+3.3V或+5V表示1，0V表示0

        RS232电平：-3~-15V表示1，+3~+15V表示0

        RS485电平：两线压差+2~+6V表示1，-2~-6V表示0（差分信号）

5、串口参数及时序

（1）波特率：串口通信的速率

（2）起始位：标志一个数据帧的开始，固定为低电平

（3）数据位：数据帧的有效载荷，1为高电平，0为低电平，低位先行

（4）校验位：用于数据验证，根据数据位计算得来

（5）停止位：用于数据帧间隔，固定为高电平

三、USART简介

1、USART（Universal Synchronous/Asynchronous Receiver/Transmitter）通用同步/异步收发器

（1）USART是STM32内部集成的硬件外设，可根据数据寄存器的一个字节数据自动生成数据帧时序，从TX引脚发送出去，也可自动接收RX引脚的数据帧时序，拼接为一个字节数据，存放在数据寄存器里

（2）自带波特率发生器，最高达4.5Mbits/s

（3）可配置数据位长度（8/9）、停止位长度（0.5/1/1.5/2）

（4）可选校验位（无校验/奇校验/偶校验）

（5）支持同步模式、硬件流控制、DMA、智能卡、IrDA（用于红外通信的）、LIN（局域网的通信协议）

（6）STM32F103C8T6 USART资源： USART1（APB2总线上的设备）、 USART2（APB1）、 USART3（APB1）

2、USART框图

3、USART引脚

4、USART基本结构

5、数据帧

6、起始位侦测

7、数据采样

8、波特率发生器（分频器）

        发送器和接收器的波特率由波特率寄存器BRR里的DIV确定

        计算公式：波特率 = fPCLK2/1 / (16 * DIV)

9、数据模式

（1）HEX模式/十六进制模式/二进制模式：以原始数据的形式显示

（2）文本模式/字符模式：以原始数据编码后的形式显示

10、USART串口数据包

（1）HEX数据包

（2）文本数据包

（3）HEX数据包接收

（4）文本数据包接收

四、串口发送

1、按照以下接线方式连接，并将STLINK插到电脑上

2、查看串口驱动是否有问题

3、串口函数驱动模块

（1）USART库函数的功能

（2）Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>			//对printf进行重定向，将printf打印的东西输出到串口，因为printf默认输出到屏幕，单片机没有屏幕，所以要进行重定向
#include <stdarg.h>			//对sprintf进行封装的头文件

void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);		//开启时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;						//初始化GPIO
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;//TX:复用推挽输出
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	
	USART_InitTypeDef USART_InitStructure;						//初始化USART
	USART_InitStructure.USART_BaudRate=9600;
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode=USART_Mode_Tx;
	USART_InitStructure.USART_Parity=USART_Parity_No;//校验位
	USART_InitStructure.USART_StopBits=USART_StopBits_1;
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;
	USART_Init(USART1,&USART_InitStructure);
	
	USART_Cmd(USART1,ENABLE);									//开启USART
	
}

void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1,Byte);
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
}

void Serial_SendArray(uint8_t *Array,uint16_t Length)
{
	uint16_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendByte(Array[i]);
	}
}

void Serial_SendString(char *String)
{
	uint8_t i;
	for(i=0;String[i]!='\0';i++)
	{
		Serial_SendByte(String[i]);
	}
}

uint32_t Serial_Pow(uint32_t X,uint32_t Y)
{
	uint32_t Result =1;
	while(Y--)
	{
		Result *=X;
	}
	return Result;	//Result=X^Y
}

void Serial_SendNumber(uint32_t Number,uint8_t Length)
{
	uint8_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendByte(Number/Serial_Pow(10,Length - i - 1)%10 + '0');	//加上'0'或者0x30是以字符形式显示加的偏移
	}
}

int fputc(int ch,FILE *f)	//重定向
{
	Serial_SendByte(ch);
	return ch;
}

void Serial_Printf(char *format, ...)		//format：用来接收格式化字符串，...:用来接收后面的可变参数列表
{
	char String[100];
	va_list arg;//定义一个参数列表变量
	va_start(arg,format);//从format位置开始接收参数表，放在arg里面
	vsprintf(String,format,arg);//sprintf只能接受直接写的参数，对于封装格式，要用vsprintf
	va_end(arg);//释放参数表
	Serial_SendString(String);
}

（3）Serial.h

#ifndef __SERIAL_H
#define __SERIAL_H

#include <stdio.h>

void Serial_Init(void);
void Serial_SendByte(uint8_t Byte);
void Serial_SendArray(uint8_t *Array,uint16_t Length);
void Serial_SendString(char *String);
uint32_t Serial_Pow(uint32_t X,uint32_t Y);
void Serial_SendNumber(uint32_t Number,uint8_t Length);
void Serial_Printf(char *format, ...);

#endif

4、编写main.c代码

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"


int main(void)
{
	OLED_Init();
	Serial_Init();
	
	Serial_SendByte('A');						//发送字节
	
	uint8_t MyArray[]={0x42,0x43,0x44,0x45};	//发送数组
	Serial_SendArray(MyArray,4);
	
	Serial_SendString("\r\nNum1=");				//发送字符串
	
	Serial_SendNumber(111,3);					//发送字符形式的数字
	
	printf("\r\nNum2=%d",222);					//printf函数的移植法，重定向，printf只能有一个，重定向到串口1，串口2就没了
	
	char String[100];							//sprintf：多个串口都想用printf的方法
	sprintf(String,"\r\nNum3=%d",333);//sprintf可以指定打印位置，不涉及重定向
	Serial_SendString(String);
	
	Serial_Printf("\r\nNum4=%d",444);			//封装sprintf
	Serial_Printf("\r\n");
	Serial_Printf("你好，世界");//显示汉字的方法

	while(1)
	{
		
	}
}

5、实现效果

6、注意修改配置

（1）printf函数的移植法

        a.需要勾选Use MicroLIB

        b.重定向

（2）显示汉字的方法乱码的解决方案

        a.utf-8编码方式

        b.GB2312编码

删掉文字，重新打开文件，字体变为宋体，编码格式才算改过来

五、串口发送+接收

1、串口函数驱动模块

（1）Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>			//对printf进行重定向，将printf打印的东西输出到串口，因为printf默认输出到屏幕，单片机没有屏幕，所以要进行重定向
#include <stdarg.h>			//对sprintf进行封装的头文件

uint8_t Serial_RxData;
uint8_t Serial_RxFlag;

void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);		//开启时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;						//初始化GPIO
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;//TX:复用推挽输出
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;//RX:上拉输入，也可以选择浮空输入
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	
	USART_InitTypeDef USART_InitStructure;						//初始化USART
	USART_InitStructure.USART_BaudRate=9600;
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode=USART_Mode_Tx | USART_Mode_Rx;
	USART_InitStructure.USART_Parity=USART_Parity_No;//校验位
	USART_InitStructure.USART_StopBits=USART_StopBits_1;
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;
	USART_Init(USART1,&USART_InitStructure);
	
	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);				//开启中断，开启RXNE标志位到NVIC的输出
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);				//NVIC配置
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel=USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
	NVIC_Init(&NVIC_InitStructure);
	
	USART_Cmd(USART1,ENABLE);									//开启USART
	
}

/*
	发送字节
*/
void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1,Byte);
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
}

/*
	发送数组
*/
void Serial_SendArray(uint8_t *Array,uint16_t Length)
{
	uint16_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendByte(Array[i]);
	}
}

/*
	发送字符串
*/
void Serial_SendString(char *String)
{
	uint8_t i;
	for(i=0;String[i]!='\0';i++)
	{
		Serial_SendByte(String[i]);
	}
}

uint32_t Serial_Pow(uint32_t X,uint32_t Y)
{
	uint32_t Result =1;
	while(Y--)
	{
		Result *=X;
	}
	return Result;	//Result=X^Y
}

/*
	发送字符形式的数字
*/
void Serial_SendNumber(uint32_t Number,uint8_t Length)
{
	uint8_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendByte(Number/Serial_Pow(10,Length - i - 1)%10 + '0');	//加上'0'或者0x30是以字符形式显示加的偏移
	}
}

int fputc(int ch,FILE *f)	//重定向
{
	Serial_SendByte(ch);
	return ch;
}

/*
	sprintf的封装
*/
void Serial_Printf(char *format, ...)		//format：用来接收格式化字符串，...:用来接收后面的可变参数列表
{
	char String[100];
	va_list arg;//定义一个参数列表变量
	va_start(arg,format);//从format位置开始接收参数表，放在arg里面
	vsprintf(String,format,arg);//sprintf只能接受直接写的参数，对于封装格式，要用vsprintf
	va_end(arg);//释放参数表
	Serial_SendString(String);
}

/*
	获取接收标志位
*/
uint8_t Serial_GetRxFlag(void)
{
	if(Serial_RxFlag == 1)
	{
		Serial_RxFlag = 0;
		return 1;
	}
	return 0;
}

/*
	获取接收数据
*/
uint8_t Serial_GetRxData(void)
{
	return Serial_RxData;
}

/*
	中断
*/
void USART1_IRQHandler(void)
{
	if(USART_GetITStatus(USART1,USART_IT_RXNE) == SET)
	{
		Serial_RxData =USART_ReceiveData(USART1);
		Serial_RxFlag =1;
		USART_ClearITPendingBit(USART1,USART_IT_RXNE);
	}
}

（2）Serial.h

#ifndef __SERIAL_H
#define __SERIAL_H

#include <stdio.h>

void Serial_Init(void);
void Serial_SendByte(uint8_t Byte);
void Serial_SendArray(uint8_t *Array,uint16_t Length);
void Serial_SendString(char *String);
uint32_t Serial_Pow(uint32_t X,uint32_t Y);
void Serial_SendNumber(uint32_t Number,uint8_t Length);
void Serial_Printf(char *format, ...);

uint8_t Serial_GetRxFlag(void);
uint8_t Serial_GetRxData(void);


#endif

2、编写main.c代码

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"

uint8_t RxData;

int main(void)
{
	OLED_Init();
	Serial_Init();
	
	OLED_ShowString(1,1,"RxData:");

	while(1)
	{
		if(Serial_GetRxFlag() == 1)
		{
			RxData = Serial_GetRxData();
			Serial_SendByte(RxData);
			OLED_ShowHexNum(1,8,RxData,2);
		}
	}
}

3、实现效果

六、串口收发HEX数据包

1、按照以下接线方式连接，并将STLINK插到电脑上

2、HEX数据包函数驱动模块

（1）Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>			//对printf进行重定向，将printf打印的东西输出到串口，因为printf默认输出到屏幕，单片机没有屏幕，所以要进行重定向
#include <stdarg.h>			//对sprintf进行封装的头文件

uint8_t Serial_TxPacket[4];
uint8_t Serial_RxPacket[4];
uint8_t Serial_RxFlag;

void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);		//开启时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;						//初始化GPIO
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;//TX:复用推挽输出
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;//RX:上拉输入，也可以选择浮空输入
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	
	USART_InitTypeDef USART_InitStructure;						//初始化USART
	USART_InitStructure.USART_BaudRate=9600;
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode=USART_Mode_Tx | USART_Mode_Rx;
	USART_InitStructure.USART_Parity=USART_Parity_No;//校验位
	USART_InitStructure.USART_StopBits=USART_StopBits_1;
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;
	USART_Init(USART1,&USART_InitStructure);
	
	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);				//开启中断，开启RXNE标志位到NVIC的输出
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);				//NVIC配置
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel=USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
	NVIC_Init(&NVIC_InitStructure);
	
	USART_Cmd(USART1,ENABLE);									//开启USART
	
}

/*
	发送字节
*/
void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1,Byte);
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
}

/*
	发送数组
*/
void Serial_SendArray(uint8_t *Array,uint16_t Length)
{
	uint16_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendByte(Array[i]);
	}
}

/*
	发送字符串
*/
void Serial_SendString(char *String)
{
	uint8_t i;
	for(i=0;String[i]!='\0';i++)
	{
		Serial_SendByte(String[i]);
	}
}

uint32_t Serial_Pow(uint32_t X,uint32_t Y)
{
	uint32_t Result =1;
	while(Y--)
	{
		Result *=X;
	}
	return Result;	//Result=X^Y
}

/*
	发送字符形式的数字
*/
void Serial_SendNumber(uint32_t Number,uint8_t Length)
{
	uint8_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendByte(Number/Serial_Pow(10,Length - i - 1)%10 + '0');	//加上'0'或者0x30是以字符形式显示加的偏移
	}
}

int fputc(int ch,FILE *f)	//重定向
{
	Serial_SendByte(ch);
	return ch;
}

/*
	sprintf的封装
*/
void Serial_Printf(char *format, ...)		//format：用来接收格式化字符串，...:用来接收后面的可变参数列表
{
	char String[100];
	va_list arg;//定义一个参数列表变量
	va_start(arg,format);//从format位置开始接收参数表，放在arg里面
	vsprintf(String,format,arg);//sprintf只能接受直接写的参数，对于封装格式，要用vsprintf
	va_end(arg);//释放参数表
	Serial_SendString(String);
}

/*
	发送带包头包尾的数据包
*/
void Serial_SendPacket(void)
{
	Serial_SendByte(0xFF);
	Serial_SendArray(Serial_TxPacket,4);
	Serial_SendByte(0xFE);
}

/*
	获取接收标志位
*/
uint8_t Serial_GetRxFlag(void)
{
	if(Serial_RxFlag == 1)
	{
		Serial_RxFlag = 0;
		return 1;
	}
	return 0;
}

/*
	中断接收数据包
*/
void USART1_IRQHandler(void)
{
	static uint8_t RxState = 0;	//静态变量类似于全局变量，函数进入只会初始化一次0，在函数退出后数据仍然有效，但是只能在本函数使用
	static uint8_t pRxPacket = 0;	
	if(USART_GetITStatus(USART1,USART_IT_RXNE) == SET)
	{
		uint8_t RxData = USART_ReceiveData(USART1);
		if(RxState == 0)
		{
			if(RxData == 0xFF)
			{
				RxState = 1;
				pRxPacket=0;
			}
		}
		else if(RxState == 1)
		{
			Serial_RxPacket[pRxPacket] = RxData;
			pRxPacket++;
			if(pRxPacket >=4)
			{
				RxState = 2;
			}
		}
		else if(RxState == 2)
		{
			if(RxData == 0xFE)
			{
				RxState = 0;
				Serial_RxFlag = 1;
			}
		}
		USART_ClearITPendingBit(USART1,USART_IT_RXNE);
	}
}

（2）Serial.h

#ifndef __SERIAL_H
#define __SERIAL_H

#include <stdio.h>

extern uint8_t Serial_TxPacket[];
extern uint8_t Serial_RxPacket[];

void Serial_Init(void);
void Serial_SendByte(uint8_t Byte);
void Serial_SendArray(uint8_t *Array,uint16_t Length);
void Serial_SendString(char *String);
uint32_t Serial_Pow(uint32_t X,uint32_t Y);
void Serial_SendNumber(uint32_t Number,uint8_t Length);
void Serial_Printf(char *format, ...);

uint8_t Serial_GetRxFlag(void);


void Serial_SendPacket(void);

#endif

 3、编写main.c代码

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "button.h"

uint8_t KeyNum;

int main(void)
{
	OLED_Init();
	Button_Init();
	Serial_Init();
	
	OLED_ShowString(1,1,"TxPacket");
	OLED_ShowString(3,1,"RxPacket");
	
	Serial_TxPacket[0]=0x01;
	Serial_TxPacket[1]=0x02;
	Serial_TxPacket[2]=0x03;
	Serial_TxPacket[3]=0x04;
	

	while(1)
	{
		KeyNum = Button_GetNum();
		if(KeyNum == 1)
		{
			Serial_TxPacket[0]++;
			Serial_TxPacket[1]++;
			Serial_TxPacket[2]++;
			Serial_TxPacket[3]++;
			
			Serial_SendPacket();
			
			OLED_ShowHexNum(2,1,Serial_TxPacket[0],2);
			OLED_ShowHexNum(2,4,Serial_TxPacket[1],2);
			OLED_ShowHexNum(2,7,Serial_TxPacket[2],2);
			OLED_ShowHexNum(2,10,Serial_TxPacket[3],2);
		}
		if(Serial_GetRxFlag() == 1)
		{
			OLED_ShowHexNum(4,1,Serial_RxPacket[0],2);
			OLED_ShowHexNum(4,4,Serial_RxPacket[1],2);
			OLED_ShowHexNum(4,7,Serial_RxPacket[2],2);
			OLED_ShowHexNum(4,10,Serial_RxPacket[3],2);
			
		}
	}
}

 4、实现效果

串口收发HEX数据包

七、串口收发文本数据包

1、按照以下接线方式连接，并将STLINK插到电脑上

2、文本数据包函数驱动模块

（1）Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>			//对printf进行重定向，将printf打印的东西输出到串口，因为printf默认输出到屏幕，单片机没有屏幕，所以要进行重定向
#include <stdarg.h>			//对sprintf进行封装的头文件

char Serial_RxPacket[100];
uint8_t Serial_RxFlag;

void Serial_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);		//开启时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;						//初始化GPIO
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;//TX:复用推挽输出
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;//RX:上拉输入，也可以选择浮空输入
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	
	USART_InitTypeDef USART_InitStructure;						//初始化USART
	USART_InitStructure.USART_BaudRate=9600;
	USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode=USART_Mode_Tx | USART_Mode_Rx;
	USART_InitStructure.USART_Parity=USART_Parity_No;//校验位
	USART_InitStructure.USART_StopBits=USART_StopBits_1;
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;
	USART_Init(USART1,&USART_InitStructure);
	
	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);				//开启中断，开启RXNE标志位到NVIC的输出
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);				//NVIC配置
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel=USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
	NVIC_Init(&NVIC_InitStructure);
	
	USART_Cmd(USART1,ENABLE);									//开启USART
	
}

/*
	发送字节
*/
void Serial_SendByte(uint8_t Byte)
{
	USART_SendData(USART1,Byte);
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
}

/*
	发送数组
*/
void Serial_SendArray(uint8_t *Array,uint16_t Length)
{
	uint16_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendByte(Array[i]);
	}
}

/*
	发送字符串
*/
void Serial_SendString(char *String)
{
	uint8_t i;
	for(i=0;String[i]!='\0';i++)
	{
		Serial_SendByte(String[i]);
	}
}

uint32_t Serial_Pow(uint32_t X,uint32_t Y)
{
	uint32_t Result =1;
	while(Y--)
	{
		Result *=X;
	}
	return Result;	//Result=X^Y
}

/*
	发送字符形式的数字
*/
void Serial_SendNumber(uint32_t Number,uint8_t Length)
{
	uint8_t i;
	for(i=0;i<Length;i++)
	{
		Serial_SendByte(Number/Serial_Pow(10,Length - i - 1)%10 + '0');	//加上'0'或者0x30是以字符形式显示加的偏移
	}
}

int fputc(int ch,FILE *f)	//重定向
{
	Serial_SendByte(ch);
	return ch;
}

/*
	sprintf的封装
*/
void Serial_Printf(char *format, ...)		//format：用来接收格式化字符串，...:用来接收后面的可变参数列表
{
	char String[100];
	va_list arg;//定义一个参数列表变量
	va_start(arg,format);//从format位置开始接收参数表，放在arg里面
	vsprintf(String,format,arg);//sprintf只能接受直接写的参数，对于封装格式，要用vsprintf
	va_end(arg);//释放参数表
	Serial_SendString(String);
}

/*
	中断接收数据包
*/
void USART1_IRQHandler(void)
{
	static uint8_t RxState = 0;	//静态变量类似于全局变量，函数进入只会初始化一次0，在函数退出后数据仍然有效，但是只能在本函数使用
	static uint8_t pRxPacket = 0;	
	if(USART_GetITStatus(USART1,USART_IT_RXNE) == SET)
	{
		uint8_t RxData = USART_ReceiveData(USART1);
		if(RxState == 0)
		{
			if(RxData == '@' && Serial_RxFlag == 0)	//连续发送数据包，程序处理不及时，可能导致数据包错位，防止发送太快，还没有处理完，就跳过包头了
			{
				RxState = 1;
				pRxPacket=0;
			}
		}
		else if(RxState == 1)
		{
			if(RxData == '\r')
			{
				RxState = 2;
			}
			else
			{
				Serial_RxPacket[pRxPacket] = RxData;
				pRxPacket++;
			}
		}
		else if(RxState == 2)
		{
			if(RxData == '\n')
			{
				RxState = 0;
				Serial_RxPacket[pRxPacket] = '\0';
				Serial_RxFlag = 1;
			}
		}
		USART_ClearITPendingBit(USART1,USART_IT_RXNE);
	}
}

（2）Serial.h

#ifndef __SERIAL_H
#define __SERIAL_H

#include <stdio.h>

extern char Serial_RxPacket[];
extern uint8_t Serial_RxFlag;

void Serial_Init(void);
void Serial_SendByte(uint8_t Byte);
void Serial_SendArray(uint8_t *Array,uint16_t Length);
void Serial_SendString(char *String);
void Serial_SendNumber(uint32_t Number,uint8_t Length);
void Serial_Printf(char *format, ...);

#endif

 3、编写main.c代码

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "LED.h"

#include <string.h>	//判断字符串可以调用C语言字符串的官方库

int main(void)
{
	OLED_Init();
	LED_Init();
	Serial_Init();
	
	OLED_ShowString(1,1,"TxPacket");
	OLED_ShowString(3,1,"RxPacket");
	
	
	

	while(1)
	{
		if(Serial_RxFlag ==1)
		{
			OLED_ShowString(4,1,"                ");
			OLED_ShowString(4,1,Serial_RxPacket);
			
			if(strcmp(Serial_RxPacket,"LED_ON") == 0)	//判断两个字符串是否相等
			{
				LED1_ON();
				Serial_SendString("LED_ON_OK\r\n");
				OLED_ShowString(2,1,"                ");
				OLED_ShowString(2,1,"LED_ON_OK");
			}
			else if(strcmp(Serial_RxPacket,"LED_OFF") == 0)	//判断两个字符串是否相等
			{
				LED1_OFF();
				Serial_SendString("LED_OFF_OK\r\n");
				OLED_ShowString(2,1,"                ");
				OLED_ShowString(2,1,"LED_OFF_OK");
			}
			else
			{
				Serial_SendString("ERROR_COMMAND\r\n");
				OLED_ShowString(2,1,"                ");
				OLED_ShowString(2,1,"ERROR_COMMAND");
			}
			Serial_RxFlag=0;
		}
	}
}

 4、实现效果

串口收发文本数据包