9 串口通信（三）

9.4 USART串口数据包

HEX数据包

1）固定包长，含包头包尾

例如陀螺仪的数据，需要XYZ坐标一起打包

2）可变包长，含包头包尾

如果定义的包头包尾刚刚好也是数据，这样容易混淆，解决的办法：

1.限制载荷数据的范围；
2.使用固定长度的数据包，进行数据对齐；
3.增加包头包尾的数量

包头包尾不一定全部都需要，比如可以只需要一个包头，把包尾删掉

固定包长和可变包长的选择问题

文本数据包

1）固定包长，含包头包尾

2）可变包长，含包头包尾

HEX数据包和文本数据包优缺点：

HEX数据包传输直接，解析数据非常简单，适合一些模块发送原始的数据，比如使用串口通信的陀螺仪和温湿度传感器等；
文本数据包数据直观易理解，非常灵活，比较适合输入指令进行人机交互的场合，比如蓝牙模块常用的AT指令，CNC和3D打印的常用G代码。

HEX数据包接收

在程导设计中，需没计一个能记住不同状态的机制，在不同状态执行不同的操作，同时还要进行状态的合理转移，这种程序设计思维称为状态机，

第一个状态（S=0）：等待包头；第二个状态（S=1）：接收数据；第三个状态（S=2）:等待包尾。

文本数据包接收

9.5 串口收发HEX数据包&串口收发文本数据包

1)串口收发HEX数据包

主函数：

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

uint8_t KeyNum;

int main(void)
{
	OLED_Init();
	Key_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 = Key_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);
		}
	}
}

Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>

//记得在头文件声明数组外部可调用，加上extern
uint8_t Serial_TxPacket[4];
uint8_t Serial_RxPacket[4];
uint8_t Serial_RxFlag;

void Serial_Init(void)
{
	//第一步，开启时钟，把需要用的USART和GPIO的时钟打开
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	//第二步，GPIO初始化，把TX配置成复用推挽输出
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	//把RX配置成上拉输入
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	//第三步，初始化USART，直接使用一个结构体
	USART_InitTypeDef USART_InitStructure;
	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
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);		//分组
	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，发送功能准备完毕
	USART_Cmd(USART1, ENABLE);
}

//发送一个字节数据的函数
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]);
	}
}

//次方函数，X的Y次方
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y --)
	{
		Result *= X;
	}
	return Result;
}

//发送一个数字数据的函数（从高位到低位）
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');
	}
}

//fputc函数重定向到串口，print打印就是不断调用fputc函数一个个打印的
int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

//对sprintf函数进行封装（char *format：用来接收格式化字符串，...：用来接收后面可变参数列表）
void Serial_Printf(char *format, ...)
{
	char String[100];
	va_list arg;
	va_start(arg, format);
	vsprintf(String, format, arg);
	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;
	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)串口收发文本数据包

主函数：

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

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遗漏出来长的数据字符串
			OLED_ShowString(4, 1, Serial_RxPacket);		//然后再写入
			
			if (strcmp(Serial_RxPacket, "LED_ON") == 0)	//strcmp函数用于判断两个字符串是否相等，相等为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;
		}
	}
}

Serial.c

#include "stm32f10x.h"                  // Device header
#include <stdio.h>
#include <stdarg.h>

//记得在头文件声明数组外部可调用，加上extern
char Serial_RxPacket[100];
uint8_t Serial_RxFlag;

void Serial_Init(void)
{
	//第一步，开启时钟，把需要用的USART和GPIO的时钟打开
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	//第二步，GPIO初始化，把TX配置成复用推挽输出
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	//把RX配置成上拉输入
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	//第三步，初始化USART，直接使用一个结构体
	USART_InitTypeDef USART_InitStructure;
	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
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);		//分组
	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，发送功能准备完毕
	USART_Cmd(USART1, ENABLE);
}

//发送一个字节数据的函数
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]);
	}
}

//次方函数，X的Y次方
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
	uint32_t Result = 1;
	while (Y --)
	{
		Result *= X;
	}
	return Result;
}

//发送一个数字数据的函数（从高位到低位）
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');
	}
}

//fputc函数重定向到串口，print打印就是不断调用fputc函数一个个打印的
int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

//对sprintf函数进行封装（char *format：用来接收格式化字符串，...：用来接收后面可变参数列表）
void Serial_Printf(char *format, ...)
{
	char String[100];
	va_list arg;
	va_start(arg, format);
	vsprintf(String, format, arg);
	va_end(arg);
	Serial_SendString(String);
}

//状态机
void USART1_IRQHandler(void)
{
	static uint8_t RxState = 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';	//给字符组最后一个字符加一个结束标志位\0，方便后续处理
				Serial_RxFlag = 1;
			}
		}
		
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);  //读后自动清除
	}
}

注意：数据发送不能过快，否则程序会没有反应