STM32USART串口数据包

已于 2024-03-01 17:45:59 修改
阅读量1.6k 收藏 28
点赞数 36
分类专栏： STM32学习记录 文章标签： stm32 嵌入式硬件 单片机
于 2024-03-01 17:42:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53922901/article/details/136396488
版权

文章目录

前言

当串口需要发送多个字节的数据时，使用数据包的形式来发送和接收是更加方便的，还可以更好的区分各个字节数据所对应的内容。例如需要发送X,Y,Z来控制陀螺仪传感器的X,Y,Z，就可以使用数据包的格式。

一、介绍部分

数据包两种包装方式（分割数据）

发送一连串数据时，无法精准的确定此数据对应哪一位，所以需要分割数据来使其位置一一对应。或者限制数据的大小来避免数据与包头包尾重复。

1. 使用包头加包尾把数据给包裹起来
在数据与包头包尾有重复时，尽量使用固定包长的方法，以免错误的识别到包头或包尾导致数据错误。
2. 使用一位标志位来确定数据开始

HEX数据包

在这里插入图片描述

文本数据包

在这里插入图片描述

数据包的收发流程

数据包的发送

和普通的数据发送一致，使用一个数组来接收这个数据包，然后使用相关的发送函数即可。

数据包的接收

每接收一个字节的数据，程序就会进入一次中断然后退出中断，所以每个数据的接收是独立的，所以要针对不同的状态进行对应的判断和进行相关的偏移，使这些数据关联起来，也就是状态机思路。

固定包长的hex数据包接收

如图，判断包头为状态s=1，判断成功使状态s=2，则接收数据状态，接收满4个数据后，使状态s=3，判断包尾，判断成功后进入下一轮。
在这里插入图片描述

可变包长的文本数据包接收

在这里插入图片描述

二、实例部分

固定包长的hex数据包接收

使按下按键可以发送递增数据包，将接收的数据包与发送的数据包都显示到OLED上

连接线路

在这里插入图片描述

代码实现

串口配置Serial.c

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

uint8_t TxData[4];	// 发送数据包
uint8_t RxData[4];  // 接收数据包
uint8_t 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;	// A9 发送数据
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		// 50Hz翻转速度
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;		// 上拉输出
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;	// A10 接收数据
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		// 50Hz翻转速度
	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
	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);

	
	// USART1使能
	USART_Cmd(USART1,ENABLE);
}

// 发送函数
void USART_SendByte(uint8_t Byte){
	USART_SendData(USART1,Byte);
	// 等待写入完成，写入完成之后会将标志位自动清0
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
}

// 发送数组函数
void USART_SendArray(uint8_t *Array,uint16_t Length){
	uint8_t i = 0;
	for(i=0;i<Length;i++){
		USART_SendData(USART1,Array[i]);
		// 等待写入完成，写入完成之后会将标志位自动清0
		while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
	}
}

// 发送字符串函数
void USART_SendString(uint8_t *String){
	uint8_t i = 0;
	for(i=0;String[i]!='\0';i++){
		USART_SendData(USART1,String[i]);
		// 等待写入完成，写入完成之后会将标志位自动清0
		while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
	}
}

// 返回X的Y次方
uint32_t Serial_Pow(uint32_t X,uint32_t Y){
	uint32_t Result = 1;
	while(Y--){
		Result *= X;
	}
	return Result;
}
// 发送数字函数
void USART_SendNum(uint32_t Num,uint16_t Length){
	uint8_t i = 0;
	for(i=0;i<Length;i++){
		USART_SendByte(Num / Serial_Pow(10,Length-i-1) % 10 + 0x30);
		// 等待写入完成，写入完成之后会将标志位自动清0
		while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
	}
}

//重定向fputc函数，fputc是printf函数的底层，printf通过不停的调用fputc来达到输出的效果
//重定向到串口
int fputc(int ch,FILE *f){
	USART_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);
	USART_SendString((uint8_t*)String);
}

// 获取RxFlag
uint8_t USART_GetRxFlag(void){
	if(RxFlag == 1){
		RxFlag = 0;
		return 1;
	}
	return 0;
}


void USART_SendPacket(void){
	USART_SendByte(0xff);				// 发送包头
	USART_SendArray(TxData,4);	// 发送数据
	USART_SendByte(0xfe);				// 发送包尾
}

//中断函数
void USART1_IRQHandler(void){
	static uint8_t RxStatus = 0;		// 数据包状态
	static uint8_t RxCount = 0;
	if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET){
		uint8_t RXDATA = USART_ReceiveData(USART1);	// 获取接收到的数据
		if(RxStatus == 0){
			if(RXDATA == 0xff){
				RxStatus = 1;
			}
		}else if(RxStatus == 1){
			RxData[RxCount] = RXDATA;
			RxCount++;
			if(RxCount >= 4){
				RxCount = 0;
				RxStatus = 2;
			}
		}else if(RxStatus == 2){
			if(RXDATA == 0xfe){
				RxStatus = 0;
				RxFlag = 1;
			}
		}
	}
}

按键button.c

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

/**
  * @brief  初始化Button相关端口
  * @param 	无
  * @retval 无
  */
void Button_Init(void){
	// 初始化时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;		// 上拉输出,按下为0
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;	
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		// 50Hz翻转速度
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	// 使这两个端口默认高电平，不然初始化后默认是低电平
	GPIO_SetBits(GPIOB, GPIO_Pin_1);
}
/**
  * @brief  返回所按按键值
  * @param 	无
  * @retval KeyNum 按键值
  */
uint8_t Key_Num(void){
	uint8_t KeyNum = 0;
	if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1)==0){
		Delay_ms(20);
		while(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1)==0);
		Delay_ms(20);
		KeyNum = 1;
	}
	if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11)==0){
		Delay_ms(20);
		while(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11)==0);
		Delay_ms(20);
		KeyNum = 11;
	}
	return KeyNum;
}

主函数main.c

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

uint8_t KeyNum;

int main(void)
{
	OLED_Init();
	OLED_ShowString(1, 1, "TxData:");
	OLED_ShowString(3, 1, "RxData:");
	Button_Init();
	Serial_Init();
	TxData[0] = 0x01;
	TxData[1] = 0x02;
	TxData[2] = 0x03;
	TxData[3] = 0x04;
	
	//USART_SendPacket();
	while (1)
	{
		KeyNum = Key_Num();
		if(KeyNum == 1){
			TxData[0] ++;
			TxData[1] ++;
			TxData[2] ++;
			TxData[3] ++;
			USART_SendPacket();
			OLED_ShowHexNum(2,1,TxData[0],2);
			OLED_ShowHexNum(2,4,TxData[1],2);
			OLED_ShowHexNum(2,7,TxData[2],2);
			OLED_ShowHexNum(2,10,TxData[3],2);
		}
		if(USART_GetRxFlag() == 1){
			OLED_ShowHexNum(4,1,RxData[0],2);
			OLED_ShowHexNum(4,4,RxData[1],2);
			OLED_ShowHexNum(4,7,RxData[2],2);
			OLED_ShowHexNum(4,10,RxData[3],2);
		}
	}
}

可变包长的文本数据包接收

主要功能为接收字符串，通过特定的字符串来实现led的点亮和关闭，并把相关信息显示在OLED上

连接线路

在这里插入图片描述

代码实现

led配置led.c

#include "stm32f10x.h"                  // Device header


/**
  * @brief  初始化LED相关端口，让LED所在端口可以被直接赋值
  * @param 	无
  * @retval 无
  */
void LED_Init(void){
	// 初始化时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	// 配置LED所在端口
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;		// 通用推挽输出
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		// 50Hz翻转速度
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	// 使这两个端口默认高电平，不然初始化后默认是低电平
	GPIO_SetBits(GPIOA, GPIO_Pin_1);
}
/**
  * @brief  LED1亮
  * @param 	无
  * @retval 无
  */
void LED1_On(void){
	GPIO_ResetBits(GPIOA, GPIO_Pin_1);
}
/**
  * @brief  LED1关
  * @param 	无
  * @retval 无
  */
void LED1_Off(void){
	GPIO_SetBits(GPIOA, GPIO_Pin_1);
}
/**
  * @brief  LED2亮
  * @param 	无
  * @retval 无
  */
void LED2_On(void){
	GPIO_ResetBits(GPIOA, GPIO_Pin_2);
}
/**
  * @brief  LED2关
  * @param 	无
  * @retval 无
  */
void LED2_Off(void){
	GPIO_SetBits(GPIOA, GPIO_Pin_2);
}
/**
  * @brief  LED1取反
  * @param 	无
  * @retval 无
  */
void LED1_Reverse(void){
	// 读取端口状态，根据状态取反
	if(GPIO_ReadOutputDataBit(GPIOA,GPIO_Pin_1) == 0)
		GPIO_SetBits(GPIOA, GPIO_Pin_1);
	else
		GPIO_ResetBits(GPIOA, GPIO_Pin_1);
}
/**
  * @brief  LED2取反
  * @param 	无
  * @retval 无
  */
void LED2_Reverse(void){
	// 读取端口状态，根据状态取反
	if(GPIO_ReadOutputDataBit(GPIOA,GPIO_Pin_2) == 0)
		GPIO_SetBits(GPIOA, GPIO_Pin_2);
	else
		GPIO_ResetBits(GPIOA, GPIO_Pin_2);
}

串口配置serial.c

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

char RxData[100];  // 接收数据包
uint8_t 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;	// A9 发送数据
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		// 50Hz翻转速度
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;		// 上拉输出
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;	// A10 接收数据
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		// 50Hz翻转速度
	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
	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);

	
	// USART1使能
	USART_Cmd(USART1,ENABLE);
}

// 发送函数
void USART_SendByte(uint8_t Byte){
	USART_SendData(USART1,Byte);
	// 等待写入完成，写入完成之后会将标志位自动清0
	while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
}

// 发送数组函数
void USART_SendArray(uint8_t *Array,uint16_t Length){
	uint8_t i = 0;
	for(i=0;i<Length;i++){
		USART_SendData(USART1,Array[i]);
		// 等待写入完成，写入完成之后会将标志位自动清0
		while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
	}
}

// 发送字符串函数
void USART_SendString(uint8_t *String){
	uint8_t i = 0;
	for(i=0;String[i]!='\0';i++){
		USART_SendData(USART1,String[i]);
		// 等待写入完成，写入完成之后会将标志位自动清0
		while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
	}
}

// 返回X的Y次方
uint32_t Serial_Pow(uint32_t X,uint32_t Y){
	uint32_t Result = 1;
	while(Y--){
		Result *= X;
	}
	return Result;
}
// 发送数字函数
void USART_SendNum(uint32_t Num,uint16_t Length){
	uint8_t i = 0;
	for(i=0;i<Length;i++){
		USART_SendByte(Num / Serial_Pow(10,Length-i-1) % 10 + 0x30);
		// 等待写入完成，写入完成之后会将标志位自动清0
		while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
	}
}

//重定向fputc函数，fputc是printf函数的底层，printf通过不停的调用fputc来达到输出的效果
//重定向到串口
int fputc(int ch,FILE *f){
	USART_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);
	USART_SendString((uint8_t*)String);
}


//中断函数
void USART1_IRQHandler(void){
	static uint8_t RxStatus = 0;		// 数据包状态
	static uint8_t RxCount = 0;
	if(USART_GetITStatus(USART1,USART_IT_RXNE)==SET){
		uint8_t RXDATA = USART_ReceiveData(USART1);	// 获取接收到的数据
		if(RxStatus == 0){
			if(RXDATA == '@' && RxFlag == 0){
				RxStatus = 1;
				RxCount = 0;		// 初始化之前的数据长度
			}
		}else if(RxStatus == 1){
			if(RXDATA == '\r')
				RxStatus = 2;
			else{
				RxData[RxCount] = RXDATA;
				RxCount++;
			}
		}else if(RxStatus == 2){
			if(RXDATA == '\n'){
				RxStatus = 0;
				RxFlag = 1;
				RxData[RxCount] = '\0';		// 加入字符串结束标志位
			}
		}
		USART_ClearITPendingBit(USART1, USART_IT_RXNE); // 清除标志位
	}
}

主函数mian.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();
	Serial_Init();
	LED_Init();
	OLED_ShowString(1, 1, "TxData:");
	OLED_ShowString(3, 1, "RxData:");
	
	while (1)
	{
		if(RxFlag == 1){
			OLED_ShowString(4,1,"                "); // 显示前擦除这行
			OLED_ShowString(4,1,RxData);
			
			if(strcmp(RxData,"LED_ON")==0){
				LED1_On();
				USART_SendString((uint8_t*)"LED_ON_OK\r\n");
				OLED_ShowString(2,1,"                ");
				OLED_ShowString(2,1,"LED_ON_OK");
			}
			else if(strcmp(RxData,"LED_OFF")==0){
				LED1_Off();
				USART_SendString((uint8_t*)"LED_OFF_OK\r\n");
				OLED_ShowString(2,1,"                ");
				OLED_ShowString(2,1,"LED_OFF_OK");
			}
			else{
				USART_SendString((uint8_t*)"ERR_CMD\r\n");
				OLED_ShowString(2,1,"                ");
				OLED_ShowString(2,1,"ERR_CMD");
			}
			RxFlag = 0;
		}
	}
}

补充

这里没有使用函数封装标志位自动清除，在许多读写操作进行时可能因为读取速度太慢导致数据接收错位，所以在主函数中手动把标志位清0，保证把每个数据包接收完毕后才可以开始下一次接收，同时把serial.c的包头判断时加入标志位判断即if(RXDATA == ‘@’ && RxFlag == 0)。

CC Cian
关注
  • 36
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32:串口收发文本数据包(内含：发送文本数据实验图+代码)
wo12369874的博客
10-17 1719
STM32:串口收发文本数据包(内含：发送文本数据实验图+代码)
STM32串口发送数据
热门推荐
yihuliunian的博客
05-15 3万+
串口通信经常作为开发调试的工具，所以先介绍下串口通信。 串口通讯(Serial Communication)是一种设备间非常常用的串行通讯方式，因为它简单便捷，大部分电子设备都支持该通讯方式，电子工程师在调试设备时也经常使用该通讯方式输出调试信息。目前STM32一般只使用 RXD、TXD 以及 GND 三条信号线，直接传输数据信号。 STM32的串口通信外设有USART和UART。USART是...
STM32串口通讯完美接收变长字节数据代码
04-17
STM32串口通讯完美接收变长字节数据代码
【STM32串口通信】
m0_64750258的博客
01-06 2182
STM32串口通信，阻塞式、中断式、DMA
USART串口协议——串口发送接收以及串口收发数据包
最新发布
qq_45419343的博客
06-03 903
Receiver/Transmitter）通用同步/异步收发器（1）USART是STM32内部集成的硬件外设，可根据数据寄存器的一个字节数据自动生成数据帧时序，从TX引脚发送出去，也可自动接收RX引脚的数据帧时序，拼接为一个字节数据，存放在数据寄存器里（2）自带波特率发生器，最高达4.5Mbits/s（3）可配置数据位长度（8/9）、停止位长度（4）可选校验位（无校验/奇校验/偶校验）（5）支持同步模式硬件流控制DMA智能卡IrDA（用于红外通信的）LIN（局域网的通信协议）
STM32笔记——USART发送和接收数据包
ssssshhbh的博客
03-16 1174
STM32笔记——USART发送和接收数据包
STM-32：串口收发数据包—串口收发HEX数据包/串口收发文本数据包
立于皓月之边，不弱星光之势
04-11 5752
STM-32：串口收发数据包—串口收发HEX数据包/串口收发文本数据包
串口发送数据包（不丢字节）
07-10
串口发送数据包，不丢包
Stm32Usart.zip_STM32 串口例程_STM32USART_STM32串口例程
09-14
在STM32的众多外设中，通用异步收发传输器（USART）是进行串行通信的重要接口，适用于数据交换和调试。本文将详细阐述STM32串口（USART）的工作原理、配置步骤以及如何在Keil开发环境中实现串口通信。 1. **STM32...
usart_stm32_STM32F405串口_
09-29
在这些系统中，串行通信接口（USART）扮演着至关重要的角色，它允许设备与其他设备进行数据传输，例如传感器、显示器或者PC等。在本项目中，我们将探讨如何在STM32F405上实现串口通信。 首先，让我们理解串口通信的...
stm32 USART DMA + IDLE Line dma+空闲中断+数据包发送和解析
05-28
首先，USART是STM32中的串行通信接口，它允许设备与外部设备进行全双工通信。在DMA模式下，数据传输无需CPU介入，大大提高了传输效率。当设置IDLE Line中断时，STM32可以在检测到USART线路进入空闲状态（即无数据...
基于STM32F103 处理器的串口发送数据程序
11-05
基于STM32F103 处理器的串口发送数据程序，使用输入输出重定向，在程序中可以使用 printf scanf
STM32单片机发送十六进制数据包例程
03-04
单片机发送十六进组数据包例程，例程中未四个十六进制数据一组，可随意添加，MDK语言环境。
串口通信 实时解析或发送串口的数据包
04-14
通过C#实现串口通信，里面的代码展示了如何监听计算机中的串口，解析数据或者发送数据，做串口开发的可以参考
STM32串口中断接收发送数据
07-11
该程序编写了STM32F103三个串口初始化程序，可快速调用，同时支持接收和发送单个字符和多个字符，并存储数据，方便接收数据后的通信协议校验，支持自定义接收数据最大长度，重写printf函数。
stm32的USART的DMA配置
02-06
ZET6芯片是STM32系列的一种，具备多种外设接口，其中串行通信接口（USART）是其常用功能之一。在进行高速数据传输时，为了提高效率并减轻CPU负担，可以利用DMA（直接存储器访问）技术。 **USART DMA配置详解** 1. ...
stm32使用串口进行通讯之发送数据
白云苍狗
11-16 1万+
STM32串口通讯发送数据 printf重定向 sprintf封装 stmF103C8T6
【USART】串口数据包
weixin_53328450的博客
07-24 1098
/当接收到【0xFF】就知道一个数据包来了，接着再接收到的4个字节当作数据包的第1、2、3、4个数据存在一个数组里。一批数据规定有4个字节，在这4个字节之前加一个自定义包头【0xFF】，在这4个字节之后加一个自定义包尾【0xFE】如果不是【FF】证明数据包没有对齐，等待包头出现，状态仍然S=0（下次进中断根据S=0判断包头）最开始S=0，收到一个数据进中断，根据S=0进入第一个状态的程序，判断数据是不是包头【FF】最开始S=0，收到一个数据进中断，根据S=0进入第一个状态的程序，判断数据是不是包头【@】
STM32系列——串口收发数据基础
weixin_62261692的博客
03-10 3272
用stm32f103c8t6实现简单串口收发功能。
stm32f103串口收发数据包
07-14
对于STM32F103系列的微控制器，串口收发数据包的实现步骤如下： 1. 配置串口参数：首先，你需要配置串口的波特率、数据位、停止位和校验位等参数。这可以通过修改USART_CR1和USART_CR2寄存器来实现。具体的配置取决于你的需求，可以参考STM32F103参考手册中的串口章节。 2. 初始化串口：在配置完成后，你需要初始化串口。这可以通过设置USART_CR1寄存器的UE位来使能串口。 3. 发送数据：要发送数据包，你可以将要发送的数据写入USART_DR寄存器。数据可以是单个字节或者是一系列字节的数组。你可以使用循环来发送多个字节的数据。 4. 接收数据：要接收数据包，你可以通过读取USART_DR寄存器来获取接收到的数据。你可以使用轮询方式或者中断方式来接收数据。 以下是一个简单的示例代码，演示了如何在STM32F103上进行串口收发数据包： ```c #include "stm32f10x.h" void USART2_Init(void) { // 配置GPIO引脚 GPIO_InitTypeDef GPIO_InitStruct; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2; // USART2_TX GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3; // USART2_RX GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &GPIO_InitStruct); // 配置USART2 USART_InitTypeDef USART_InitStruct; RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); USART_InitStruct.USART_BaudRate = 115200; USART_InitStruct.USART_WordLength = USART_WordLength_8b; USART_InitStruct.USART_StopBits = USART_StopBits_1; USART_InitStruct.USART_Parity = USART_Parity_No; USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None; USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; USART_Init(USART2, &USART_InitStruct); USART_Cmd(USART2, ENABLE); } void USART2_SendData(uint8_t data) { while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET); USART_SendData(USART2, data); } uint8_t USART2_ReceiveData(void) { while (USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET); return USART_ReceiveData(USART2); } int main(void) { USART2_Init(); // 发送数据包 uint8_t txData[] = {0x01, 0x02, 0x03}; for (int i = 0; i < sizeof(txData); i++) { USART2_SendData(txData[i]); } // 接收数据包 uint8_t rxData[sizeof(txData)]; for (int i = 0; i < sizeof(rxData); i++) { rxData[i] = USART2_ReceiveData(); } while (1) { // 主循环 } } ``` 这只是一个简单的例子，你可以根据自己的需求进行修改和扩展。希望对你有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值