STM32入门笔记11_USART串口数据包+案例: USART接收HEX数据包 USART接收文本数据包

已于 2023-06-30 23:06:07 修改
阅读量3.2k 收藏 25
点赞数 3
分类专栏： 单片机学习笔记 文章标签： stm32 单片机 嵌入式硬件 c语言
于 2023-04-06 21:00:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nanxl1/article/details/129999034
版权

USART串口数据包

数据模式

  • HEX模式/十六进制模式/二进制模式: 以原始数据的形式显示
  • 文本模式/字符模式
    在这里插入图片描述
    在这里插入图片描述

HEX数据包

  • 固定包长, 含包头包尾
    在这里插入图片描述

  • 可变包长, 含包头包尾

在这里插入图片描述

文本数据包

  • 固定包长, 含包头包尾

在这里插入图片描述

  • 可变包长, 含包头包尾

在这里插入图片描述

HEX数据包接收

在这里插入图片描述
在这里插入图片描述

文本数据包接收

在这里插入图片描述
在这里插入图片描述

状态机

状态机(State Machine): 实际就是指一个数学模型，可反映事物的不同状态，也就是数电学的状态转换图

想用好状态机的思想需要明白以下四个概念：

  • State, 状态(一个状态机至少有两种状态) 即图中 S, 当 S=0，S=1，S=2即对应了状态机的三种不同的状态
  • Event, 事件 图中收到‘@’，收到‘r’， 收到’\n’, 收到其他数据 即为四种不同的
  • Action, 动作 一般来说，每个事件发生后要有对应的动作(比如说 收到LED_ON指令(事件) 开启LED(动作))
  • Transition, 变换 特定事件发生后, 状态机的状态发生变化

状态机的思想在各种程序的编写中使用广泛

案例1: USART收发HEX数据包

主要函数

/*
	发送HEX数据包 
*/
void Serial_SendHexPacket(uint8_t * Arr)
{
	Send_Byte(0xFF);  // 发送包头
	Serial_SendArr(Arr, 4);
	Send_Byte(0xFE);  // 发送包尾
	Serial_SendString("\r\n");
}

/*
	中断函数, 根据状态机的思想
*/
void USART1_IRQHandler(void)
{
	static uint8_t i = 0;  // 下标
	if(USART_GetITStatus(USART1, USART_IT_RXNE) == SET)  // 接收寄存器不空
	{		
		uint8_t Serial_RxData;
		Serial_RxData = USART_ReceiveData(USART1);  // 接收数据
		if(RxState == 0)  // 等待包头
		{
			if(Serial_RxData == 0xFF)  // 获取到包头
			{
				RxState = 1;  // 转换
				i = 0;
			}
		}
		else if(RxState == 1) // 接收数据
		{
			
			RxPacket[i++] = Serial_RxData;
			if(i >= 4)  // 接收完数据
			{
				i = 0;
				RxState = 2;  // 转换状态
			}
		}else if(RxState == 2)  // 等待包尾
		{
			if(Serial_RxData==0xFE) // 接收到包尾
			{	
				RxState = 0; // 转换状态
				RxFlag = 1;
			}
		}
		// 清除中断标志
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);
	}
}

主要代码

main.c
#include "stm32f10x.h" 
#include "delay.h"
#include "OLED.h"
#include "key.h"
#include "serial.h"
// USART串口接收HEX数据包
// 2023年4月4日09:16:55
uint8_t Key_Num;
int main(void)
{
	OLED_Init();
	Serial_Init();
	Init_Key();
	OLED_ShowString(1, 1, "TxPacket");
	OLED_ShowString(3, 1, "RxPacket");
	TxPacket[0] = 0x00;
	TxPacket[1] = 0x01;
	TxPacket[2] = 0x02;
	TxPacket[3] = 0x03;
	Serial_SendHexPacket((uint8_t*)TxPacket);
	while(1)
	{
		Key_Num = Get_KeyNum();
		if(Key_Num == 2)  // 按键发送
		{
			TxPacket[0]++;
			TxPacket[1]++;
			TxPacket[2]++;
			TxPacket[3]++;
			Serial_SendHexPacket((uint8_t*)TxPacket);
			OLED_ShowHexNum(2, 1, TxPacket[0], 2);
			OLED_ShowHexNum(2, 4, TxPacket[1], 2);
			OLED_ShowHexNum(2, 7, TxPacket[2], 2);
			OLED_ShowHexNum(2, 10, TxPacket[3], 2);
		}
		if(RxFlag)  // 将接受的数据打印到OLED屏
		{
			OLED_ShowHexNum(4, 1, RxPacket[0], 2);
			OLED_ShowHexNum(4, 4, RxPacket[1], 2);
			OLED_ShowHexNum(4, 7, RxPacket[2], 2);
			OLED_ShowHexNum(4, 10, RxPacket[3], 2);
			RxFlag = 0;
		}
		
	}
}
Serial.c
#include "stm32f10x.h"

uint8_t RxPacket[4];  // 保存接收到的数据包
uint8_t TxPacket[4];  // 保存要发送的数据包
uint8_t RxFlag;  // 接收标志
uint8_t RxState; // 接收状态
void Serial_Init(void)
{
	// RCC使能时钟
	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_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_Rx | USART_Mode_Tx;
	USART_InitStructure.USART_Parity=USART_Parity_No;  // 奇偶校验
	USART_InitStructure.USART_StopBits=USART_StopBits_1;  // 停止位
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;  // 8位
	USART_Init(USART1, &USART_InitStructure);
	
	// 打开USART中断
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);  // 接收寄存器非空(正在接收)
	
	// 配置NVIC
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel= USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;
	NVIC_Init(&NVIC_InitStructure);
	
	// 启动USART
	USART_Cmd(USART1, ENABLE);
}

/*
	发送单个数据
*/
void Send_Byte(uint16_t Byte)
{
	USART_SendData(USART1, Byte);
	while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);  // 等待发送完毕
}

/*
	发送字符串
*/
void Serial_SendString(char * String)
{
	uint8_t i;
	for(i=0; String[i] != '\0'; ++i)
	{
		Send_Byte(String[i]);
	}
}

/*
	发送数组
*/
void Serial_SendArr(uint8_t * Arr, uint8_t Length)
{
	for(uint8_t i=0; i<Length; ++i)
	{
		Send_Byte(Arr[i]);
	}
}

/*
	发送HEX数据包 
*/
void Serial_SendHexPacket(uint8_t * Arr)
{
	Send_Byte(0xFF);
	Serial_SendArr(Arr, 4);
	Send_Byte(0xFE);
	Serial_SendString("\r\n");
}

/*
	中断函数
*/
void USART1_IRQHandler(void)
{
	static uint8_t i = 0;  // 下标
	if(USART_GetITStatus(USART1, USART_IT_RXNE) == SET)  // 接收寄存器不空
	{		
		uint8_t Serial_RxData;
		Serial_RxData = USART_ReceiveData(USART1);  // 接收数据
		if(RxState == 0)  // 等待包头
		{
			if(Serial_RxData == 0xFF)  // 获取到包头
			{
				RxState = 1;  // 转换
				i = 0;
			}
		}
		else if(RxState == 1) // 接收数据
		{
			
			RxPacket[i++] = Serial_RxData;
			if(i >= 4)  // 接收完数据
			{
				i = 0;
				RxState = 2;  // 转换状态
			}
		}else if(RxState == 2)  // 等待包尾
		{
			if(Serial_RxData==0xFE) // 接收到包尾
			{	
				RxState = 0; // 转换状态
				RxFlag = 1;
			}
		}
		// 清除中断标志
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);
	}
}
Serial.h
#ifndef __SERIAL_H
#define __SERIAL_H
void Serial_Init(void);
void Send_Byte(uint16_t Byte);
void Serial_SendString(char * String);
void Serial_SendArr(uint8_t * Arr, uint8_t Length);
void Serial_SendHexPacket(uint8_t * Arr);
void Serial_SendTxtPacket(char * String);
extern char RxPacket[];
extern char TxPacket[];
extern uint8_t RxFlag; 
extern uint8_t RxState;

#endif

案例2: USART收发文本数据包

主要函数

/*
	中断函数 状态机思想
*/
void USART1_IRQHandler(void)
{
	static uint8_t pRxData = 0;
	if(USART_GetITStatus(USART1, USART_IT_RXNE) == SET)  // 接收寄存器不空
	{		
		uint8_t Serial_RxData;
		Serial_RxData = USART_ReceiveData(USART1);  // 接收数据
		if(RxState == 0)  // 等待包头
		{
			if(Serial_RxData == '@' && RxFlag==0)  // 收到包头  
			{
				RxState = 1;  // 转换状态
				pRxData = 0;
			}
		}
		else if(RxState == 1)  // 接收数据打包
		{
			
			if(Serial_RxData == '\r')  // 收到完整数据
			{
				RxPacket[pRxData++] = Serial_RxData;  // 'r'
				RxState = 2;
			}else
			{
				RxPacket[pRxData++] = Serial_RxData;
			}

		}
		else if(RxState==2) // 等待包尾
		{
			if(Serial_RxData=='\n')
			{
				RxState = 0;
				RxPacket[pRxData++] = '\n';  // '\n'
				RxPacket[pRxData] = '\0';  // '字符串结束标志'
				RxFlag = 1;  // 接收完成标志位
			}
		}
		// 清除中断标志
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);
	}
}

主要代码

main.c
#include "stm32f10x.h" 
#include "delay.h"
#include "OLED.h"
#include "serial.h"
#include "LED.h"
#include <string.h>  // 字符串处理函数
// USART串口接收文本数据包
// 2023年4月6日19:22:18
uint8_t Key_Num;
int main(void)
{
	OLED_Init();
	Serial_Init();  // 串口初始化
	LED_Init();
	OLED_ShowString(1, 1, "TxPacket");
	OLED_ShowString(3, 1, "RxPacket");
	while(1)
	{
		if(RxFlag)  // 收到一个数据包
		{
			OLED_ShowString(4, 1, "                ");
			OLED_ShowString(4, 1, RxPacket);
            // 判断指令
			if(strcmp(RxPacket, "LED_On\r\n")==0)  
			{
				LED_On();  // 开灯
				Serial_SendString("LED_ON_OK\r\n");
				OLED_ShowString(2, 1, "                ");
				OLED_ShowString(2, 1, "LED_ON_OK");
			}else if(strcmp(RxPacket, "LED_Off\r\n")==0)  // strcmp 可以比较两字符串是否相同
			{
				LED_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");
			}
			RxFlag = 0;  // 清除自定义标志
		}
		
	}
}
serial.c
#include "stm32f10x.h"

char RxPacket[100];  // 保存接收到的数据包
char TxPacket[100];  // 保存要发送的数据包
uint8_t RxFlag;  // 接收标志
uint8_t RxState; // 接收状态
void Serial_Init(void)
{
	// RCC使能时钟
	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_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_Rx | USART_Mode_Tx;
	USART_InitStructure.USART_Parity=USART_Parity_No;  // 奇偶校验
	USART_InitStructure.USART_StopBits=USART_StopBits_1;  // 停止位
	USART_InitStructure.USART_WordLength=USART_WordLength_8b;  // 8位
	USART_Init(USART1, &USART_InitStructure);
	
	// 打开USART中断
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);  // 接收寄存器非空(正在接收)
	
	// 配置NVIC
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel= USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;
	NVIC_Init(&NVIC_InitStructure);
	
	// 启动USART
	USART_Cmd(USART1, ENABLE);
}

/*
	发送单个数据
*/
void Send_Byte(uint16_t Byte)
{
	USART_SendData(USART1, Byte);
	while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);  // 等待发送完毕
}

/*
	发送字符串
*/
void Serial_SendString(char * String)
{
	uint8_t i;
	for(i=0; String[i] != '\0'; ++i)
	{
		Send_Byte(String[i]);
	}
}

/*
	发送数组
*/
void Serial_SendArr(uint8_t * Arr, uint8_t Length)
{
	for(uint8_t i=0; i<Length; ++i)
	{
		Send_Byte(Arr[i]);
	}
}

/*
	发送HEX数据包 
*/
void Serial_SendHexPacket(uint8_t * Arr)
{
	Send_Byte(0xFF);
	Serial_SendArr(Arr, 4);
	Send_Byte(0xFE);
	Serial_SendString("\r\n");
}

/*
	发送文本数据包
*/
void Serial_SendTxtPacket(char * String)
{
	Serial_SendString("@");
	Serial_SendString(String);
	Serial_SendString("\r\n");
}

/*
	中断函数
*/
void USART1_IRQHandler(void)
{
	static uint8_t pRxData = 0;
	if(USART_GetITStatus(USART1, USART_IT_RXNE) == SET)  // 接收寄存器不空
	{		
		uint8_t Serial_RxData;
		Serial_RxData = USART_ReceiveData(USART1);  // 接收数据
		if(RxState == 0)  // 等待包头
		{
			if(Serial_RxData == '@' && RxFlag==0)  // 收到包头  
			{
				RxState = 1;  // 转换状态
				pRxData = 0;
			}
		}
		else if(RxState == 1)  // 接收数据打包
		{
			
			if(Serial_RxData == '\r')  // 收到完整数据
			{
				RxPacket[pRxData++] = Serial_RxData;
				RxState = 2;
			}else
			{
				RxPacket[pRxData++] = Serial_RxData;
			}

		}
		else if(RxState==2) // 等待包尾
		{
			if(Serial_RxData=='\n')
			{
				RxState = 0;
				RxPacket[pRxData++] = '\n';
				RxPacket[pRxData] = '\0';
				RxFlag = 1;  // 接收完成标志位
			}
		}
		// 清除中断标志
		USART_ClearITPendingBit(USART1, USART_IT_RXNE);
	}
}
serial.h
#ifndef __SERIAL_H
#define __SERIAL_H
void Serial_Init(void);
void Send_Byte(uint16_t Byte);
void Serial_SendString(char * String);
void Serial_SendArr(uint8_t * Arr, uint8_t Length);
void Serial_SendHexPacket(uint8_t * Arr);
void Serial_SendTxtPacket(char * String);
extern char RxPacket[];
extern char TxPacket[];
extern uint8_t RxFlag; 
extern uint8_t RxState;

#endif

参考资料

江科大STM32入门教程
什么是状态机？ - Peter 王广忠的文章 - 知乎

nanxl1
关注
  • 3
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
usart(spi).rar_usart to spi_串口发送hex
09-24
本程序，使用串口异步通信方式，将01 02 03 04***0A以hex的格式发送到计算机的串口。 每次单片机复位，发送一次。使用的是16f74芯片
【CubeIDE】STM32 HAL库史上最详细教程(一)：UART串口收发
qq_42652838的博客
08-04 4万+
博主能力有限，有错误望大佬指出    0x00 文章内容： UART阻塞方式收发 UART中断方式收发 UART中断回调函数 UART DMA方式收发 printf()函数串口重定向 0x01 UART阻塞方式收发 CubeMX or CubeIDE配置 1.开启debug 2.使用外部晶振     如果你的板子上没有晶振的话，就不要开了，不然stm32跑不起来 注： HSE：外部高速晶振     &
STM32标准库开发——串口收发HEX/文本数据包
纵行山河万里~
01-19 416
以0xFF为开头，0xFE为包围，中间固定四个字节长度的数据。
STM32学习笔记16：USART串口数据包
最新发布
m0_52540136的博客
02-11 1203
数据包的作用是把一个个单独的数据打包起来，方便进行多字节的数据通信。数据包的任务就是把属于同一批的数据进行打包和分割，方便接收方进行识别。数据包有多种分割方式，比如在数据的高位添加标志位、额外添加包头包尾等，串口数据包通常使用的是额外添加包头包尾的方式。以下列举了两种数据包格式，第一种是固定包长，含包头包尾，也就是每个数据包的长度都固定不变，数据包前面是包头，后面是包尾；第二种是可变包长，含包头包尾，也就是每个数据包的长度可以是不一样的，前面是包头，后面是包尾。
USART1固定长度数据包(hex)例程
01-03
USART1固定长度数据包(hex)例程
STM32学习笔记（十九）- 串口发送，收发，收发hex和文本数据
m0_74081875的博客
10-28 1194
封装一个函数，使得可以可以发送数据包的包头和包尾，还有有效载荷的数组。需要定义一个标志当前状态的变量，判断该数据是包头尾还是有效载荷。定义需要发送的数据包，固定有效载荷长度为4。然后在main.c中给数组传入数值。main.c 在OLED显示。Serial.c部分代码。Serial.h要声明。Serial.c要声明。
stm32f103c8串口收发例程
05-31
基于stm32f103c8t6的串口收发程序，编译软件为keil4。
江科大32——USART发送数据包原理
m0_56700794的博客
04-04 1381
只要通过包头包尾对齐数据，就可以严格知道那个数据是包头包尾，哪个数据是载荷数据，在接收载荷数据的时候不会判断它是否是包头包尾，在接收包头包尾时，会判断它是否属于包头包尾，用于数据对齐，经过几个数据包的对齐之后，剩下的数据包就不会出现问题了。，如果收到@就进入接收状态，在这个状态下接收数据，同时，这个状态还应该兼具等待包尾的功能。打包的方法可以自己设计，比如在XYZXYA数据流中，数据包的第一个数据即X的数据包，最高位置1，其余数据置0，接收数据后，判断最高位，如果是1就是X数据，接下来的数据就是Y和Z。
STM-32：USART串口协议、串口外设—数据发送/数据发送+接收
立于皓月之边，不弱星光之势
04-10 9418
STM-32：USART串口协议、串口外设—数据发送/数据发送+接收
备赛电赛学习STM32（十二）：USART串口进阶
m0_61022809的博客
01-27 1499
这里数据包都是一个字节一个字节组成的，如果你想发送16位的整型数据、32位的整型数据、float、double、甚至是结构体，其实都没问题，因为它们内部其实都是由一个字节一个字节组成的，只需要用一个uint8_t的指针指向它，把它们当成一个字节数组发送就行了。并不是所有情况我们都需要包头和包尾，比如我们可以只要一个包头，把包尾删掉，这样数据格式就是一个包头+4个数据，当监测到FF开始接收，收够4个字节置标志位，一个数据包接收完成（这样，载荷和宝投诉重复的问题会严重一些）
串口数据接收处理的一种方法
Engineer Hoo的博客
09-11 5478
在处理串口接收到的数据时，面临的问题主要是是如何解析接收到的数据，对于错误的如何处理等。不管是在微控制器中使用串口还是在桌面应用中使用串口，都需要解决这个接收的数据包处理的问题。最近在做一个应用，主要是上位机发送指令，查询下位机相关的数据。假设一帧数据是由10字节构成的，指令和应答数据均为10字节，应答数据发送频率为5Hz。有两个问题需要解决，第一个就是数据帧什么时候接收完成，第二个接收完成如何处...
关于STM32程序烧录的问题
08-04
绍了STM32单片机的程序烧录时的物理连接问题、hex问题等内容。
proteus仿真--两个STM32，各连8个流水灯，使用串口通讯进行同步
07-02
作品：proteus仿真--两个STM32，各连8个流水灯，使用串口通讯进行同步 使用材料：STM32F103、LED 平台：proteus 和 keil 技术实现：两个STM32，甲机连着8个流水灯，乙机连着8个流水灯，两机使用串口通讯，实现LED...
STM32 Uboot Hex文件 Nucleo144 discovery
06-24
压缩包内有两个用于Stm32F4xx的uboot烧录文件，使用的是自带开发板的USART1和USART3,基于Emcraft生成，使用NUCLEO F446ZE测试通过，用于F4XX系列应该都无问题
STM-32：串口收发数据包—串口收发HEX数据包/串口收发文本数据包
立于皓月之边，不弱星光之势
04-11 5142
STM-32：串口收发数据包—串口收发HEX数据包/串口收发文本数据包
STM32之USART串口接收数据处理
热门推荐
xiao小青年
04-28 8万+
//原帖http://bbs.elecfans.com/forum.php?mod=viewthread&tid=445463 //在学习过程中发现几处编译错误，并改正； //主要贴出定义、和中断函数部分； uint8_t usart_rx_buf[5][40];    //接收缓冲,最大40个字节 uint8_t usart_rx_temporary[40]; //数据保存暂存器,最
【STM32学习】——USART串口数据包&HEX/文本数据包&收发流程&串口收发HEX/文本数据包实操
weixin_51658186的博客
03-27 4883
本次学习有两个实操代码，第一个是串口收发HEX数据包，第二个是串口收发文本数据包做任何事情，都要有一股坚忍不拔的毅力，只要坚持，挺过风雨，终会看见彩虹；只要坚持，走过黑暗，总会拥抱黎明；只要坚持，战胜失败，总能赢得成功！今天的学习分享到此就结束了，我们下次再见！！STM32定时器输入捕获（IC）STM32定时器输出比较（PWM波）STM32定时中断STM32外部中断STM32GPIO精讲。
STM32串口接收数据包（自定义帧头帧尾）
m0_67069564的博客
12-06 2407
本实验基于stm32c8t6单片机，串口作为基础且重要的外设，具有广泛的应用。本文主要理解串口数据包的发送与接收是如何实现的，重要的是理解程序的实现思路。
串口接收完整一帧数据包
u011878611的博客
05-02 4404
学习记：本文介绍3种使用串口接受一帧完整数据包的方法，串口接收数据是字节接收的，串口每接收1字节数据，产生一个串口中断，我们在中断中将接收到的数据存放到buf中进行保存，但是数据的发送和接收都是按照帧为单位进行传输的，因此我们要在接收数据的同时判断当前接收的数据是否是完整的一帧。一般串口完整数据帧的定义：帧头（2字节，例如AA、BB） + 数据长度（2字节） + 数据 + CRC16校验（2字节） + 帧尾（2字节）
USART_ReceiveData解析
05-17
USART_ReceiveData() 函数是用于从 USART 接收数据的函数，其定义如下： ```c uint16_t USART_ReceiveData(USART_TypeDef* USARTx) ``` 其中，参数 USARTx 是USART外设的指针，可以是 USART1、USART2、USART3 等。 USART_ReceiveData() 函数会返回一个 uint16_t 类型的数据，这个数据就是从 USART 接收到的数据，返回值的范围是 0x00-0xFF，也就是 8 位二进制数。 需要注意的是，USART_ReceiveData() 函数是阻塞函数，如果 USART 接收缓冲区没有数据，程序会一直等待，直到有数据到来才会返回。因此，在使用 USART_ReceiveData() 函数时，需要注意程序的阻塞问题，可以采用中断或者 DMA 方式来接收 USART 数据，以提高程序的效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值