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"
#include "iap.h"
/* USER CODE END Includes */
#if 1
#define IR_ROM1   0x08000000
#else
#define IR_ROM1   0x08020000
#endif

/* 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] = {0x31,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, 0x10, 0x03 ,0xae};//读取编号为04地址的温度传感器数据
//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;

uint8_t bufMain[128];

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

// for debug，将信息输出到指定的uart总线上
static void DumpMsg(uint8_t *msg)
{
	HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_RESET);
	delay_sys_us(80);
	HAL_UART_Transmit_IT(&huart2,msg,strlen(msg));		
	while (huart2.gState == HAL_UART_STATE_BUSY_TX)
	{
		osDelay(1);
	}
	delay_sys_us(80);
	HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_SET);
}

#include <stdarg.h>
void printx(const char *log,...)
{
	osMutexAcquire(myMutex01Handle, portMAX_DELAY);
    va_list ap;
    va_start(ap,log);
    vsnprintf(bufMain,sizeof(bufMain),log,ap);
    va_end(ap);

    DumpMsg(bufMain);
	osMutexRelease(myMutex01Handle);
}

/* 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] = 1;											//默认每仓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] < 8))
			pcang->RKG_Num[i] = Flash_buff[i];
		else	
			pcang->RKG_Num[i]  = 1;																			//默认每仓1人孔阀
	}
	Flash_ReadBytes(Flash_buff,ADDR_XYF_NUM,8);
	for(i = 0;i < 8;i++)
	{
		if((Flash_buff[i] < 8))
			pcang->XYF_Num[i] = Flash_buff[i];
		else
			pcang->XYF_Num[i] = 1;		//默认每仓1卸油阀   slm
	}
	Flash_ReadBytes(Flash_buff,ADDR_HDF_NUM,8);
	for(i = 0;i < 8;i++)
	{
		if((Flash_buff[i] < 8))
			pcang->HDF_Num[i] = Flash_buff[i];
		else
			pcang->HDF_Num[i] = 1;		    //默认每仓1海底阀   slm
	}
	
	
	Flash_ReadBytes(Flash_buff,ADDR_YQHS_TYPE,1);
	if(Flash_buff[0] == 0xffff)
		pcang->YQHS = 0;           //默认无油气回收     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,ADDR_SENSOR_BUS_MAX_RETRY,1);
	if(Flash_buff[0] == 0xffff)
		pcang->sensorBusMaxReTry = 3;
	else
		pcang->sensorBusMaxReTry = Flash_buff[0];
	
	Flash_ReadBytes(Flash_buff,CANG1_LEVEL_CAL,8);
	if(Flash_buff[0] == 0xffff)
	{
		for(i=0;i<pcang->Cang_Num;++i)
		{
			plevel[i+1].Level_Cal_zero = 0;
		}
	}
	else
	{
		for (i = 0; i < pcang->Cang_Num; ++i)
		{
			hex_to_float1.arr[3] = (uint8_t)(Flash_buff[0+2*i] >> 8);
			hex_to_float1.arr[2] = (uint8_t)(Flash_buff[0+2*i] & 0xFF); // Flash_buff[3];
			hex_to_float1.arr[1] = (uint8_t)(Flash_buff[1+2*i] >> 8);
			hex_to_float1.arr[0] = (uint8_t)(Flash_buff[1+2*i] & 0xFF);
			plevel[i + 1].Level_Cal_zero = hex_to_float1.Ldcal_zero_temp;
		}
	}
	
	
	

	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)
	{
		for (i = 0; i < 8; i++)
		{
			prkg[i].RKG_StateKeepNum = 5;           //默认人孔盖角度传感器
			pxyf[i].XYF_StateKeepNum = 5;
		}
		
		
		phdf->HDF_StateKeepNum = 5;
		pangle->Angle_StateKeepNum = 5;
		plevel->Level_StateKeepNum = 5;
		ptem->TEM_StateKeepNum = 5;
	}
	else
	{
		for (i = 0; i < 8; i++)
		{
			prkg[i].RKG_StateKeepNum = Flash_buff[0];         
			pxyf[i].XYF_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
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
	GPIO_InitTypeDef GPIO_InitStruct = {0};

	int spr000;
  /* USER CODE END 1 */
#if	IR_ROM1 == 0x08000000	
	Start_BootLoader();
#else	
	SCB->VTOR = 0x08020000;
	__set_PRIMASK(0);
#endif	
  /* 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
	//if(1)//打开看门狗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,128);
	spr000=sprintf((char*)bufMain,"sysytem reset...%5d, watchDogOn=%d, version:%d",5,WatchDogOn,Version_Soft[7]);
	//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,Uart3_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
	//if(1)//打开看门狗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;
	uint16_t ModbusCRC = 0,xyfaddr_max = 0,hdfaddr_max;                     				 //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;
	
	xyfaddr_max=0;
	hdfaddr_max=0;
	for(i = 0;i < pcang->Cang_Num;i++)
	{
		xyfaddr_max += pcang->XYF_Num[i];
		hdfaddr_max += pcang->HDF_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(10);    																								  //以ms为单位
    //HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_0);
	  HAL_GPIO_TogglePin(WDI_sp706_kanmemgou_GPIO_Port, WDI_sp706_kanmemgou_Pin);	
		//	continue;
		if(Flash_Change)																									//如果有对Flash进行改动，则重新计算xyfaddr_max
		{
			xyfaddr_max = 0;
			hdfaddr_max = 0;
			for(i = 0;i < pcang->Cang_Num;i++)
			{
				xyfaddr_max += pcang->XYF_Num[i];
				hdfaddr_max += pcang->HDF_Num[i];
			}
			Flash_Change = 0;
		}
		
		if(pkzq->USE_XYF == 0)    //平台未控制卸油阀总线，正常轮询数据
		{

			if(i001==0)  	//发送卸油阀传感器命令轮询
			{
				if ((pcang->XYF_INSTALL != 0) && (pcang->XYF_Type != 2))
				{

					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);
					HAL_UART_Transmit_IT(&huart3, CMD_XYF, 8);
					while (huart3.gState == HAL_UART_STATE_BUSY_TX)
					{
						osDelay(1);
					}
					HAL_GPIO_WritePin(GPIOB, con02_uart3_xieyoufa_Pin, GPIO_PIN_SET); //
					pxyf[CMD_XYF[0] - 0x10].RTData_Num++; //每个传感器发送帧累加

					if (CMD_XYF[0] - 0x10 < xyfaddr_max)
						CMD_XYF[0]++;
					else
						CMD_XYF[0] = 0x11;
				}
				else
				{
					i001 = 3;
				}
			}
			if (i001 == 3) //发送姿态传感器轮询
			{
				if (pcang->Angle) //发送角度传感器命令轮询
				{

					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++;
				}
				else
				{
					i001 = 6;
				}
			}

			if(i001==6)             //发送壁挂油传感器命令轮询
			{
					if(pcang->BGY_INSTALL)
					{
						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); 
					}
					else
					{
						i001=9;
					}    					
			}
			if (i001 == 9) //发送智能海底阀传感器命令轮询
			{
				if (pcang->HDF_INSTALL != 0 && pcang->HDF_Type)
				{

					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 < hdfaddr_max)
						CMD_HDF[0]++;
					else
						CMD_HDF[0] = 0x21;
				}
				else
				{
					i001 = 12;
				}
			}

			if(i001==12)          //发送油气回收传感器命令轮询
			{
					if(pcang->YQHS)
					{
					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
					{
							i001=0;
							continue;
					}
			}					
		}
		else											//平台通过卸油阀总线直接操作传感器
		{
			if(i002 == 3)
			{
				HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_RESET);//
				delay_sys_us(80);
#if 0				
				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);
#else
				HAL_UART_Transmit_IT(&huart3,XYF_TxBuf,Uart_len_TouChuan);		
				while (huart3.gState == HAL_UART_STATE_BUSY_TX)
				{
					osDelay(1);
				}
#endif				
				HAL_GPIO_WritePin(GPIOB,con02_uart3_xieyoufa_Pin,GPIO_PIN_SET);     //
			}
			else if(i002 == 0x06)
			{
#if 0				
				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);//				
#endif				
				pkzq->USE_XYF = 0;
				i002 = 0;				
			}
			i002++;
			if((flagU3Rx==1) && (i002 > 3))
			{
				pkzq->USE_XYF = 0;
				i002 = 0;
				continue;
			}
		}
		

	  //来自UART3的命令 电路板上标志位卸油阀
		if(flagU3Rx==1)
		{
				flagU3Rx=0;
#if 0				
				if(USART3_RX_BUF002[0]!=0x11)
			{
				pxyf[1].XYF_ErrorCnt++;
			  if(pxyf[1].XYF_ErrorCnt>35)
				{
				  pxyf[1].XYF_Error = 1;

				}
			}
			
       		if(USART3_RX_BUF002[0]!=0x12)
			{
				pxyf[2].XYF_ErrorCnt++;
			  if(pxyf[2].XYF_ErrorCnt>35)
				{
				  pxyf[2].XYF_Error = 1;
				}
			}	
#endif					
			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 0						
						if(USART3_RX_BUF002[3]>0x01)//阀门开关状态
						{
							pxyf[i].XYF_ErrorCnt++;
						}
						else if(i < XYF_BUF_DEP)
						{
							
							i++;
						}
						if(i == XYF_BUF_DEP)
						{
							i = 0;
						}
#else
						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];
#endif						
						XYF_state(USART3_RX_BUF002[0] - 0x10);
						
					}
					else if(USART3_RX_BUF002[1] == 0x06)             	//写入数据返回  判断写入是否成功
					{
																																											//清除控制器占用标志																																								
						//整理卸油阀协议后添加
					}
					i001=3;
					continue;
				}
			}
			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;			
			
		}
		else
		{
			if (i001 == 2)
			{
				if(CMD_XYF[0] == 0x11)
				{
					i = xyfaddr_max;
				}
				else
				{
					i = CMD_XYF[0] - 0x11;
				}
				pxyf[i].XYF_ErrorCnt++;
				if (pxyf[i].XYF_ErrorCnt > pcang->sensorBusMaxReTry)
				{
					pxyf[i].XYF_ErrorCnt = pcang->sensorBusMaxReTry + 1;
					pxyf[i].XYF_Error = 1;
				}
			}
		}
		if(i001<15)
			i001++;
		else
			i001 = 0;
		osDelay(40);
  }
  /* 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;
	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;
	leveladdr_max=0;
	if(pcang->Temperture==2)
		pcang->Temperture=3;
	for(i = 0;i < pcang->Cang_Num;i++)
	{
		rkgaddr_max += pcang->RKG_Num[i];										//人孔盖最大地址							
		leveladdr_max++;
	}
	/*if(pcang->RKG_Type==0)
	{
		rkgaddr_max += 1;
	}*/
	//if(((pcang->Level)|0xff) == 0)
	{
			if(((pcang->Temperture)&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(10);    																								  //以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;
			leveladdr_max=0;
			if(pcang->Temperture==2)
				pcang->Temperture=3;
			for(i = 0;i < pcang->Cang_Num;i++)
			{
				rkgaddr_max += pcang->RKG_Num[i];										//人孔盖最大地址							
				leveladdr_max++;
			}
			/*if(pcang->RKG_Type==0)
			{
				rkgaddr_max += 1;
			}*/
			//if(((pcang->Level>)|0xff) == 0)
			{
					if(((pcang->Temperture)&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)  					  //发送人控大盖盖命令轮询
			{
				if((pcang->RKG_DG != 0) && (pcang->RKG_Type!=2))
				{
					if(pcang->RKG_Type == 0)
					{	
						if(CMD_RKG[0] == 0x1)
						{
							if(i003 >= rkgaddr_max)
								i003 = 0;
							++i003;
							CMD_RKG[0] = 1+i003*2;
							prkg[i003].RTData_Num++; 
						}
						else
						{
							CMD_RKG[0] = 0x1;
							prkg[0].RTData_Num++; 
						}	
					}
					else					
					{
						prkg[CMD_RKG[0] - 0x30].RTData_Num++; 

						if(CMD_RKG[0] - 0x30 < rkgaddr_max)
						{
							++i003;
							CMD_RKG[0]=0x30+i003;
						}	
						else
						{
							CMD_RKG[0] = 0x31;
							i003 = 1;
						}
					}
					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_IT(&huart1,CMD_RKG,8);		
						while (huart1.gState == HAL_UART_STATE_BUSY_TX)
						{
							osDelay(1);
						}
					}  //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  0		
					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
#endif					
					
					
				}
				else 
					i001 = 3;
			}
			
			if(i001==3)		          //发送小盖传感器轮询
			{
				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 = 6;
			}
			
			if(i001==6)  					  //发送磁致伸缩液位计命令轮询  邵磊明增加
			{
				if(pcang->Level == 0)					       //没有液位传感器
				{
					i001=9;
				}
				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_UART_Transmit_IT(&huart1,CMD_GetTempAndYewei,8);		
					while (huart1.gState == HAL_UART_STATE_BUSY_TX)
					{
						osDelay(1);
					}
					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 < leveladdr_max)
							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_UART_Transmit_IT(&huart1, CMD_LDYW, 8);
				while (huart1.gState == HAL_UART_STATE_BUSY_TX)
				{
					osDelay(1);
				}
				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_LDYW[0] - 0x50].RTData_Num++;

				if (CMD_LDYW[0] - 0x50 < leveladdr_max)
					CMD_LDYW[0]++;
				else
					CMD_LDYW[0] = 0x51;
				}
				else
					i001=9;
			}
			
			if(i001==9)  					  //发送华天三点式温度传感器命令轮询  邵磊明增加
			{
				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_IT(&huart1,CMD_GetTempHuaTian,8);		
					while (huart1.gState == HAL_UART_STATE_BUSY_TX)
					{
						osDelay(1);
					}
					//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 0									
					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
#endif					
					{
						ptem[CMD_GetTempHuaTian[0] - 0x60].RTData_Num++; 		
					}						
						if(CMD_GetTempHuaTian[0] - 0x60 < temaddr_max)
							CMD_GetTempHuaTian[0] = CMD_GetTempHuaTian[0]+1;
						else
							CMD_GetTempHuaTian[0] = 0x61;

				}
				else
				{
					i001=0x0;
					continue;
				}	
			}	
		}
		else											//平台通过卸油阀总线直接操作传感器
		{
			if(i002 == 3)
			{
				extern uint16_t Uart_len_TouChuan;
				HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_RESET);//
				delay_sys_us(80);
#if 0				
				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);
#else
				HAL_UART_Transmit_IT(&huart1,RKG_TxBuf,Uart_len_TouChuan);		
				while (huart1.gState == HAL_UART_STATE_BUSY_TX)
				{
					osDelay(1);
				}
#endif					
				HAL_GPIO_WritePin(GPIOB,Con01_uart1_rankonggai_Pin,GPIO_PIN_SET);//
				flagU1Rx=0;
			}
			
			i002++;
			if(((flagU1Rx==1) && (i002 > 3)) || i002>10)
			{
				pkzq->USE_RKG = 0;	
				i002 = 0;	
				continue;
			}
		}
		

		
		
	  //来自UART1,即人孔盖总线的命令 电路板上标志位人孔盖
		if(flagU1Rx==1)
		{
			flagU1Rx = 0;
			receive_error = 0;
			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[head+0] >= 0x30 && USART1_RX_BUF002[head+0] <= 0x3F) || (USART1_RX_BUF002[head+0] >= 0x1 && USART1_RX_BUF002[head+0] <= 0x10))        //人孔大盖数据   地址0x30为基准传感器
			{
				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((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))      //读取数据返回
				{//童赟    磁电编码    磁编码  人孔盖
					if(USART1_RX_BUF002[head]==1)
					{
						prkg[0].RKDG_ErrorCnt = 0;
						prkg[0].RKDG_Error=0;
					}
					else
					{
						prkg[i003].RKDG_ErrorCnt = 0;
						prkg[i003].RKDG_Error=0;
					}
					
					if(USART1_RX_BUF002[head]==1)
					{
						AGL_AddNewData(RKG_angle,0);
					}
					else
					{
						AGL_AddNewData(RKG_angle,i003);
					}
					   
#if 0					
					//邵磊明修改  20211027    从rkg.c剪切到此处
					if(psATsk3[i003].uiDG < 0 ||psATsk3[USART1_RX_BUF002[head]-0x30].uiDG >= 27000)//角度
					{
							prkg[USART1_RX_BUF002[head]-0x30].RKDG_ErrorCnt++;  
					}
#endif					
					
				//	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(pcang->RKG_Type == 0)
					{
						AGL_CalcDeltaAll(USART1_RX_BUF002[head],0);	
					}	
#if  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;
							rkdg_cnt++;
						}
					}
					if(rkdg_cnt == RKG_BUF_DEP)
					{
						rkdg_cnt = 0;
					}
#endif					
				//李伟修改  20211027    从rkg.c剪切到此处；开始
					if (USART1_RX_BUF002[head] != 1)
					{
						if (psATsk3[i003].uiDG >= 0 || psATsk3[i003].uiDG <= 27000) //角度
						{
							if (-psATsk3[i003].uiDG > prkg->RKG_Threshold || psATsk3[i003].uiDG > prkg->RKG_Threshold)
								prkg[i003].RKDG_StateCnt++;
							else
								prkg[i003].RKDG_StateCnt = 0;

							if (prkg[i003].RKDG_StateCnt >= prkg[i003].RKG_StateKeepNum)
							{
								// RisingEdge++;
								prkg[i003].RKDG_StateCnt = prkg[i003].RKG_StateKeepNum;
								prkg[i003].RKDG_State = 1;
							}
							else
							{
								prkg[i003].RKDG_State = 0;
							}
						}
					}

				//李伟修改  20211027    从rkg.c剪切到此处；开始	
					i001 = 3;
					continue;
				}
			}
			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))             	//写入数据返回
				{
						
				}
				i001 = 6;
				continue;
			}
			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] != 0x20)			//校验数据长度
				{
					receive_error = 1;	
				}
				else if(ModbusCRC != LIB_CRC_MODBUS(USART1_RX_BUF002,35))		//校验CRC
				{
					receive_error = 1;	
				}
				if((USART1_RX_BUF002[head+1] == 0x04)&&(receive_error == 0))      //读取返回雷达数据 slm
				{
					  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))             	//写入数据返回
				{
					
				}			  
			 }
			 i001 = 9;
			 continue;
			}
			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))
				{
					if(pcang->Temperture==1) //1点
					{
						ptem[USART1_RX_BUF002[head]-0x60].TEM_HData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];
						ptem[USART1_RX_BUF002[head]-0x60].TEM_MData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];
						ptem[USART1_RX_BUF002[head]-0x60].TEM_LData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];
					}
					else if(pcang->Temperture==3) //1点
					{
						i = USART1_RX_BUF002[head]-0x61;
						switch (i%3)
						{
						case 0:
							ptem[(i/3)+1].TEM_HData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];
							break;
						case 1:
							ptem[(i/3)+1].TEM_MData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];
							break;
						case 2:
							ptem[(i/3)+1].TEM_LData[1] =  USART1_RX_BUF002[3]<<8|USART1_RX_BUF002[4];
							break;
						default:
							break;
						}
					}
#if 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;
					}
#endif					

				}
				i001 = 0;
			 	continue;
			}
			else if(0)  //暂未使用
			{
				
			}
			else if(0)   //暂未使用
			{
			
			}	
		}
	  else
		{
			if (i001 == 2)
			{
				if(pcang->RKG_Type == 0)
				{
					if(CMD_RKG[0] == 0x1)
					{
						i = 0;
					}
					else
					{
						i = i003;
					}	
				}
				else
				{
					i = i003;
				}
				
				prkg[i].RKDG_ErrorCnt++;
				if (prkg[i].RKDG_ErrorCnt > pcang->sensorBusMaxReTry)
				{
					prkg[i].RKDG_ErrorCnt = pcang->sensorBusMaxReTry + 1;
					prkg[i].RKDG_Error = 1;
				}
			}
			if (i001 == 8) //液位错误
			{
				if(pcang->Level == 1)
				{
					i = CMD_GetTempAndYewei[0];	
				}
				else if(pcang->Level == 2)
				{
					i = CMD_LDYW[0];	
				}
				if(pcang->Level)
				{
					if(i==0x51)
					{
						i = leveladdr_max;
					}
					else
					{
						i = i - 0x51;
					}
					plevel[i].Level_ErrorCnt++; 
				}
			}
		}		
		if(i001<0x0c)
			i001++;
		else
			i001 = 0;
		osDelay(40);	
  }
  /* 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];
uint32_t KZQ_RTerror = 0;
/* 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,SetSuccess = 0,ModbusCRC1 = 0,SetSuccess1 = 0,SetSuccess2=0,SetSuccess3=0;                 
	static uint16_t i = 0;
	int i000;
	uint8_t* send_ptr;
	uint16_t send_len;
	uint32_t tmpU32;
	
	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)
	{
		flagU2Rx = 0;
		if ((rx1_len > 300) || ((USART2_RX_BUF002[0] == 0xa5) && (USART2_RX_BUF002[1] == 0x5a)))
		{
			tmpU32 = (USART2_RX_BUF002[0] << 24) | (USART2_RX_BUF002[1] << 16) | (USART2_RX_BUF002[2] << 8) | (USART2_RX_BUF002[3]);
			if (StartBytes_IAP == tmpU32)
			{
				Process_CMD_IAP_Update();
				continue;
			}
		}
		// 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)) //判断帧头
		{
			if (data_lengthU2 != 131)
			{
				++KZQ_RTerror;
				continue;
			}
			for (i000 = 0; i000 < (data_lengthU2 - 3) / 2; 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, (data_lengthU2 - 3) / 2);
			data_lengthU2 = (data_lengthU2 - 3) / 2;
		}
		if (data_lengthU2 < 5)
			continue;
		ModbusCRC = USART2_RX_BUF002[data_lengthU2 - 1] << 8;
		ModbusCRC |= USART2_RX_BUF002[data_lengthU2 - 2];
		ModbusCRC1 = LIB_CRC_MODBUS(USART2_RX_BUF002, data_lengthU2 - 2);

		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 != ModbusCRC1)		//校验CRC
		{
			pkzq->KZQ_Error++;
			KZQ_RTerror = 1;
		}*/
		else
		{
			pkzq->KZQ_Error = 0;
			KZQ_RTerror = 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 0x80: SetSuccess = RW_SensorBusMaxRetry(ptx);										//传感器总线重试最大值来获取异常
						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 0x0220:
						SetSuccess=Read_SoftVersion(ptx);
						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;
				}
				send_len=0;
				if(pkzq->sensor_reg == 0x13)
				{
					send_ptr =  F_STATE;
					send_len = 62;
				}
				else if(SetSuccess2)
				{
					SetSuccess2=0;
					send_ptr = ptx;
					send_len = 148;
				}	
				else if(SetSuccess3)
				{
					SetSuccess3=0;
					send_ptr = ptx;
					send_len = 96;
				}								
				else if(SetSuccess1)
				{
					SetSuccess1=0;
					ptx[232] = 0x00;
					ptx[233] = 0x00;
					send_ptr = ptx;
					send_len = 234;
				}
				 else if(SetSuccess)
				{
					ptx[60] = 0x00;
					ptx[61] = 0x00;
					send_ptr = ptx;
					send_len = 62;
				}
				else
				{
					ptx[60] = 0xFF;
					ptx[61] = 0xFF;
					send_ptr = ptx;
					send_len = 62;
				}
				SetSuccess = 0;
				if(send_len)
				{
					ModbusCRC = LIB_CRC_MODBUS(send_ptr,send_len);
					send_ptr[send_len] = ModbusCRC>>8;
					send_ptr[send_len+1] = ModbusCRC&0xff;
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_RESET);//
					delay_sys_us(80);
					HAL_UART_Transmit_IT(&huart2,send_ptr,send_len+2);		
					while (huart2.gState == HAL_UART_STATE_BUSY_TX)
					{
						osDelay(1);
					}
					delay_sys_us(80);
					HAL_GPIO_WritePin(GPIOA,con03_uart2_kongzhiqi_Pin,GPIO_PIN_SET);//
				}	
			}
			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;
	uint8_t i;
	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 (i = 0; i < pcang->Cang_Num+1; i++)
		{
			// Value_Manage(i);
			// 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_4cang;
					HArrayTsk05 = H_4cang;
					break;
				}

				v000 = Calc_Vol(plevel[i].Level_Data, VolArrayTsk05, HArrayTsk05, i);
				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****/