STM32个人学习笔记（标准库）-2023.09.23

最新推荐文章于 2024-06-07 22:16:40 发布

Skystrike.️

最新推荐文章于 2024-06-07 22:16:40 发布

阅读量134

点赞数

文章标签： stm32 学习笔记

本文链接：https://blog.csdn.net/qq_50714547/article/details/133207268

版权

第九节、USART串口协议

9.1 USART简介

通信接口：

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

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

串口通信：

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

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

串口的硬件电路：

简单双向串口通信有两根通信线（发送端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（差分信号）。使用RS485电平，通信最远可达上千米。

串口参数及时序：

波特率：串口通信的速率（一般来说，串口是异步通信，所以需要约定一个通信速率）。波特率即为每秒传输码元的个数。

起始位：标志一个数据帧的开始，固定为低电平。具体的原理是：当从空闲转为发送数据时，会产生一个起始位，这个起始位固定位低电平，标志着数据传输的开始，同理，在数据传输结束后会产生一个停止位，停止位固定为高电平，标志着数据传输完成，并且一直保持为高电平直到下一次数据传输开始。

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

校验位：用于数据验证，根据数据位计算得来。校验可以选择三种模式：无校验、奇校验、偶校验。（无校验的波形如左图所示，奇偶校验的波形如右图所示）

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

9.2 串口时序波形分析

TX引脚输出定时翻转的高低电平，RX引脚定时读取引脚的高低电平，每个字节的数据加上起始位、停止位、可选的校验位打包为数据帧，依次输出在TX引脚，另一端RX引脚依次接收，就完成了字节数据的传递。

9.3 USART外设

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

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

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

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

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

支持同步模式、硬件流控制、DMA、智能卡、IrDA、LIN。

USART的框图：

STM32的起始位监测：

STM32具有起始位监测的功能，具体的实现方法是：输入电路对采样时钟进行了细分，以波特率的16倍频率进行采样，最开始时，空闲状态为高电平，当采样开始时，检测到低电平产生。在起始位，将进行16次采样，如果没有噪声，则采样的结果都应该是0。接收电路将在下降沿的3,5,7次进行采样，8,9,10次在进行一次采样，并且要求每一批采样里的三个数据中至少有2个为0。当只有2个0，1个1时，状态寄存器中将置一个NE的噪声标志位。否则就不算检测到起始位。

波特率发生器：

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

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

9.4 USART的基本结构

根据上图,USART初始化可分为以下几个步骤：

1、RCC开启时钟，将需要用到的USART和GPIO的时钟打开。

2、GPIO初始化，将TX配置为复用输出，RX配置为输入。

3、配置USART。

4、当只需要发送功能时，直接开启USART;当同时需要接收功能时，可能需要配置中断。

9.5 USART相关库函数

void USART_DeInit(USART_TypeDef* USARTx);//恢复缺省配置
void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct);//USART初始化
void USART_StructInit(USART_InitTypeDef* USART_InitStruct);//结构体初始化
/*配置时钟同步输出*/
void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct);
void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct);

void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState);//使能USART
void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState);//中断配置
void USART_DMACmd(USART_TypeDef* USARTx, uint16_t USART_DMAReq, FunctionalState NewState);//开启USART到DMA的触发通道
void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address);
void USART_WakeUpConfig(USART_TypeDef* USARTx, uint16_t USART_WakeUp);
void USART_ReceiverWakeUpCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint16_t USART_LINBreakDetectLength);
void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);//发送数据-写DR寄存器
uint16_t USART_ReceiveData(USART_TypeDef* USARTx);//接收数据-读DR寄存器
void USART_SendBreak(USART_TypeDef* USARTx);
void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime);
void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler);
void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_OverSampling8Cmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_OneBitMethodCmd(USART_TypeDef* USARTx, FunctionalState NewState);
void USART_IrDAConfig(USART_TypeDef* USARTx, uint16_t USART_IrDAMode);
void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState);
/*标志位相关函数*/
FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG);
void USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG);
ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT);
void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT);

9.6 代码实现USART功能

9.6.1 串口发送

Serial.c:

#include "stm32f10x.h"                  // Device header
#include "stdio.h"
#include "stdarg.h"
void Serial_Init(void)
{
	/*RCC开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	/*GPIO初始化*/
	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*/
	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*/
	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;
}
/*发送数字函数*/
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函数*/
int fputc(int ch,FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

/*对sprintf函数进行封装*/
void Serial_Printf(char *format,...)
{
	char String[100];
	va_list arg;//定义一个参数列表变量
	va_start(arg,format);//从format位置开始接收参数表
	vsprintf(String,format,arg);
	va_end(arg);
	Serial_SendString(String);
}

main函数：

#include "stm32f10x.h"                  // Device header
#include "OLED.h"
#include "Delay.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);
	char String[100];
	sprintf(String,"\r\nNum3=%d",333);
	Serial_SendString(String);
	
	Serial_Printf("\r\nNum4=%d",444);
	Serial_Printf("\r\n");
	while(1)
	{
	
	}
}

最终串口助手上的结果如下图:

9.6.2 串口发送与接收

对于串口接收，可以采用查询或中断两种方法，使用查询时，只需判断RXNE标志位，如果RXNE标志位置1，说明收到数据，调用ReceiveData读取DR寄存器就可以。

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开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	/*GPIO初始化*/
	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*/
	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*/
	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=2;
	NVIC_Init(&NVIC_InitStructure);
	/*使能USART*/
	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;
}
/*发送数字函数*/
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函数*/
int fputc(int ch,FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

/*对sprintf函数进行封装*/
void Serial_Printf(char *format,...)
{
	char String[100];
	va_list arg;//定义一个参数列表变量
	va_start(arg,format);//从format位置开始接收参数表
	vsprintf(String,format,arg);
	va_end(arg);
	Serial_SendString(String);
}

/*获得数据标志位函数*/
uint8_t Serial_GetFlag(void)
{
	if(Serial_RxFlag == 1)
	{
		Serial_RxFlag = 0;
		return 1;
	}
	else
	{
		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);
	}
}

main函数：

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

uint8_t RxData;
int main(void)
{
	OLED_Init();
	Serial_Init();
	OLED_ShowString(1,1,"RxData:");
	
	while(1)
	{
		if(Serial_GetFlag() == 1)
		{
		RxData = Serial_GetRxData();
		Serial_SendByte(RxData);
		OLED_ShowHexNum(1,8,RxData,2);
		}
	}
}

9.7 USART串口数据包

HEX数据包：

包头包尾数据重复问题：当想要传输的数据和包头包尾的数据重复，可能会引起误判。对应这种问题，有以下的几个解决方法：

1、限制载荷数据的范围。

2、使用固定长度数据包。

3、增加包头包尾的数量。

文本数据包：

文本数据包通常使用换行字符作为结尾，比较灵活。

上面两种数据包各有优劣，HEX数据包的优势在于：传输直接、解析数据非常简单，适合模块发送原始数据；而缺点就是灵活性不足，载荷容易和包头包尾重复。文本数据包的优势在于：数据直观易理解，非常灵活，适合输入指令进行人机交互的场合；缺点就是解析效率低。

HEX数据包的接收

状态机：在程序中，设计一个能记住不同状态的机制，在不同的状态，执行不同的操作，同时还要进行状态的合理转移。

9.8 代码实现串口收发数据包

串口收发HEX数据包

Serial.c:

#include "stm32f10x.h"                  // Device header
#include "stdio.h"
#include "stdarg.h"
uint8_t Serial_TxPacket[4];
uint8_t Serial_RxPacket[4];
uint8_t Serial_RxFlag;
void Serial_Init(void)
{
	/*RCC开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	/*GPIO初始化*/
	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*/
	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*/
	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=2;
	NVIC_Init(&NVIC_InitStructure);
	/*使能USART*/
	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;
}
/*发送数字函数*/
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函数*/
int fputc(int ch,FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

/*对sprintf函数进行封装*/
void Serial_Printf(char *format,...)
{
	char String[100];
	va_list arg;//定义一个参数列表变量
	va_start(arg,format);//从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_GetFlag(void)
{
	if(Serial_RxFlag == 1)
	{
		Serial_RxFlag = 0;
		return 1;
	}
	else
	{
		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);
	}
}

main函数：

#include "stm32f10x.h"                  // Device header
#include "OLED.h"
#include "Delay.h"
#include "Serial.h"
#include "Key.h"
uint8_t RxData;
uint8_t KeyNum;
int main(void)
{
	OLED_Init();
	Serial_Init();
	Key_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_GetFlag() == 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"
char Serial_RxPacket[100];
uint8_t Serial_RxFlag;
void Serial_Init(void)
{
	/*RCC开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	/*GPIO初始化*/
	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*/
	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*/
	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=2;
	NVIC_Init(&NVIC_InitStructure);
	/*使能USART*/
	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;
}
/*发送数字函数*/
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函数*/
int fputc(int ch,FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

/*对sprintf函数进行封装*/
void Serial_Printf(char *format,...)
{
	char String[100];
	va_list arg;//定义一个参数列表变量
	va_start(arg,format);//从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';
			Serial_RxFlag = 1;
		}
	}
	USART_ClearITPendingBit(USART1,USART_IT_RXNE);
	}
}

main函数：

#include "stm32f10x.h"                  // Device header
#include "OLED.h"
#include "Delay.h"
#include "Serial.h"
#include "Key.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,"LED1_ON") == 0)
			{
			LED1_ON();
			Serial_SendString("LED1_ON_OK\r\n");
			OLED_ShowString(2,1,"                ");
			OLED_ShowString(2,1,"LED1_ON_OK");
			}
			else if(strcmp(Serial_RxPacket,"LED1_OFF") == 0)
			{
			LED1_OFF();
			Serial_SendString("LED1_OFF_OK\r\n");
			OLED_ShowString(2,1,"                ");
			OLED_ShowString(2,1,"LED1_OFF_OK");
			}
			else if(strcmp(Serial_RxPacket,"LED2_ON") == 0)
			{
			LED2_ON();
			Serial_SendString("LED2_ON_OK\r\n");
			OLED_ShowString(2,1,"                ");
			OLED_ShowString(2,1,"LED2_ON_OK");
			}
			else if(strcmp(Serial_RxPacket,"LED2_OFF") == 0)
			{
			LED2_OFF();
			Serial_SendString("LED2_OFF_OK\r\n");
			OLED_ShowString(2,1,"                ");
			OLED_ShowString(2,1,"LED2_OFF_OK");
			}
			else
			{
			Serial_SendString("ERROR_COMMAND\r\n");
			OLED_ShowString(2,1,"                ");
			OLED_ShowString(2,1,"ERROR_COMMAND");
			}
			
			Serial_RxFlag =0;
		}
		
	}
}

Skystrike.️

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
STM32个人学习笔记（标准库）-2023.09.23

通信接口：通信的目的：将一个设备的数据传送到另一个设备，扩展硬件系统。通信协议：制定通信的规则，通信双方按照协议规则进行数据收发。串口通信：串口是一种应用十分广泛的通讯接口，串口成本低、容易使用、通信线路简单，可实现两个设备的互相通信。单片机的串口可以使单片机与单片机、单片机与电脑、单片机与各式各样的模块互相通信，极大地扩展了单片机的应用范围，增强了单片机系统的硬件实力。串口的硬件电路：简单双向串口通信有两根通信线（发送端TX和接收端RX）TX与RX要交叉连接。
复制链接

扫一扫