STM32——USART串口

一、通信接口

• 通信的目的：将一个设备的数据传送到另一个设备，扩展硬件系统
• 通信协议：制定通信的规则，通信双方按照协议规则进行数据收发

• 单端信号通信的双方必须要共地，因为都是对GND的电压差
• 同步信号都由一根时钟线，异步信号需要规定采样频率等
• 差分电平抗干扰好，适用于远距离传输
• 多设备需要通过寻址

二、串口通信

• 串口是一种应用十分广泛的通讯接口，串口成本低、容易使用、通信线路简单，可实现两个设备的互相通信
• 单片机的串口可以使单片机与单片机、单片机与电脑（通过USB转串口模块）、单片机与各式各样的模块互相通信，极大地扩展了单片机的应用范围，增强了单片机系统的硬件实力

• CH340芯片实现USB协议转串口协议

三、硬件电路

• 简单双向串口通信有两根通信线（发送端TX和接收端RX）
  • 复杂的串口通信还有时钟引脚，硬件流控制引脚
• TX与RX要交叉连接
• 当只需单向的数据传输时，可以只接一根通信线（单工通信）
• 当电平标准不一致时，需要加电平转换芯片

四、电平标准

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

  • TTL电平：+3.3V或+5V表示1，0V表示0
  • RS232电平：-3 ~ -15V表示1，+3 ~ +15V表示0
  • RS485电平：两线压差+2 ~ +6V表示1，-2 ~ -6V表示0（差分信号）

五、串口参数及时序

串口发送数据的数据帧

• 波特率：串口通信的速率（串口采样频率）
  • 每秒传输码元个数，单位：码元（位）/秒，bps
• 起始位：标志一个数据帧的开始，固定为低电平
• 数据位：数据帧的有效载荷，1为高电平，0为低电平，低位先行（stm32的USART外设会自动翻转电平）
• 校验位：用于数据验证，根据数据位中1的个数计算得来（无、奇、偶校验）【CRC校验更好】
• 停止位：用于数据帧间隔，固定为高电平

六、STM32的USART外设简介

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

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

• 自带波特率发生器，最高达4.5Mbits/s【其实就是分频器，比如APB2总线是72MHZ频率，分频之后得到波特率时钟，在此频率下收发信号】

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

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

• 支持同步模式（多了时钟CLK输出）、硬件流控制（接收方在控制线上置高电平表示还未准备接收数据）、DMA、智能卡、IrDA、LIN

• STM32F103C8T6 USART资源： USART1（APB2总线）、 USART2、 USART3

七、USART框图

数据的流动

• 发送数据寄存器（TDR）——》发送移位寄存器——》TX
• RX——》接收移位寄存器——》接受数据寄存器（RDR）

工作原理

• 当发送数据寄存器（TDR）将一个字节的数据发送到移位寄存器时，此时TXE标志位会置1，表示TDR可以写入新的数据，然后移位寄存器在发送控制器的做用下一位一位的发送到TX引脚，当移位寄存器为空的时候发送数据寄存器就会将一个字节的数据写入到移位寄存器。

• RX将数据发送到接收移位寄存器，在接收控制器的作用下，将数据从移位寄存器发送到接受数据寄存器（RDR），此时RXNE置1

• 采用两个寄存器进行缓存，可以提高工作效率

• 发送数据寄存器和接受数据寄存器占用同一个地址，即软件上只有一个寄存器的存在，硬件上是两个寄存器

增强功能介绍

• 硬件数据流控：避免数据接收发送太快而导致丢失数据

• 需要接外部支持流控的串口，（例如内部的nRTS与外部的nCTS交叉连接进行通信，可以接收则发送低电平）

  • nRTS（request，n低电平有效）
  • nCTS（clear）

• SCLK

  • 配合发送移位寄存器工作，每发送一位，时钟就走一个周期，只支持输出，作用是兼容别的协议，例如SPI

• 唤醒单元

  • 实现串口挂载多设备，在一条总线上接多个设备，每个设备都有一个地址，要通信先寻址

• 中断控制

  • 右边是状态寄存器SR，其中TXE表示发送寄存器为空，RXNE表示接收寄存器为空
  • 左边是控制寄存器CR

• USART_BRR波特率发生器

  • 发送器时钟与接收器时钟
  • USART1是72MHZ，USART2/3是36MHZ

八、USART基本结构

• 接收到数据会置标示位为1，同时可以申请中断，需要配置中断ITConfig和NVIC
• 输入采用浮空输入或上拉输入，串口空闲时是高电平，不能使用下拉输入

引脚的模式

九、数据帧

• 空闲帧和断开帧是局域网协议使用
• 9位字长一般设置一个校验位
• 8位字长一般不设置校验位

• 一般采用一个停止位

十、起始位侦测和采样位置对齐

• 对一位采样16次
• 有噪声EN位会置1

十一、数据采样

十二、波特率发生器

• DIV分为整数和小数，实现更加细腻的分频

• 发送器和接收器的波特率由波特率寄存器USART_BRR里的DIV确定，通过以下公式计算并写入到寄存器中，使用库函数只需要写波特率，会自动计算DIV的值并写入寄存器中

  • 计算公式：波特率 = fPCLK2/1 / (16 * DIV)【内部16倍波特率的采样时钟，一位采样16次】

十三、数据模式

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

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

• ASCLL编码表
  

• 发送方与接收方的数据传输过程，发送方也可以发送字符A，会通过ASCLL编码表转化为十六进制发送给接收方
  

十四、串口发送

电路设计

• PA9引脚接收电脑端发送的数据，在OLED显示屏上打印

关键代码

serial.c

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

void Serial_Init(void)
{
    
    
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	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);
	
	USART_InitTypeDef USART_InitStructure;
	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);
}
//发送一个字节数据
void Serial_SendByte(uint8_t Byte)
{
    
    
	USART_SendData(USART1, Byte);//调用该函数，Byte变量会写入到TDR
	while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);//等待数据从DR寄存器到移位寄存器，TXE标志位会置1，无须手动清零，在对USART_DR写操作时会将该位清零
}
//发送一个数组
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;
	//空字符0的转义形式就是'\0'
	//在ASCLL中一个字符占一个字节
	for (i = 0; String[i] != '\0'; i ++)
	{
    
    
		Serial_SendByte(String[i]);
	}
}

/*
	需要拆分数字，以十进制形式拆开
	12345/10000%10=1
	123456/1000%10=2
	
	数字/10*x%10=某一位
	写次方函数返回x的y次方
*/

//次方函数，返回值为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');
		//从高位到低位依次发送，以字符的形式发送要加偏移0x30即'0'
	}
	}
}
//printf（）的重定向
int fputc(int ch, FILE *f)
{
    
    
	Serial_SendByte(ch);
	return ch;
}
//方法三：封装sprintf
/*
	sprintf支持可变参数，在封装的时候要注意
	引入头文件#include <stdarg.h>

*/
void Serial_Printf(char *format, ...)//...接收可变参数列表
{
    
    
	char String[100];
	va_list arg;//定义一个参数列表变量va_list 类型名，arg变量名
	va_start(arg, format);//从format位置开始接收参数表，放在arg里面
	vsprintf(String, format, arg);
	va_end(arg);//释放参数表
	Serial_SendString(String);
}

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(0x41);
	
	uint8_t MyArray[] = {
    
    0x42, 0x43, 0x44, 0x45};
	Serial_SendArray(MyArray, 4);
	
	Serial_SendString("\r\nNum1=");
	
	Serial_SendNumber(111, 3);
	//printf重定向方法一
	printf("\r\nNum2=%d", 222);
	
	//printf重定向方法二：不涉及重定向，适用于多个串口都使用printf
	char String[100];//定义接收格式化字符串的位置
	sprintf(String, "\r\nNum3=%d", 333);//sprintf是格式化输出，第一个参数是指定格式化打印的位置
	Serial_SendString(String);
	
	//printf重定向方法三：封装sprintf
	Serial_Printf("\r\nNum4=%d", 444);
	Serial_Printf("\r\n");
	
	while (1)
	{
    
    
		
	}
}

USART_SendData()函数

该函数的作用是向DR寄存器发送一个字节的数据

void USART_SendData(USART_TypeDef* USARTx, uint16_t Data)
{
    
    
  /* Check the parameters */
  assert_param(IS_USART_ALL_PERIPH(USARTx));
  assert_param(IS_USART_DATA(Data)); 
    
  /* Transmit Data */
  USARTx->DR = (Data & (uint16_t)0x01FF);//与运算将高位清零
}

方法一：printf函数的移植

• 勾选精简库Use MicroLIB
  
• printf重定向
  • printf函数默认输出到屏幕，需要修改为串口通道
  • 引入printf的头文件：#include <stdio.h>
  • 重新写fputc（）函数，因为printf函数调用fputc实现输出功能，所以修改fputc函数内部，重定向到串口

    int fputc(int ch, FILE *f)
    {
            
            
    	Serial_SendByte(ch);
    	return ch;
    }
    

显示汉字不乱码

采用UTF-8编码

• 添加该命令
  
• 修改编码模式
  
• 修改文本编码模式
  

采用GB2312编码

• 修改编码模式，重启文件
  

• 修改文本编码模式
  

十五、串口发送+接收（只支持一个字节的接收）

电路设计

• PA9引脚接收电脑端发送的数据，在OLED显示屏上打印
• PA10引脚发送发送移位寄存器里面的数据到电脑端

关键代码

串口接收可以采用查询和中断两种，查询方法是在main函数中查找标志位并读取数据，采用中断方式也是RXNE标志位置1然后会发起中断，需要打开中断通道和写中断响应函数

serial.c

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

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_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);
	
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//输入模式改为上拉输入
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10引脚为RX
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	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);
	
	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_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]);
	}
}

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

int fputc(int ch, FILE *f)
{
    
    
	Serial_SendByte(ch);
	return ch;
}

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);
}
//返回RXNE标志位的状态
uint8_t Serial_GetRxFlag(void)
{
    
    
	if (Serial_RxFlag == 1)
	{
    
    
		Serial_RxFlag = 0;
		return 1;
	}
	return 0;
}
//返回DR寄存器里面的值
uint8_t Serial_GetRxData(void)
{
    
    
	return Serial_RxData;
}

void USART1_IRQHandler(void)
{
    
    
	if (USART_GetITStatus(USART1, USART_IT_RXNE) == SET)//RXNE置1表示数据达到DR寄存器
	{
    
    
		Serial_RxData = USART_ReceiveData(USART1);//读取DR寄存器的值后RXNE就会清零
		Serial_RxFlag = 1;
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);//清除RXNE标志位，可以不清除
	}
}

main.c

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

uint8_t RxData;

int main(void)
{
    
    
	OLED_Init();
	OLED_ShowString(1, 1, "RxData:");
	
	Serial_Init();
	
	while (1)
	{
    
    
		if (Serial_GetRxFlag() == 1)
		{
    
    
			RxData = Serial_GetRxData();//获取数据寄存器里面的值
			Serial_SendByte(RxData);//将数据寄存器里面的值发送到串口
			OLED_ShowHexNum(1, 8, RxData, 2);//在屏幕打印发送到串口的值
		}
	}
}

十六、串口数据包的定义

数据包的作用就是将属于同一批的数据进行打包和分割

HEX数据包格式定义

• 如何避免数据和包头包尾重复？
  • 限制载荷数据的范围，避免和包头包尾重复
  • 尽量使用固定长度的数据包，只要对齐就不会判断错误
  • 增加包头包尾的数量，呈现出载荷出现不了的状态

文本数据包格式定义

• 每个字节经过编码和译码
• 通常以换行作为包尾
• Hex数据包适合发送原始数据，缺点是容易载荷与包头包尾重复
• 文本数据包发送适合蓝牙模块的AT指令，CNC和3D打印的G代码，缺点是解析效率低

十七、串口数据包的接收

• 由于每收到一个字节，程序都会进入中断，而各个字节之间存在关系，需要记录他们之间的关系，需要使用状态机来进行合理的操作
• 使用状态机的方法来接收一个数据包，设置多标志状态，在不同状态执行不同操作，同时还有进行状态的合理转移

HEX数据包接收流程

文本数据包接收流程

十七、串口收发HEX数据包

功能：PB1接入按钮，点击按钮发送数据包，PC端的串口助手打印接收到的数据，显示屏展示接收到的数据

关键代码

serial.c

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

uint8_t Serial_TxPacket[4];				//只存储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_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);
	
	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_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);
	
	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_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]);
	}
}

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

int fputc(int ch, FILE *f)
{
    
    
	Serial_SendByte(ch);
	return ch;
}

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);
	}
}

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);
void Serial_SendNumber(uint32_t Number, uint8_t Length);
void Serial_Printf(char *format, ...);

void Serial_SendPacket(void);
uint8_t Serial_GetRxFlag(void);

#endif

main.c

#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);
		}
	}
}

十八、串口收发文本数据包

功能：PA1接小灯，串口助手输入特定数据包完成开灯关灯操作

关键代码

serial.c

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

char Serial_RxPacket[100];				//"@MSG\r\n"
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_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);
	
	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_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);
	
	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_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]);
	}
}

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

int fputc(int ch, FILE *f)
{
    
    
	Serial_SendByte(ch);
	return ch;
}

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)//避免接收数据太快，等到数据包接收状态标志位为0才开始接收新的数据包
			{
    
    
				RxState = 1;
				pRxPacket = 0;
			}
		}
		else if (RxState == 1)
		{
    
    
		//由于数据长度不定，每次都需要判断是否接收到\r，是则等待包尾，不是则继续接收
			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);
	}
}

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

main.c

#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_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;
		}
	}
}

参考视频：江科大自化协