Collect/Core/Src/main.c

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under Ultimate Liberty license
  * SLA0044, the "License"; You may not use this file except in compliance with
  * the License. You may obtain a copy of the License at:
  *                             www.st.com/SLA0044
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "cmsis_os.h"
#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include "event_groups.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "string.h"
#include "stdio.h"
#include "usart.h"
#include "config.h"
#include "rkg.h"
#include "cang.h"
#include "kzq.h"
#include "level.h"
#include "tem.h"
#include "angle.h"
#include "xyf.h"
#include "hdf.h"
#include "bgy.h"
#include "yqhs.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
#define 	ADDR_Is_In_ElecFence	0x05D0	//	1488		���Ƿ��ڵ���Χ����
uint8_t REST = 0;
uint32_t usage_Tsk12=0;


 //============================================================
 sT2C_RemoteCaliDat T2C_RemoteCaliDat001  =
{
 
   0x3901,
	 0x9551000,
	 0x0003,
   ADDR_Is_In_ElecFence,//0x0000,
	 0x0001,        //���������ݸ���
   0x55aa55aa,    //������4�ֽ�
   {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,\
	 25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44},
	 0x7788,//������2�ֽ�
   0x99aa   //У��2�ֽ�
};
sT2C_RemoteCaliDat *pT2C_RemoteCaliData = &T2C_RemoteCaliDat001; 



/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define RT_ERRORCNT  60                    //�����շ����ݴ�������




/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */


uint8_t CMD_KZQ[256] =
{0x39,0x01,0x95,0x50,0x00,0x01,0x00,0x03,
0x00,0x00,0x00,0x00,0x95,0x05,0xaa,0xaa,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};

//ж�ͷ�ָ��
uint8_t CMD_XYF[8] = {0x11,0x03,0x00,0x00,0x00,0x01,0x00,0x00};
uint8_t Data_Head[2] = {0x0D,0x0A};
//���׷�ָ��

uint8_t CMD_HDF[16] = 
{0x21,0x03,0x2a,0,0,0,0,0,0xaa,0xbb,0xcc,0xdd,0xee,0xdd,0xcc,0xbb};

//�˿׸�ָ��31 03 00 02 00 02
uint8_t CMD_RKG[8] = {0x01,0x03,0x00,0x02,0x00,0x02,0x00,0x00};//31 06 00 10 00 ff //0x01,0x03,0x00,0x02,0x00,0x02,0x00,0x00
uint8_t CMD_RKG_CBM[12] = {0x0D,0x0A,0x31,0x03,0x00,0x02,0x00,0x02,0x00,0x00,0x0D,0x0A};
uint8_t CMD_RKG_XG[12] = {0x41,0x03,0x00,0x02,0x00,0x02,0x00,0x00};
 
//��������
uint8_t CMD_YQHS[8] = {0xE4,0x03,0x00,0x00,0x00,0x01,0x00,0x00};
//��Ǵ�������ȡЭ�� 01 03 00 02 00 02 CRC
uint8_t CMD_Angle_XY[] = {0x71,0x03,0x00,0x3d,0x00,0x03,0x00,0x00};
//ж����������ȡЭ��
uint8_t CMD_Biguayou[] = {0x81,0x03,0x00,0x00,0x00,0x01,0x9B,0xCA};
//uint8_t CMD_Angle_X[] = {0xE0,0x03,0x00,0x02,0x00,0x02,0x00,0x00};   
//uint8_t CMD_Angle_Y[] = {0xE1,0x03,0x00,0x02,0x00,0x02,0x00,0x00};
uint8_t CMD_LDYW[8]={0x51,0x04,0x0a,0x0f,0x00,0x02};//�豸��ַ�������룬��ַ4�ֽ�   ���أ��豸��ַ�������룬���ݳ��ȣ�����4�ֽ�
uint8_t CMD_GetTempAndYewei[8]={0x51, 0x04, 00, 00, 00, 0x02, 0x00 ,0x00};//��ȡ���Ϊ04��ַ���¶ȴ���������{0x51, 0x04, 00, 00, 00, 0x10, 0x03 ,0xae};
//61-6f 03 00 04 00 01 C6 8A----��ȡ���촫�����ĵ�1���¶ȵ㣬��ַΪx10����ӽ����Ӳֵ��¶ȵ�
uint8_t CMD_GetTempHuaTian[8]={0x61, 0x03, 00, 04, 00, 01,0,0};//��ȡ���촫�����ĵ�һ���¶ȵ�



//�ű��봫������ȡЭ�� ��

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
CRC_HandleTypeDef hcrc;

DAC_HandleTypeDef hdac;
DMA_HandleTypeDef hdma_dac_ch2;

TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim4;

UART_HandleTypeDef huart5;
UART_HandleTypeDef huart1;
UART_HandleTypeDef huart2;
UART_HandleTypeDef huart3;
DMA_HandleTypeDef hdma_usart1_rx;
DMA_HandleTypeDef hdma_usart1_tx;
DMA_HandleTypeDef hdma_usart2_rx;
DMA_HandleTypeDef hdma_usart3_rx;

/* Definitions for defaultTask */
osThreadId_t defaultTaskHandle;
const osThreadAttr_t defaultTask_attributes = {
  .name = "defaultTask",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for myTask02 */
osThreadId_t myTask02Handle;
const osThreadAttr_t myTask02_attributes = {
  .name = "myTask02",
  .stack_size = 256 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for myTask03 */
osThreadId_t myTask03Handle;
const osThreadAttr_t myTask03_attributes = {
  .name = "myTask03",
  .stack_size = 256 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for myTask04 */
osThreadId_t myTask04Handle;
const osThreadAttr_t myTask04_attributes = {
  .name = "myTask04",
  .stack_size = 256 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for myTask05 */
osThreadId_t myTask05Handle;
const osThreadAttr_t myTask05_attributes = {
  .name = "myTask05",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for myTask06 */
osThreadId_t myTask06Handle;
const osThreadAttr_t myTask06_attributes = {
  .name = "myTask06",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for myTask07 */
osThreadId_t myTask07Handle;
const osThreadAttr_t myTask07_attributes = {
  .name = "myTask07",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for myTask08 */
osThreadId_t myTask08Handle;
const osThreadAttr_t myTask08_attributes = {
  .name = "myTask08",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for myTask09 */
osThreadId_t myTask09Handle;
const osThreadAttr_t myTask09_attributes = {
  .name = "myTask09",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for myTask10 */
osThreadId_t myTask10Handle;
const osThreadAttr_t myTask10_attributes = {
  .name = "myTask10",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for myTask11 */
osThreadId_t myTask11Handle;
const osThreadAttr_t myTask11_attributes = {
  .name = "myTask11",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityLow,
};
/* Definitions for myTask12 */
osThreadId_t myTask12Handle;
const osThreadAttr_t myTask12_attributes = {
  .name = "myTask12",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) (osPriorityLow-6),
};
/* Definitions for myQueue01 */
osMessageQueueId_t myQueue01Handle;
const osMessageQueueAttr_t myQueue01_attributes = {
  .name = "myQueue01"
};
/* Definitions for myQueue02 */
osMessageQueueId_t myQueue02Handle;
const osMessageQueueAttr_t myQueue02_attributes = {
  .name = "myQueue02"
};
/* Definitions for myQueue03 */
osMessageQueueId_t myQueue03Handle;
const osMessageQueueAttr_t myQueue03_attributes = {
  .name = "myQueue03"
};
/* Definitions for myQueue04 */
osMessageQueueId_t myQueue04Handle;
const osMessageQueueAttr_t myQueue04_attributes = {
  .name = "myQueue04"
};
/* Definitions for myQueue05 */
osMessageQueueId_t myQueue05Handle;
const osMessageQueueAttr_t myQueue05_attributes = {
  .name = "myQueue05"
};
/* Definitions for myQueue06 */
osMessageQueueId_t myQueue06Handle;
const osMessageQueueAttr_t myQueue06_attributes = {
  .name = "myQueue06"
};
/* Definitions for myTimer01 */
osTimerId_t myTimer01Handle;
const osTimerAttr_t myTimer01_attributes = {
  .name = "myTimer01"
};
/* Definitions for myTimer02 */
osTimerId_t myTimer02Handle;
const osTimerAttr_t myTimer02_attributes = {
  .name = "myTimer02"
};
/* Definitions for myTimer03 */
osTimerId_t myTimer03Handle;
const osTimerAttr_t myTimer03_attributes = {
  .name = "myTimer03"
};
/* Definitions for myTimer04 */
osTimerId_t myTimer04Handle;
const osTimerAttr_t myTimer04_attributes = {
  .name = "myTimer04"
};
/* Definitions for myTimer05 */
osTimerId_t myTimer05Handle;
const osTimerAttr_t myTimer05_attributes = {
  .name = "myTimer05"
};
/* Definitions for myTimer06 */
osTimerId_t myTimer06Handle;
const osTimerAttr_t myTimer06_attributes = {
  .name = "myTimer06"
};
/* Definitions for myTimer07 */
osTimerId_t myTimer07Handle;
const osTimerAttr_t myTimer07_attributes = {
  .name = "myTimer07"
};
/* Definitions for myTimer08 */
osTimerId_t myTimer08Handle;
const osTimerAttr_t myTimer08_attributes = {
  .name = "myTimer08"
};
/* Definitions for myTimer09 */
osTimerId_t myTimer09Handle;
const osTimerAttr_t myTimer09_attributes = {
  .name = "myTimer09"
};
/* Definitions for myTimer10 */
osTimerId_t myTimer10Handle;
const osTimerAttr_t myTimer10_attributes = {
  .name = "myTimer10"
};
/* Definitions for myMutex01 */
osMutexId_t myMutex01Handle;
const osMutexAttr_t myMutex01_attributes = {
  .name = "myMutex01"
};
/* Definitions for myMutex02 */
osMutexId_t myMutex02Handle;
const osMutexAttr_t myMutex02_attributes = {
  .name = "myMutex02"
};
/* Definitions for myMutex03 */
osMutexId_t myMutex03Handle;
const osMutexAttr_t myMutex03_attributes = {
  .name = "myMutex03"
};
/* Definitions for myMutex04 */
osMutexId_t myMutex04Handle;
const osMutexAttr_t myMutex04_attributes = {
  .name = "myMutex04"
};
/* Definitions for myMutex05 */
osMutexId_t myMutex05Handle;
const osMutexAttr_t myMutex05_attributes = {
  .name = "myMutex05"
};
/* Definitions for myMutex06 */
osMutexId_t myMutex06Handle;
const osMutexAttr_t myMutex06_attributes = {
  .name = "myMutex06"
};
/* Definitions for myMutex07 */
osMutexId_t myMutex07Handle;
const osMutexAttr_t myMutex07_attributes = {
  .name = "myMutex07"
};
/* Definitions for myMutex08 */
osMutexId_t myMutex08Handle;
const osMutexAttr_t myMutex08_attributes = {
  .name = "myMutex08"
};
/* Definitions for myRecursiveMutex01 */
osMutexId_t myRecursiveMutex01Handle;
const osMutexAttr_t myRecursiveMutex01_attributes = {
  .name = "myRecursiveMutex01",
  .attr_bits = osMutexRecursive,
};
/* Definitions for myRecursiveMutex02 */
osMutexId_t myRecursiveMutex02Handle;
const osMutexAttr_t myRecursiveMutex02_attributes = {
  .name = "myRecursiveMutex02",
  .attr_bits = osMutexRecursive,
};
/* Definitions for myRecursiveMutex03 */
osMutexId_t myRecursiveMutex03Handle;
const osMutexAttr_t myRecursiveMutex03_attributes = {
  .name = "myRecursiveMutex03",
  .attr_bits = osMutexRecursive,
};
/* Definitions for myRecursiveMutex04 */
osMutexId_t myRecursiveMutex04Handle;
const osMutexAttr_t myRecursiveMutex04_attributes = {
  .name = "myRecursiveMutex04",
  .attr_bits = osMutexRecursive,
};
/* Definitions for myBinarySem01 */
osSemaphoreId_t myBinarySem01Handle;
const osSemaphoreAttr_t myBinarySem01_attributes = {
  .name = "myBinarySem01"
};
/* Definitions for myBinarySem02 */
osSemaphoreId_t myBinarySem02Handle;
const osSemaphoreAttr_t myBinarySem02_attributes = {
  .name = "myBinarySem02"
};
/* Definitions for myBinarySem03 */
osSemaphoreId_t myBinarySem03Handle;
const osSemaphoreAttr_t myBinarySem03_attributes = {
  .name = "myBinarySem03"
};
/* Definitions for myBinarySem04 */
osSemaphoreId_t myBinarySem04Handle;
const osSemaphoreAttr_t myBinarySem04_attributes = {
  .name = "myBinarySem04"
};
/* Definitions for myBinarySem05 */
osSemaphoreId_t myBinarySem05Handle;
const osSemaphoreAttr_t myBinarySem05_attributes = {
  .name = "myBinarySem05"
};
/* Definitions for myBinarySem06 */
osSemaphoreId_t myBinarySem06Handle;
const osSemaphoreAttr_t myBinarySem06_attributes = {
  .name = "myBinarySem06"
};
/* Definitions for myBinarySem07 */
osSemaphoreId_t myBinarySem07Handle;
const osSemaphoreAttr_t myBinarySem07_attributes = {
  .name = "myBinarySem07"
};
/* Definitions for myBinarySem08 */
osSemaphoreId_t myBinarySem08Handle;
const osSemaphoreAttr_t myBinarySem08_attributes = {
  .name = "myBinarySem08"
};
/* Definitions for myCountingSem01 */
osSemaphoreId_t myCountingSem01Handle;
const osSemaphoreAttr_t myCountingSem01_attributes = {
  .name = "myCountingSem01"
};
/* Definitions for myCountingSem02 */
osSemaphoreId_t myCountingSem02Handle;
const osSemaphoreAttr_t myCountingSem02_attributes = {
  .name = "myCountingSem02"
};
/* Definitions for myCountingSem03 */
osSemaphoreId_t myCountingSem03Handle;
const osSemaphoreAttr_t myCountingSem03_attributes = {
  .name = "myCountingSem03"
};
/* Definitions for myCountingSem04 */
osSemaphoreId_t myCountingSem04Handle;
const osSemaphoreAttr_t myCountingSem04_attributes = {
  .name = "myCountingSem04"
};
/* Definitions for myEvent01 */
osEventFlagsId_t myEvent01Handle;
const osEventFlagsAttr_t myEvent01_attributes = {
  .name = "myEvent01"
};
/* Definitions for myEvent02 */
osEventFlagsId_t myEvent02Handle;
const osEventFlagsAttr_t myEvent02_attributes = {
  .name = "myEvent02"
};
/* Definitions for myEvent03 */
osEventFlagsId_t myEvent03Handle;
const osEventFlagsAttr_t myEvent03_attributes = {
  .name = "myEvent03"
};
/* Definitions for myEvent04 */
osEventFlagsId_t myEvent04Handle;
const osEventFlagsAttr_t myEvent04_attributes = {
  .name = "myEvent04"
};
/* Definitions for myEvent05 */
osEventFlagsId_t myEvent05Handle;
const osEventFlagsAttr_t myEvent05_attributes = {
  .name = "myEvent05"
};
/* Definitions for myEvent06 */
osEventFlagsId_t myEvent06Handle;
const osEventFlagsAttr_t myEvent06_attributes = {
  .name = "myEvent06"
};
/* Definitions for myEvent07 */
osEventFlagsId_t myEvent07Handle;
const osEventFlagsAttr_t myEvent07_attributes = {
  .name = "myEvent07"
};
/* Definitions for myEvent08 */
osEventFlagsId_t myEvent08Handle;
const osEventFlagsAttr_t myEvent08_attributes = {
  .name = "myEvent08"
};
/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_UART5_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_USART3_UART_Init(void);
static void MX_CRC_Init(void);
static void MX_DAC_Init(void);
static void MX_TIM1_Init(void);
static void MX_TIM4_Init(void);
void StartDefaultTask(void *argument);
void StartTask02(void *argument);
void StartTask03(void *argument);
void StartTask04(void *argument);
void StartTask05(void *argument);
void StartTask06(void *argument);
void StartTask07(void *argument);
void StartTask08(void *argument);
void StartTask09(void *argument);
void StartTask10(void *argument);
void StartTask11(void *argument);
void StartTask12(void *argument);
void Callback01(void *argument);
void Callback02(void *argument);
void Callback03(void *argument);
void Callback04(void *argument);
void Callback05(void *argument);
void Callback06(void *argument);
void Callback07(void *argument);
void Callback08(void *argument);
void Callback09(void *argument);
void Callback010(void *argument);
void Cang_Init(void);

static void MX_NVIC_Init(void);
/* USER CODE BEGIN PFP */
void Flash_ReadBytes(uint16_t* sorBuf,uint32_t FlashAddr,uint16_t len)
{
	uint16_t* p = sorBuf;
	uint8_t i = 0,j = 0;
	uint32_t addr = FlashAddr;
	while(len--)
	{
		i = *(uint32_t*)addr++;
		j = *(uint32_t*)addr++;
		*p++ = j<<8|i;
	}
}
uint16_t Flashbuf[2048]__attribute__ ((at(0X20001000)));// {0};
//uint8_t   UART_RX_BUF[1024]   __attribute__ ((at(0X20001000))); 
void Flash_WriteBytes(uint16_t* sorBuf,uint32_t FlashAddr,uint16_t len)
{

	uint32_t Offset_ADDR = 0,Page_StartAddr = 0,i = 0;
	Offset_ADDR = FlashAddr%0x800;
	Page_StartAddr = FlashAddr - Offset_ADDR;
	//����PageError
	uint32_t PageError = 0;
	FLASH_EraseInitTypeDef f;

	f.TypeErase = FLASH_TYPEERASE_PAGES;
	__nop();
	f.PageAddress =Page_StartAddr;
	f.NbPages = 1;

	Flash_ReadBytes(Flashbuf,Page_StartAddr,0x400);
	
	for(i = 0;i<len;i++)
		Flashbuf[Offset_ADDR/2+i] = sorBuf[i];
	
	//1������FLASH
  HAL_FLASH_Unlock();
	__nop();

  //2������FLASH
  //��ʼ��FLASH_EraseInitTypeDef

  //��������
  HAL_FLASHEx_Erase(&f, &PageError);
	
	__nop();
  //3����FLASH��д
  for(uint16_t i = 0;i< 0x400 ;i++)
  {
      HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD , Page_StartAddr + (i * 2), Flashbuf[i]);
  }

    //4����סFLASH
    HAL_FLASH_Lock();
	
}

	typedef union{
   float Ldcal_zero_temp;   //�����ʹ�������Һλ�¶�һ�崫����
   uint8_t arr[4];
  }Hex_to_float1;
Hex_to_float1 hex_to_float1;
	
	
	
void Cang_Init(void)
{
	Cang_Inf* pcang = &cang_inf;
	RKG_Inf*  prkg  = rkg_inf;
	XYF_Inf*  pxyf  = xyf_inf;
	HDF_Inf*  phdf  = hdf_inf;
	Angle_Inf* pangle = &angle_inf;
	Level_Inf* plevel = level_inf;
	TEM_Inf* ptem = tem_inf;

  
	uint16_t Flash_buff[64] = {0};
	uint16_t i = 0;
	

	
	Flash_ReadBytes(Flash_buff,ADDR_CANG_NUM,6);
	if(Flash_buff[0] == 0xffff)
	{
	Flash_WriteBytes(Volume_1cang,ADD_CANG1_TABLE,200);
  Flash_WriteBytes(Volume_2cang,ADD_CANG2_TABLE,200);
	Flash_WriteBytes(Volume_3cang,ADD_CANG3_TABLE,200);
  Flash_WriteBytes(Volume_4cang,ADD_CANG4_TABLE,200);	
		pcang->Cang_Num = 3;													//Ĭ������
  }
		else
		pcang->Cang_Num = Flash_buff[0];

	if(Flash_buff[1] == 0xffff)
	{
		i = 0;
		while(i < pcang->Cang_Num)
		{
			pcang->RKG_Num[i] = 1;													//Ĭ��ÿ��1�˿״��
			pcang->RKG_DG = 1;															//Ĭ���д��
			i++;
		}
	}
	else
	{
		i = 0;
		while(i <pcang->Cang_Num)
		{
			pcang->RKG_Num[i] = Flash_buff[1];							//Ĭ��ÿ��1�˿׸�	
			pcang->RKG_DG = Flash_buff[1];
			i++;
		}
	}
	
	if(Flash_buff[2] == 0xffff)
		pcang->RKG_XG = 0;																	//Ĭ�����˿�С��
	else
		pcang->RKG_XG = Flash_buff[2];
	
	if(Flash_buff[3] == 0xffff)
	{
		i = 0;
		while(i <pcang->Cang_Num)
		{
  		pcang->XYF_INSTALL = 1;                     //  Ĭ����ж�ͷ�SLM  
			pcang->XYF_Num[i] = 2;											//Ĭ��ÿ��1ж�ͷ�
			i++;
		}
	}
	else
	{
		i = 0;
		while(i <pcang->Cang_Num)
		{
						pcang->XYF_INSTALL = 1;                     //  Ĭ����ж�ͷ�SLM  
			pcang->XYF_Num[i] = Flash_buff[3];					i++;
		}
	}
	
	if(Flash_buff[4] == 0xffff)
	{
		i = 0;
		while(i <pcang->Cang_Num)
		{
			pcang->HDF_INSTALL = 1;
			pcang->HDF_Num[i] = 1;											//Ĭ��ÿ��1���׷�
			i++;
		}
	}
	else
	{
		i = 0;
		while(i <pcang->Cang_Num)
		{
						pcang->HDF_INSTALL = 1;//slm
			pcang->HDF_Num[i] = Flash_buff[4];												
			i++;
		}
	}
	
	Flash_ReadBytes(Flash_buff,ADDR_RKGSENSOR_TYPE,1);
	if(Flash_buff[0] == 0xffff)
		pcang->RKG_Type = 1;        										   //Ĭ���˿׸ǽǶȴ�����     1�ŵ���봫����
	else
		pcang->RKG_Type = Flash_buff[0];

	Flash_ReadBytes(Flash_buff,ADDR_XYFSENSOR_TYPE,1);
	if(Flash_buff[0] == 0xffff)
		pcang->XYF_Type = 0;       												    //Ĭ��ж�ͷ���������һ
	else
		pcang->XYF_Type = Flash_buff[0];

	Flash_ReadBytes(Flash_buff,ADDR_HDFSENSOR_TYPE,1);
	if(Flash_buff[0] == 0xffff)
		pcang->HDF_Type = 1;      															     //Ĭ�ϵ׷������   1���ܵ׷�
	else
		pcang->HDF_Type = Flash_buff[0];
	
	
	Flash_ReadBytes(Flash_buff,ADDR_RKG_NUM,8);										//����Ƿ�Է������༰������������
	for(i = 0;i < 8;i++)
	{
		if((Flash_buff[i] > 0) && (Flash_buff[i] < 8))
		pcang->RKG_Num[i] = Flash_buff[i];	
		pcang->RKG_Num[i]  = 1;																			//Ĭ��ÿ��1�˿׷�
	}
	Flash_ReadBytes(Flash_buff,ADDR_XYF_NUM,8);
	for(i = 0;i < 8;i++)
	{
		if((Flash_buff[i] > 0) && (Flash_buff[i] < 8))
		pcang->XYF_Num[i] = Flash_buff[i];
		pcang->XYF_Num[i] = 2;		//Ĭ��ÿ��1ж�ͷ�   slm
	}
	Flash_ReadBytes(Flash_buff,ADDR_HDF_NUM,8);
	for(i = 0;i < 8;i++)
	{
		if((Flash_buff[i] > 0) && (Flash_buff[i] < 8))
			pcang->HDF_Num[i] = Flash_buff[i];
		pcang->HDF_Num[i] = 1;		    //Ĭ��ÿ��1���׷�   slm
	}
	
	
	Flash_ReadBytes(Flash_buff,ADDR_YQHS_TYPE,1);
	if(Flash_buff[0] == 0xffff)
		pcang->YQHS = 1;           //Ĭ������������     slm
	else
		pcang->YQHS = Flash_buff[0];
	
	Flash_ReadBytes(Flash_buff,ADDR_LEVEL_TYPE,1);
	if(Flash_buff[0] == 0xffff)
		pcang->Level = 2;           //Ĭ�ϴ�������Һλ������   slm
	else
		pcang->Level = Flash_buff[0];
	
	Flash_ReadBytes(Flash_buff,CANG1_LEVEL_CAL,8);
	if(Flash_buff[0] == 0xffff)
	{
						hex_to_float1.arr[0] = 0;
					  hex_to_float1.arr[1] = 0;
					  hex_to_float1.arr[2] = 0;
					  hex_to_float1.arr[3] = 0;					
						plevel[1].Level_Cal_zero = 0;
						hex_to_float1.arr[0] = 0;
					  hex_to_float1.arr[1] = 0;
					  hex_to_float1.arr[2] = 0;
					  hex_to_float1.arr[3] = 0;					
						plevel[2].Level_Cal_zero = 0;		
						hex_to_float1.arr[0] = 0;
					  hex_to_float1.arr[1] = 0;
					  hex_to_float1.arr[2] = 0;
					  hex_to_float1.arr[3] = 0;					
						plevel[3].Level_Cal_zero = 0;
						hex_to_float1.arr[0] = 0;
					  hex_to_float1.arr[1] = 0;
					  hex_to_float1.arr[2] = 0;
					  hex_to_float1.arr[3] = 0;					
						plevel[4].Level_Cal_zero = 0;				
	}
	else
	{

						hex_to_float1.arr[3] = (uint8_t)(Flash_buff[0]>>8);;//Flash_buff[4];
					  hex_to_float1.arr[2] = (uint8_t)(Flash_buff[0]&0xFF);// Flash_buff[3];
					  hex_to_float1.arr[1] = (uint8_t)(Flash_buff[1]>>8);;//Flash_buff[6];
					  hex_to_float1.arr[0] = (uint8_t)(Flash_buff[1]&0xFF);;//Flash_buff[5];					
						plevel[1].Level_Cal_zero = hex_to_float1.Ldcal_zero_temp;
		        __NOP();
						hex_to_float1.arr[3] = Flash_buff[2]>>8;;//Flash_buff[4];
					  hex_to_float1.arr[2] = Flash_buff[2]&0xFF;// Flash_buff[3];
					  hex_to_float1.arr[1] = Flash_buff[3]>>8;;//Flash_buff[6];
					  hex_to_float1.arr[0] = Flash_buff[3]&0xFF;;//Flash_buff[5];	
						plevel[2].Level_Cal_zero = hex_to_float1.Ldcal_zero_temp;		
		        __NOP();
						hex_to_float1.arr[3] = (uint8_t)(Flash_buff[4]>>8);;//Flash_buff[4];
					  hex_to_float1.arr[2] = (uint8_t)(Flash_buff[4]&0xFF);// Flash_buff[3];
					  hex_to_float1.arr[1] = (uint8_t)(Flash_buff[5]>>8);;//Flash_buff[6];
					  hex_to_float1.arr[0] = (uint8_t)(Flash_buff[5]&0xFF);;//Flash_buff[5];					
						plevel[3].Level_Cal_zero = hex_to_float1.Ldcal_zero_temp;
		        __NOP();
						hex_to_float1.arr[3] = Flash_buff[6]>>8;;//Flash_buff[4];
					  hex_to_float1.arr[2] = Flash_buff[6]&0xFF;// Flash_buff[3];
					  hex_to_float1.arr[1] = Flash_buff[7]>>8;;//Flash_buff[6];
					  hex_to_float1.arr[0] = Flash_buff[7]&0xFF;;//Flash_buff[5];	
						plevel[4].Level_Cal_zero = hex_to_float1.Ldcal_zero_temp;		
		        __NOP();		
	}
	
	
	

	Flash_ReadBytes(Flash_buff,ADDR_TEM_TYPE,1);
	if(Flash_buff[0] == 0xffff)
		pcang->Temperture = 1;           //Ĭ�����¶ȴ�����
	else
		pcang->Temperture = Flash_buff[0];
		
	Flash_ReadBytes(Flash_buff,ADDR_ANGLE_TYPE,1);
	if(Flash_buff[0] == 0xffff)
		pcang->Angle = 1;           //Ĭ������̬������
	else
		pcang->Angle = Flash_buff[0];	
	
	Flash_ReadBytes(Flash_buff,ADDR_SDATEJUDGE_NUM,1);
	if(Flash_buff[0] == 0xffff)
	{
		prkg[1].RKG_StateKeepNum = 5;           //Ĭ���˿׸ǽǶȴ�����
		pxyf[2].XYF_StateKeepNum = 5;
		phdf->HDF_StateKeepNum = 5;
		pangle->Angle_StateKeepNum = 5;
		plevel->Level_StateKeepNum = 5;
		ptem->TEM_StateKeepNum = 5;
	}
	else
	{
		prkg[1].RKG_StateKeepNum = Flash_buff[0];           //Ĭ���˿׸ǽǶȴ�����
		prkg[2].RKG_StateKeepNum = Flash_buff[0];           //Ĭ���˿׸ǽǶȴ�����
		pxyf->XYF_StateKeepNum = Flash_buff[0];
		phdf->HDF_StateKeepNum = Flash_buff[0];
		
		__NOP();
		pangle->Angle_StateKeepNum = Flash_buff[0];
		plevel->Level_StateKeepNum = Flash_buff[0];
		ptem->TEM_StateKeepNum = Flash_buff[0];
	}	
}



/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**4
  * @brief  The application entry point.
  * @retval int
  */
	uint8_t bufMain[128];
int main(void)
{
  /* USER CODE BEGIN 1 */
	GPIO_InitTypeDef GPIO_InitStruct = {0};

	int spr000;
  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */
	Cang_Init();																					//Ӧ�ó����ʼ������
	RKG_Init();
	XYF_Init();
	BGY_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_DMA_Init();
  MX_USART1_UART_Init();
  MX_UART5_Init();
  MX_USART2_UART_Init();
  MX_USART3_UART_Init();
  MX_CRC_Init();
  MX_DAC_Init();
  MX_TIM1_Init();
  MX_TIM4_Init();

  /* Initialize interrupts */
  MX_NVIC_Init();
  /* USER CODE BEGIN 2 */	
	HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_SET);//�л�Ϊ����ģʽ
	HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);//�л�Ϊ����ģʽ
	HAL_GPIO_WritePin(con03_uart2_kongzhiqi_GPIO_Port,con03_uart2_kongzhiqi_Pin,GPIO_PIN_SET);//�л�Ϊ����ģʽ
	
	////////////////���Ź����¸��ݺ궨���ʼ��////////////////////
	GPIO_InitStruct.Pin = WDI_sp706_kanmemgou_Pin;
	if(WatchDogOn)//�򿪿��Ź�sp706
	{
		GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	}
	else
	{
		GPIO_InitStruct.Mode = GPIO_MODE_INPUT;	
	}
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(WDI_sp706_kanmemgou_GPIO_Port, &GPIO_InitStruct);
	///////////////////////////////////////////////////////////////
	
	
	HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_RESET);//�л�Ϊ����ģʽCON=0;// 
	HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_RESET);//�л�Ϊ����ģʽ
	HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_RESET);//�л�Ϊ����ģʽ
	HAL_GPIO_WritePin(con03_uart2_kongzhiqi_GPIO_Port,con03_uart2_kongzhiqi_Pin,GPIO_PIN_RESET);//�л�Ϊ����ģʽ
	
	HAL_Delay(2);
	memset(bufMain,0,32);
	spr000=sprintf((char*)bufMain,"sysytem reset...%5d",5);
	//HAL_UART_Transmit(&huart1,bufMain,32,300);
	HAL_UART_Transmit(&huart2,bufMain,spr000,300);
	//HAL_UART_Transmit(&huart3,bufMain,32,300);
	
 
	HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_SET);//�л�Ϊ����ģʽ
	HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);//�л�Ϊ����ģʽ
	HAL_GPIO_WritePin(con03_uart2_kongzhiqi_GPIO_Port,con03_uart2_kongzhiqi_Pin,GPIO_PIN_SET);//�л�Ϊ����ģʽ

	

  /* USER CODE END 2 */

  /* Init scheduler */
  osKernelInitialize();
  /* Create the mutex(es) */
  /* creation of myMutex01 */
  myMutex01Handle = osMutexNew(&myMutex01_attributes);

  /* creation of myMutex02 */
  myMutex02Handle = osMutexNew(&myMutex02_attributes);

  /* creation of myMutex03 */
  myMutex03Handle = osMutexNew(&myMutex03_attributes);

  /* creation of myMutex04 */
  myMutex04Handle = osMutexNew(&myMutex04_attributes);

  /* creation of myMutex05 */
  myMutex05Handle = osMutexNew(&myMutex05_attributes);

  /* creation of myMutex06 */
  myMutex06Handle = osMutexNew(&myMutex06_attributes);

  /* creation of myMutex07 */
  myMutex07Handle = osMutexNew(&myMutex07_attributes);

  /* creation of myMutex08 */
  myMutex08Handle = osMutexNew(&myMutex08_attributes);

  /* Create the recursive mutex(es) */
  /* creation of myRecursiveMutex01 */
  myRecursiveMutex01Handle = osMutexNew(&myRecursiveMutex01_attributes);

  /* creation of myRecursiveMutex02 */
  myRecursiveMutex02Handle = osMutexNew(&myRecursiveMutex02_attributes);

  /* creation of myRecursiveMutex03 */
  myRecursiveMutex03Handle = osMutexNew(&myRecursiveMutex03_attributes);

  /* creation of myRecursiveMutex04 */
  myRecursiveMutex04Handle = osMutexNew(&myRecursiveMutex04_attributes);

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* Create the semaphores(s) */
  /* creation of myBinarySem01 */
  myBinarySem01Handle = osSemaphoreNew(1, 1, &myBinarySem01_attributes);

  /* creation of myBinarySem02 */
  myBinarySem02Handle = osSemaphoreNew(1, 1, &myBinarySem02_attributes);

  /* creation of myBinarySem03 */
  myBinarySem03Handle = osSemaphoreNew(1, 1, &myBinarySem03_attributes);

  /* creation of myBinarySem04 */
  myBinarySem04Handle = osSemaphoreNew(1, 1, &myBinarySem04_attributes);

  /* creation of myBinarySem05 */
  myBinarySem05Handle = osSemaphoreNew(1, 1, &myBinarySem05_attributes);

  /* creation of myBinarySem06 */
  myBinarySem06Handle = osSemaphoreNew(1, 1, &myBinarySem06_attributes);

  /* creation of myBinarySem07 */
  myBinarySem07Handle = osSemaphoreNew(1, 1, &myBinarySem07_attributes);

  /* creation of myBinarySem08 */
  myBinarySem08Handle = osSemaphoreNew(1, 1, &myBinarySem08_attributes);

  /* creation of myCountingSem01 */
  myCountingSem01Handle = osSemaphoreNew(2, 2, &myCountingSem01_attributes);

  /* creation of myCountingSem02 */
  myCountingSem02Handle = osSemaphoreNew(2, 2, &myCountingSem02_attributes);

  /* creation of myCountingSem03 */
  myCountingSem03Handle = osSemaphoreNew(2, 2, &myCountingSem03_attributes);

  /* creation of myCountingSem04 */
  myCountingSem04Handle = osSemaphoreNew(2, 2, &myCountingSem04_attributes);

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* Create the timer(s) */
  /* creation of myTimer01 */
  myTimer01Handle = osTimerNew(Callback01, osTimerPeriodic, NULL, &myTimer01_attributes);

  /* creation of myTimer02 */
  myTimer02Handle = osTimerNew(Callback02, osTimerPeriodic, NULL, &myTimer02_attributes);

  /* creation of myTimer03 */
  myTimer03Handle = osTimerNew(Callback03, osTimerPeriodic, NULL, &myTimer03_attributes);

  /* creation of myTimer04 */
  myTimer04Handle = osTimerNew(Callback04, osTimerPeriodic, NULL, &myTimer04_attributes);

  /* creation of myTimer05 */
  myTimer05Handle = osTimerNew(Callback05, osTimerPeriodic, NULL, &myTimer05_attributes);

  /* creation of myTimer06 */
  myTimer06Handle = osTimerNew(Callback06, osTimerPeriodic, NULL, &myTimer06_attributes);

  /* creation of myTimer07 */
  myTimer07Handle = osTimerNew(Callback07, osTimerPeriodic, NULL, &myTimer07_attributes);

  /* creation of myTimer08 */
  myTimer08Handle = osTimerNew(Callback08, osTimerPeriodic, NULL, &myTimer08_attributes);

  /* creation of myTimer09 */
  myTimer09Handle = osTimerNew(Callback09, osTimerPeriodic, NULL, &myTimer09_attributes);

  /* creation of myTimer10 */
  myTimer10Handle = osTimerNew(Callback010, osTimerPeriodic, NULL, &myTimer10_attributes);

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* Create the queue(s) */
  /* creation of myQueue01 */
  myQueue01Handle = osMessageQueueNew (16, sizeof(uint16_t), &myQueue01_attributes);

  /* creation of myQueue02 */
  myQueue02Handle = osMessageQueueNew (16, sizeof(uint16_t), &myQueue02_attributes);

  /* creation of myQueue03 */
  myQueue03Handle = osMessageQueueNew (16, sizeof(uint16_t), &myQueue03_attributes);

  /* creation of myQueue04 */
  myQueue04Handle = osMessageQueueNew (16, sizeof(uint16_t), &myQueue04_attributes);

  /* creation of myQueue05 */
  myQueue05Handle = osMessageQueueNew (16, sizeof(uint16_t), &myQueue05_attributes);

  /* creation of myQueue06 */
  myQueue06Handle = osMessageQueueNew (16, sizeof(uint16_t), &myQueue06_attributes);

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* creation of defaultTask */
  defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);

  /* creation of myTask02 */
  myTask02Handle = osThreadNew(StartTask02, NULL, &myTask02_attributes);

  /* creation of myTask03 */
  myTask03Handle = osThreadNew(StartTask03, NULL, &myTask03_attributes);

  /* creation of myTask04 */
  myTask04Handle = osThreadNew(StartTask04, NULL, &myTask04_attributes);

  /* creation of myTask05 */
  myTask05Handle = osThreadNew(StartTask05, NULL, &myTask05_attributes);

  /* creation of myTask06 */
  myTask06Handle = osThreadNew(StartTask06, NULL, &myTask06_attributes);

  /* creation of myTask07 */
  myTask07Handle = osThreadNew(StartTask07, NULL, &myTask07_attributes);

  /* creation of myTask08 */
  myTask08Handle = osThreadNew(StartTask08, NULL, &myTask08_attributes);

  /* creation of myTask09 */
  myTask09Handle = osThreadNew(StartTask09, NULL, &myTask09_attributes);

  /* creation of myTask10 */
  myTask10Handle = osThreadNew(StartTask10, NULL, &myTask10_attributes);

  /* creation of myTask11 */
  myTask11Handle = osThreadNew(StartTask11, NULL, &myTask11_attributes);

  /* creation of myTask12 */
  myTask12Handle = osThreadNew(StartTask12, NULL, &myTask12_attributes);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */

  /* creation of myEvent01 */
  myEvent01Handle = osEventFlagsNew(&myEvent01_attributes);

  /* creation of myEvent02 */
  myEvent02Handle = osEventFlagsNew(&myEvent02_attributes);

  /* creation of myEvent03 */
  myEvent03Handle = osEventFlagsNew(&myEvent03_attributes);

  /* creation of myEvent04 */
  myEvent04Handle = osEventFlagsNew(&myEvent04_attributes);

  /* creation of myEvent05 */
  myEvent05Handle = osEventFlagsNew(&myEvent05_attributes);

  /* creation of myEvent06 */
  myEvent06Handle = osEventFlagsNew(&myEvent06_attributes);

  /* creation of myEvent07 */
  myEvent07Handle = osEventFlagsNew(&myEvent07_attributes);

  /* creation of myEvent08 */
  myEvent08Handle = osEventFlagsNew(&myEvent08_attributes);

  /* USER CODE BEGIN RTOS_EVENTS */
  /* add events, ... */
  /* USER CODE END RTOS_EVENTS */

  /* Start scheduler */
  osKernelStart();

  /* We should never get here as control is now taken by the scheduler */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		
		
		
	}
   /* USER CODE END WHILE */

   /* 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();
  }
}

/**
  * @brief NVIC Configuration.
  * @retval None
  */
static void MX_NVIC_Init(void)
{
  /* USART3_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(USART3_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(USART3_IRQn);
  /* USART1_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(USART1_IRQn);
  /* USART2_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(USART2_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(USART2_IRQn);
  /* TIM4_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(TIM4_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(TIM4_IRQn);
  /* TIM1_UP_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(TIM1_UP_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(TIM1_UP_IRQn);
  /* DMA1_Channel6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
  /* DMA1_Channel5_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
  /* DMA1_Channel3_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}

/**
  * @brief CRC Initialization Function
  * @param None
  * @retval None
  */
static void MX_CRC_Init(void)
{

  /* USER CODE BEGIN CRC_Init 0 */

  /* USER CODE END CRC_Init 0 */

  /* USER CODE BEGIN CRC_Init 1 */

  /* USER CODE END CRC_Init 1 */
  hcrc.Instance = CRC;
  if (HAL_CRC_Init(&hcrc) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN CRC_Init 2 */

  /* USER CODE END CRC_Init 2 */

}

/**
  * @brief DAC Initialization Function
  * @param None
  * @retval None
  */
static void MX_DAC_Init(void)
{

  /* USER CODE BEGIN DAC_Init 0 */

  /* USER CODE END DAC_Init 0 */

  DAC_ChannelConfTypeDef sConfig = {0};

  /* USER CODE BEGIN DAC_Init 1 */

  /* USER CODE END DAC_Init 1 */
  /** DAC Initialization
  */
  hdac.Instance = DAC;
  if (HAL_DAC_Init(&hdac) != HAL_OK)
  {
    Error_Handler();
  }
  /** DAC channel OUT2 config
  */
  sConfig.DAC_Trigger = DAC_TRIGGER_SOFTWARE;
  sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
  if (HAL_DAC_ConfigChannel(&hdac, &sConfig, DAC_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN DAC_Init 2 */

  /* USER CODE END DAC_Init 2 */

}

/**
  * @brief TIM1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM1_Init(void)
{

  /* USER CODE BEGIN TIM1_Init 0 */

  /* USER CODE END TIM1_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 0;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 65535;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV4;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */

}

/**
  * @brief TIM4 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM4_Init(void)
{

  /* USER CODE BEGIN TIM4_Init 0 */

  /* USER CODE END TIM4_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM4_Init 1 */

  /* USER CODE END TIM4_Init 1 */
  htim4.Instance = TIM4;
  htim4.Init.Prescaler = 0;
  htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim4.Init.Period = 65535;
  htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM4_Init 2 */

  /* USER CODE END TIM4_Init 2 */

}

/**
  * @brief UART5 Initialization Function
  * @param None
  * @retval None
  */
static void MX_UART5_Init(void)
{

  /* USER CODE BEGIN UART5_Init 0 */

  /* USER CODE END UART5_Init 0 */

  /* USER CODE BEGIN UART5_Init 1 */

  /* USER CODE END UART5_Init 1 */
  huart5.Instance = UART5;
  huart5.Init.BaudRate = 115200;
  huart5.Init.WordLength = UART_WORDLENGTH_8B;
  huart5.Init.StopBits = UART_STOPBITS_1;
  huart5.Init.Parity = UART_PARITY_NONE;
  huart5.Init.Mode = UART_MODE_TX_RX;
  huart5.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart5.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart5) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN UART5_Init 2 */

  /* USER CODE END UART5_Init 2 */

}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */
	extern uint8_t USART1_RX_BUF[Uart1_BUF_SIZE];

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 9600;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */
	
	__HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
 
	HAL_UART_Receive_DMA(&huart1,USART1_RX_BUF,Uart1_BUF_SIZE);

  /* USER CODE END USART1_Init 2 */

}

/**
  * @brief USART2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART2_UART_Init(void)
{

  /* USER CODE BEGIN USART2_Init 0 */

  /* USER CODE END USART2_Init 0 */

  /* USER CODE BEGIN USART2_Init 1 */

  /* USER CODE END USART2_Init 1 */
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 38400;//19200
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART2_Init 2 */
	__HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE);
	
 
 
	HAL_UART_Receive_DMA(&huart2,USART2_RX_BUF,Uart2_BUF_SIZE);

  /* USER CODE END USART2_Init 2 */

}

/**
  * @brief USART3 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART3_UART_Init(void)
{

  /* USER CODE BEGIN USART3_Init 0 */

  /* USER CODE END USART3_Init 0 */

  /* USER CODE BEGIN USART3_Init 1 */

  /* USER CODE END USART3_Init 1 */
  huart3.Instance = USART3;
  huart3.Init.BaudRate = 9600;
  huart3.Init.WordLength = UART_WORDLENGTH_8B;
  huart3.Init.StopBits = UART_STOPBITS_1;
  huart3.Init.Parity = UART_PARITY_NONE;
  huart3.Init.Mode = UART_MODE_TX_RX;
  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART3_Init 2 */
	
	
		__HAL_UART_ENABLE_IT(&huart3, UART_IT_IDLE);



		HAL_UART_Receive_DMA(&huart3,USART3_RX_BUF,Uart2_BUF_SIZE);

  /* USER CODE END USART3_Init 2 */

}

/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();
  __HAL_RCC_DMA2_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA1_Channel4_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel4_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);
  /* DMA2_Channel4_5_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Channel4_5_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA2_Channel4_5_IRQn);

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, LED1_Pin|LED2_Pin|con03_uart2_kongzhiqi_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, con02_uart3_xieyoufa_Pin|Con01_uart1_rankonggai_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(WDI_sp706_kanmemgou_GPIO_Port, WDI_sp706_kanmemgou_Pin, GPIO_PIN_RESET);
	

  /*Configure GPIO pins : LED1_Pin LED2_Pin con03_uart2_kongzhiqi_Pin */
  GPIO_InitStruct.Pin = LED1_Pin|LED2_Pin|con03_uart2_kongzhiqi_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);


  /*Configure GPIO pins : con02_uart3_xieyoufa_Pin Con01_uart1_rankonggai_Pin */
  GPIO_InitStruct.Pin = con02_uart3_xieyoufa_Pin|Con01_uart1_rankonggai_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pins : IN01_Pin PB15 */
  GPIO_InitStruct.Pin = GPIO_PIN_14|GPIO_PIN_15;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pins : PC6 PC7 PC8 PC9 */
  GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pins : PA8 PA11 */
  GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_11;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : WDI_sp706_kanmemgou_Pin */
  GPIO_InitStruct.Pin = WDI_sp706_kanmemgou_Pin;

	if(WatchDogOn)//�򿪿��Ź�sp706
	{
		GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	
	}
	else
	{
		GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
	
	}
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(WDI_sp706_kanmemgou_GPIO_Port, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/**
 * @funNm : delay_sys_us
 * @brief : ��ʱnus
 * @param : nus:Ҫ��ʱ��us��.	0~204522252(���ֵ��2^32/fac_us@fac_us=168)	 
 * @retval: void
 */
void delay_sys_us(uint32_t Delay)//1��delay�����1.5us
{
	uint32_t cnt = Delay * 8;  
    uint32_t i = 0;
    for(i = 0; i < cnt; i++)__NOP();
}



/* USER CODE END 4 */

/* USER CODE BEGIN Header_StartDefaultTask */
/**
  * @brief  Function implementing the defaultTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void *argument)
{
  /* USER CODE BEGIN 5 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END 5 */
}

/* USER CODE BEGIN Header_StartTask02 */
/**
* @brief Function implementing the myTask02 thread.
* @param argument: Not used
* @retval None
*/
uint8_t Flash_Change = 0;                //�����������
uni_float tprture001,tprture002,tprture003,Yewei001,tprtureAver;
/* USER CODE END Header_StartTask02 */
/*
//����ж�ͷ�������������ѯ
//���ͽǶȴ�����������ѯ
//���ͱڹ��ʹ�����������ѯ
//�������ܺ��׷�������������ѯ
//�����������մ�����������ѯ
*/
void StartTask02(void *argument)				 															//ж�ͷ����ߴ�����������ѯ  UART3
{
  /* USER CODE BEGIN StartTask02 */
	uint8_t i001=0,i002 = 0,rx_len = 0;
	uint16_t ModbusCRC = 0,xyfaddr_max = 0;                     				 //xyfaddr_max:ж�ͷ���ߵ�ַ������ÿ��ж�ͷ�֮�ͼ���ó�
	static uint16_t i = 0,j = 0,receive_error = 0;
	HDF_Inf* phdf = hdf_inf;
	KZQ_Inf* pkzq = &kzq_inf;
	XYF_Inf* pxyf = xyf_inf;
	Cang_Inf* pcang = &cang_inf;
	Angle_Inf* pangle = &angle_inf;


	for(i = 0;i < pcang->Cang_Num;i++)
	{
		xyfaddr_max += pcang->XYF_Num[i];
	}
	i = 0;
	
	extern uint8_t USART2_RX_BUF002[Uart2_BUF_SIZE];
	extern uint8_t USART1_RX_BUF002[Uart2_BUF_SIZE];
	extern uint8_t USART3_RX_BUF002[Uart2_BUF_SIZE];
  extern int data_lengthU2,data_lengthU1,data_lengthU3;	
	extern int flagU1Rx,flagU2Rx,flagU3Rx;
	extern uint8_t USART3_RX_BUF002_print[Uart3_BUF_SIZE];
	extern uint8_t  XYF_TxBuf[70];
	extern uint16_t Uart_len_TouChuan;
	
  /* Infinite loop */
  for(;;)
  {
    osDelay(30);    																								  //��msΪ��λ
    //HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_0);
	  HAL_GPIO_TogglePin(WDI_sp706_kanmemgou_GPIO_Port, WDI_sp706_kanmemgou_Pin);			
		if(Flash_Change)																									//����ж�Flash���иĶ��������¼���xyfaddr_max
		{
			xyfaddr_max = 0;
			for(i = 0;i < pcang->Cang_Num;i++)
			{
				xyfaddr_max += pcang->XYF_Num[i];
			}
			Flash_Change = 0;
		}
		
		if(pkzq->USE_XYF == 0)    //ƽ̨δ����ж�ͷ����ߣ�������ѯ����
		{
			if(i001==0)  				   	//����ж�ͷ�������������ѯ
			{
				if(pcang->XYF_INSTALL != 0)
		    {

				ModbusCRC = LIB_CRC_MODBUS(CMD_XYF,6);
				CMD_XYF[6] = ModbusCRC>>8;
				CMD_XYF[7] = ModbusCRC&0xff;
				HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_RESET);//
				delay_sys_us(80);																																
      //	  if((pcang->XYF_Type == 1)||(CMD_XYF[0] == 0x11))																			//�������
			//	  if(pcang->XYF_Type == 1)
			//		HAL_UART_Transmit(&huart3,Data_Head,2,10);																//����֡ͷ
				HAL_UART_Transmit(&huart3,CMD_XYF,8,100);
      //	if((pcang->XYF_Type == 1)||(CMD_XYF[0] == 0x11))																			//�������
			//	if(pcang->XYF_Type == 1)
			//	HAL_UART_Transmit(&huart3,Data_Head,2,10);																//����֡β
				delay_sys_us(80);
				HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);//
			/*	if(pxyf[CMD_XYF[0]-0x10].RTData_Num > 5)                          //�շ����ݴ������RT_ERRORCNT
				{
					pxyf[CMD_XYF[0]-0x10].RTData_Num = RT_ERRORCNT;
					pxyf[CMD_XYF[0]-0x10].XYF_ErrorCnt = RT_ERRORCNT;
				}
				else 
					pxyf[CMD_XYF[0]-0x10].RTData_Num++;         */        //ÿ������������֡�ۼ�
				
				if(CMD_XYF[0] - 0x10 <  8)//xyfaddr_max
					CMD_XYF[0]++;
				else
					CMD_XYF[0] = 0x11;
		    }
		    else
		    {			
	      	i001 = 3;	
		    }				
		  }

			if(pcang->Angle)        //���ͽǶȴ�����������ѯ
			{
				 if(i001==3)						//������̬��������ѯ
				 {
					ModbusCRC = LIB_CRC_MODBUS(CMD_Angle_XY,6);
					CMD_Angle_XY[6] = ModbusCRC>>8;
					CMD_Angle_XY[7] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_RESET);
					delay_sys_us(80);
					HAL_UART_Transmit(&huart3,CMD_Angle_XY,8,100);	                           //ֻ֧�ֵ�ָ����Ƕ�ȡ����������
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);     
				
					if(pangle->RTData_NumX > RT_ERRORCNT)
					{
					pangle->RTData_NumX = RT_ERRORCNT;
					pangle->Angle_ErrorCnt = RT_ERRORCNT;
					}
					else
					pangle->RTData_NumX ++;
				 }
			}
      if(i001==6)             //���ͱڹ��ʹ�����������ѯ
			{
					ModbusCRC = LIB_CRC_MODBUS(CMD_Biguayou,6);
					CMD_Biguayou[6] = ModbusCRC>>8;
					CMD_Biguayou[7] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_RESET);
					delay_sys_us(80);
					HAL_UART_Transmit(&huart3,CMD_Biguayou,8,100);	                           //ֻ֧�ֵ�ָ����Ƕ�ȡ����������
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);     			
			
		
			}		
      if(i001==9)             //�������ܺ��׷�������������ѯ
			{
				if(pcang->HDF_INSTALL != 0)
		    {

					ModbusCRC = LIB_CRC_MODBUS(CMD_HDF,14);
					CMD_HDF[14] = ModbusCRC>>8;
					CMD_HDF[15] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_RESET);
					delay_sys_us(80);
					HAL_UART_Transmit(&huart3,CMD_HDF,16,100);	                           //ֻ֧�ֵ�ָ����Ƕ�ȡ����������
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);     
				if(phdf[CMD_HDF[0]-0x20].RTData_Num > 50)                          //�շ����ݴ������RT_ERRORCNT
				{
				  //phdf[CMD_HDF[0]-0x20].RTData_Num = RT_ERRORCNT;
					//phdf[CMD_HDF[0]-0x20].HDF_ErrorCnt = RT_ERRORCNT;
				}
				else 
					phdf[CMD_HDF[0]-0x20].RTData_Num++;                 //ÿ������������֡�ۼ�
				
				if(CMD_HDF[0] - 0x21 < 3)
					CMD_HDF[0]++;
				else
					CMD_HDF[0] = 0x21;
		    }
		    else
		    {			
	      	i001 = 20;	
		    }								

			}	

      if(i001==12)          //�����������մ�����������ѯ
			{
				
					ModbusCRC = LIB_CRC_MODBUS(CMD_YQHS,6);
					CMD_YQHS[6] = ModbusCRC>>8;
					CMD_YQHS[7] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_RESET);
					delay_sys_us(80);
					HAL_UART_Transmit(&huart3,CMD_YQHS,8,100);	                           //ֻ֧�ֵ�ָ����Ƕ�ȡ����������
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);     			
			
		
			}					
		}
		else											//ƽ̨ͨ��ж�ͷ�����ֱ�Ӳ���������
		{
			if(i002 == 3)
			{
				HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_RESET);//
				delay_sys_us(80);
				if((XYF_TxBuf[0] == 0x0D)&&(XYF_TxBuf[0] == 0x0A))
					HAL_UART_Transmit(&huart3,XYF_TxBuf,12,100);	
				else
				HAL_UART_Transmit(&huart3,XYF_TxBuf,8,100);	
				delay_sys_us(80);
				HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);     //
			}
			else if(i002 == 0x06)
			{
				
				HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_RESET);//
				delay_sys_us(80);
				HAL_UART_Transmit(&huart3,ALL_TxBuf,16,100);
				delay_sys_us(80);
				HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);//

			}
			else if(i002 == 0x09)//slm 0x0c
			{
				HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_RESET);//
				delay_sys_us(80);
				HAL_UART_Transmit(&huart3,ALL_TxBuf,Uart_len_TouChuan,100);
				delay_sys_us(80);
				HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);//				
				
				pkzq->USE_XYF = 0;
				i002 = 0;				
			}
			i002++;
		}
		

	  //����UART3������ ��·���ϱ�־λж�ͷ�
		if(flagU3Rx==1)
		{
       if(USART3_RX_BUF002[0]!=0x11)
			{
				pxyf[1].XYF_ErrorCnt++;
			  if(pxyf[1].XYF_ErrorCnt>150)
				{
          pxyf[1].XYF_ErrorCnt=150;					
				  pxyf[1].XYF_Error = 1;

				}
			}
				
       if(USART3_RX_BUF002[0]!=0x12)
			{
				pxyf[2].XYF_ErrorCnt++;
			  if(pxyf[2].XYF_ErrorCnt>150)
				{
					pxyf[2].XYF_ErrorCnt=150;
				  pxyf[2].XYF_Error = 1;
			
				}
			}
       if(USART3_RX_BUF002[0]!=0x13)
			{
				pxyf[3].XYF_ErrorCnt++;
			  if(pxyf[3].XYF_ErrorCnt>150)
				{
          pxyf[3].XYF_ErrorCnt=150;					
				  pxyf[3].XYF_Error = 1;

				}
			}
				
      if(USART3_RX_BUF002[0]!=0x14)
			{
				pxyf[4].XYF_ErrorCnt++;
			  if(pxyf[4].XYF_ErrorCnt>150)
				{
					pxyf[4].XYF_ErrorCnt=150;
				  pxyf[4].XYF_Error = 1;
			
				}
			}		

      if(USART3_RX_BUF002[0]!=0x15)
			{
				pxyf[5].XYF_ErrorCnt++;
			  if(pxyf[5].XYF_ErrorCnt>150)
				{
          pxyf[5].XYF_ErrorCnt=150;					
				  pxyf[5].XYF_Error = 1;

				}
			}
				
      if(USART3_RX_BUF002[0]!=0x16)
			{
				pxyf[6].XYF_ErrorCnt++;
			  if(pxyf[6].XYF_ErrorCnt>150)
				{
					pxyf[6].XYF_ErrorCnt=150;
				  pxyf[6].XYF_Error = 1;
			
				}
			}
      if(USART3_RX_BUF002[0]!=0x17)
			{
				pxyf[7].XYF_ErrorCnt++;
			  if(pxyf[7].XYF_ErrorCnt>150)
				{
          pxyf[7].XYF_ErrorCnt=150;					
				  pxyf[7].XYF_Error = 1;

				}
			}
				
       if(USART3_RX_BUF002[0]!=0x18)
			{
				pxyf[8].XYF_ErrorCnt++;
			  if(pxyf[8].XYF_ErrorCnt>150)
				{
					pxyf[8].XYF_ErrorCnt=150;
				  pxyf[8].XYF_Error = 1;
			
				}
			}		



       if(USART3_RX_BUF002[0]==0x11)
			{
				pxyf[1].XYF_ErrorCnt=pxyf[1].XYF_ErrorCnt;
			}			
				
       if(USART3_RX_BUF002[0]==0x12)
			{
				pxyf[2].XYF_ErrorCnt=pxyf[2].XYF_ErrorCnt;
			}			
       if(USART3_RX_BUF002[0]==0x13)
			{
				pxyf[3].XYF_ErrorCnt=pxyf[3].XYF_ErrorCnt;
			}			
				
       if(USART3_RX_BUF002[0]==0x14)
			{
				pxyf[4].XYF_ErrorCnt=pxyf[4].XYF_ErrorCnt;
			}				

       if(USART3_RX_BUF002[0]==0x15)
			{
				pxyf[5].XYF_ErrorCnt=pxyf[5].XYF_ErrorCnt;
			}			
				
       if(USART3_RX_BUF002[0]==0x16)
			{
				pxyf[6].XYF_ErrorCnt=pxyf[6].XYF_ErrorCnt;
			}			
       if(USART3_RX_BUF002[0]==0x17)
			{
				pxyf[7].XYF_ErrorCnt=pxyf[7].XYF_ErrorCnt;
			}			
				
       if(USART3_RX_BUF002[0]==0x18)
			{
				pxyf[8].XYF_ErrorCnt=pxyf[8].XYF_ErrorCnt;
			}					
			
			if(USART3_RX_BUF002[0] >= 0x10 && USART3_RX_BUF002[0] <= 0x1F)        //ж�ͷ�����
			{ 
				ModbusCRC = USART3_RX_BUF002[5]<<8;
				ModbusCRC |= USART3_RX_BUF002[6];
				pxyf[USART3_RX_BUF002[0]-0x10].RTData_Num = 1;
				if(USART3_RX_BUF002[1]!=0x03&&USART3_RX_BUF002[1]!=0x06)              //������
				{
					receive_error = 1;
				}
				else if(USART3_RX_BUF002[2] != 0x02)			//У�����ݳ���
				{
					receive_error = 1;
				}
				else if(ModbusCRC != LIB_CRC_MODBUS(USART3_RX_BUF002,5))		//��CRC
				{
					receive_error = 1;
				}
				
				if(receive_error == 0)
				{
					pxyf[USART3_RX_BUF002[0]-0x10].XYF_ErrorCnt = 0;
					pxyf[USART3_RX_BUF002[0]-0x10].XYF_Error = 0;
					if(USART3_RX_BUF002[1] == 0x03)      //��ȡ���ݷ���
					{
						if(USART3_RX_BUF002[3]>0x01)//���ſ���״̬
						{
							pxyf[i].XYF_ErrorCnt++;
						}
						else if(i < XYF_BUF_DEP)
						{
							pxyf[i].XYF_ErrorCnt = 0;
							pxyf[USART3_RX_BUF002[0] - 0x10].XYF_Data1[0] = USART3_RX_BUF002[3];
							pxyf[USART3_RX_BUF002[0] - 0x10].XYF_Data2[0] = USART3_RX_BUF002[4];
							i++;
						}
						if(i == XYF_BUF_DEP)
						{
							i = 0;
						}
						
						XYF_state(USART3_RX_BUF002[0] - 0x10);
						
					}
					else if(USART3_RX_BUF002[1] == 0x06)             	//д�����ݷ���  �ж�д���Ƿ�ɹ�
					{
																																											//���������ռ�ñ�־																																								
						//����ж�ͷ�Э�������
					}
				}
			}
			else if(USART3_RX_BUF002[0] >=0x70 && USART3_RX_BUF002[0] <= 0x7f)	                        //��̬���ݣ�Ŀǰ���֧��3��
			{
				ModbusCRC = USART3_RX_BUF002[7]<<8;
				ModbusCRC |= USART3_RX_BUF002[8];
				pangle->RTData_NumX = 1;
				if(USART3_RX_BUF002[1]!=0x03&&USART3_RX_BUF002[1]!=0x06)              //������
				{
					receive_error = 1;
				}
				else if(USART3_RX_BUF002[2] >= 0x08)			//У�����ݳ���
				{
					receive_error = 1;
				}
				else if(ModbusCRC != LIB_CRC_MODBUS(USART3_RX_BUF002,USART3_RX_BUF002[2]+3))		//��CRC
				{
					//receive_error = 1;
				}
				
				if(receive_error == 0)
				{
					if(USART3_RX_BUF002[1] ==0x03)
					{
						if(j < ANGLE_BUF_DEP)
						{
							pangle->Angle_ErrorCnt = 0;
							//if(USART3_RX_BUF002[2] == 0x02)
								pangle->Angle_DataX[j] =  USART3_RX_BUF002[3]<<8|USART3_RX_BUF002[4];
							//if(USART3_RX_BUF002[2] > 0x02)
								pangle->Angle_DataY[j] =  USART3_RX_BUF002[5]<<8|USART3_RX_BUF002[6];
						//	if(USART3_RX_BUF002[2] > 0x04)
								pangle->Angle_DataZ[j] =  USART3_RX_BUF002[7]<<8|USART3_RX_BUF002[8];
							j++;
						}
						if(j == ANGLE_BUF_DEP)
						{
							j = 0;
						}
					}
					else
					{
																																																																																		
						//����ж�ͷ�Э�������
					
					}
				}
			}
			else if(USART3_RX_BUF002[0] >= 0x20 && USART3_RX_BUF002[0] <= 0x2F )  //���ܺ��׷�����
			{
				
				Get_ZN_hdf_data();
			
			}
			else if(USART3_RX_BUF002[0] == 0xe4)                                  //������������
			{
			  Get_Yqhuishou_data();
			}
			else if(USART3_RX_BUF002[0] >= 0x81 && USART3_RX_BUF002[0] <= 0x8F)   //�ڹ�������
			{
				Get_Biguayou_data();       
			}


			receive_error = 0;			
			flagU3Rx=0;
		}
		else
		{

				pxyf[1].XYF_ErrorCnt++;
			  if(pxyf[1].XYF_ErrorCnt>150)
				{
			  	pxyf[1].XYF_ErrorCnt = 150;					
				  pxyf[1].XYF_Error = 1;
				}
				pxyf[2].XYF_ErrorCnt++;
			  if(pxyf[2].XYF_ErrorCnt>150)
				{
				  pxyf[2].XYF_ErrorCnt=150	;			
				  pxyf[2].XYF_Error = 1;
				}
				pxyf[3].XYF_ErrorCnt++;
			  if(pxyf[3].XYF_ErrorCnt>150)
				{
				  pxyf[3].XYF_ErrorCnt=150	;			
				  pxyf[3].XYF_Error = 1;
				}	
				pxyf[4].XYF_ErrorCnt++;
			  if(pxyf[4].XYF_ErrorCnt>150)
				{
				  pxyf[4].XYF_ErrorCnt=150	;			
				  pxyf[4].XYF_Error = 1;
				}	
				pxyf[5].XYF_ErrorCnt++;
			  if(pxyf[5].XYF_ErrorCnt>150)
				{
			  	pxyf[5].XYF_ErrorCnt = 150;					
				  pxyf[5].XYF_Error = 1;
				}
				pxyf[6].XYF_ErrorCnt++;
			  if(pxyf[6].XYF_ErrorCnt>150)
				{
				  pxyf[6].XYF_ErrorCnt=150	;			
				  pxyf[6].XYF_Error = 1;
				}
				pxyf[7].XYF_ErrorCnt++;
			  if(pxyf[7].XYF_ErrorCnt>150)
				{
				  pxyf[7].XYF_ErrorCnt=150	;			
				  pxyf[7].XYF_Error = 1;
				}	
				pxyf[8].XYF_ErrorCnt++;
			  if(pxyf[8].XYF_ErrorCnt>150)
				{
				  pxyf[8].XYF_ErrorCnt=150	;			
				  pxyf[8].XYF_Error = 1;
				}					
		
		}
		if(i001<2)
			i001++;
		else
			i001 = 0;
  }
  /* USER CODE END StartTask02 */
}

/* USER CODE BEGIN Header_StartTask03 */
/**
* @brief Function implementing the myTask03 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask03 */
/*
//���ͻ�������ʽ�¶ȴ�����������ѯ
//�����˿ش�Ǹ�������ѯ
//�״�Һλ����������

//����С�Ǵ�������ѯ
//���ʹ�������Һλ��������ѯ
� 
*/
#include "rkg.h"

void StartTask03(void *argument)															//�˿׸����ߴ�����   UART1
{
  /* USER CODE BEGIN StartTask03 */
  /* Infinite loop */
   /* USER CODE BEGIN StartTask02 */
  static  uint8_t i001=0,i002 = 0,i003 = 0,receive_error = 0;
	uint16_t rkgaddr_max = 0,temaddr_max = 0,leveladdr_max = 0,RKG_angle = 0;                      
	static uint16_t i = 0,rkdg_cnt = 0,rkxg_cnt = 0,level_cnt = 0,tem_cnt = 0,temp_dot_cnt=0,temp_dot_dex=0,ModbusCRC = 0,ModbusCRC1 = 0,Hextofloat = 0;
	uint16_t rx_len,head = 0;
	S_ANGLEDATA* psATsk3 = gs_AngleData;	
	KZQ_Inf* pkzq = &kzq_inf;
	RKG_Inf* prkg = rkg_inf;
	Cang_Inf* pcang = &cang_inf;
	Level_Inf* plevel = level_inf;
	TEM_Inf* ptem = tem_inf;
	typedef union{
   float QDGH_data_temp;   //�����ʹ�������Һλ�¶�һ�崫����
   uint8_t arr[4];
  }Hex_to_float;
	static Hex_to_float hex_to_float;
	
	for(i = 0;i < pcang->Cang_Num;i++)
	{
		rkgaddr_max += pcang->RKG_Num[i];										//�˿׸�����ַ							
		leveladdr_max++;
	}
	if(((pcang->Level>>8)|0xff) == 0)
	{
			if(((pcang->Temperture>>8)|0xff) == 0)
			{
				temaddr_max = leveladdr_max;										//�¶���󼯳ɵ�ַ	
			}
			else
			{
				temaddr_max = leveladdr_max*(pcang->Temperture|0xff);      //�¶������ɢ��ַ	
			}
	}
	i = 0;
	extern uint8_t USART1_RX_BUF002[Uart2_BUF_SIZE];
  extern int data_lengthU1;	
	extern int flagU1Rx;
	extern uint8_t USART1_RX_BUF002_print[Uart1_BUF_SIZE];
  /* Infinite loop */
  for(;;)
  {
     osDelay(50);    																								  //��msΪ��λ
     //HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_0);   //�Ѿ�����task12 500ms��˸ �������޸�
	   HAL_GPIO_TogglePin(WDI_sp706_kanmemgou_GPIO_Port, WDI_sp706_kanmemgou_Pin);	      
		 if(Flash_Change)
		 {
			rkgaddr_max = 0;
			for(i = 0;i < pcang->Cang_Num;i++)
			{
				rkgaddr_max += pcang->RKG_Num[i];										//�˿׸�����ַ							
				leveladdr_max++;
			}
			if(((pcang->Level>>8)|0xff) == 0)
			{
					if(((pcang->Temperture>>8)|0xff) == 0)
					{
						temaddr_max = leveladdr_max;										//�¶���󼯳ɵ�ַ	
					}
					else
					{
						temaddr_max = leveladdr_max*(pcang->Temperture|0xff);      //�¶������ɢ��ַ	
					}
			}
			Flash_Change = 0;
		 }
		
		
		
		if(pkzq->USE_RKG == 0)    //ƽ̨δ����ж�ͷ����ߣ�������ѯ����
		{
			if(i001==0)  					  //�����˿ش�Ǹ�������ѯ
			{
				pcang->RKG_Type = 1;
				if(pcang->RKG_DG != 0)
				{
					ModbusCRC = LIB_CRC_MODBUS(CMD_RKG,6);
					CMD_RKG[6] = ModbusCRC>>8;
					CMD_RKG[7] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					if(pcang->RKG_Type == 0x01)
					//	HAL_UART_Transmit(&huart1,Data_Head,2,10);	
					HAL_UART_Transmit(&huart1,CMD_RKG,8,100);	
					if(pcang->RKG_Type == 0x01)
			    //HAL_UART_Transmit(&huart1,Data_Head,2,10);	
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_SET);//
		
				/*	if(prkg[CMD_RKG[0] - 0x30].RTData_Num > RT_ERRORCNT)				//ÿ��������ÿ����һ֡  ��׼�Ƕ�Ϊ0x30
					{
						prkg[CMD_RKG[0] - 0x30].RTData_Num = RT_ERRORCNT;
						prkg[CMD_RKG[0] - 0x30].RKDG_ErrorCnt = RT_ERRORCNT;
					}
					else
						prkg[CMD_RKG[0] - 0x30].RTData_Num++; */

					if(pcang->RKG_Type == 0)
					{	

						if(CMD_RKG[0] < 9)//rkgaddr_max
							CMD_RKG[0]+=2;
						else
							CMD_RKG[0] = 1;
					}
					else					
					{
						if(CMD_RKG[0]  < 9)//rkgaddr_max
							CMD_RKG[0]+=2;
						else
							CMD_RKG[0] = 1;
					}
				}
				else 
					i001 = 3;
			}
			
			if(i001==6)		          //����С�Ǵ�������ѯ
			{
				pcang->RKG_XG = 0;
				if(pcang->RKG_XG == 0x01)				
				{
					ModbusCRC = LIB_CRC_MODBUS(CMD_RKG_XG,6);
					CMD_RKG_XG[6] = ModbusCRC>>8;
					CMD_RKG_XG[7] = ModbusCRC&0xff;

					HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					if(pcang->RKG_Type == 0x01)
						HAL_UART_Transmit(&huart1,Data_Head,2,10);	
					HAL_UART_Transmit(&huart1,CMD_RKG_XG,8,100);	
					if(pcang->RKG_Type == 0x01)
						HAL_UART_Transmit(&huart1,Data_Head,2,10);	
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_SET);//
					if(prkg[CMD_RKG_XG[0]-0x40].RTData_Num > RT_ERRORCNT)
					{
						prkg[CMD_RKG_XG[0]-0x40].RTData_Num = RT_ERRORCNT;
						prkg[CMD_RKG_XG[0]-0x40].RKXG_ErrorCnt = RT_ERRORCNT;
					}
					else
						prkg[CMD_RKG_XG[0]-0x40].RTData_Num++;                  //ÿ������������֡�ۼ�
					if(CMD_RKG_XG[0] - 0x41 < rkgaddr_max -1)
						CMD_RKG_XG[0]++;
					else
						CMD_RKG_XG[0] = 0x41;
				}	
				else	
					i001 = 9;
			}
			
			if(i001==3)  					  //���ʹ�������Һλ��������ѯ  ����������
			{
				pcang->Level = 1;
				if(pcang->Level == 0)					       //û��Һλ������
				{
					i001=6;

				}
				else if(pcang->Level == 1)					//����������������ѯ ����������
				{
					ModbusCRC = LIB_CRC_MODBUS(CMD_GetTempAndYewei,6);
					CMD_GetTempAndYewei[6] = ModbusCRC>>8;
					CMD_GetTempAndYewei[7] = ModbusCRC&0xff;
	
				
					HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					HAL_UART_Transmit(&huart1,CMD_GetTempAndYewei,8,100);	
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_SET);//
					
					if(plevel[CMD_GetTempAndYewei[0]-0x50].RTData_Num > RT_ERRORCNT)
					{
						plevel[CMD_GetTempAndYewei[0]-0x50].RTData_Num = RT_ERRORCNT;
						plevel[CMD_GetTempAndYewei[0]-0x50].Level_ErrorCnt = RT_ERRORCNT;
					}
					else
						plevel[CMD_GetTempAndYewei[0]-0x50].RTData_Num++;                 //ÿ������������֡�ۼ�  ��׼�Ƕ�Ϊ0x30
					if(CMD_GetTempAndYewei[0]-0x50 < 4)
						CMD_GetTempAndYewei[0]++;
					else
						CMD_GetTempAndYewei[0] = 0x51;
				}
				else if(pcang->Level == 2)          //�״�Һλ������������ѯ 20210818������
				{
						ModbusCRC = LIB_CRC_MODBUS(CMD_LDYW,6);
		        CMD_LDYW[6] = ModbusCRC>>8;
		        CMD_LDYW[7] = ModbusCRC&0xff;		

		        HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_RESET);//
		        delay_sys_us(80);
		        HAL_UART_Transmit(&huart1,CMD_LDYW,8,100);	
		        delay_sys_us(80);
		        HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_SET);//
					if(prkg[CMD_RKG[0] - 0x50].RTData_Num > RT_ERRORCNT)				//ÿ��������ÿ����һ֡  ��׼�Ƕ�Ϊ0x30
					{
						plevel[CMD_RKG[0] - 0x50].RTData_Num = RT_ERRORCNT;
						plevel[CMD_RKG[0] - 0x50].Level_ErrorCnt = RT_ERRORCNT;
					}
					else
						plevel[CMD_RKG[0] - 0x50].RTData_Num++; 

						if(CMD_LDYW[0] - 0x50 < leveladdr_max-1)
							CMD_LDYW[0]++;
						else
							CMD_LDYW[0] = 0x51;
									
					
				
				}
				else
					i001=6;
			}
			
			if(i001==9)  					  //���ͻ�������ʽ�¶ȴ�����������ѯ  ����������
			{
				pcang->Temperture = 0;
				if(pcang->Temperture != 0)					
				{
				  taskENTER_CRITICAL();		
					ModbusCRC = LIB_CRC_MODBUS(CMD_GetTempHuaTian,6);
					CMD_GetTempHuaTian[6] = ModbusCRC>>8;
					CMD_GetTempHuaTian[7] = ModbusCRC&0xff;
	
				
					HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					HAL_UART_Transmit(&huart1,CMD_GetTempHuaTian,8,100);	
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_SET);//
				     taskEXIT_CRITICAL();					
					if(ptem[CMD_GetTempHuaTian[0] - 0x60].RTData_Num > RT_ERRORCNT)				//ÿ��������ÿ����һ֡  ��׼�Ƕ�Ϊ0x30
					{
						ptem[CMD_GetTempHuaTian[0] - 0x60].RTData_Num = RT_ERRORCNT;
						ptem[CMD_GetTempHuaTian[0] - 0x60].TEM_ErrorCnt = RT_ERRORCNT;
					}
					else
					{
						ptem[CMD_GetTempHuaTian[0] - 0x60].RTData_Num++; 		
					}						
						if(CMD_GetTempHuaTian[0] - 0x60 < 6)
							CMD_GetTempHuaTian[0] = CMD_GetTempHuaTian[0]+1;
						else
							CMD_GetTempHuaTian[0] = 0x61;

				}
				else
					i001=0x0c;
			}	
		}
		else											//ƽ̨ͨ��ж�ͷ�����ֱ�Ӳ���������
		{
			if(i002 == 3)
			{
				HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_RESET);//
				delay_sys_us(80);
				if((RKG_TxBuf[0] == 0x0D)&&(RKG_TxBuf[1] == 0x0A))
					HAL_UART_Transmit(&huart1,RKG_TxBuf,12,100);	
				else
					HAL_UART_Transmit(&huart1,RKG_TxBuf,8,100);
				delay_sys_us(80);
				HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_SET);//
			}
			else if(i002 == 6)
			{
	      pkzq->USE_RKG = 0;	
				i002 = 0;
			}
		//	else if(i002 == 9)
		//	{	
		//	}					
			i002++;
		}
		

	  //����UART1,���˿׸����ߵ����� ��·���ϱ�־λ�˿׸�
		if(flagU1Rx==1)
		{
			rx_len = USART1_RX_BUF002[2];
			ModbusCRC = USART1_RX_BUF002[(3+rx_len)]<<8;
			ModbusCRC |= USART1_RX_BUF002[(3+rx_len+1)];


			if(USART1_RX_BUF002[0] == 0x01&&USART1_RX_BUF002[1] == 0x03)
			{
				if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,7))		//��CRC
				{					
					receive_error = 1;	
				}
			   USART1_RX_BUF002[0] = 0x30;
			}
			else if(USART1_RX_BUF002[0] == 0x03&&USART1_RX_BUF002[1] == 0x03)
			{
				if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,7))		//��CRC
				{					
					receive_error = 1;	
				}
			   USART1_RX_BUF002[0] = 0x31;
			}
			else if(USART1_RX_BUF002[0] == 0x05&&USART1_RX_BUF002[1] == 0x03)
			{
				if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,7))		//��CRC
				{					
					receive_error = 1;	
				}
			   USART1_RX_BUF002[0] = 0x32;
			}	
			else if(USART1_RX_BUF002[0] == 0x07&&USART1_RX_BUF002[1] == 0x03)
			{
				if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,7))		//��CRC
				{					
					receive_error = 1;	
				}				
			   USART1_RX_BUF002[0] = 0x33;
			}
			else if(USART1_RX_BUF002[0] == 0x09&&USART1_RX_BUF002[1] == 0x03)
			{
				if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,7))		//��CRC
				{					
					receive_error = 1;	
				}				
			   USART1_RX_BUF002[0] = 0x34;
			}	
			if(USART1_RX_BUF002[0]!=0x30)
			{
				prkg[0].RKDG_ErrorCnt++;
			  if(prkg[0].RKDG_ErrorCnt>200)
				{
				  prkg[0].RKDG_ErrorCnt = 200;					
				  prkg[0].RKDG_Error = 1;
				}
			}					
			if(USART1_RX_BUF002[0]!=0x31)
			{
				prkg[1].RKDG_ErrorCnt++;
			  if(prkg[1].RKDG_ErrorCnt>200)
				{
				  prkg[1].RKDG_ErrorCnt = 200;					
				  prkg[1].RKDG_Error = 1;
				}
			}				
      if(USART1_RX_BUF002[0]!=0x32)
			{
				prkg[2].RKDG_ErrorCnt++;
			  if(prkg[2].RKDG_ErrorCnt>200)
				{
				  prkg[2].RKDG_ErrorCnt=200;					
				  prkg[2].RKDG_Error = 1;	
				}
			}
			if(USART1_RX_BUF002[0]!=0x33)
			{
				prkg[3].RKDG_ErrorCnt++;
			  if(prkg[3].RKDG_ErrorCnt>200)
				{
				  prkg[3].RKDG_ErrorCnt = 200;					
				  prkg[3].RKDG_Error = 1;
				}
			}				
      if(USART1_RX_BUF002[0]!=0x34)
			{
				prkg[4].RKDG_ErrorCnt++;
			  if(prkg[4].RKDG_ErrorCnt>200)
				{
				  prkg[4].RKDG_ErrorCnt=200;					
				  prkg[4].RKDG_Error = 1;	
				}
			}			
			if(USART1_RX_BUF002[head+0] >= 0x30 && USART1_RX_BUF002[head+0] <= 0x3F)        //�˿״������   ��ַ0x30Ϊ��׼������
			{
			// rx_len = USART1_RX_BUF002[2];
			// ModbusCRC1 = USART1_RX_BUF002[(3+rx_len)+1]<<8;
			// ModbusCRC1 |= USART1_RX_BUF002[(3+rx_len)];
				prkg[USART1_RX_BUF002[head+0]-0x30].RKDG_ErrorCnt=0;
				prkg[USART1_RX_BUF002[head+0]-0x30].RKDG_Error = 0;	
				prkg[USART1_RX_BUF002[head+0]-0x30].RTData_Num = 1;
				if(USART1_RX_BUF002[head+1]!=0x03&&USART1_RX_BUF002[head+1]!=0x06)              //������
				{
					receive_error = 1;	
				}
				else if(USART1_RX_BUF002[head+2] != 0x04)			//У�����ݳ���
				{
					receive_error = 1;	
				}
				else if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,7))		//��CRC
				{					
					//receive_error = 1;	
				}
				  pcang->CRC2 = LIB_CRC_MODBUS(USART1_RX_BUF002,7);
//				if((pcang->RKG_Type == 0)&&(USART1_RX_BUF002[head]>=0x30)&&(USART1_RX_BUF002[head] <=0x4F))
					RKG_angle = (USART1_RX_BUF002[head+4]<<8)|USART1_RX_BUF002[head+3];
//				else
//					RKG_angle = (USART1_RX_BUF002[head+3]<<8)|USART1_RX_BUF002[head+4];
				if((USART1_RX_BUF002[head+1] == 0x03)&&(receive_error == 0))      //��ȡ���ݷ���
				{//ͯ�S    �ŵ����    �ű���  �˿׸�
					prkg[USART1_RX_BUF002[head]-0x30].RKDG_ErrorCnt = 0;
					prkg[USART1_RX_BUF002[head]-0x30].RTData_Num = 1;
					AGL_AddNewData(RKG_angle,USART1_RX_BUF002[head]);   
					

					
					
					
		      //��Ǵ�ǽǶȼ��� 	
					if(pcang->RKG_Type == 1)
					AGL_CalcDeltaAll(USART1_RX_BUF002[head],0);					
			
					if(rkdg_cnt < RKG_BUF_DEP)
					{
						if(USART1_RX_BUF002[head] == 0x30)
						{
							prkg[USART1_RX_BUF002[head] - 0x30].RKG_JZData[rkdg_cnt] = RKG_angle;
						}
						else 
						{
							prkg[USART1_RX_BUF002[head] - 0x30].RKG_DGData[rkdg_cnt] = RKG_angle;
						}
					}
					if(rkdg_cnt == RKG_BUF_DEP)
					{
						rkdg_cnt = 0;
					}


					if(psATsk3[USART1_RX_BUF002[head] - 0x30].uiDG >= 0 &&psATsk3[USART1_RX_BUF002[head] - 0x30].uiDG <= 18000)//�Ƕ�
					{
					    if( - psATsk3[USART1_RX_BUF002[head] - 0x30].uiDG > prkg->RKG_Threshold || psATsk3[USART1_RX_BUF002[head] - 0x30].uiDG > prkg->RKG_Threshold)
							prkg[USART1_RX_BUF002[head] - 0x30].RKDG_StateCnt++;
					    else
							prkg[USART1_RX_BUF002[head] - 0x30].RKDG_StateCnt = 0;

           
					
					
				      if(prkg[USART1_RX_BUF002[head] - 0x30].RKDG_StateCnt >= 8)//prkg[USART1_RX_BUF002[head] - 0x30].RKG_StateKeepNum
				      {
              //RisingEdge++;
					     prkg[USART1_RX_BUF002[head] - 0x30].RKDG_StateCnt = 8;
						   prkg[USART1_RX_BUF002[head] - 0x30].RKDG_State = 1;
				      }
			    	  else
				      {
						   prkg[USART1_RX_BUF002[head] - 0x30].RKDG_State = 0;

				      }
			    }

			
				}

			}
			else if(USART1_RX_BUF002[head+0] >= 0x40 && USART1_RX_BUF002[head+0] <= 0x4F)   //�˿�С������   ��ַ0x30Ϊ��׼������
			{
				prkg[USART1_RX_BUF002[head] - 0x30].RKXG_ErrorCnt = 0;
				prkg[USART1_RX_BUF002[head+0]-0x40].RTData_Num = 1;
				if(USART1_RX_BUF002[head+1]!=0x03&&USART1_RX_BUF002[head+1]!=0x06)              //������
				{
					receive_error = 1;	
				}
				else if(USART1_RX_BUF002[head+2] != 0x04)			//У�����ݳ���
				{
					receive_error = 1;	
				}
				else if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,7))		//��CRC
				{
					receive_error = 1;	
				}
				if((USART1_RX_BUF002[head+1] == 0x03)&&(receive_error == 0))      //��ȡ���ݷ���
				{
					AGL_AddNewData((USART1_RX_BUF002[head+3]<<8)|USART1_RX_BUF002[head+4],USART1_RX_BUF002[head]);
					if(rkxg_cnt < RKG_BUF_DEP)
					{
						prkg[USART1_RX_BUF002[head] - 0x40].RKG_XGData[rkxg_cnt] = USART1_RX_BUF002[head+4]<<8;
						prkg[USART1_RX_BUF002[head] - 0x40].RKG_XGData[rkxg_cnt] |= USART1_RX_BUF002[head+3];
						rkxg_cnt++;
					}
					if(rkxg_cnt == RKG_BUF_DEP)
					{
						rkxg_cnt = 0;
					}
				}
				else if((USART1_RX_BUF002[head+1] == 0x06)&&(receive_error == 0))             	//д�����ݷ���
				{
						
				}
			}
			else if(USART1_RX_BUF002[0] >= 0x50 && USART1_RX_BUF002[0] <= 0x5F)             //Һλ������  ����������
			{
			 if(pcang->Level == 1)					                                                //���������������������� ����������
			 {
				plevel[USART1_RX_BUF002[0]-0x50].RTData_Num = 1;//Һλ����Ϣ����  
				plevel[USART1_RX_BUF002[0]-0x50].Level_ErrorCnt = 0;
				if(USART1_RX_BUF002[1]!=0x04)              //У�鹦����USART1_RX_BUF002[1]!=0x04&&..
				{
					receive_error = 1;	
				}
				else if(USART1_RX_BUF002[2] != 0x04)			//У�����ݳ���
				{
					receive_error = 1;	
				}
				else if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,7))		//��CRC
				{
					receive_error = 1;	
				}
				if((USART1_RX_BUF002[head+1] == 0x04)&&(receive_error == 0))      //��ȡ�����״����� slm
				{
					Hextofloat = (uint16_t)USART1_RX_BUF002[3]<<8;
					Hextofloat |= (uint16_t)USART1_RX_BUF002[4];
					hex_to_float.QDGH_data_temp = (float)Hextofloat;
					Hextofloat = (uint16_t)USART1_RX_BUF002[5]<<8;
					Hextofloat |= (uint16_t)USART1_RX_BUF002[6];
					hex_to_float.QDGH_data_temp = hex_to_float.QDGH_data_temp + ((float)Hextofloat)/0xffff;
					plevel[USART1_RX_BUF002[head]-0x50].Level_Data = (hex_to_float.QDGH_data_temp)/1000;
				/*	hex_to_float.arr[0] = USART1_RX_BUF002[5];
					  hex_to_float.arr[1] = USART1_RX_BUF002[6];
					  hex_to_float.arr[2] = USART1_RX_BUF002[3];
					  hex_to_float.arr[3] = USART1_RX_BUF002[4];				
						plevel[USART1_RX_BUF002[head]-0x50].Level_Data = hex_to_float.QDGH_data_temp;
					  hex_to_float.arr[0] = USART1_RX_BUF002[13];
					  hex_to_float.arr[1] = USART1_RX_BUF002[14];
					  hex_to_float.arr[2] = USART1_RX_BUF002[11];
					  hex_to_float.arr[3] = USART1_RX_BUF002[12];				
						plevel[USART1_RX_BUF002[head]-0x50].Avr_temp = hex_to_float.QDGH_data_temp;
					  hex_to_float.arr[0] = USART1_RX_BUF002[17];
					  hex_to_float.arr[1] = USART1_RX_BUF002[18];
					  hex_to_float.arr[2] = USART1_RX_BUF002[15];
					  hex_to_float.arr[3] = USART1_RX_BUF002[16];				
						plevel[USART1_RX_BUF002[head]-0x50].Avr_temp = hex_to_float.QDGH_data_temp;
					  hex_to_float.arr[0] = USART1_RX_BUF002[21];
					  hex_to_float.arr[1] = USART1_RX_BUF002[22];
					  hex_to_float.arr[2] = USART1_RX_BUF002[19];
					  hex_to_float.arr[3] = USART1_RX_BUF002[20];				
						plevel[USART1_RX_BUF002[head]-0x50].Bdot_temp = hex_to_float.QDGH_data_temp;
					  hex_to_float.arr[0] = USART1_RX_BUF002[25];
					  hex_to_float.arr[1] = USART1_RX_BUF002[26];
					  hex_to_float.arr[2] = USART1_RX_BUF002[23];
					  hex_to_float.arr[3] = USART1_RX_BUF002[24];				
						plevel[USART1_RX_BUF002[head]-0x50].Cdot_temp = hex_to_float.QDGH_data_temp;					
				*/	
				}
				else if((USART1_RX_BUF002[head+1] == 0x06)&&(receive_error == 0))             	//д�����ݷ���
				{
					
				}
			 }
			 else if(pcang->Level == 2)                                                     //�״�Һλ�������������� ����������
			 {
				plevel[USART1_RX_BUF002[0]-0x50].RTData_Num = 1;//Һλ����Ϣ����  
				plevel[USART1_RX_BUF002[0]-0x50].Level_ErrorCnt = 0;
				if(USART1_RX_BUF002[1]!=0x04)              //У�鹦����USART1_RX_BUF002[1]!=0x04&&..
				{
					receive_error = 1;	
				}
				else if(USART1_RX_BUF002[2] != 0x04)			//У�����ݳ���
				{
					receive_error = 1;	
				}
				else if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,7))		//��CRC
				{
					receive_error = 1;	
				}
				pcang->CRC1 = LIB_CRC_MODBUS(USART1_RX_BUF002,7);
				if((USART1_RX_BUF002[head+1] == 0x04)&&(receive_error == 0))      //��ȡ�����״����� slm
				{
					  //Һλ������  Һλ������
					  hex_to_float.arr[0] = USART1_RX_BUF002[4];
					  hex_to_float.arr[1] = USART1_RX_BUF002[3];
					  hex_to_float.arr[2] = USART1_RX_BUF002[6];
					  hex_to_float.arr[3] = USART1_RX_BUF002[5];					
						plevel[USART1_RX_BUF002[head]-0x50].Level_Data = hex_to_float.QDGH_data_temp;

				}
				else if((USART1_RX_BUF002[head+1] == 0x06)&&(receive_error == 0))             	//д�����ݷ���
				{
					
				}			  
			 }
			}
			else if(USART1_RX_BUF002[0] >=0x60 && USART1_RX_BUF002[0] <= 0x6f)	            //��������ʽ�¶ȴ������������� ����������
			{
				ptem[CMD_GetTempHuaTian[0] - 0x60].RTData_Num = 1;//�������
				ptem[CMD_GetTempHuaTian[0] - 0x60].TEM_ErrorCnt = 0;
				if(USART1_RX_BUF002[1]!=0x03&&USART1_RX_BUF002[1]!=0x06)              //������
				{
					receive_error = 1;
				}
				else if(USART1_RX_BUF002[2] != 0x02)			//У�����ݳ���
				{
					receive_error = 1;
				}
				else if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,5))		//��CRC
				{
					receive_error = 1;
				}
				else if((USART1_RX_BUF002[head+1] == 0x03)&&(receive_error == 0))
				{

						switch(USART1_RX_BUF002[head])//pcang->Temperture&0xFF
						{
							case 0x61:
								ptem[USART1_RX_BUF002[head]-0x60].TEM_HData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];								
								break;
							case 0x62:
								ptem[USART1_RX_BUF002[head]-0x61].TEM_MData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];
							  break;
							case 0x63:
								ptem[USART1_RX_BUF002[head]-0x62].TEM_LData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];
								break;
							case 0x64:
								ptem[USART1_RX_BUF002[head]-0x62].TEM_HData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];								
								break;
							case 0x65:
								ptem[USART1_RX_BUF002[head]-0x63].TEM_MData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];
							  break;
							case 0x66:
								ptem[USART1_RX_BUF002[head]-0x64].TEM_LData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];							
							  break;
							default:
								
								break;
					  }

				}
			}
			else if(0)  //��δʹ��
			{
				
			}
			else if(0)   //��δʹ��
			{
			
			}	
			flagU1Rx = 0;
			receive_error = 0;
		}
	  else
		{
				prkg[0].RKDG_ErrorCnt++;
			  if(prkg[0].RKDG_ErrorCnt>120)
				{
					prkg[0].RKDG_ErrorCnt=120;
				  prkg[0].RKDG_Error = 1;	
				}			
				prkg[1].RKDG_ErrorCnt++;
			  if(prkg[1].RKDG_ErrorCnt>120)
				{
					prkg[1].RKDG_ErrorCnt=120;
				  prkg[1].RKDG_Error = 1;	
				}
				prkg[2].RKDG_ErrorCnt++;
			  if(prkg[2].RKDG_ErrorCnt>120)
				{
					prkg[2].RKDG_ErrorCnt=120;
				  prkg[2].RKDG_Error = 1;	
				}		
				prkg[3].RKDG_ErrorCnt++;
			  if(prkg[3].RKDG_ErrorCnt>120)
				{
					prkg[3].RKDG_ErrorCnt=120;
				  prkg[3].RKDG_Error = 1;	
				}
				prkg[4].RKDG_ErrorCnt++;
			  if(prkg[4].RKDG_ErrorCnt>120)
				{
					prkg[4].RKDG_ErrorCnt=120;
				  prkg[4].RKDG_Error = 1;	
				}						
		
		}
		if(i001<0x03)
			i001++;
		else
			i001 = 0;	
  }
  /* USER CODE END StartTask03 */
}

/* USER CODE BEGIN Header_StartTask04 */
/**
* @brief Function implementing the myTask04 thread.
* @param argument: Not used
* @retval None
*/
#include "Data_deal.h"


uint8_t USART2_RX_BUF003[128];
uint8_t F_STATE[70] = {0};
uint8_t ptxCang01Temp[150];
/* USER CODE END Header_StartTask04 */
void StartTask04(void *argument)                                    //���������ݴ���   uart2
{
  /* USER CODE BEGIN StartTask04 */
  /* Infinite loop */
	uint8_t* ptx = CMD_KZQ;   
	uint16_t ModbusCRC = 0,KZQ_RTerror = 0,SetSuccess = 0,ModbusCRC1 = 0,SetSuccess1 = 0,SetSuccess2=0,SetSuccess3=0;                 
	static uint16_t i = 0;
	int i000;
	
	KZQ_Inf* pkzq = &kzq_inf;

	extern uint8_t USART2_RX_BUF002[Uart2_BUF_SIZE];

  extern int data_lengthU2;	
	extern int flagU2Rx;
	extern uint8_t USART2_RX_BUF002_print[Uart2_BUF_SIZE];
  /* Infinite loop */
  for(;;)
  {
    osDelay(50);    																								  //��msΪ��λ
	//	HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_0);

		HAL_GPIO_TogglePin(WDI_sp706_kanmemgou_GPIO_Port, WDI_sp706_kanmemgou_Pin);		
		if(flagU2Rx==1)
		{
			KZQ_RTerror = 0;
			//ASCת��Ϊ16���ƣ��յ�����Ϊ��3901��ͷ�������ܳ���131�ֽ�
			if((USART2_RX_BUF002[0] == 0x3A) && (USART2_RX_BUF002[1] == 0x33)&& (USART2_RX_BUF002[2] == 0x39)&& (USART2_RX_BUF002[3] == 0x30))   //�ж�֡ͷ
			{
				for(i000=0;i000<64;i000++)
				{
					T2C_RemoteCaliDat001.PayLoadData[i000]=MODBUS_ASCII_AsciiToHex(USART2_RX_BUF002+1+0+i000*2);
					
					USART2_RX_BUF003[i000]=MODBUS_ASCII_AsciiToHex(USART2_RX_BUF002+1+0+i000*2);

				}	
				//����������ݿ�������
				memcpy(USART2_RX_BUF002,USART2_RX_BUF003,64);
				__nop();
			}
			
			__nop();
			ModbusCRC = USART2_RX_BUF002[62]<<8;
			ModbusCRC |= USART2_RX_BUF002[63];
			
			if((USART2_RX_BUF002[0] != 0x39) && (USART2_RX_BUF002[1] <= 0x01)&& (USART2_RX_BUF002[2] <= 0x95)&& (USART2_RX_BUF002[3] <= 0x50))   //�ж�֡ͷ
			{
				pkzq->KZQ_Error++;
				KZQ_RTerror = 1;
			}
			else if(USART2_RX_BUF002[5]!=0x01)            					  //У���ַ
			{
				pkzq->KZQ_Error++;
				KZQ_RTerror = 1;
			}
			else if((USART2_RX_BUF002[7] != 0x03)&&(USART2_RX_BUF002[7] != 0x06))			//У�����ݳ���
			{
				pkzq->KZQ_Error++;
				KZQ_RTerror = 1;
			}
//			else if(ModbusCRC != LIB_CRC_MODBUS(USART2_RX_BUF002,62))		//��CRC
//			{	
//				pkzq->KZQ_Error++;
//				KZQ_RTerror = 1;
//			}
			else
			{
				pkzq->KZQ_Error = 0;
				for(i = 0;i < 64;i++)
				pkzq->data_buf[i] = USART2_RX_BUF002[i];
				for(i = 0;i < 16;i++)
				ptx[i] = USART2_RX_BUF002[i];
			}	
			
			
			if(KZQ_RTerror == 0)
			{
				pkzq->sensor_reg = USART2_RX_BUF002[8];
				pkzq->sensor_reg = pkzq->sensor_reg<<8;
				pkzq->sensor_reg |= USART2_RX_BUF002[9];
				switch(pkzq->sensor_reg)
				{
					case 0x10:  RstCPU();                                   //��λ
						break;
					case 0x11:
						break;
					case 0x12:
						break;
					case 0x13: Sen_CangState_old(F_STATE);                //��Э��  ���䷧��״̬               
						break;
	
					
					
					case 0x20: SetSuccess = Read_CangState(ptx);           //��ȡ��״̬
						break;
					case 0x21:
						break;
					case 0x22:
						break;
					case 0x23:
						break;
					case 0x24:
						break;
					case 0x25:
						break;
					case 0x26:
						break;
					case 0x27: SetSuccess = Read_CangSensorData(ptx);			//��ȡ�ִ�����
						break;
					case 0x28:
						break;
					case 0x29:
						break;
					
					
					case 0x40: SetSuccess = Angle_SetZero(ptx);						//��̬����������
									for(i = 0;i < 64;i++)
										ptx[i] = USART2_RX_BUF002[i];
						break;
					case 0x41:
						break;
					case 0x42:
						break;
					case 0x43:
						break;
					
					
					case 0x50: SetSuccess = XYF_SetOFF(ptx);                        //Զ��ж�ͷ��궨��    slm
									for(i = 0;i < 64;i++)
										ptx[i] = USART2_RX_BUF002[i];
						break;
					case 0x51: SetSuccess = XYF_SetThreshold(ptx);                  //����ж�ͷ���������������
						break;
					case 0x52: SetSuccess = RKG_SetZero(ptx);											  //�˿׸Ǵ���������
									for(i = 0;i < 64;i++)
										ptx[i] = USART2_RX_BUF002[i];
						break;
					case 0x53: 
						break;
					case 0x54:
						break;
					case 0x55: SetSuccess = Read_Sensor(ptx);											    // Զ�̶�ȡ����������  slm
						break;
					
					
					case 0x70:
						break;
					case 0x71: SetSuccess = BGY_SetThreshold(ptx);													//�����˿׸ǿ�������
						break;
					case 0x72: SetSuccess = RKG_SetThreshold(ptx);													//�����˿׸ǿ�������
						break;
					case 0x73: SetSuccess = Sensor_SetJudgefNum(ptx);											//���ÿ����жϴ���
						break;
					case 0x74: SetSuccess = CJQ_SetConfig(ptx);														//���òɼ�������
										 Flash_Change = 1;
						break;
					case 0x75: SetSuccess = RKG_SetTypeNum(ptx);														//�����˿׸����ࡢ����
										 Flash_Change = 1;
						break;
					case 0x76: SetSuccess = XYF_SetTypeNum(ptx);														//����ж�ͷ����ࡢ����
										 Flash_Change = 1;
						break;
					case 0x77: SetSuccess = HDF_SetTypeNum(ptx);														//���ú��׷����ࡢ����
										 Flash_Change = 1;
						break;
					case 0x78: SetSuccess = Level_SetType(ptx);														//����Һλ������
										 Flash_Change = 1;
						break;
					case 0x79: SetSuccess = Angle_SetType(ptx);														//������̬����������
										 Flash_Change = 1;
						break;
					case 0x7a: SetSuccess = Tem_SetType(ptx);															//�����¶ȴ���������
										// Flash_Change = 1;
						break;
			    case 0x7b: HDF_Set_CloseVal(ptx);										                      //�������ܺ��׷��Ŵ���
										 Flash_Change = 1;
						break;				 
			    case 0x7c: HDF_Set_Threshold(ptx);										                      //�������ܺ��׷��Ŵ���
										 Flash_Change = 1;	
						break;				 
			    case 0x7d: HDF_Set_Gain(ptx);										                      //�������ܺ��׷��Ŵ���
										 Flash_Change = 1;		 
						break;
			    case 0x7e: HDF_Reset(ptx);										                        //�������ܺ��׷��Ŵ���
										 Flash_Change = 1;		 
						break;	
			    case 0x017e: TOUCHUAN_UART_NUM(ptx);										              //�������ܺ��׷��Ŵ���
										 Flash_Change = 1;		 
						break;				
					case 0x0180: SetSuccess = GRB_SET_Table(ptx);										      //���ݱ�����  ����������
										 Flash_Change = 1;		 
						break;
					case 0x0190: SetSuccess = Level_SetCalvalue(ptx);														//����Һλ����� ����������
										 Flash_Change = 1;	
					case 0x0121: //SetSuccess = Level_SetCalvalue(ptx);														//����Һλ������
										   // Flash_Change = 1;										 
						break;		
					case 0x0122://SetSuccess = Level_SetCalvalue(ptx);														//����Һλ������
										  // Flash_Change = 1;										 
						break;	
					case 0x1121: 
						SetSuccess1 = Read_CangSensorData_1to4(ptx);														//����1-4������
							 
						break;
					case 0x1193: 
						SetSuccess2 = Read_CangSensorData_1(ptx);														//����1������
							 
						break;		
					case 0x1194: 
						SetSuccess2 = Read_CangSensorData_2(ptx);														//����2������
							 
						break;
					case 0x1195: 
						SetSuccess2 = Read_CangSensorData_3(ptx);														//����3������
							 
						break;
					case 0x1196: 
						SetSuccess2 = Read_CangSensorData_4(ptx);														//����4������
							 
						break;		
					case 0x1197: 
						SetSuccess2 = Read_CangSensorData_5(ptx);														//����5������
							 
						break;
					case 0x1198: 
						SetSuccess2 = Read_CangSensorData_6(ptx);														//����6������
							 
						break;	
					case 0x1199: 
						SetSuccess2 = Read_CangSensorData_7(ptx);														//����7������
							 
						break;
					case 0x119a: 
						SetSuccess2 = Read_CangSensorData_8(ptx);														//����8������
							 
						break;	
					case 0x119b: 
						SetSuccess3 = Read_ZhencheSensorData1(ptx);														//����1-4������
							 
						break;					
					default:
						break;
				}
				if(pkzq->sensor_reg == 0x13)
				{
					ModbusCRC = LIB_CRC_MODBUS(F_STATE,62);
					F_STATE[62] = ModbusCRC>>8;
					F_STATE[63] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					HAL_UART_Transmit(&huart2,F_STATE,64,100);		
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_SET);//

				}
				else if(SetSuccess2)
				{
					SetSuccess2=0;
					ModbusCRC = LIB_CRC_MODBUS(ptx,148);
					ptx[148] = ModbusCRC>>8;
					ptx[149] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					taskENTER_CRITICAL();
					HAL_UART_Transmit(&huart2,ptx,150,150);
          taskEXIT_CRITICAL();					
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_SET);//
				}	
				else if(SetSuccess3)
				{
					SetSuccess3=0;
					ModbusCRC = LIB_CRC_MODBUS(ptx,96);
					ptx[96] = ModbusCRC>>8;
					ptx[97] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					taskENTER_CRITICAL();
					HAL_UART_Transmit(&huart2,ptx,98,150);	
          taskEXIT_CRITICAL();					
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_SET);//
				}								
				else if(SetSuccess1)
				{
					SetSuccess1=0;
					ptx[232] = 0x00;
					ptx[233] = 0x00;
					ModbusCRC = LIB_CRC_MODBUS(ptx,234);
					ptx[234] = ModbusCRC>>8;
					ptx[235] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					taskENTER_CRITICAL();
					HAL_UART_Transmit(&huart2,ptx,236,500);
          taskEXIT_CRITICAL();						
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_SET);//
				}
				 else if(SetSuccess)
				{
					ptx[60] = 0x00;
					ptx[61] = 0x00;
					ModbusCRC = LIB_CRC_MODBUS(ptx,62);
					ptx[62] = ModbusCRC>>8;
					ptx[63] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					HAL_UART_Transmit(&huart2,ptx,64,100);		
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_SET);//
				}
				else
				{
					ptx[60] = 0xFF;
					ptx[61] = 0xFF;
					ModbusCRC = LIB_CRC_MODBUS(ptx,62);
					ptx[62] = ModbusCRC>>8;
					ptx[63] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					HAL_UART_Transmit(&huart2,ptx,64,100);		
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_SET);//
				}
				SetSuccess = 0;	
			}
			flagU2Rx = 0;
		}
  }
  /* USER CODE END StartTask04 */
}

/* USER CODE BEGIN Header_StartTask05 */
/**
* @brief Function implementing the myTask05 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask05 */
#include"level.h"
void StartTask05(void *argument)
{
  /* USER CODE BEGIN StartTask05 */
  /* Infinite loop */
	Level_Inf* plevel = level_inf;
	Cang_Inf* pcang = &cang_inf;
	float v000;
	uint16_t* VolArrayTsk05=Volume_1cang;
 	const uint16_t* HArrayTsk05=H_1cang;
  for(;;)
  {
 	  HAL_GPIO_TogglePin(WDI_sp706_kanmemgou_GPIO_Port, WDI_sp706_kanmemgou_Pin);	
		AGL_JudgeState();
		for(uint8_t i = 0;i < 5;i++)
		{
			switch (i)
      {
				case 0:
				  //VolArrayTsk05=Volume_1cang;
				  // HArrayTsk05=H_1cang;    
					break;
				case 1:
					VolArrayTsk05=Volume_1cang;
				  HArrayTsk05=H_1cang;
					break;
				case 2:
					VolArrayTsk05=Volume_2cang;
				  HArrayTsk05=H_2cang;
					break;
				case 3:
					VolArrayTsk05=Volume_3cang;
				  HArrayTsk05=H_3cang;
					break;
				case 4:
					VolArrayTsk05=Volume_4cang;
				  HArrayTsk05=H_4cang;
					break;
      	default:
				 //VolArrayTsk05=Volume_1cang;
				 // HArrayTsk05=H_1cang;
      		break;
      }
			
			v000=Calc_Vol(plevel[i].Level_Data,VolArrayTsk05,HArrayTsk05,i);
			__NOP;
			plevel[i].Volume_Data=v000;
			
			DF_State(i);
			//BGY_state(i);
      osDelay(100);
		}			
			
			




					
  }
  /* USER CODE END StartTask05 */
}

/* USER CODE BEGIN Header_StartTask06 */
/**
* @brief Function implementing the myTask06 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask06 */
void StartTask06(void *argument)
{
  /* USER CODE BEGIN StartTask06 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartTask06 */
}

/* USER CODE BEGIN Header_StartTask07 */
/**
* @brief Function implementing the myTask07 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask07 */
void StartTask07(void *argument)
{
  /* USER CODE BEGIN StartTask07 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartTask07 */
}

/* USER CODE BEGIN Header_StartTask08 */
/**
* @brief Function implementing the myTask08 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask08 */
void StartTask08(void *argument)
{
  /* USER CODE BEGIN StartTask08 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartTask08 */
}

/* USER CODE BEGIN Header_StartTask09 */
/**
* @brief Function implementing the myTask09 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask09 */
void StartTask09(void *argument)
{
  /* USER CODE BEGIN StartTask09 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartTask09 */
}

/* USER CODE BEGIN Header_StartTask10 */
/**
* @brief Function implementing the myTask10 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask10 */
void StartTask10(void *argument)
{
  /* USER CODE BEGIN StartTask10 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartTask10 */
}

/* USER CODE BEGIN Header_StartTask11 */
/**
* @brief Function implementing the myTask11 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask11 */
void StartTask11(void *argument)
{
  /* USER CODE BEGIN StartTask11 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartTask11 */
}

/* USER CODE BEGIN Header_StartTask12 */
/**
* @brief Function implementing the myTask12 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask12 */
void StartTask12(void *argument)
{
  /* USER CODE BEGIN StartTask12 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(500);
		usage_Tsk12++;
		HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_0);
		HAL_GPIO_TogglePin(WDI_sp706_kanmemgou_GPIO_Port, WDI_sp706_kanmemgou_Pin);	
  }
  /* USER CODE END StartTask12 */
}

/* Callback01 function */
void Callback01(void *argument)
{
  /* USER CODE BEGIN Callback01 */

  /* USER CODE END Callback01 */
}

/* Callback02 function */
void Callback02(void *argument)
{
  /* USER CODE BEGIN Callback02 */

  /* USER CODE END Callback02 */
}

/* Callback03 function */
void Callback03(void *argument)
{
  /* USER CODE BEGIN Callback03 */

  /* USER CODE END Callback03 */
}

/* Callback04 function */
void Callback04(void *argument)
{
  /* USER CODE BEGIN Callback04 */

  /* USER CODE END Callback04 */
}

/* Callback05 function */
void Callback05(void *argument)
{
  /* USER CODE BEGIN Callback05 */

  /* USER CODE END Callback05 */
}

/* Callback06 function */
void Callback06(void *argument)
{
  /* USER CODE BEGIN Callback06 */

  /* USER CODE END Callback06 */
}

/* Callback07 function */
void Callback07(void *argument)
{
  /* USER CODE BEGIN Callback07 */

  /* USER CODE END Callback07 */
}

/* Callback08 function */
void Callback08(void *argument)
{
  /* USER CODE BEGIN Callback08 */

  /* USER CODE END Callback08 */
}

/* Callback09 function */
void Callback09(void *argument)
{
  /* USER CODE BEGIN Callback09 */

  /* USER CODE END Callback09 */
}

/* Callback010 function */
void Callback010(void *argument)
{
  /* USER CODE BEGIN Callback010 */

  /* USER CODE END Callback010 */
}

 /**
  * @brief  Period elapsed callback in non blocking mode
  * @note   This function is called  when TIM8 interrupt took place, inside
  * HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
  * a global variable "uwTick" used as application time base.
  * @param  htim : TIM handle
  * @retval None
  */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  /* USER CODE BEGIN Callback 0 */

  /* USER CODE END Callback 0 */
  if (htim->Instance == TIM8) {
    HAL_IncTick();
  }
  /* USER CODE BEGIN Callback 1 */

  /* USER CODE END Callback 1 */
}

/**
  * @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 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/