# wit_queue

**Repository Path**: lzm2018/wit_queue

## Basic Information

- **Project Name**: wit_queue
- **Description**: 单片机的工具库-极简队列
不限平台-串口等外设的数据出入队列
- **Primary Language**: C
- **License**: MulanPSL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-12-31
- **Last Updated**: 2023-12-31

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# wit_queue

#### 介绍
单片机的工具库-串行数据队列解析框架
不限平台
移植简单


#### 软件架构
极简功能函数，用户调用即可


#### 安装教程

1.  将queue.c  queue.h添加到工程中，参考使用说明中UsartCheck_hex()即可使用

#### 使用说明
本文以stm32 串口1中断解析为例来说明使用方法。

1.  包含头文件

`#include "queue.h"`

2.  定义全局结构体

`Queue_t myqueue;`

3.  在main中初始化结构体

`s_queue_empty(&myqueue);`

4.  在串口1的中断接收函数中将数据逐个字节存入队列

```
uint8_t data_uart1_rx;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	HAL_UART_Receive_IT(&huart1,(uint8_t *)&data_uart1_rx, 1);//接收一个字节
  s_queue_in(&myqueue,&data_uart1_rx,1);
}
```
5.  在需要处理的地方取出数据并解析

此处制定的通信格式为“head len sum_a data1 data2 ... datan  sum_b tail”

先对包头长度进行一次校验来确定长度可信：head+len=sum_a

再根据长度接收数据后做校验，检查包尾：data1 + data2 + ... + datan = sum_b

例如正常数据包为aa07b1010201030910fc

在while1中调用UsartCheck_hex()函数即可

``` 
typedef enum
{
	USART_STEP_HEAD,		
	USART_STEP_LENGHT,		
	USART_STEP_SUM_A,		
	USART_STEP_DATA,		
	USART_STEP_SUM_B,		
}RCV_SETP_TYPEDEF;
 ```
```
void UsartCheck_hex()
{
	static unsigned char Lenght = 0;
	static unsigned char sum_a = 0;
	unsigned char i,temp;
	unsigned char data;
	switch(RcvPos)
	{
		case USART_STEP_HEAD:			//
			if(s_queue_len(&myqueue))
			{
					s_queue_out(&myqueue,&data);
					if(data == DATA_HEAD)
					{
						RcvPos = USART_STEP_LENGHT;
					}
			}
		break;
		case USART_STEP_LENGHT:					//
			if(s_queue_len(&myqueue))
			{
					s_queue_out(&myqueue,&data);
					Lenght = data;
					if(Lenght > 3)//长度至少为3，意为最短数据包为6个字节“head len sum_a data sum_b tail”
					{
						RcvPos = USART_STEP_SUM_A;
					}
					else
					{
						RcvPos = USART_STEP_HEAD;
					}
			}
		break;
		case USART_STEP_SUM_A:					//
			if(s_queue_len(&myqueue))
			{
					s_queue_out(&myqueue,&sum_a);
					if(Lenght + DATA_HEAD==sum_a)
					{
						RcvPos = USART_STEP_DATA;
					}
					else//校验“head len sum_a”未通过
					{
						//为了防止数据包结构为“head head len sum_a”时，丢弃掉正常数据，做出过滤
						if(DATA_HEAD == Lenght)
						{
							Lenght=sum_a;
							RcvPos = USART_STEP_SUM_A;
						}
						else 
						{
							if(DATA_HEAD == sum_a)
							{
								RcvPos = USART_STEP_LENGHT;
							}
							else
							{
								RcvPos = USART_STEP_HEAD;
							}
						}

					}
			}
		break;
		case USART_STEP_DATA:						//
			if(s_queue_len(&myqueue) >= Lenght)
			{
				for(i=0; i<Lenght; i++)
				{
					 //
					s_queue_out(&myqueue,&RxDataBuff[i]);
				}
				data=0;
				for(i=0; i<Lenght-2; i++)
				{
					 data+=RxDataBuff[i];
				}
				if(data == RxDataBuff[Lenght-2] && DATA_TAIL == RxDataBuff[Lenght-1])
				{
					data_process();
				}
				else//数据包错误
				{
					
				}
				sum_a = 0;
				Lenght = 0;
				RcvPos = USART_STEP_HEAD;
			}
		break;
		default:;
	}
}
```