【USART】USART串口数据包

最新推荐文章于 2024-07-10 22:33:23 发布
最新推荐文章于 2024-07-10 22:33:23 发布
阅读量42 收藏
点赞数
分类专栏： STM32 单片机 文章标签： 单片机 stm32 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wr_9794/article/details/133321107
版权

USART串口数据包

数据包

在这里插入图片描述

此外还有文本数据包

数据包接收流程

在这里插入图片描述

串口发送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_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;
	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_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_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);
	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');
	}
}

int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

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 Serial_SendPacket(void)
{
    Serial_SendByte(0xFF);
    Serial_SendArray(Serial_TxPacket, 4);
    Serial_SendByte(0xFe);
}

uint8_t Serial_GetRxFlag(void)
{
	if (Serial_RxFlag == 1)
	{
		Serial_RxFlag = 0;
		return 1;
	}
	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);
	}
}


// 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, ...);
void Serial_SendPacket(void);

uint8_t Serial_GetRxFlag(void);

#endif


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

uint8_t KeyNum;
int main(void)
{
	OLED_Init();
	Key_Init ();
	Serial_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_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);
        }
	}
}

以上就是串口发送HEX数据包代码

串口发送文本数据包

// 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_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;
	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_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_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);
	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');
	}
}

int fputc(int ch, FILE *f)
{
	Serial_SendByte(ch);
	return ch;
}

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 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);
	}
}


// Serial.h
#ifndef __SERIAL_H
#define __SERIAL_H

#include <stdio.h>

extern char Serial_RxPacket[];
extern uint8_t Serial_RxFlag;
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, ...);



#endif


// main.c
#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Serial.h"
#include "Key.h"
#include "LED.h"
#include <string.h>

int main(void)
{
	OLED_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,"LED_ON") == 0)
            {
                LED1_ON();
                Serial_SendString("LED_ON_OK\r\n");
                OLED_ShowString(2,1,"                ");
                OLED_ShowString(2,1,"LED_ON");                
            }
            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");                
            }
            else 
            {
                Serial_SendString("ERROR_COMMAND\r\n");
                OLED_ShowString(2,1,"                ");
                OLED_ShowString(2,1,"ERROR_COMMAND");                
              
          }
          
          Serial_RxFlag = 0;
            
        }
      
	}
}

串口控制LED点亮与熄灭

半步成诗！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
USART空闲中断发送数据包
08-17
USART（通用同步异步收发传输器）是嵌入式系统中常见的串行通信接口，广泛应用于单片机之间的通信。在这个项目中，我们将详细探讨如何利用STM32的USART空闲中断来发送一帧完整的数据包，以及该过程中的关键知识点。 ...
USART1固定长度数据包(hex)例程
01-03
STM32是一款广泛应用于嵌入式系统的高性能微处理器，其串行通信接口（USART）是与外部设备进行数据交换的关键组件。 首先，我们需要理解串口协议。串口通信是一种简单的同步串行通信方式，通过数据线发送和接收数据...
STM32USART串口数据包
qq_53922901的博客
03-01 1699
当串口需要发送多个字节的数据时，使用数据包的形式来发送和接收是更加方便的，还可以更好的区分各个字节数据所对应的内容。例如需要发送X,Y,Z来控制陀螺仪传感器的X,Y,Z，就可以使用数据包的格式。
STM32标准库——（13）USART串口数据包
2301_78772787的博客
02-29 1377
所以需要第三个状态，如果只有一个包尾，那在出现包尾之后，就可以直接回到初始状态了，只需要两个状态就行，因为接收数据和等待包尾需要在一个状态里同时进行，由于串口的包头包尾不会出现在数据中，所以基本不会出现数据错位的现象，这就是使用状态机接收文本数据包的方法。类似于置标志位，但标志位只有0和1，而状态机允许多标志位状态，初始时，S=0表示等待包头状态。同样也是利用状态机，定义3个状态，第一个状态，等待包头，判断收到的是不是我们规定的。，如果不是，则正常接收，如果是,则不接收，同时跳到下一个状态，
stm32-USART串口接收数据包
weixin_73268359的博客
08-02 559
stm32，串口收发数据包
STM32入门笔记11_USART串口数据包+案例: USART接收HEX数据包 USART接收文本数据包
nanxl1的博客
04-06 3511
状态机实际就是指一个数学模型，可反映事物的不同状态，也就是数电学的状态转换图。状态机的思想在各种程序的编写中使用广泛。
USART串口数据包
L199023的博客
07-10 684
流程为：开始s=0.收到一个数据，进中断，根据s=0，进入第一个状态的程序，判断数据是不是包头FF，如果是，代表收到包头，之后置s=1，退出中断，结束，下次再进入中断，根据s=1，就可以进行接收数据的程序了，收到数据，就存入数组中，再用变量，记录收了多少个数据，如果没收够4个数据，就一直接收状态，收够了，s就等于2，结束中断，下次进入中断，就可以进入下一个状态了，最后一个状态就是等待包尾，是不是FE，如果是，s就置0，结束中断，下次进入最初状态，这就是状态机的思路。每个数据包长度可变，前面包头，后面包尾。
USART串口协议——串口发送接收以及串口收发数据包
qq_45419343的博客
06-03 908
Receiver/Transmitter）通用同步/异步收发器（1）USART是STM32内部集成的硬件外设，可根据数据寄存器的一个字节数据自动生成数据帧时序，从TX引脚发送出去，也可自动接收RX引脚的数据帧时序，拼接为一个字节数据，存放在数据寄存器里（2）自带波特率发生器，最高达4.5Mbits/s（3）可配置数据位长度（8/9）、停止位长度（4）可选校验位（无校验/奇校验/偶校验）（5）支持同步模式硬件流控制DMA智能卡IrDA（用于红外通信的）LIN（局域网的通信协议）
【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进入第一个状态的程序，判断数据是不是包头【@】
USART串口通讯
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
07-18 4851
USART串口通讯，UART与USART区别，RS-232标准。
6.1USART串口数据包
2301_76540867的博客
02-16 229
串口发送与接收数据，师从B站江科大
USART串口数据包（HEX和文本）
ww20200711的博客
03-08 819
/接收状态位，状态0位检测包头，状态1位接收数据，状态2位检测包尾。//接收包头后置1开始接收数据。//接收完成后置状态2检测包尾。//数据接收完成置结束标志位1。//接收完成后已接收数据位清0。if(pRxPacket ==4) //判断是否接收数据完成。if(RxData==0xFF) //检测包头。if(RxData==0xFE) //检测包尾。
USART1非固定长度数据包(字符串)例程
01-03
STM32是一款基于ARM Cortex-M内核的微控制器，广泛应用于嵌入式系统设计，而USART（通用同步/异步收发传输器）是其通信接口中的一个重要组成部分，用于实现串行通信。 串口协议是通信的基础，它定义了数据传输的...
usart.rar_c51的usart
09-23
USART（Universal Synchronous/Asynchronous Receiver/Transmitter）通用同步/异步接收器/发射器是微控制器中常见的通信接口，常用于设备间的串行通信。C51是Microchip公司的8051系列单片机的一种高级语言，它提供了...
usart.zip_atmega16 usart
09-24
在电子工程领域，特别是在嵌入式系统的设计与开发中，UART（通用异步接收发送器）是一种常用的串行通信接口，而Atmel的ATmega16微控制器是广泛应用的8位AVR微处理器之一。本资源"usart.zip_atmega16 usart"主要包含...
BKP备份寄存器和实时时钟笔记
上山的月的博客
07-09 1231
一份不错的江科大STM32教学视频笔记，关于STM32的BKP和RTC部分，内容清晰明了，整体架构层次分明。
STM32实战篇：按键控制LED
qq_74114817的博客
07-09 264
有两个按键，分别控制两个LED灯。当按键按下后，灯的亮暗状态改变。由图可知，按键一端直接接地，故另一端所对应IO引脚的输入模式应该为。
基于AT89C51单片机篮球计时计分器的设计（含文档、源码与proteus仿真，以及系统详细介绍）
最新发布
m0_56379011的博客
07-10 858
3系统调试3.1初始状态显示3.2甲队加分显示3.3乙队加分显示3.4 倒计时显示4 总结本设计报告介绍了一种基于AT89S51单片机的交通灯的设计方法，本论文完成了系统的硬件设计与制作，详细介绍了系统硬件设计的过程，并结合软件系统完成了整个系统的软、硬件联调，系统工作良好，实现了基本功能。这次课设是我们遇到过的较大的设计。
嵌入式系统中的实时操作系统任务调度策略
qq_38140936的博客
07-09 850
在嵌入式系统中，实时任务调度是确保系统响应性和稳定性的关键方面之一。不同的任务调度策略可以影响系统的性能和实时性。和，并提供相应的代码示例。固定优先级调度是一种基于任务优先级的调度策略，优先级高的任务将在优先级低的任务之前执行。这种策略适用于对实时性要求严格的系统。循环时间片调度是一种轮流分配时间片给每个任务的策略。每个任务在时间片内执行，然后切换到下一个任务。这种调度策略适用于相对较简单的系统，能够提供公平的任务执行机会。当涉及嵌入式开发时，选择适当的通信方式以及对硬件资源的管理是至关重要的。
stm32串口数据包通讯
07-27
对于STM32串口数据包通讯，你可以使用STM32的UART（通用异步收发器）模块来实现。下面是一个基本的示例代码，演示了如何配置和发送数据包： ```c #include "stm32xxxx.h" // 根据你的具体型号更改头文件名 void ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值