【自学嵌入式：stm32单片机】串口收发HEX数据包
串口收发HEX数据包
接线图
接收数据的状态图
代码实现
标准库实现
已开源到：https://gitee.com/qin-ruiqian/jiangkeda-stm32
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, ...);
uint8_t Serial_GetRxFlag(void);
void Serial_SendPacket(void);
#endif
Serial.c
#include "stm32f10x.h" // Device header
#include "stdio.h" //重写printf
#include "stdarg.h" //封装用
uint8_t Serial_RxFlag; //串口接收标志位
//缓冲区只存储载荷数据，不存储包头和包尾
uint8_t Serial_TxPacket[4]; //发送数据包的缓冲区
uint8_t Serial_RxPacket[4]; //接收数据包的缓冲区
// 初始化串口通信
void Serial_Init(void)
{
// 开启时钟，USART1是APB2的外设，其他的串口都是APB1的外设
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
// 开启GPIO时钟，后续在PA9 PA10读写数据
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
// 初始化GPIO引脚
// 将PA9配置为复用推挽输出，供USART1的TX使用
// 将PA10配置为上拉输入，供USART1的RX使用
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; // 复用推挽输出
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; // PA9做TX
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
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; // 1位停止位
USART_InitStructure.USART_WordLength = USART_WordLength_8b; // 8位字长，不需要奇偶校验位
USART_Init(USART1, &USART_InitStructure);
// 开启USART
USART_Cmd(USART1, ENABLE);
//对于串口接收来说，可以使用查询和中断两种方法
//如果使用查询，那初始化就结束了
//如果使用中断，那还需要在这里开启中断，配置NVIC
USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
//配置NVIC
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //2分组
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
//优先级都随便给个1
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_Init(&NVIC_InitStructure);
}
// 串口发送一个字节的数据
void Serial_SendByte(uint8_t Byte)
{
USART_SendData(USART1, Byte);
// 还需要等待一下，等TDR的数据转移到移位寄存器
// 要不然数据还在TDR进行等待，我们再写入数据，就会产生数据覆盖
while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET); // 等待发送寄存器空标志位置1
// 标志位置SET（高电平）后不需要手动清零
// 下一次再SendData，标志位自动清零
}
// 发送一个数组
// Array是数组首地址
// Length是数组长度
void Serial_SendArray(uint8_t *Array, uint16_t Length)
{
uint16_t i = 0; // 循环变量
for (i = 0; i < Length; i++)
{
Serial_SendByte(Array[i]);
}
}
// 发送一个字符串
void Serial_SendString(char *String)
{
uint8_t i = 0; // 循环遍历
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 = 0; // 循环遍历
for (i = 0; i < Length; i++)
{
//从个位开始发
Serial_SendByte(Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
}
}
//重写fputc函数
//printf函数的底层
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位置开始接收参数列表，放在arg里面
// 使用vsprintf将格式化字符串写入缓冲区
// vsprintf与sprintf类似，但接收的是可变参数列表，对封装格式，要用vsprintf
vsprintf(String, format, arg);
va_end(arg); //释放参数列表
Serial_SendString(String);
}
//获取串口接收标志位
uint8_t Serial_GetRxFlag(void)
{
if(Serial_RxFlag == 1)
{
Serial_RxFlag = 0;
return 1;
}
return 0;
}
//发送一个数据包
void Serial_SendPacket(void)
{
Serial_SendByte(0xFF); //发送包头
Serial_SendArray(Serial_TxPacket, 4); //发送载荷数据
Serial_SendByte(0xFE); //发送包尾
}
//中断处理
//用状态机完成接收数据包逻辑处理
void USART1_IRQHandler(void)
{
static uint8_t RxState = 0;
static uint8_t pRxPacket = 0; //指示接收到了第几个字节（下标判断），类似栈顶
//先判断标志位
if(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == SET)
{
uint8_t RxData = USART_ReceiveData(USART1);
//等待包头
switch(RxState)
{
case 0: //等待包头的程序
if(RxData == 0xFF)
{
RxState = 1; //说明收到包头，转移状态
pRxPacket = 0; //收到包头，开始接收，栈顶清零，为下次接收做准备
}
else
{
RxState = 0;
}
break;
case 1: //接收数据的程序
Serial_RxPacket[pRxPacket] = RxData;
pRxPacket++;
if(pRxPacket >= 4) //接收完所有载荷数据
{
RxState = 2; //转移到下一个状态
}
else
{
RxState = 1;
}
break;
case 2: //等待包尾的程序
if(RxData == 0xFE) //如果是包尾
{
RxState = 0; //回到最初的状态
Serial_RxFlag = 1; //置接收标志位为1
}
else
{
RxState = 2;
}
break;
}
}
}
main.c
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "MYOLED.h"
#include "Serial.h"
#include "Key.h"
uint8_t KeyNum; //按键键码值
int main(void)
{
MYOLED_Init();
Key_Init();
Serial_Init();
MYOLED_ShowString(0,0,"TxPacket");
MYOLED_ShowString(0,2,"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();
MYOLED_ShowHexNum(0,1,Serial_TxPacket[0],2);
MYOLED_ShowHexNum(3,1,Serial_TxPacket[1],2);
MYOLED_ShowHexNum(6,1,Serial_TxPacket[2],2);
MYOLED_ShowHexNum(9,1,Serial_TxPacket[3],2);
}
if(Serial_GetRxFlag() == 1)
{
//中断函数写入，这里读出
//如果读的太慢，就会造成读乱的情况
MYOLED_ShowHexNum(0,3,Serial_RxPacket[0],2);
MYOLED_ShowHexNum(3,3,Serial_RxPacket[1],2);
MYOLED_ShowHexNum(6,3,Serial_RxPacket[2],2);
MYOLED_ShowHexNum(9,3,Serial_RxPacket[3],2);
}
}
}
HAL库实现
已开源到：https://gitee.com/qin-ruiqian/jiangkeda-stm32-hal
Serial.h
/*
* Serial.h
*
* Created on: Aug 19, 2025
* Author: Administrator
*/
#ifndef HARDWARE_SERIAL_H_
#define HARDWARE_SERIAL_H_
//为了重写printf的全局变量
extern UART_HandleTypeDef* __printf_uhtd;
#include <stdio.h>
typedef struct Serial{
UART_HandleTypeDef* uhtd;
uint8_t Serial_RxData; //串口接收的数据
uint8_t Serial_RxFlag; //串口接收标志位
//缓冲区只存储载荷数据，不存储包头和包尾
uint8_t Serial_TxPacket[4]; //发送数据包的缓冲区
uint8_t Serial_RxPacket[4]; //接收数据包的缓冲区
uint8_t RxState; //接收数据包状态机状态
uint8_t pRxPacket; //指示接收到了第几个字节（下标判断），类似栈顶
}Serial;
void Serial_Init(Serial* pSerial, UART_HandleTypeDef* uhtd);
void Serial_SendByte(Serial* pSerial, uint8_t Byte);
void Serial_SendArray(Serial* pSerial, uint8_t *Array, uint16_t Length);
void Serial_SendNumber(Serial* pSerial, uint32_t Number, uint8_t Length);
void Serial_SendString(Serial* pSerial, char *String);
void Serial_Printf(Serial* pSerial, char* format, ...);
uint8_t Serial_GetRxFlag(Serial* pSerial);
void Serial_SendPacket(Serial* pSerial);
void Serial_ReceivePacketHandler(Serial* pSerial);
#endif /* HARDWARE_SERIAL_H_ */
Serial.c
/*
* Serial.c
*
* Created on: Aug 19, 2025
* Author: Administrator
*/
#include "stm32f1xx_hal.h"
#include "Serial.h"
#include "stdio.h" //重写printf
#include "stdarg.h" //封装用
#include "string.h" //获取字符串长度
UART_HandleTypeDef* __printf_uhtd;
//初始化
//传指针方便更新状态
//如果初始化函数中对句柄采用值传递（而非指针传递），会导致句柄状态无法被正确更新，进而使中断启动失败。
void Serial_Init(Serial* pSerial, UART_HandleTypeDef* uhtd)
{
pSerial->uhtd = uhtd;
__printf_uhtd = uhtd;
pSerial->Serial_RxData = 0;
pSerial->Serial_RxFlag = 0;
memset(pSerial->Serial_TxPacket, 0, sizeof(pSerial->Serial_TxPacket));
memset(pSerial->Serial_RxPacket, 0, sizeof(pSerial->Serial_RxPacket));
pSerial->RxState = 0;
pSerial->pRxPacket = 0;
HAL_UART_Receive_IT(pSerial->uhtd, &(pSerial->Serial_RxData), 1);
}
// 串口发送一个字节的数据
void Serial_SendByte(Serial* pSerial, uint8_t Byte)
{
HAL_UART_Transmit(pSerial->uhtd, &Byte, 1, HAL_MAX_DELAY);
}
// 发送一个数组
// Array是数组首地址
// Length是数组长度
void Serial_SendArray(Serial* pSerial, uint8_t *Array, uint16_t Length)
{
HAL_UART_Transmit(pSerial->uhtd, Array, Length, HAL_MAX_DELAY);
}
// 发送一个字符串
void Serial_SendString(Serial* pSerial, char *String)
{
HAL_UART_Transmit(pSerial->uhtd, (uint8_t *)String, strlen(String), HAL_MAX_DELAY);
}
//取次方函数
uint32_t Serial_Pow(uint32_t X, uint32_t Y)
{
uint32_t Result = 1;
while(Y--)
{
Result *= X;
}
return Result;
}
//发送一个数字
void Serial_SendNumber(Serial* pSerial, uint32_t Number, uint8_t Length)
{
uint8_t i = 0; // 循环遍历
for (i = 0; i < Length; i++)
{
//从个位开始发
Serial_SendByte(pSerial, Number / Serial_Pow(10, Length - i - 1) % 10 + '0');
}
}
//STM32CubeIDE用的是GCC
//Keil是fputc可以，STM32CubeIDE是用GCC，用的是__io_putchar
//此处是条件编译语句，让两类编译器都兼容
#ifdef __GNUC__
int __io_putchar(int ch)
{
uint8_t data = (uint8_t)ch; // 显式转换为uint8_t（1字节），匹配串口传输的字节类型
HAL_UART_Transmit(__printf_uhtd, &data, 1, HAL_MAX_DELAY);
return ch;
}
#else
int fputc(int ch, FILE *stream)
{
uint8_t data = (uint8_t)ch; // 显式转换为uint8_t（1字节），匹配串口传输的字节类型
HAL_UART_Transmit(__printf_uhtd, &data, 1, HAL_MAX_DELAY);
return ch;
}
#endif
//对sprintf进行封装
//用可变参数
void Serial_Printf(Serial* pSerial, char* format, ...)
{
char String[100]; //定义缓冲区存储格式化后的字符串
va_list arg; // 声明可变参数列表
va_start(arg, format); //从format位置开始接收参数列表，放在arg里面
// 使用vsprintf将格式化字符串写入缓冲区
// vsprintf与sprintf类似，但接收的是可变参数列表，对封装格式，要用vsprintf
vsprintf(String, format, arg);
va_end(arg); //释放参数列表
HAL_UART_Transmit(pSerial->uhtd, (uint8_t *)String, strlen(String), HAL_MAX_DELAY);
}
//获取串口接收标志位
uint8_t Serial_GetRxFlag(Serial* pSerial)
{
if(pSerial->Serial_RxFlag == 1)
{
pSerial->Serial_RxFlag = 0;
return 1;
}
return 0;
}
//发送一个数据包
void Serial_SendPacket(Serial* pSerial)
{
Serial_SendByte(pSerial, 0xFF); //发送包头
Serial_SendArray(pSerial, pSerial->Serial_TxPacket, 4); //发送载荷数据
Serial_SendByte(pSerial, 0xFE); //发送包尾
}
//用状态机完成接收数据包逻辑（此函数放入中断回调函数中）
void Serial_ReceivePacketHandler(Serial* pSerial)
{
HAL_UART_Receive_IT(pSerial->uhtd, &(pSerial->Serial_RxData), 1);
//等待包头
switch(pSerial->RxState)
{
case 0: //等待包头的程序
if(pSerial->Serial_RxData == 0xFF)
{
pSerial->RxState = 1; //说明收到包头，转移状态
pSerial->pRxPacket = 0; //收到包头，开始接收，栈顶清零，为下次接收做准备
}
else
{
pSerial->RxState = 0;
}
break;
case 1: //接收数据的程序
pSerial->Serial_RxPacket[pSerial->pRxPacket] = pSerial->Serial_RxData;
pSerial->pRxPacket++;
if(pSerial->pRxPacket >= 4) //接收完所有载荷数据
{
pSerial->RxState = 2; //转移到下一个状态
}
else
{
pSerial->RxState = 1;
}
break;
case 2: //等待包尾的程序
if(pSerial->Serial_RxData == 0xFE) //如果是包尾
{
pSerial->RxState = 0; //回到最初的状态
pSerial->Serial_RxFlag = 1; //置接收标志位为1
}
else
{
pSerial->RxState = 2;
}
break;
}
}
main.c
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2025 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "Serial.h"
#include "MYOLED.h"
#include "Key.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
Serial serial;
uint8_t KeyNum; //按键键码值
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1)
{
Serial_ReceivePacketHandler(&serial);
}
}
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
MYOLED_Init();
Serial_Init(&serial, &huart1);
MYOLED_ShowString(0,0,"TxPacket");
MYOLED_ShowString(0,2,"RxPacket");
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
KeyNum = Key_GetNum();
if(KeyNum == 1)
{
serial.Serial_TxPacket[0]++;
serial.Serial_TxPacket[1]++;
serial.Serial_TxPacket[2]++;
serial.Serial_TxPacket[3]++;
Serial_SendPacket(&serial);
MYOLED_ShowHexNum(0,1,serial.Serial_TxPacket[0],2);
MYOLED_ShowHexNum(3,1,serial.Serial_TxPacket[1],2);
MYOLED_ShowHexNum(6,1,serial.Serial_TxPacket[2],2);
MYOLED_ShowHexNum(9,1,serial.Serial_TxPacket[3],2);
}
if(Serial_GetRxFlag(&serial) == 1)
{
//中断函数写入，这里读出
//如果读的太慢，就会造成读乱的情况
MYOLED_ShowHexNum(0,3,serial.Serial_RxPacket[0],2);
MYOLED_ShowHexNum(3,3,serial.Serial_RxPacket[1],2);
MYOLED_ShowHexNum(6,3,serial.Serial_RxPacket[2],2);
MYOLED_ShowHexNum(9,3,serial.Serial_RxPacket[3],2);
}
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
实现效果
浙公网安备 33010602011771号