STM32串口通信--(基于HAL库|自定义命令调参|API移植简单)

文章目录

  • 前言
  • STM32串口通信--(基于HAL库|自定义命令调试)
    • 一、STM32cubemx配置
    • 二、Keil中断基本配置
      • (1)基本配置
      • (2)在main函数下面使用回调函数
    • 三、自定义协议配置
        • (1)输出调试信息配置
        • (2)对两个函数进行重新写,方便阅读和移植
        • (3)协议说明
        • (4)处理数据
        • (4)调用说明
      • 2、移植说明
      • 3、完整的串口相关代码代码(不包cubemx已经帮我们已经配置好的代码,代码分别在自己创建的My_Usart.c和My_Usart.h
    • 四、注意
    • 五、更高级实现


前言

代码和函数有部分更新,想要思路是没有变化的。My_usart.c和My_usart.h修改后代码可读性更好,移植更方便。

STM32串口通信–(基于HAL库|自定义命令调试)

之前写过一篇基于标准库的串口通信和匿名上位机使用的教程,但是这个上位机的发送功能(结合蓝牙模块)是比较好用的,但接收功能配置起来麻烦,用来串口发送数据调试麻烦,只能发送8位的数据,使用起来很不方便。因此写下这篇,有方便的API接口函数,移植起来方便,使用起来也简单


比较难理解的就是自定义的数据帧的协议的书写,包括头帧和尾帧以及中间分格的帧,但是如果不能理解,移植过来使用也是很简单的。

如果是发送数据,需要显示波形,可以看我之前写的博客。使用匿名上位机,这个上位机使用起来也比较方便,比较适合调试。

匿名V7上位机简单教程


正片开始

为什么要使用协议,不使用协议不是更简单吗

使用协议的其中一个原因是,为了保证数据准确性,也就是减少错误率,使得判断更为精准。如果自己写过比较简单的串口接收和判断的函数(无协议),遇到比较多数据的情况,很容易引起误判。

一、STM32cubemx配置

这里用正点原子STM32F103ZETX的板子作为实例

主要是配置串口接收中断,发送部分在main中,采取阻塞的方式发送,这里从只是进行串口的配置

使用PA9,PA10,默认配置 (一般都是使用默认配置,波特率115200) , 勾选全局中断(使用接收中断)
STM32串口通信--(基于HAL库|自定义命令调参|API移植简单)_第1张图片
串口中断一定要勾选,优先级按自己按照需要安排
STM32串口通信--(基于HAL库|自定义命令调参|API移植简单)_第2张图片
串口通信的STM32cubemx串口通信配置到此,接下来是在keil进行的串口代码的书写

二、Keil中断基本配置

主要是使用下面的三个函数,发送,接收,回调函数。

//在stm32f1xx_hal_uart.c中的三个函数基本配置就差不多完成了
//接收中断函数
HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
//回调函数
__weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
//阻塞发送函数
HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)

STM32串口通信--(基于HAL库|自定义命令调参|API移植简单)_第3张图片

(1)基本配置

main函数种的配置,只是加上了HAL_UART_Receive_IT()的函数

extern void SystemClock_Config(void);
char S_uart_temp=0;
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 */ 	
  HAL_UART_Receive_IT(&huart1,&S_uart_temp,0X01);//必须使能这个,每次接受完一次数据就要重新调用这个函数;//必须使能这个,每次接受完一次数据就要重新调用这个函数
  /* USER CODE END 2 */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

(2)在main函数下面使用回调函数

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    HAL_UART_Transmit(&huart1,ch,1,0xFFFF);//阻塞方式打印
	HAL_UART_Receive_IT(&huart1,&S_uart_temp,0X01
}

到此,基本的通信配置完成,做完前期工作,STM32能够使用串口进行通信,下面是协议的书写,也是重点。


三、自定义协议配置

(1)输出调试信息配置

在进行协议配置前,我们先对printf进行重定向,方便调试和输出信息,也就是使用在HAL库中使用printf,加入以下代码即可

#include "stdio.h"
#ifdef __GNUC__
  #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
  #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif

PUTCHAR_PROTOTYPE
{
  //Usart_sent_data((uint8_t *)ch);可以使用这个函数,也可以不用,建议使用,方便移植printf
  HAL_UART_Transmit(&huart1,(uint8_t *)&ch,1,0xFFFF);//阻塞方式打印
  return ch;
}

(2)对两个函数进行重新写,方便阅读和移植
//函数名:  Usart_get_data
//作者:    Silent Knight
//日期:    2021-08-4
//功能:    中断串口接收单个字符
//输入参数:无
//返回值:  类型(char)
//          返回接收字符
//修改记录:
//=================================================================
char Usart_get_data(void)
{
	HAL_UART_Receive_IT(&huart1,&S_uart_temp,0X01);//必须使能这个,每次接受完一次数据就要重新调用这个函数;
	return S_uart_temp;
}
//函数名:  Usart_sent_data
//作者:    Silent Knight
//日期:    2021-08-4
//功能:    串口输出单个字符
//输入参数:uint8_t *ch
//					需要发送单个字符的地址
//返回值:  类型(void)
//修改记录:
//=================================================================
void Usart_sent_data(uint8_t *ch)
{
	HAL_UART_Transmit(&huart1,ch,1,0xFFFF);//阻塞方式打印
}
(3)协议说明

这个是通信层面的协议,只是包括头帧和尾帧的协议。发送数据的一方必须使用此协议,才能进行有效的通信。例如,发送方发送数据为"(PID=2.22)",这样包括头帧 ‘(’,和尾帧 ‘)’,STM32才能知道有效数据是PID=2.22。没有的话,数据一概视为垃圾数据,不处理。

初始化配置

先对初始化一些变量,方便对数据管理,这里使用结构体进行管理。

#define JUDGE_DATA_MAX_LEN 20 //判断数据有效容量
#define Max_BUFF_Len 0XFF//定义的最大数据容量

//为了方便阅读,使用下面的宏定义
#define S_Uartx_Rx     usartx_struct_ptr->Uartx_Rx
#define	S_Uartx_Tx     usartx_struct_ptr->Uartx_Tx
#define	S_Uartx_Len    usartx_struct_ptr->Uartx_Len
#define	S_Uartx_Sta    usartx_struct_ptr->Uartx_Sta
#define	S_head_flag    usartx_struct_ptr->head_flag
#define	S_teal_flag    usartx_struct_ptr->teal_flag
#define S_Uartx_Buffer usartx_struct_ptr->Uartx_Buffer
#define S_uart_temp    usartx_struct_ptr->usrt_temp_data
#define S_command_flag usartx_struct_ptr->command_flag

//自定义头帧,尾帧,命令使用方式,如果想改的话,把宏定义修改即可
#define HEAL_FLAGE '('
#define TAIL_FLAGE ')'
#define COMMAND_FLGAHE '\0'//如果算是使用命令模式的话,可以把这个宏改为'\0',使用'='是调参模式,方便调参
//串口管理结构体
typedef struct
{
	uint8_t Uartx_Buffer[Max_BUFF_Len];//缓冲数组
	uint8_t usrt_temp_data;//保存的单个数据
	int  UartX_Sta;//发送数据标志位
	int  Uartx_Rx;//状态标志位
	int  Uartx_Tx;//数据头
	int  Uartx_Len;//有效数据长度
	int  Uartx_Sta;//发送数据标志位
	char head_flag;//头帧标志位
	char teal_flag;//尾帧标志位
	char command_flag;//命令标志
}Usart_struct;

Usart_struct usartx_struct;
Usart_struct *usartx_struct_ptr=&usartx_struct;//结构体指针

void Usart_srtuct_init(void)
{
	usartx_struct_ptr->usrt_temp_data=0;//保存的单个数据
	usartx_struct_ptr->Uartx_Rx=0;//状态标志位
	usartx_struct_ptr->Uartx_Tx=0;//数据头
	usartx_struct_ptr->Uartx_Len=0;//有效数据长度
	usartx_struct_ptr->Uartx_Sta=0;//发送数据标志位
	usartx_struct_ptr->head_flag=HEAL_FLAGE;
	usartx_struct_ptr->teal_flag=TAIL_FLAGE;
	usartx_struct_ptr->command_flag=COMMAND_FLGAHE;
}

下面是比较关键的数据处理的部分,也就是判断改数据是不是符合自己的协议,数据是否有效,若是符合头帧和尾帧格式的,将数据保存下来。判断有效数据的函数在回调函数 (中断)里面调用,因为需要对每一个数据都进行判断。

额外说明:是通过Uart3_Rx来判断位置的,每一次到来就Uart3_Rx+1,具体已经在注释中有说明了

//函数名:  Usart_judge_data
//作者:    Silent Knight
//日期:    2021-08-4
//功能:    接收一个数据,并对数据进行判断
//输入参数:uint8_t *ch
//		  需要进行判断的一个数据
//返回值:  类型(void)
//修改记录:
//=================================================================

void Usart_judge_data(char *usart_data)
{	
	
		//例如数据是1123(PID=3.33),头帧:S_Uartx_Tx=5,执行5遍函数后,尾帧是14		S_Uartx_Buffer[S_Uartx_Rx]=*usart_data;
		S_Uartx_Rx++; //向下加1,方便保存,也就是原来的数据是未减之前的位置
		S_Uartx_Rx &= Max_BUFF_Len; //FIFO最大接收数据,防止溢出		
		if((S_Uartx_Buffer[S_Uartx_Rx-1])==S_head_flag)//找到头'('所在的位置
			S_Uartx_Tx = S_Uartx_Rx-1; //保存头帧的位置
		 
		if((S_Uartx_Buffer[S_Uartx_Tx] == S_head_flag&&(S_Uartx_Buffer[S_Uartx_Rx-1] == S_teal_flag))) //检测到头帧的情况下检测到尾帧')' 
   		 { 
			 //注意尾帧就是S_Uartx_Rx-1
      		 S_Uartx_Len = (S_Uartx_Rx-1)- 			(S_Uartx_Tx)+1; //有效数据长度(尾减头,包括头帧和尾帧) 
   		     S_Uartx_Sta=1;//标志位 
   		 }
}

//回调函数中调用Usart_judge_data
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart==&huart1)
	{
	//Usart_sent_data(&S_uart_temp);
		Usart_deal_data((char *)&S_uart_temp);
		Usart_get_data();
	}
}
(4)处理数据

这里面的数据处理,只是为了方便调试参数,比如调试PID,当然接收命令也是同理,这里只是以自定义命令,调试信息为例子

先对自定义的命令做出判断,判断哪一些是命令,那一些是需要调参的数据,这里我用的是 **'='进行判断,’=‘**后面的就是有效的数字。

//函数名:  judge_command
//作者:    Silent Knight
//日期:    2021-08-4
//功能:    判断命令到哪里是有效的,并返回命令长度
//输入参数:const char *str
//		      传入命令,也就是字符串
//返回值:  类型(int)
//          返回命令长度,方便判断后面的有效内容的位置
//修改记录:
//=================================================================
int judge_command(const char *str)
{
	int count = 0;
	while (*str !='=')//'='是判断的位置,也是命令停止标志
	{
		count++;
		str++;
		if(count>=JUDGE_DATA_MAX_LEN) //防止一直在while循环,如果一直找不到命令停止标准就20次循环后结束
		{
			printf("input data error");
			break;
		}
	}
	count++;//把=也加上
	return count;
}

实际有效内容的处理,主要是比较函数strncmp和字符转换函数atof的使用,把两个头文件包含进来即可

#include "stdlib.h"
#include "string.h"
//函数名:  Usart_deal_data
//作者:    Silent Knight
//日期:    2021-08-4
//功能:    传入需要判断的字符串,例如,格式:(内容=数字)
//输入参数:const char *str,写入参数的地址
//		      传入命令,也就是字符串和指令的地址
//返回值:  类型(void)
//注意:    需要修改宏定义,来使用#define //COMMAND_FLGAHE来选择使用哪种方式,如果是调参模式
//则parameter传入调试参数的数字,通过它来判断指令是否正确和判断值有没有修改成功。如果是命令模式,如果命令正确是真,则parameter为1.0,否则为0,方便判断。如果是指令模式,指令正确,parameter的值就改变,否则不变方便调试。
//实例:调参模式下,pid_p=Usart_deal_data(pid_p=0.111) printf("pid_p=%f",pid_p),一般在主函数中调用或者其他的发送线程调用
//修改记录:          2021/08/03,写完该函数
//					2021/08/04,把不能调用多条命令的BUG修改完
//					2021/08/05,把传入参数修改了,使之能正确的修改参数
//					2021/08/08,修改指令模式下的返回值
//=================================================================
void Usart_deal_data(const char *sdata,float *parameter)
{
	char floatdaer[15]={0};//临时保存内容数据
	int str_len=0;//除命令外有效数据长度
    float temp_data=0;
		
	if(S_Uartx_Sta) //有效数据来了
	{
		if(S_command_flag=='=')//调参使用
		{
			str_len=judge_command(sdata);//把命令结束的位置保存下来
			//printf("command_len=%d,",str_len);
		
			if(strncmp((const char *)&S_Uartx_Buffer[S_Uartx_Tx+1],sdata,str_len)==0)	//判断传来的数据是否符合命令,比较命令是否符合
			{
				printf("%s\r\n",&S_Uartx_Buffer[S_Uartx_Tx]);
				strncpy(floatdaer,(const char *)&S_Uartx_Buffer[(S_Uartx_Tx+str_len+1)],(S_Uartx_Len-str_len+1));//floatdate保存等于号后六位作为字符串
				//printf("%s",floatdaer);
				temp_data=atof(floatdaer);//字符串转换成为浮点型数字,遇到数字或者+-号转换开始,遇到非数字,转换结束,也就是遇到尾标转换结束
				*parameter=temp_data;//保存传入的指令参数
				printf("temp_data=%lf\r\n",*parameter);
				//重新清零
				S_Uartx_Rx = 0; 
				S_Uartx_Tx = 0; 
				S_Uartx_Sta = 0; 
			}

		}
		else//命令使用,如果是符合命令,返回1.0 ,假的返回0
		{
			str_len=judge_command(sdata);//把命令结束的位置保存下来
			//printf("command_len=%d,",str_len);
			//printf("%s",&S_Uartx_Buffer[S_Uartx_Tx]);
			if(strncmp((const char *)&S_Uartx_Buffer[S_Uartx_Tx+1],sdata,str_len-1)==0)	//判断传来的数据是否符合命令,比较命令是否符合
			{			
				printf("%s\r\n",&S_Uartx_Buffer[S_Uartx_Tx]);		
				printf("True\r\n");
					//重新清零
				*parameter=1.0;//指令为真
				S_Uartx_Rx = 0; 
				S_Uartx_Tx = 0; 
				S_Uartx_Sta = 0; 
			}
			else
			{
			*parameter=0;//指令为假
			}	
		}
	}
}


(4)调用说明

自己把命令传入这个参数,调用这个函数就能很好地使用了。

建议在main中使用,同时使用printf进行调试信息的输出

int main(void)
{
  /* USER CODE BEGIN 1 */
	float temp=0;
  /* 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 */
  Usart_srtuct_init();//结构体初始化
  Usart_get_data();//必须使能这个,每次接受完一次数据就要重新调用这个函数
  /* USER CODE END 2 */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
	Usart_deal_data("PID_P=",parameter);
	Usart_deal_data("PID_I=",parameter);
	Usart_deal_data("PID_D=",parameter);
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

输出如下:支持写入多条命令,支持写入命令加参数的模式进行调参,会有写入命令的输出,以及返回数值的输出,如果命令失败不正确,则没有返回输出

调参模式下的输出:
STM32串口通信--(基于HAL库|自定义命令调参|API移植简单)_第4张图片
命令模式下使用:和调参命令一致,只是没有输入调参的数字
STM32串口通信--(基于HAL库|自定义命令调参|API移植简单)_第5张图片

2、移植说明

提示:如果不想理解这么麻烦,只是想用,移植的时候也是很简单的,把全部东西给复制过去,然后把串口配置好,把发送串口发送单个数据的函数给修改,再把指定函数放到中断里面就行了,最后调用判断函数。

改这两个函数,只是把里面发送和接收的函数给改了就行了
void Usart_sent_data(uint8_t *ch)
{
	HAL_UART_Transmit(&huart1,ch,1,0xFFFF);//阻塞方式打印,把这个修改了
}

char Usart_get_data(void)
{
	HAL_UART_Receive_IT(&huart1,&S_uart_temp,0X01);//必须使能这个,每次接受完一次数据就要重新调用这个函数,把这个修改了
	return S_uart_temp;
}
把这两个函数放在中断,或者回调函数里面就行了
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart==&huart1)
	{
		Usart_judge_data((char *)&S_uart_temp);
		Usart_get_data();/这个用于获取数据,并把数据保存在S_uart_temp,所以,要先调用这个,在调用Usart_judge_data,因为此处已经在main中事先调用过一次了,所以放在后面,等下次调用。
	}
}

最为好用的函数就是Usart_deal_data()。使用时把宏定义修改好,选择命令或者调参的模式,然后,自己把命令传入这个参数,调用这个函数就能很好地使用了。这里的命令是任意的,喜欢传入什么命令就传入什么命令,这个命令也是可以的"f*ck you"

修改宏:

指定选择方式,需要不需要哪种方式注释掉就好了,两种方式只能选择一种哦
#define COMAND_MODE 
//#define PARAMETER_MODE


#ifdef COMAND_MODE

#define COUNT_FLAH '\0'

#else

#define	COUNT_FLAH '='

#endif

调用命令函数
float Usart_deal_data(const char *sdata);

//使用例子
//调参模式,把宏定义改了
float parem;
//调用函数,传入命令"PID_P=",'='后面的数字是需要输入的,例如在上位机这样输入,返回11.111,打印输入值
Usart_deal_data("PID_P=11.111",&parem);
//命令模式,把宏定义改了
//调用函数,传入命令"PID_P=",'='后面的数字是需要输入的,例如在上位机这样输入,如果符合命令,返回1.0,打印True
Usart_deal_data("PID_P",&parem);
if(parem==1.0) print("RIGHT COMMAND \r\n");

调参模式下的输出:
STM32串口通信--(基于HAL库|自定义命令调参|API移植简单)_第6张图片
命令模式下使用:和调参命令一致,只是没有输入调参的数字
STM32串口通信--(基于HAL库|自定义命令调参|API移植简单)_第7张图片

3、完整的串口相关代码代码(不包cubemx已经帮我们已经配置好的代码,代码分别在自己创建的My_Usart.c和My_Usart.h

main.c的文件已经囊括了本文90%的内容了

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * 

© Copyright (c) 2021 STMicroelectronics. * All rights reserved.

* * This software component is licensed by ST under BSD 3-Clause license, * the "License"; You may not use this file except in compliance with the * License. You may obtain a copy of the License at: * opensource.org/licenses/BSD-3-Clause * ****************************************************************************** */
/* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ #include "main.h" #include "usart.h" #include "gpio.h" #include "My_Usart.h" /* Private includes ----------------------------------------------------------*/ /* USER CODE BEGIN Includes */ /* 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 */ /* USER CODE END PV */ /* USER CODE BEGIN PFP */ /* USER CODE END PFP */ /* Private user code ---------------------------------------------------------*/ /* USER CODE BEGIN 0 */ /* USER CODE END 0 */ /** * @brief The application entry point. * @retval int */ extern void SystemClock_Config(void); int main(void) { /* USER CODE BEGIN 1 */ float tt=0; /* 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 */ Hc05_init();//调用相关初始化函数 /* USER CODE END 2 */ /* Infinite loop */ /* USER CODE BEGIN WHILE */ while (1) { /* USER CODE END WHILE */ Usart_deal_data("PID_P=",&tt); printf("tt=%f\r\n",tt); HAL_Delay(1000); //tt=Usart_deal_data("PID_D="); //printf("tt=%f\r\n",tt); /* 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 */ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { if(huart==&huart1) { //Usart_sent_data(&S_uart_temp); Usart_judge_data((char *)&S_uart_temp); Usart_get_data(); } } /* 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 */ void /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

My_Usart.c文件

#include "stdlib.h"
#include "string.h"
#include "usart.h"
#include "stdio.h"


PUTCHAR_PROTOTYPE
{
	//Usart_sent_data((uint8_t *)ch);
  HAL_UART_Transmit(&huart1,(uint8_t *)&ch,1,0xFFFF);//阻塞方式打印
  return ch;
}

#endif

//自定义头帧,尾帧,命令结束,如果想改的话,把宏定义修改即可
#define HEAL_FLAGE '('
#define TAIL_FLAGE ')'

//指定选择方式,需要不需要哪种方式注释掉就好了,两种方式只能选择一种哦
#define COMAND_MODE 
//#define PARAMETER_MODE


#ifdef COMAND_MODE

#define COUNT_FLAH '\0'

#else
		COUNT_FLAH '='
#endif

//蓝牙串口结构体
Usart_struct usartx_struct;
Usart_struct *ustu_ptr=&usartx_struct;//结构体指针


//串口结构体初始化
void Usart_srtuct_init(void)
{
	ustu_ptr->Usrt_temp_data=0;//保存的单个数据
	ustu_ptr->Uartx_Rx=0;//状态标志位
	ustu_ptr->Uartx_Tx=0;//数据头
	ustu_ptr->Uartx_Len=0;//有效数据长度
	ustu_ptr->Uartx_Sta=0;//发送数据标志位
	ustu_ptr->head_flag=HEAL_FLAGE;
	ustu_ptr->teal_flag=TAIL_FLAGE;
	ustu_ptr->command_flag=COUNT_FLAH;
}

//HC05初始化
void Hc05_init()
{
	Usart_srtuct_init();
	Usart_get_data();	
}

//======================================================================//
//函数名:  Usart_sent_data
//作者:    Silent Knight
//日期:    2021-08-4
//功能:    串口输出len个字符
//输入参数:uint8_t *ch,字符长度
//					需要发送单个字符的地址
//返回值:  类型(void)
//修改记录:
//======================================================================//
void Usart_sent_data(uint8_t *ch,uint8_t len)
{
	HAL_UART_Transmit(&huart1,ch,len,0xFFFF);//阻塞方式打印
}
//函数名:  judge_command
//作者:    Silent Knight
//日期:    2021-08-4
//功能:    判断命令到哪里是有效的,并返回命令长度
//输入参数:const char *str
//		      传入命令,也就是字符串
//返回值:  类型(int)
//          返回命令长度,方便判断后面的有效内容的位置
//修改记录:
//=================================================================
int judge_command(const char *str)
{
	int count = 0;
	while (*str !=COUNT_FLAH)//是判断的位置,也是命令停止标志
	{
		count++;
		str++;
		if(count>=JUDGE_DATA_MAX_LEN) //防止一直在while循环,如果一直找不到命令停止标准就20次循环后结束
		{
			//printf("input data error");
			break;
		}
	}
	count++;//把=也加上
	return count;
}
//函数名:  Usart_get_data
//作者:    Silent Knight
//日期:    2021-08-4
//功能:    中断串口接收单个字符
//输入参数:无
//返回值:  类型(char)
//          返回接收字符
//修改记录:
//=================================================================
char Usart_get_data(void)
{
	HAL_UART_Receive_IT(&huart1,&ustu_ptr->Usrt_temp_data,0X01);//必须使能这个,每次接受完一次数据就要重新调用这个函数;
	return ustu_ptr->Usrt_temp_data;
}
//函数名:  Usart_judge_data
//作者:    Silent Knight
//日期:    2021-08-4
//功能:    接收一个数据,并对数据进行判断
//输入参数:uint8_t *ch
//		  需要进行判断的一个数据
//返回值:  类型(void)
//修改记录:
//=================================================================
void Usart_judge_data(char *usart_data)
{	
		
		//例如数据是1123(PID=3.33),头帧:ustu_ptr->Uartx_Tx=5,执行5遍函数后,尾帧是14
		//UART3_GetChar(Uart3_Buffer[Uart3_Rx]);
		ustu_ptr->Uartx_Buffer[ustu_ptr->Uartx_Rx]=*usart_data;
		ustu_ptr->Uartx_Rx++; //向下加1,方便保存,也就是原来的数据是未减之前的位置
		ustu_ptr->Uartx_Rx &= 0XFF; //FIFO最大接收数据,防止溢出		
		if((ustu_ptr->Uartx_Buffer[ustu_ptr->Uartx_Rx-1])==ustu_ptr->head_flag)//找到头'('所在的位置
			ustu_ptr->Uartx_Tx = ustu_ptr->Uartx_Rx-1; //保存头帧的位置
		 
		if((ustu_ptr->Uartx_Buffer[ustu_ptr->Uartx_Tx] == ustu_ptr->head_flag&&(ustu_ptr->Uartx_Buffer[ustu_ptr->Uartx_Rx-1] == ustu_ptr->teal_flag))) //检测到头帧的情况下检测到尾帧')' 
    { 
			 //注意尾帧就是ustu_ptr->Uartx_Rx-1
       ustu_ptr->Uartx_Len = (ustu_ptr->Uartx_Rx-1)- (ustu_ptr->Uartx_Tx)+1; //有效数据长度(尾减头,包括头帧和尾帧) 
       ustu_ptr->Uartx_Sta=1;//标志位 
    }
}

//函数名:  Judge_recv
//作者:    Silent Knight
//日期:    2022-02-18
//功能:    提供一个接口判断是否一个命令是否已经到达
//输入参数: void
//返回值:   1 已经到达, 0 还未到达
//=================================================================
int Judge_recv(void)
{
	return ustu_ptr->Uartx_Sta;
}
//函数名:  Usart_deal_data
//作者:    Silent Knight
//日期:    2021-08-4
//功能:    传入需要判断的字符串,例如,格式:(内容=数字)
//输入参数:const char *str,写入参数的地址
//		      传入命令,也就是字符串和指令的地址
//返回值:  类型(void)
//注意:    需要修改宏定义,来使用#define //COMMAND_FLGAHE来选择使用哪种方式,如果是调参模式
//则parameter传入调试参数的数字,通过它来判断指令是否正确和判断值有没有修改成功。如果是命令模式,如果命令正确是真,则parameter为1.0,否则为0,方便判断。如果是指令模式,指令正确,parameter的值就改变,否则不变方便调试。
//实例:调参模式下,pid_p=Usart_deal_data(pid_p=0.111) printf("pid_p=%f",pid_p),一般在主函数中调用或者其他的发送线程调用
//修改记录:          2021/08/03,写完该函数
//					2021/08/04,把不能调用多条命令的BUG修改完
//					2021/08/05,把传入参数修改了,使之能正确的修改参数
//					2021/08/08,修改指令模式下的返回值
//=================================================================
void Usart_deal_data(const char *sdata,double *parameter)
{
	char floatdaer[15]={0};//临时保存内容数据
	int str_len=0;//除命令外有效数据长度
  double temp_data=0;
		
	if(Judge_recv()) //有效数据来了
	{
		if(ustu_ptr->command_flag=='=')//调参使用
		{
			str_len=judge_command(sdata);//把命令结束的位置保存下来
			//printf("command_len=%d,",str_len);
		
			if(strncmp((const char *)&ustu_ptr->Uartx_Buffer[ustu_ptr->Uartx_Tx+1],sdata,str_len)==0)	//判断传来的数据是否符合命令,比较命令是否符合
			{
				//printf("%s\r\n",&ustu_ptr->Uartx_Rx[ustu_ptr->Uartx_Tx]);
				strncpy(floatdaer,(const char *)&ustu_ptr->Uartx_Buffer[(ustu_ptr->Uartx_Tx+str_len+1)],(ustu_ptr->Uartx_Len-str_len+1));//floatdate保存等于号后六位作为字符串
				//printf("%s",floatdaer);
				temp_data=atof(floatdaer);//字符串转换成为浮点型数字,遇到数字或者+-号转换开始,遇到非数字,转换结束,也就是遇到尾标转换结束
				*parameter=temp_data;//保存传入的指令参数
				//printf("temp_data=%lf\r\n",*parameter);
				//重新清零
				ustu_ptr->Uartx_Rx = 0; 
				ustu_ptr->Uartx_Tx = 0; 
				ustu_ptr->Uartx_Sta = 0; 
			}

		}
		else//命令使用,如果是符合命令,返回1.0 ,假的返回0
		{
			str_len=judge_command(sdata);//把命令结束的位置保存下来
			//printf("command_len=%d,",str_len);
			//printf("%s",&ustu_ptr->Uartx_Rx[ustu_ptr->Uartx_Tx]);
			if(strncmp((const char *)&ustu_ptr->Uartx_Buffer[ustu_ptr->Uartx_Tx+1],sdata,str_len-1)==0)	//判断传来的数据是否符合命令,比较命令是否符合
			{			
				//printf("%s\r\n",&ustu_ptr->Uartx_Rx[ustu_ptr->Uartx_Tx]);		
				//printf("True\r\n");
					//重新清零
				*parameter=1.0;//指令为真
				ustu_ptr->Uartx_Rx = 0; 
				ustu_ptr->Uartx_Tx = 0; 
				ustu_ptr->Uartx_Sta = 0; 
			}
			else
			{
			*parameter=0;//指令为假
			}	
		}
	}
}


包括头文件
My_Usart.h

#ifndef __MY_USART_H__
#define __MY_USART_H__

//加入该宏定义使用printf函数
#define JUDGE_DATA_MAX_LEN 20
#define Max_BUFF_Len 0XFF//定义的最大数据容量


//串口管理结构体
typedef struct
{
	rt_uint8_t  Uartx_Buffer[Max_BUFF_Len];//缓冲数组
	rt_uint8_t  Usrt_temp_data;//保存的单个数据
	rt_uint8_t  Uartx_Rx;//状态标志位
	rt_uint8_t  Uartx_Tx;//数据头
	rt_uint8_t  Uartx_Len;//有效数据长度
	rt_uint8_t  Uartx_Sta;//发送数据标志位
	char head_flag;//头帧标志位
	char teal_flag;//尾帧标志位
	char command_flag;//命令标志
}Usart_struct;

//HC05结构体指针
extern Usart_struct usartx_struct;
extern Usart_struct *usartx_struct_ptr;

void Hc05_init(void);
void Usart_srtuct_init(void);
void Usart_sent_data(rt_uint8_t *ch,rt_uint8_t len);
int  Judge_command(const char *str);
char Usart_get_data(void);
void Usart_judge_data(char *usart_data);
void Usart_deal_data(const char *sdata,double *parameter);
void Usart_sent_data(rt_uint8_t *ch,rt_uint8_t len);
int Judge_recv(void);

#endif


四、注意

上位机发送的数据是使用英文输入法,使用中文输入法是不对的,还有输入的命令的严格区分大小写的,这样和下位机的程序一致,记得把头帧和尾帧加上。

建议使用Windous10 的串口调试助手,这个比较好用,在微软的商店就能下载

五、更高级实现

由于这篇半年前写的,代码和思路都不够成熟,算是一个初级的版本,有兴趣想要看更高级的实现(更加复杂和难看懂),但使用起来更方便。功能和这篇文章实现的功能是一样的,但更加人性化和效率更高。

文章就放在这里啦,可以自取

基于循环队列的自定义串口协议

你可能感兴趣的:(STM32,STM32串口通信,STM32基于HAL库串口通信,自定义数据帧)