串口收发HEX数据包&串口收发文本数据包
数据包&状态机
- HEX数据包的固定长度和可变长度格式如图:
规定HEX数据以0xFF开头,以0xFE结尾,也可以作其他的规定.
- HEX数据包接收的状态机如图:
HEX数据包在被发送时,不用考虑太多细节问题(如中断,中断后的处理函数,数据包的包头包尾),只管发送就行,所以这里只列出接收数据包的状态机流程.
- 文本数据包的固定长度和可变长度格式如图:
规定文本数据以@开头,以回车键(‘\r\n’)结尾,也可以作其他的规定.
- 文本数据包接收的状态机如图:
- 文本数据包在被发送时,不用考虑太多细节问题(如中断,中断后的处理函数,数据包的包头包尾),只管发送就行,所以这里只列出接收数据包的状态机流程.
串口发送HEX数据包
- 接线图:
串口发送HEX数据包
- 修改上一个工程的Serial.c文件
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)
{
//USART1连接在APB2总线上,USART2和USART3连接在APB1总线上
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);
//PA10配置为接收引脚,故GPIO_Mode要从输入模式中选择
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 = DISABLE;
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);
// 等待发送数据寄存器空标志（TXE）置1（表示TDR为空，可接收新数据）
// 当写入USART_DR寄存器（如Serial_SendByte中的USART_SendData）时，TXE标志会自动清零
while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
}
//发送一个数组
void Serial_SendArray(uint8_t *Array,uint16_t Length)
{
uint32_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;
}
//十进制数字发送前预处理函数(递归版)
uint32_t Serial_Pow_Recusion(uint32_t X,uint32_t Y)
{
uint32_t Result;
if(Y > 0)
{
return X*Serial_Pow_Recusion(X,Y-1);
}
else
{
return 1;
}
}
//发送一个十进制数字
void Serial_SendNum(uint32_t Number,uint8_t Length)
{
uint8_t i;
for(i = 0; i < Length; i++)
{
/*
* 若直接发送数字的数值（如5），串口会将其视为二进制00000101，
* 发送到电脑端后显示为不可见的控制字符（如ENQ，ASCII 5），而非可读的'5'
* + '0'的本质是将数字的数值形式转换为对应的ASCII字符，
* + '0'的本质是将数字的数值形式转换为对应的ASCII字符，
* 确保串口发送的是可显示的数字字符（如'0'~'9'），而非不可见的二进制数值。
*/
Serial_SendByte(Number / Serial_Pow_Recusion(10,Length - i - 1) % 10 + '0');
}
}
//重定向prinf()函数
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);
vsprintf(String,format,arg);
va_end(arg);
Serial_SendString(String);
}
//将中断函数中获取到的标志位清除(若为1)并返回
uint8_t Serial_GetRxFlag(void)
{
if(Serial_RxFlag == 1)
{
Serial_RxFlag = 0;
return 1;
}
return 0;
}
//中断处理函数
void USART1_IRQHandler()
{
if(USART_GetFlagStatus(USART1,USART_IT_RXNE) == SET)
{
USART_ClearITPendingBit(USART1,USART_IT_RXNE);
}
}
//发送一个数据包
void Send_SendPacket(void)
{
Serial_SendByte(0xFF);
Serial_SendArray(Serial_TxPacket,4);
Serial_SendByte(0xFE);
}
Serial.h代码:
#ifndef __SERIAL_
#define __SERIAL_
#include <stdio.h>
extern uint8_t Serial_TxPacket[];
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_SendNum(uint32_t Number,uint8_t Length);
void Serial_Printf(char *format,...);
uint8_t Serial_GetRxData(void);
uint8_t Serial_GetRxFlag(void);
void Send_SendPacket(void);
#endif
值得注意的是:
①在Serial.h中声明的数组代码:extern uint8_t Serial_TxPacket[];,与Serial.h中的数组代码:uint8_t Serial_TxPacket[4];不同的是,Serial.h中的数据没有定义大小,而是只给了一个[],为什么要这样?答:告诉编译器这个数组存在，但不分配内存，也不需要知道具体大小,可以节省空间.若头文件中定义数组大小，当多个源文件(.c文件)包含该头文件时，会导致重复定义错误（Linker Error: multiple definition）。
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初始化
Serial_Init();
Serial_TxPacket[0] = 0x01;
Serial_TxPacket[1] = 0x02;
Serial_TxPacket[2] = 0x03;
Serial_TxPacket[3] = 0x04;
Send_SendPacket();
while (1)
{
}
}
串口接收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)
{
//USART1连接在APB2总线上,USART2和USART3连接在APB1总线上
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);
//PA10配置为接收引脚,故GPIO_Mode要从输入模式中选择
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 = DISABLE;
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);
// 等待发送数据寄存器空标志（TXE）置1（表示TDR为空，可接收新数据）
// 当写入USART_DR寄存器（如Serial_SendByte中的USART_SendData）时，TXE标志会自动清零
while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
}
//发送一个数组
void Serial_SendArray(uint8_t *Array,uint16_t Length)
{
uint32_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;
}
//十进制数字发送前预处理函数(递归版)
uint32_t Serial_Pow_Recusion(uint32_t X,uint32_t Y)
{
uint32_t Result;
if(Y > 0)
{
return X*Serial_Pow_Recusion(X,Y-1);
}
else
{
return 1;
}
}
//发送一个十进制数字
void Serial_SendNum(uint32_t Number,uint8_t Length)
{
uint8_t i;
for(i = 0; i < Length; i++)
{
/*
* 若直接发送数字的数值（如5），串口会将其视为二进制00000101，
* 发送到电脑端后显示为不可见的控制字符（如ENQ，ASCII 5），而非可读的'5'
* + '0'的本质是将数字的数值形式转换为对应的ASCII字符，
* + '0'的本质是将数字的数值形式转换为对应的ASCII字符，
* 确保串口发送的是可显示的数字字符（如'0'~'9'），而非不可见的二进制数值。
*/
Serial_SendByte(Number / Serial_Pow_Recusion(10,Length - i - 1) % 10 + '0');
}
}
//重定向prinf()函数
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);
vsprintf(String,format,arg);
va_end(arg);
Serial_SendString(String);
}
//将中断函数中获取到的标志位清除(若为1)并返回
uint8_t Serial_GetRxFlag(void)
{
if(Serial_RxFlag == 1)
{
Serial_RxFlag = 0;
return 1;
}
return 0;
}
//中断处理函数
void USART1_IRQHandler(void)
{
//static修饰的变量相当于全局变量,即使本函数在推出后,值依然保存
static uint8_t RxState = 0;
static uint8_t pRxPacket = 0;
if(USART_GetFlagStatus(USART1,USART_IT_RXNE) == SET)
{
uint8_t RxData = USART_ReceiveData(USART1);
if(RxState == 0)
{
if(RxData == 0xFF)
{
RxState = 1;
}
}
else if(RxState == 1)
{
Serial_RxPacket[pRxPacket ++] = RxData;
if(pRxPacket >= 4)
{
RxState = 2;
}
}
else if(RxState == 2)
{
if(RxData == 0xFE)
{
RxState = 0;
Serial_RxFlag = 1;
}
}
USART_ClearITPendingBit(USART1,USART_IT_RXNE);
}
}
//发送一个数据包
void Send_SendPacket(void)
{
Serial_SendByte(0xFF);
Serial_SendArray(Serial_TxPacket,4);
Serial_SendByte(0xFE);
}
值得注意的是:
①在中断处理函数void USART1_IRQHandler(void);中,static修饰的变量相当于全局变量,即使本函数在推出后,值依然保存,RxState 用来存储程序进行到哪一步,pRxPacket 用来给数组序号自增.第一个if语句的条件是用来指明现在寄存器里面有数据,该取数据了.
②在中断处理函数void USART1_IRQHandler(void);中,uint8_t RxData = USART_ReceiveData(USART1);RxData被设置为1B是因为接收寄存器最大只能接收1B数据,多了就会溢出.
③在中断处理函数void USART1_IRQHandler(void);中,代码:
if(RxState == 0) { if(RxData == 0xFF) { RxState = 1; } }
采用if嵌套的原因是:如果不采用if嵌套,直接让RxState = 1;,那么会满足下一个if条件,导致两个if条件满足.
Serial.h代码:
#ifndef __SERIAL_
#define __SERIAL_
#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_SendNum(uint32_t Number,uint8_t Length);
void Serial_Printf(char *format,...);
uint8_t Serial_GetRxData(void);
uint8_t Serial_GetRxFlag(void);
void Send_SendPacket(void);
#endif
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初始化
Serial_Init();
Serial_TxPacket[0] = 0x01;
Serial_TxPacket[1] = 0x02;
Serial_TxPacket[2] = 0x03;
Serial_TxPacket[3] = 0x04;
Send_SendPacket();
while (1)
{
if(Serial_GetRxFlag() == 1)
{
OLED_ShowHexNum(1,1,Serial_RxPacket[0],2);
OLED_ShowHexNum(1,4,Serial_RxPacket[1],2);
OLED_ShowHexNum(1,7,Serial_RxPacket[2],2);
OLED_ShowHexNum(1,10,Serial_RxPacket[3],2);
}
}
}
值得注意的是:
①在数组Serial_RxPacket[]中,系统在中断函数中调用该数组来写入数据,在主函数里调用该数组来读取数组数据,这会造成一些问题,就是数据包可能会混杂到一起.比如读取数据的过程太慢,这是后面写入的数据就有可能刷新为下一个数据包的数据,解决方法是在接收部分的代码前进行判断,是否读取的数据是排列好的数据包的数据.
- 修改一下main.c文件形成最终代码:
最终main.c代码:
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "Key.h"
uint8_t RxData;
uint8_t KeyNum;
int main(void)
{
/*模块初始化*/
OLED_Init(); //OLED初始化
Key_Init();
Serial_Init();
Serial_TxPacket[0] = 0x01;
Serial_TxPacket[1] = 0x02;
Serial_TxPacket[2] = 0x03;
Serial_TxPacket[3] = 0x04;
OLED_ShowString(1,1,"TxPacket:");
OLED_ShowString(3,1,"RxPacket:");
while (1)
{
KeyNum = Key_GetNum();
if(KeyNum == 1)
{
Serial_TxPacket[0] ++;
Serial_TxPacket[1] ++;
Serial_TxPacket[2] ++;
Serial_TxPacket[3] ++;
Send_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);
}
}
}
值得注意的是:
①发送数据包是指由STM32向电脑端发送数据,接收数据包是指由电脑端数据发送到STM32,由STM32进行接收,接收部分的代码复杂度要高于发送部分,是因为发送数据包时只管发送数据就行了,不需要考虑接收的细节,而接收数据包时要考虑发送方的数据包格式(如包头包尾),每次要接受一字节数据(因为接收寄存器大小就一字节,数据来不及接收会造成数据溢出)还要进行中断.
串口收发文本数据包
Serial.c代码:
#include "stm32f10x.h" // Device header
#include <stdio.h>
#include <stdarg.h>
//不知道要发的数据长度,这里给100
char Serial_RxPacket[100];
uint8_t Serial_RxFlag = 0;
void Serial_Init(void)
{
//USART1连接在APB2总线上,USART2和USART3连接在APB1总线上
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);
//PA10配置为接收引脚,故GPIO_Mode要从输入模式中选择
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 = DISABLE;
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);
// 等待发送数据寄存器空标志（TXE）置1（表示TDR为空，可接收新数据）
// 当写入USART_DR寄存器（如Serial_SendByte中的USART_SendData）时，TXE标志会自动清零
while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
}
//发送一个数组
void Serial_SendArray(uint8_t *Array,uint16_t Length)
{
uint32_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;
}
//十进制数字发送前预处理函数(递归版)
uint32_t Serial_Pow_Recusion(uint32_t X,uint32_t Y)
{
uint32_t Result;
if(Y > 0)
{
return X*Serial_Pow_Recusion(X,Y-1);
}
else
{
return 1;
}
}
//发送一个十进制数字
void Serial_SendNum(uint32_t Number,uint8_t Length)
{
uint8_t i;
for(i = 0; i < Length; i++)
{
/*
* 若直接发送数字的数值（如5），串口会将其视为二进制00000101，
* 发送到电脑端后显示为不可见的控制字符（如ENQ，ASCII 5），而非可读的'5'
* + '0'的本质是将数字的数值形式转换为对应的ASCII字符，
* + '0'的本质是将数字的数值形式转换为对应的ASCII字符，
* 确保串口发送的是可显示的数字字符（如'0'~'9'），而非不可见的二进制数值。
*/
Serial_SendByte(Number / Serial_Pow_Recusion(10,Length - i - 1) % 10 + '0');
}
}
//重定向prinf()函数
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);
vsprintf(String,format,arg);
va_end(arg);
Serial_SendString(String);
}
//中断处理函数
void USART1_IRQHandler(void)
{
//static修饰的变量相当于全局变量,即使本函数在推出后,值依然保存
static uint8_t RxState = 0;
static uint8_t pRxPacket = 0;
if(USART_GetFlagStatus(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;
}
}
else if(RxState == 2)
{
if(RxData == '\n')
{
RxState = 0;
//文本模式要对发送的数据最后加上一个结束标志位,方便最后对字符串进行处理
Serial_RxPacket[pRxPacket] = '\0';
Serial_RxFlag = 1;
}
}
USART_ClearITPendingBit(USART1,USART_IT_RXNE);
}
}
值得注意的是:
①在本工程中,由于文本指令长度是不确定的,所以接收数据的数组的长度尽量设置多一点,这里先给100.
②输入的文本规定以@开头,在状态机的代码中,即中断处理函数中,if(RxData == ‘@’ && Serial_RxFlag == 0),意思是检测到文本@(即文本开头,意味着文本开始传输)和Serial_RxFlag = 0(用于控制数组写入和读取的速率,防止因读取数据过慢造成的读取数据错误,在main.c中,Serial_RxFlag =0;表示数据读取完成).
③在状态机代码中,else if(RxState == 1)的语句模块中,RxData == ‘\r’表示读取到’\r’,之后要将RxState置为2,因为在文本输入结束后,要再次按一个回车键,此时文本就会产生"\r\n"的回车字符,读取到\r意味着文本读取结束(此时还没读取到\n).
④在状态机代码中,else if(RxState == 2)的语句模块中,if(RxData == ‘\n’)表示读取到\n,此时表示字符输入已经彻底结束,要进行收尾工作,将RxState 置为0,以便进行下一次的从@(文本开始标志)的读取.Serial_RxPacket[pRxPacket] = ‘\0’;将文本读取到数组后,加上一个’\0’字符(字符串结束标志位),之后方便对该子文本进行字符串操作.Serial_RxFlag = 1;表示文本读取到数组完成,之后进行main.c的后续代码操作(对保存在数组内的数据的操作),最后加上一句Serial_RxFlag =0;表示对数组内读取的文本数据操作完成,Serial_RxFlag 的不同状态实现了读取数据保存到数组完成后再次进行数据处理(从数组中取数据)的操作,存在先后顺序,不会出现因读取速度不一致导致的数据读取错误的结果.
main.c代码:
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include <string.h>
#include "LED.h"
uint8_t RxData;
uint8_t KeyNum;
int main(void)
{
/*模块初始化*/
OLED_Init(); //OLED初始化
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);
//strcmp是字符串比较函数,比较成功就返回0
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;
}
}
扫一扫
6696
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
