0301_BOOT/User/ytsf.c

/**
  ********************************  STM32F10x  *********************************
  * @文件名     ： ytsf.c
  * @作者       ： sun
  * @库版本     ： V3.5.0
  * @文件版本   ： V1.0.0
  * @日期       ： 2016年05月09日
  * @摘要       ： USART源文件
  ******************************************************************************/
/*----------------------------------------------------------------------------
  更新日志:
  2016-05-09 V1.0.0:初始版本
  ----------------------------------------------------------------------------*/
/* 包含的头文件 --------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>

#include "stm32f10x.h"

#include "ytsf.h"
#include "sx1276_api.h"
#include "usart.h"
#include "queue.h"
#include "systick.h"
#include "timer.h"
#include "eeprom.h"
#include "led.h"



uint8_t Ytsf_CMD_BUF[Ytsf_CMD_BUF_SIZE]={0x00};					//命令缓冲区




uint8_t Ytsf_CMD_PARM[Ytsf_CMD_PARM_SIZE]={0x00};				//命令参数

uint8_t MAX_CMD_LIST=0;			//命令列表数量


bool YTSF_OnUse=true;				//英泰赛福模块在位

volatile bool Port0_OnUse=true;				//端口0使用标记
volatile bool Port1_OnUse=true;			//端口1使用标记


bool Port0_GunTotal=1;			//端口0枪数
bool Port1_GunTotal=1;			//端口0枪数


bool PORT0_SN_CHANGED=false;
bool PORT1_SN_CHANGED=false;

bool PORT0_ZLJ_CHANGED = false;
bool PORT1_ZLJ_CHANGED = false;

volatile uint32_t YTSF_PORT0_Send_Delay = 0;
volatile uint32_t YTSF_PORT1_Send_Delay = 0;


volatile uint32_t YTSF_PORT0_Send_CNT = 0;
volatile uint32_t YTSF_PORT1_Send_CNT = 0;


uint8_t mYTSF_state=YTSF_STATE_IDLE;
//uint8_t mYTSF_state_port0=YTSF_STATE_IDLE;
//uint8_t mYTSF_state_port1=YTSF_STATE_IDLE;

tYTSFRxFrame_t YTSF_rx_frame;
tYTSFRxFrame_t YTSF_rx_frame_port[2];
tYTSFRxFrame_t Tax_rx_frame[2];

tDevice_t mDevice;
//tYtsfDeviceReg_t mDeviceReg;

uint8_t Ytsf_CMD_A1[]={
	0xbb,											//前导码
	0x10,											//长度码
	0x81,											//帧号
	0x00,											//端口号
	0xa1,											//命令码
	0x11,											//累计类型
	0x00,											//gun_num,00H:1号枪，01H:2号枪
	0x00,0x00,0x00,0x00,			//参数，默认0
	0x00,0x00,0x00,0x00,0x00,	//监控序列号
	0x00,0x00									//校验码
};

uint8_t Ytsf_CMD_A2[]={
	0xbb,											//前导码
	0x0d,											//长度码
	0x81,											//帧号
	0x00,											//端口号
	0xa2,											//命令码
	0x11,											//信息类型
	0x00,											//gun_num,00H:1号枪，01H:2号枪
	0x00,0x00,0x00,0x00,			//参数，默认0
	0x00,0x00,								//预留
	0x00,0x00									//校验码
};

uint8_t Ytsf_CMD_A5[]={
	0xbb,											//前导码
	0x0d,											//长度码
	0x81,											//帧号
	0x00,											//端口号
	0xa5,											//命令码
	0x11,											//信息类型
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,			//参数，时钟8字节
	0x00,0x00									//校验码
};
uint8_t CMD_LIST_polling=0;
uint16_t CMD_LIST_polling_port0=0;
uint16_t CMD_LIST_polling_port1=0;
//YTSF_CMD_Tx(Ytsf_CMD_A2_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_00);
uint8_t CMD_LIST[][6]={			//命令列表
//第0个元素表示是否使能
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_00},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_01},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_02},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_10},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_21},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_00},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_01},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_02},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_10},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A2_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_21},

{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_1,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_1,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_1,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_1,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_1,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_2,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_2,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_2,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_2,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_2,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_3,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_3,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_3,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_3,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_3,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_4,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_4,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_4,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_4,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_4,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_5,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_5,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_5,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_5,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_5,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_6,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_6,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_6,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_6,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_6,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_7,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_7,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_7,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_7,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_7,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},

{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_1,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_1,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_1,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_1,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_1,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_2,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_2,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_2,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_2,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_2,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_3,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_3,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_3,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_3,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_3,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_4,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_4,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_4,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_4,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_4,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_5,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_5,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_5,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_5,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_5,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_6,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_6,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_6,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_6,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_6,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_7,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_7,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_12},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_7,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_13},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_7,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14},
{CMD_dn,Ytsf_CMD_A1_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_7,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_20},
 

{CMD_dn,Ytsf_CMD_A5_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A5,Ytsf_CMD_TYPE_00},
{CMD_dn,Ytsf_CMD_A5_SIZE+1,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A5,Ytsf_CMD_TYPE_01},
{CMD_dn,Ytsf_CMD_A5_SIZE,Ytsf_PORT_0,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A5,Ytsf_CMD_TYPE_FF},

{CMD_dn,Ytsf_CMD_A5_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A5,Ytsf_CMD_TYPE_00},
{CMD_dn,Ytsf_CMD_A5_SIZE+1,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A5,Ytsf_CMD_TYPE_01},
{CMD_dn,Ytsf_CMD_A5_SIZE,Ytsf_PORT_1,Ytsf_GUN_NUM_0,Ytsf_CMD_INSTRUCT_A5,Ytsf_CMD_TYPE_FF},

//
{CMD_dn,0x06,TAX_PORT_0,TAX_GUN_NUM_0,0x83,0x00},
{CMD_dn,0x06,TAX_PORT_1,TAX_GUN_NUM_0,0x83,0x00},

{CMD_dn,0x07,TAX_PORT_0,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_0,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_0,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_0,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_0,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_0,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_0,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_0,TAX_GUN_NUM_0,0x86,0x00},

{CMD_dn,0x08,TAX_PORT_0,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_0,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_0,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_0,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_0,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_0,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_0,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_0,TAX_GUN_NUM_0,0x89,0x00},



{CMD_dn,0x07,TAX_PORT_1,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_1,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_1,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_1,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_1,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_1,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_1,TAX_GUN_NUM_0,0x86,0x00},
{CMD_dn,0x07,TAX_PORT_1,TAX_GUN_NUM_0,0x86,0x00},

{CMD_dn,0x08,TAX_PORT_1,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_1,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_1,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_1,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_1,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_1,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_1,TAX_GUN_NUM_0,0x89,0x00},
{CMD_dn,0x08,TAX_PORT_1,TAX_GUN_NUM_0,0x89,0x00}

};



int16_t YTSF_SET_STATE_port(uint8_t mport,uint8_t s,uint8_t mode);
int16_t TAX_SET_STATE_port(uint8_t mport,uint8_t s,uint8_t mode);

/********************************
获取命令列表总数
********************************/
uint8_t Get_MAX_CMD_LIST(void)
{
	MAX_CMD_LIST = sizeof(CMD_LIST)/sizeof(CMD_LIST[0]);
	return MAX_CMD_LIST;
}


void YTSF_GPIO_Init(void)
{
 
 GPIO_InitTypeDef  GPIO_InitStructure;
 //YTSF_GPIO_REV1_RST_N				PC8
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);	//使能PC端口时钟         //复位
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;				 			//PC.8 端口配置
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 			//推挽输出
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;		 		//IO口速度为2MHz
 GPIO_Init(GPIOC, &GPIO_InitStructure);					 				//根据设定参数初始化GPIOC 8
 GPIO_SetBits(GPIOC,GPIO_Pin_8);		                    //置高PC8
	
 //YTSF_GPIO_REV2							PB4
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);	//使能PB端口时钟  预留的
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;				 			//PB.4 端口配置
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; 			//推挽输出
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;		 		//IO口速度为2MHz
 GPIO_Init(GPIOB, &GPIO_InitStructure);					 				//根据设定参数初始化GPIOB 4
 //GPIO_SetBits(GPIOB,GPIO_Pin_4);		                    //置高PB4
	
 //YTSF_GPIO_REV3_DETECT_N		A11
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	 //使能PA端口时钟
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;	//Pin_11 Pin_12 端口配置
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; 		 //推挽输出
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;		 //IO口速度为2MHz
 GPIO_Init(GPIOA, &GPIO_InitStructure);	
 //GPIO_SetBits(GPIOA,GPIO_Pin_11);	        //在位
 
 //YTSF_GPIO_REV4_EN_N				A12
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	 //使能PA端口时钟
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;	//Pin_12 端口配置
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 //推挽输出
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;		 //IO口速度为2MHz
 GPIO_Init(GPIOA, &GPIO_InitStructure);					 //根据设定参数初始化GPIOA.11,12
 GPIO_ResetBits(GPIOA,GPIO_Pin_12);       //使能            //低使能

}
/********************************
初始化
********************************/
uint8_t Get_Ytsf_init(void){
	


	
//	uint32_t mID=0x83010001;
	uint16_t temp=0;
	
	
	uint8_t returncode = 1;
	
	YTSF_GPIO_Init();
	
	
	if(YTSF_GPIO_DETECT==0)
	{
		YTSF_OnUse=true;
		YTSF_GPIO_EN();
		YTSF_DEBUG1("YTSF_GPIO_DETECT=%d,there is a YTSF DATA MODEL!\r\n",YTSF_GPIO_DETECT);
    
    GPIO_ResetBits(GPIOB,GPIO_Pin_10); 	
	  YTSF_GPIO_RST();
    TIMDelay_Nms(1000);
    
    YTSF_GPIO_SET();
    GPIO_SetBits(GPIOB,GPIO_Pin_10); 	
    
    //TIMDelay_Nms(1000);
	}
	else{
		YTSF_OnUse=false;
		YTSF_GPIO_DN();
		YTSF_DEBUG1("YTSF_GPIO_DETECT=%d,there is no YTSF DATA MODEL!\r\n",YTSF_GPIO_DETECT);
		//return 1;
	}
	
	
	
	
	memset(&mDevice,0,sizeof(mDevice));
	
	//mDevice.port[0].state_m=1;
	mDevice.port[0].gun[0].state=1;
	
	if(EE_ReadVariable(VirtAddVarTab[CURSET_YTSF_PORT0_SN0], &temp)==0)
	{
		mDevice.port[0].mntr_sn[0] = temp & 0xff;
	}
	if(EE_ReadVariable(VirtAddVarTab[CURSET_YTSF_PORT0_SN1], &temp)==0)
	{
		mDevice.port[0].mntr_sn[1] = (temp>>8) & 0xff;
		mDevice.port[0].mntr_sn[2] = (temp>>0) & 0xff;
	}
	if(EE_ReadVariable(VirtAddVarTab[CURSET_YTSF_PORT0_SN2], &temp)==0)
	{
		mDevice.port[0].mntr_sn[3] = (temp>>8) & 0xff;
		mDevice.port[0].mntr_sn[4] = (temp>>0) & 0xff;
	}
	
	
	
	//mDevice.port[1].state=1;
	mDevice.port[1].gun[0].state=1;
	
	if(EE_ReadVariable(VirtAddVarTab[CURSET_YTSF_PORT1_SN0], &temp)==0)
	{
		mDevice.port[1].mntr_sn[0] = temp & 0xff;
	}
	if(EE_ReadVariable(VirtAddVarTab[CURSET_YTSF_PORT1_SN1], &temp)==0)
	{
		mDevice.port[1].mntr_sn[1] = (temp>>8) & 0xff;
		mDevice.port[1].mntr_sn[2] = (temp>>0) & 0xff;
	}
	if(EE_ReadVariable(VirtAddVarTab[CURSET_YTSF_PORT1_SN2], &temp)==0)
	{
		mDevice.port[1].mntr_sn[3] = (temp>>8) & 0xff;
		mDevice.port[1].mntr_sn[4] = (temp>>0) & 0xff;
	}
  
	//读取ID信息
	if(EE_ReadVariable(VirtAddVarTab[CURSET_DEVICE_DevAddr0], &temp)==0)
	{
		mDevice.device_id = (((uint32_t)temp) << 16);
	}
  else{
    mDevice.device_id = ((uint32_t)(0xFFFF) << 16);
  }
	if(EE_ReadVariable(VirtAddVarTab[CURSET_DEVICE_DevAddr1], &temp)==0)
	{
		mDevice.device_id +=  (uint32_t)temp;
	}
  else{
		mDevice.device_id +=  (0xFFFF);
  }
  
  
  
  mDevice.chan_index = 0;
  mDevice.chan_total = 0;
  mDevice.port[Ytsf_PORT_0].zlj_state=0;
  mDevice.port[Ytsf_PORT_1].zlj_state=0;
  
  mDevice.chk_zlj = 0;
  mDevice.lora_send_state = 1;
  
	mDevice.encrypt = YTSF_OnUse;
  mDevice.ytsf_state = YTSF_OnUse;
  
  mDevice.lora_nosend_timeout = 60*1000;
  mDevice.lora_nosend_period = TickCounter - mDevice.lora_nosend_timeout;
  
  //LoRa_SendTimeCouter = TickCounter - LoRa_SendTimeOut;
  
  
  mDevice.port[Ytsf_PORT_0].loop_sn_timeout  = 5*1000;
  mDevice.port[Ytsf_PORT_0].loop_sn_period   = TickCounter;// - mDevice.port[Ytsf_PORT_0].loop_sn_timeout;
  
  mDevice.port[Ytsf_PORT_0].loop_zlj_timeout = 20*1000;
  mDevice.port[Ytsf_PORT_0].loop_zlj_period  = TickCounter - mDevice.port[Ytsf_PORT_0].loop_zlj_timeout;
  
  mDevice.port[Ytsf_PORT_0].loop_dc_timeout  = 8*1000;
  mDevice.port[Ytsf_PORT_0].loop_dc_period   = TickCounter - mDevice.port[Ytsf_PORT_0].loop_dc_timeout;
  
  
  mDevice.port[Ytsf_PORT_1].loop_sn_timeout  = 5*1000;
  mDevice.port[Ytsf_PORT_1].loop_sn_period   = TickCounter - mDevice.port[Ytsf_PORT_1].loop_sn_timeout/2 + 1;
  
  mDevice.port[Ytsf_PORT_1].loop_zlj_timeout = 20*1000;
  mDevice.port[Ytsf_PORT_1].loop_zlj_period  = TickCounter - mDevice.port[Ytsf_PORT_1].loop_zlj_timeout/2 +1;
  
  mDevice.port[Ytsf_PORT_1].loop_dc_timeout  = 8*1000;
  mDevice.port[Ytsf_PORT_1].loop_dc_period   = TickCounter - mDevice.port[Ytsf_PORT_1].loop_dc_timeout+1;
  
  
  
	//mDeviceReg init
  if(mDevice.lora_send_state)
    Get_MAX_CMD_LIST();
	
  YTSF_SET_STATE_port(Ytsf_PORT_0,YTSF_STATE_IDLE,STATE_M_MODE_INIT);
  YTSF_SET_STATE_port(Ytsf_PORT_1,YTSF_STATE_IDLE,STATE_M_MODE_INIT);
  
  TAX_SET_STATE_port(TAX_PORT_0,YTSF_STATE_IDLE,STATE_M_MODE_INIT);
  TAX_SET_STATE_port(TAX_PORT_1,YTSF_STATE_IDLE,STATE_M_MODE_INIT);
  
  
#ifdef XXXXYTSF_DEBUG_EN
	for(i=0;i<MAX_CMD_LIST;i++)
	{
		for(j=0;j<6;j++)
			//YTSF_DEBUG("%02x ",CMD_LIST[i][j]);
		
		//YTSF_DEBUG("\r\n");
			printf("%02x ",CMD_LIST[i][j]);
			printf("\r\n");
	}
#endif
	/*
	index = Get_CMD_Index_ByParm(Ytsf_PORT_0,0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_00);
	YTSF_DEBUG1("index=%d\r\n",index);
	if(index >=0)
		YTSF_CMD_Tx(CMD_LIST[index][1],CMD_LIST[index][2],CMD_LIST[index][3],CMD_LIST[index][4],CMD_LIST[index][5]);
	
	
	TIMDelay_Nms(500);
	index = Get_CMD_Index_ByParm(Ytsf_PORT_1,0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_00);
	YTSF_DEBUG1("index=%d\r\n",index);
	if(index >=0)
		YTSF_CMD_Tx(CMD_LIST[index][1],CMD_LIST[index][2],CMD_LIST[index][3],CMD_LIST[index][4],CMD_LIST[index][5]);
	
	TIMDelay_Nms(500);
	*/
	returncode = 0;
	return returncode;
}

/********************************
命令使能，通过索引寻址
********************************/
int16_t Set_CMD_Enable_ByIndex(uint16_t index)
{
	if(index >= MAX_CMD_LIST) 
		return -1;
	CMD_LIST[index][0] = CMD_en;
	return 0;
}

/********************************
命令去使能，通过索引寻址
********************************/
int16_t ReSet_CMD_Enable_ByIndex(uint16_t index)
{
	if(index >= MAX_CMD_LIST) 
		return -1;
	CMD_LIST[index][0] = CMD_dn;
	return 0;
}


/********************************
命令使能，通过参数寻址
********************************/
int16_t Set_CMD_Enable_ByParm(uint8_t port,uint8_t gun,uint8_t instruct,uint8_t type)
{
	uint16_t i=0;
	for(i=0;i<MAX_CMD_LIST;i++)
	{
		if((CMD_LIST[i][2] == port)&&(CMD_LIST[i][3] == gun)&&(CMD_LIST[i][4] == instruct)&&(CMD_LIST[i][5] == type))
			CMD_LIST[i][0] = CMD_en;
	}
	return i;
}
/********************************
命令去使能，通过参数寻址
********************************/
int16_t ReSet_CMD_Enable_ByParm(uint8_t port,uint8_t gun,uint8_t instruct,uint8_t type)
{
	uint16_t i=0;
	for(i=0;i<MAX_CMD_LIST;i++)
	{
		if((CMD_LIST[i][2] == port)&&(CMD_LIST[i][3] == gun)&&(CMD_LIST[i][4] == instruct)&&(CMD_LIST[i][5] == type))
			CMD_LIST[i][0] = CMD_dn;
	}
	return i;
}

/********************************
命令使能，通过端口寻址
********************************/
int16_t Set_CMD_Enable_ByPort(uint8_t port)
{
	uint16_t i=0;
	for(i=0;i<MAX_CMD_LIST;i++)
	{
		if(CMD_LIST[i][2] == port)
			CMD_LIST[i][0] = CMD_en;
	}
	return i;
}
/********************************
命令去使能，通过端口寻址
********************************/
int16_t ReSet_CMD_Enable_ByPort(uint8_t port)
{
	uint16_t i=0;
	for(i=0;i<MAX_CMD_LIST;i++)
	{
		if(CMD_LIST[i][2] == port)
			CMD_LIST[i][0] = CMD_dn;
	}
	return i;
}

/********************************
命令使能，通过端口及枪号寻址
********************************/
int16_t Set_CMD_Enable_ByGun(uint8_t port,uint8_t gun)
{
	uint16_t i=0;
	for(i=0;i<MAX_CMD_LIST;i++)
	{
		if((CMD_LIST[i][2] == port)&&(CMD_LIST[i][3] == gun))
			CMD_LIST[i][0] = CMD_en;
	}
	return i;
}

/********************************
命令去使能，通过端口及枪号寻址
********************************/
int16_t ReSet_CMD_Enable_ByGun(uint8_t port,uint8_t gun)
{
	uint8_t i=0;
	for(i=0;i<MAX_CMD_LIST;i++)
	{
		if((CMD_LIST[i][2] == port)&&(CMD_LIST[i][3] == gun))
			CMD_LIST[i][0] = CMD_dn;
	}
	return i;
}

/********************************
获取索引，通过参数寻址
********************************/
int16_t Get_CMD_Index_ByParm(uint8_t port,uint8_t gun,uint8_t instruct,uint8_t type)
{
	uint8_t i =0;
	
	for(i=0;i<MAX_CMD_LIST;i++)
	{
		if((CMD_LIST[i][2]==port)&&(CMD_LIST[i][3]==gun)&&(CMD_LIST[i][4]==instruct)&&(CMD_LIST[i][5]==type))
			return i;
	}
	
	YTSF_DEBUG1("port=%d,gun=%d,instruct=%d,type=%d\r\n",port,gun,instruct,type);
	return -1;
}
/************************************************
函数名称 ： Get_Ytsf_CMD_A1
功    能 ： 发送命令
参    数 ： cmd				命令指针
						size			命令长度
						port			端口
						type			命令类型
						gun				抢号
						parameter	参数
返 回 值 ： 无
作    者 ： scx
*************************************************/
int8_t Get_Ytsf_CMD(uint8_t size,uint8_t port,uint8_t gun,uint8_t instruct,uint8_t type){

	uint8_t i=0;
//	uint8_t j=0;
	uint8_t sum_check=0;
	uint8_t temp=0;
	uint8_t index=0;
	uint16_t crc=0;
	uint8_t *cmd=Ytsf_CMD_BUF;
//	uint8_t tbuf[128];
//	uint8_t tlen=0;

	//0xa1	累计数读取指令
	//0xa2	油机信息读取指令
	//0xa5	模块操作指令
	//0xaf	中转指令
	
	switch(instruct){
		case Ytsf_CMD_INSTRUCT_A1:
			index = 0;
			if(size!=Ytsf_CMD_A1_SIZE)
				return YTSF_CMD_ERROR_LEN;//帧长度错误.
			
			if(cmd==NULL)
				return YTSF_CMD_ERROR_CMD;//指令指针为空.
			
			if((type==Ytsf_CMD_TYPE_11)|(type==Ytsf_CMD_TYPE_12)|(type==Ytsf_CMD_TYPE_13)|(type==Ytsf_CMD_TYPE_14)|(type==Ytsf_CMD_TYPE_20))
			{
				index=0;
			}
			else{
				return YTSF_CMD_ERROR_TYPE;//累计类型错误
				}
			
			cmd[index++]=0xbb;							//前导码，固定0xbb
			cmd[index++]=size-2;						//帧长度
			cmd[index++]=0x81;							//帧号,单帧固定0x81
			cmd[index++]=port;							//端口号，税控口号
			cmd[index++]=instruct;					//指令码
			cmd[index++]=type;							//类型码
			cmd[index++]=gun;								//枪号
			if((type==0x11)|(type==0x14))
			{
				cmd[index++]=0x00;						//操作参数
				cmd[index++]=0x00;
				cmd[index++]=0x00;
				cmd[index++]=0x00;
			}
			
			else if(type==0x20)
			{
				cmd[index++]=0x01;						//操作参数
				cmd[index++]=0x00;
				cmd[index++]=0x00;
				cmd[index++]=0x00;
			}
			else
			{
				cmd[index++]=Ytsf_CMD_PARM[0];		//操作参数
				cmd[index++]=Ytsf_CMD_PARM[1];
				cmd[index++]=Ytsf_CMD_PARM[2];
				cmd[index++]=Ytsf_CMD_PARM[3];
			}
			temp = 0;
			for(i=0;i<5;i++){
				if((mDevice.port[port].mntr_sn[i]==0)|(mDevice.port[port].mntr_sn[i]==0xff))
					temp++;
			}
			if(temp>=5)
				return YTSF_CMD_ERROR_SN;
				
			cmd[index++]=mDevice.port[port].mntr_sn[0];			//监控序列号
			cmd[index++]=mDevice.port[port].mntr_sn[1];			//监控序列号
			cmd[index++]=mDevice.port[port].mntr_sn[2];			//监控序列号
			cmd[index++]=mDevice.port[port].mntr_sn[3];			//监控序列号
			cmd[index++]=mDevice.port[port].mntr_sn[4];			//监控序列号
			
			crc = GetCRC16(cmd,size-2);
			
			cmd[index++]=crc>>8;						//crc16校验，
			cmd[index++]=crc>>0;
			break;
		case Ytsf_CMD_INSTRUCT_A2:
			index = 0;
			if(size!=Ytsf_CMD_A2_SIZE)
				return YTSF_CMD_ERROR_LEN;//帧长度错误.
			
			if(cmd==NULL)
				return YTSF_CMD_ERROR_CMD;//指令指针为空.
			
			if((type==Ytsf_CMD_TYPE_00)|(type==Ytsf_CMD_TYPE_01)|(type==Ytsf_CMD_TYPE_02)|(type==Ytsf_CMD_TYPE_10)|(type==Ytsf_CMD_TYPE_11)|(type==Ytsf_CMD_TYPE_20)|(type==Ytsf_CMD_TYPE_21))
			{
				index=0;
			}
			else{
				return YTSF_CMD_ERROR_TYPE;//信息类型错误
				}
			cmd[index++]=0xbb;							//前导码，固定0xbb
			cmd[index++]=size-2;						//帧长度
			cmd[index++]=0x81;							//帧号,单帧固定0x81
			cmd[index++]=port;							//端口号，税控口号
			cmd[index++]=instruct;					//指令码
			cmd[index++]=type;							//类型码
			cmd[index++]=gun;								//枪号
			
			cmd[index++]=0x00;							//操作参数
			cmd[index++]=0x00;
			cmd[index++]=0x00;
			cmd[index++]=0x00;
			
			cmd[index++]=0x00;							//预留参数		
			cmd[index++]=0x00;							//预留参数
			
			crc = GetCRC16(cmd,size-2);
			
			cmd[index++]=crc>>8;						//crc16校验，
			cmd[index++]=crc>>0;
			break;
			
		case Ytsf_CMD_INSTRUCT_A5:
			index = 0;
			if(cmd==NULL)
				return YTSF_CMD_ERROR_CMD;//指令指针为空.
			
			if((type==0x00)|(type==0xff))
			{
				if(size!=8)
					return YTSF_CMD_ERROR_LEN;									//帧长度错误.
			}
			
			if(type==0x01)
			{
				if(size!=9)
					return YTSF_CMD_ERROR_LEN;									//帧长度错误.
			}
			
			
			if((type==Ytsf_CMD_TYPE_00)|(type==Ytsf_CMD_TYPE_01)|(type==Ytsf_CMD_TYPE_FF))
			{
				index=0;
			}
			else{
				return YTSF_CMD_ERROR_TYPE;//操作类型错误
				}
			
			cmd[index++]=0xbb;							//前导码，固定0xbb
			cmd[index++]=size-2;						//帧长度
			cmd[index++]=0x81;							//帧号,单帧固定0x81
			cmd[index++]=port;							//端口号，税控口号
			cmd[index++]=instruct;					//指令码
			cmd[index++]=type;							//类型码
			
			
			if(type==0x01)
			{
				cmd[index++]=0x00;							//0x00读,0x01写
				/*
				cmd[index++]=Ytsf_CMD_PARM[1];							//时间
				cmd[index++]=Ytsf_CMD_PARM[2];							//时间
				cmd[index++]=Ytsf_CMD_PARM[3];							//时间
				cmd[index++]=Ytsf_CMD_PARM[4];							//时间
				cmd[index++]=Ytsf_CMD_PARM[5];							//时间
				cmd[index++]=Ytsf_CMD_PARM[6];							//时间
				cmd[index++]=Ytsf_CMD_PARM[7];							//时间
				*/
			}
			crc = GetCRC16(cmd,size-2);
			cmd[index++]=crc>>8;						//crc16校验，
			cmd[index++]=crc>>0;
			break;
		case 0x83:
			index = 0;
			if(cmd==NULL)
				return YTSF_CMD_ERROR_CMD;//指令指针为空.
			
			if(size!=6)
				return YTSF_CMD_ERROR_LEN;									//帧长度错误.
			
			cmd[index++]=0xbb;							//前导码，固定0xbb
			cmd[index++]=size-2;						//帧长度
			cmd[index++]=0xff;							//帧号,
			cmd[index++]=0x83;							//指令码
			cmd[index++]=0x00;					    //参数，枪号
      
			for(i=2;i<index;i++){
        sum_check ^=cmd[i];
      }
      cmd[index++] = sum_check;       //和校验
      
			break;
		case 0x86:
			index = 0;
			if(cmd==NULL)
				return YTSF_CMD_ERROR_CMD;//指令指针为空.
			
			if(size!=7)
				return YTSF_CMD_ERROR_LEN;									//帧长度错误.
			
			cmd[index++]=0xbb;							//前导码，固定0xbb
			cmd[index++]=size-2;						//帧长度
			cmd[index++]=0xff;							//帧号,
			cmd[index++]=0x86;							//指令码
			cmd[index++]=gun;					      //参数，枪号
			cmd[index++]=0x01;					    //return_method，01明文输出
      
			for(i=2;i<index;i++){
        sum_check ^=cmd[i];
      }
      cmd[index++] = sum_check;       //和校验
      
			break;
		case 0x89:
			index = 0;
			if(cmd==NULL)
				return YTSF_CMD_ERROR_CMD;//指令指针为空.
			
			if(size!=8)
				return YTSF_CMD_ERROR_LEN;									//帧长度错误.
			
			cmd[index++]=0xbb;							//前导码，固定0xbb
			cmd[index++]=size-2;						//帧长度
			cmd[index++]=0xff;							//帧号,
			cmd[index++]=0x86;							//指令码
			cmd[index++]=gun;					      //参数，枪号
			cmd[index++]=0x00;					    //mode,0x00累计加油,0x01出厂调试用油量,0x02剂量后油量
			cmd[index++]=0x01;					    //return_method，0x01明文输出
      
			for(i=2;i<index;i++){
        sum_check ^=cmd[i];
      }
      
      cmd[index++] = sum_check;       //和校验
      
			break;
		default:
			return YTSF_CMD_ERROR_CMD;
	}
	return index;
}

/************************************************
函数名称 ： YTSF_CMD_Tx_A1
功    能 ： 发送命令
参    数 ： cmd				命令指针
						size			命令长度
						port			端口
						type			命令类型
						gun				抢号
						parameter	参数
返 回 值 ： 无
作    者 ： scx
*************************************************/

uint8_t YTSF_CMD_Tx(uint8_t size,uint8_t port,uint8_t gun,uint8_t instruct,uint8_t type){
	
	int8_t cmd_l=0;
//	uint8_t sout[64]={0};
//	uint8_t lout=0;
//	uint8_t tmp=0;
//	uint16_t i=0;
	//uint8_t result=0;
	
//cmd_l=Get_Ytsf_CMD(Ytsf_CMD_A2_SIZE,Ytsf_PORT_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_00,Ytsf_GUN_NUM_0);
	cmd_l=Get_Ytsf_CMD(size,port,gun,instruct,type);
	
	if(cmd_l<0)
		switch(cmd_l){
			case YTSF_CMD_ERROR_CMD:
				YTSF_DEBUG1("YTSF_CMD_ERROR_CMD\r\n");
				break;
			case YTSF_CMD_ERROR_LEN:
				YTSF_DEBUG1("YTSF_CMD_ERROR_LEN\r\n");
				break;
			case YTSF_CMD_ERROR_TYPE:
				YTSF_DEBUG1("YTSF_CMD_ERROR_TYPE\r\n");
				break;
			case YTSF_CMD_ERROR_SN:
				YTSF_DEBUG1("YTSF_CMD_ERROR_SN\r\n");
				break;
			
			default:
				break;
	}
	
	if(cmd_l < 0)
		YTSF_DEBUG1("YTSF SEND CMD,获取发送指令失败\r\n");
	else if(cmd_l < 100)
	{
		YTSF_DEBUG1("YTSF SEND CMD=");
		YTSF_DEBUG2(Ytsf_CMD_BUF,cmd_l);
	}
	else
		YTSF_DEBUG1("YTSF SEND CMD,指令长达太长，>100.\r\n");
		
	
	
			
	if(cmd_l>0)
	{
		UART4_SendNByte(Ytsf_CMD_BUF,cmd_l);
		if(port==0){
			YTSF_PORT0_Send_CNT++;
			YTSF_PORT0_Send_Delay = TickCounter;
      start_led(2,cmd_l,10,30*10);//(led,delay*0.1ms,duty,period*0.1ms)
		}
		if(port==1){
			YTSF_PORT1_Send_CNT++;
			YTSF_PORT1_Send_Delay = TickCounter;
      start_led(3,cmd_l,10,30*10);//(led,delay*0.1ms,duty,period*0.1ms)
		}
	}
	
	
	return 0;
}
/*

uint8_t Ytsf_CMD_polling(void){
	uint8_t i =0;
	
	if(CMD_LIST[CMD_LIST_polling][0]!=CMD_en)
	{
		for(i=0;i<MAX_CMD_LIST;i++)
		{
			if(CMD_LIST[(i+CMD_LIST_polling+1) % MAX_CMD_LIST][0]==CMD_dn) 
			{
				continue;
			}else{
				CMD_LIST_polling=(i+CMD_LIST_polling+1) % MAX_CMD_LIST;
				break;
			}
		}
	}

	if(CMD_LIST[CMD_LIST_polling][0]==CMD_en)
	{
		YTSF_DEBUG("\r\n\r\n");
		YTSF_DEBUG1("CMD_LIST_polling=%d\r\n",CMD_LIST_polling);
		//YTSF_CMD_Tx(Ytsf_CMD_A2_SIZE,		Ytsf_PORT_0,		Ytsf_GUN_NUM_0,				Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_00);
		YTSF_CMD_Tx(CMD_LIST[CMD_LIST_polling][1],CMD_LIST[CMD_LIST_polling][2],CMD_LIST[CMD_LIST_polling][3],CMD_LIST[CMD_LIST_polling][4],CMD_LIST[CMD_LIST_polling][5]);
	}
	CMD_LIST_polling++;
	CMD_LIST_polling%=MAX_CMD_LIST;
	
	return CMD_LIST_polling;
}

*/

uint8_t Ytsf_CMD_polling_port(uint8_t mport){
	uint8_t i =0;
	uint16_t *poll;
  if(mport == Ytsf_PORT_0){
    poll = &CMD_LIST_polling_port0;
  }

  if(mport == Ytsf_PORT_1){
    poll = &CMD_LIST_polling_port1;
  }
  
	YTSF_DEBUG1("Ytsf_CMD_polling_port mport=%d,poll=%d.\r\n",mport,*poll);
  
	if(CMD_LIST[*poll][0]!=CMD_en)
	{
		for(i=0;i<MAX_CMD_LIST;i++)
		{
			if((CMD_LIST[(i+*poll+1) % MAX_CMD_LIST][0]!=CMD_en) || (CMD_LIST[(i+*poll+1) % MAX_CMD_LIST][2]!=mport))
			{
				continue;
			}else{
				*poll=(i+*poll+1) % MAX_CMD_LIST;
				break;
			}
		}
	}

	if((CMD_LIST[*poll][0]==CMD_en)&&(CMD_LIST[*poll][2]==mport))
	{
		YTSF_DEBUG("\r\n\r\n");
		YTSF_DEBUG1("CMD port[%d] index =%d\r\n",mport,*poll);
		//YTSF_CMD_Tx(Ytsf_CMD_A2_SIZE,		Ytsf_PORT_0,		Ytsf_GUN_NUM_0,				Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_00);
		YTSF_CMD_Tx(CMD_LIST[*poll][1],CMD_LIST[*poll][2],CMD_LIST[*poll][3],CMD_LIST[*poll][4],CMD_LIST[*poll][5]);
	}
	*poll = *poll +1;
	*poll = *poll % MAX_CMD_LIST;
	
	return *poll;
}





/************************************************
函数名称 ： GetYtsfStatus
功    能 ： 获取英泰赛福状态
参    数 ： 无
返 回 值 ： 无
作    者 ： scx
*************************************************/
uint8_t GetYtsfStatus(void){
	return 0;
}


/************************************************
函数名称 ： GetYtsfStatus
功    能 ： 获取英泰赛福状态
参    数 ： 无
返 回 值 ： crc
作    者 ： scx
*************************************************/
uint16_t GetCRC16(uint8_t *_buff,uint32_t _len)
{
    uint32_t i,j;
    uint16_t crc;
    uint16_t temp;

    crc=(uint16_t)CRC_INIT_VALUE;
    for(i=0;i<_len;i++)
    {
        temp=_buff[i];
        temp &=0x00FF;
        crc^=temp;

        for(j=0;j<8;j++)
        {
            if((crc&0x0001)!=0x00)
            {
                crc>>=1;
                crc^=0xA001;
            }
            else
            {
                crc>>=1;
            }
        }
    }
 
		//printf("%x   " ,crc);
    return crc;
}

int8_t Ytsf_CMD_Analysis2(tYTSFRxFrame_t *frame,uint8_t *sbuf,uint8_t slen){
	
	int8_t ReturnCode = -1;
	uint16_t scrc=0x0000;
	uint8_t tbuf[128];
	uint8_t tlen = 0;
	int16_t i=0;
	
	YTSF_DEBUG1("Rev len=%d,CMD=",slen);
	YTSF_DEBUG2(sbuf,slen);
	
	if(sbuf==NULL)
	{
		YTSF_DEBUG1("error:tbuf==NULL\r\n");
		return ReturnCode;
	}
  //帧中除了帧头为 BB 外，不再出现 BB，如果出现 BB 则转义为BA 01；如果出现 BA 则转义为 BA 00；帧长度和校验码都按转义前来计算。
  //检查0xba 0x00，并替换为0xba
  tlen = 0;
  for(i = 0;i < slen - 1; i ++){
    if((sbuf[i] == 0xba) && (sbuf[i+1] == 0x00)){
      tbuf[tlen++] = 0xba;
      i++;
    }
    else{
      tbuf[tlen++] = sbuf[i];
    }
  }
  if(!((sbuf[slen-2] == 0xba) && (sbuf[slen-1] == 0x00))){
    tbuf[tlen++] = sbuf[i];
  }
  
  //检查0xba 0x01，并替换为0xbb
  slen = 0;
  for(i = 0;i < tlen - 1; i ++){
    if((tbuf[i] == 0xba) && (tbuf[i+1] == 0x01)){
      sbuf[slen++] = 0xbb;
      i++;
    }
    else{
      sbuf[slen++] = tbuf[i];
    }
  }
  if(!((tbuf[tlen-2] == 0xba) && (tbuf[tlen-1] == 0x01))){
    sbuf[slen++] = tbuf[i];
  }
  
	//帧头(1Byte)
	frame->fhead = sbuf[0];
	if(frame->fhead!=0xbb)
	{
		YTSF_DEBUG1("error:frame->fhead != 0xbb,fhead=0x%02X\r\n",frame->fhead);
		return ReturnCode;
	}
	//帧长度(1Byte)
	frame->flen = sbuf[1];
	if(frame->flen>32)
	{
		YTSF_DEBUG1("error:len > 32,frame->flen=0x%02X\r\n",frame->flen);
		return ReturnCode;
	}

	if(frame->flen!=slen-2)
	{
		YTSF_DEBUG1("error:frame->flen!=slen-2,frame->flen=0x%02X,slen=0x%02X\r\n",frame->flen,slen);
		return ReturnCode;
	}
	//CRC校验(2Byte)
	frame->fcrc = GetCRC16(sbuf,frame->flen);
	scrc = (sbuf[frame->flen]<<8 | sbuf[frame->flen+1]);
	if(frame->fcrc != scrc)
	{
		YTSF_DEBUG1("error:crc error!,frame->fcrc=0x%04X,scrc=0x%04X\r\n",frame->fcrc,scrc);
		return ReturnCode;
	}
	//税控口编号(1Byte)，0税控口1，1税控口2
	frame->fport 		= sbuf[3];
	frame->fcmd 		= sbuf[4];
	frame->ftype 		= sbuf[5];
	//start_led(frame->fport+2,slen,99,10*10);//(led,delay*0.1ms,duty,period*0.1ms)
  
	//枪号
	if(frame->fcmd == Ytsf_CMD_INSTRUCT_A1)
		frame->fgun		= sbuf[6];
	else if(frame->fcmd == Ytsf_CMD_INSTRUCT_A2)
		frame->fgun		= sbuf[6];
	else
		frame->fgun		= 0x00;
	mDevice.port[frame->fport].gun_index = frame->fgun;
	//读取结果
	     if(frame->fcmd == Ytsf_CMD_INSTRUCT_A1)
		frame->fresult		= sbuf[7];
	else if(frame->fcmd == Ytsf_CMD_INSTRUCT_A2)
		frame->fresult		= sbuf[7];
	else if(frame->fcmd == Ytsf_CMD_INSTRUCT_A5)
		frame->fresult		= sbuf[6];
	else
		frame->fresult		= 0xff;
		
	switch(frame->fresult){
		case	0x00:YTSF_DEBUG1("指令执行错误\r\n");break;
		case	0x01:YTSF_DEBUG1("指令执行成功\r\n");break;
		case	0x02:YTSF_DEBUG1("数据模块忙，稍后再试\r\n");break;
		case	0x03:YTSF_DEBUG1("监控微处理器忙，稍后再试\r\n");break;
		case	0x04:YTSF_DEBUG1("监控微处理器通讯超时，超时时间设定为10秒\r\n");break;
		case	0x05:YTSF_DEBUG1("查询的记录不存在\r\n");break;
		case	0x10:YTSF_DEBUG1("监控微处理器序列号不存在\r\n");break;
		case	0x11:YTSF_DEBUG1("密文数据解密错误\r\n");break;
		default :break;
	}
	
	
	if(frame->fresult!=0x01){
		mDevice.port[frame->fport].zlj_state=0;
		return ReturnCode;
	}
	
	
	//读取数据(NByte)
	if(frame->fcmd == Ytsf_CMD_INSTRUCT_A1){
		frame->fldata = slen-10;
		memcpy(frame->fdata,sbuf+8,slen-10);
	}
	else if(frame->fcmd == Ytsf_CMD_INSTRUCT_A2){
		frame->fldata = slen-10;
		memcpy(frame->fdata,sbuf+8,slen-10);
	}
	else if(frame->fcmd == Ytsf_CMD_INSTRUCT_A5){
		frame->fldata = slen-9;
		memcpy(frame->fdata,sbuf+7,slen-9);
	}
	else{
		//frame->fldata = 0xff;
		//memset(frame->fdata,0xff,32);
	}
	
	
	YTSF_DEBUG1("frame:\r\n");
	YTSF_DEBUG("frame->fhead=0x%02X\r\n",frame->fhead);
	YTSF_DEBUG("frame->flen=0x%02X\r\n",frame->flen);
	YTSF_DEBUG("frame->findex=0x%02X\r\n",frame->findex);
	YTSF_DEBUG("frame->fport=0x%02X\r\n",frame->fport);
	YTSF_DEBUG("frame->fcmd=0x%02X\r\n",frame->fcmd);
	YTSF_DEBUG("frame->ftype=0x%02X\r\n",frame->ftype);
	if(frame->fgun!=0xff)
		YTSF_DEBUG("frame->fgun=0x%02X\r\n",frame->fgun);
	if(frame->fresult!=0xff)
	YTSF_DEBUG("frame->fresult=0x%02X\r\n",frame->fresult);
	
	YTSF_DEBUG("frame->fldata=0x%02X,frame->fdata=",frame->fldata);
	if(frame->fldata!=0xff){
		YTSF_DEBUG2(frame->fdata,frame->fldata);
		//YTSF_DEBUG("\r\n");
	}
	YTSF_DEBUG("frame->fcrc=0x%04X\r\n",frame->fcrc);
	
	if((frame->fcmd == Ytsf_CMD_INSTRUCT_A2)||(frame->ftype == Ytsf_CMD_TYPE_00)){
	
		if((frame->fdata[5] >= '0') && (frame->fdata[5] <= '8') ){
      mDevice.port[frame->fport].mntr_factory = 1;
			YTSF_DEBUG1("税控口%d,芯片厂家为：英泰赛福\r\n",frame->fport);
    }
		if((frame->fdata[5] >= 'A') && (frame->fdata[5] <= 'H') ){
      mDevice.port[frame->fport].mntr_factory = 2;
			YTSF_DEBUG1("税控口%d,芯片厂家为：拓盛\r\n",frame->fport);
    }
      
    switch(frame->fdata[5]){
      case '0':
      case '1':
      case 'A':
      case 'a':
        mDevice.port[frame->fport].gun_max = 1;
        break;
      case '2':
      case '3':
      case 'B':
      case 'b':
        mDevice.port[frame->fport].gun_max = 2;
        break;
      case 'C':
      case 'c':
        mDevice.port[frame->fport].gun_max = 3;
        break;
      case '4':
      case 'D':
      case 'd':
        mDevice.port[frame->fport].gun_max = 4;
        break;
      case '6':
      case 'F':
      case 'f':
        mDevice.port[frame->fport].gun_max = 6;
        break;
      case '8':
      case 'H':
      case 'h':
        mDevice.port[frame->fport].gun_max = 8;
        break;
      default:
        mDevice.port[frame->fport].gun_max = 1;
        break;
        
    }
    
    for(i=0;i<(mDevice.port[frame->fport].gun_max);i++){
      Set_CMD_Enable_ByParm(frame->fport,i,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14);
    }
    
    for(i=0;i<(sizeof(CMD_LIST)/sizeof(CMD_LIST[0])-1);i++)
    {
      if((CMD_LIST[i][2]==frame->fport)&&(CMD_LIST[i][3]>mDevice.port[frame->fport].gun_max))
        CMD_LIST[i][0]=CMD_dn;
    };
	}
	
	if((frame->fcmd == Ytsf_CMD_INSTRUCT_A1) || (frame->fcmd == Ytsf_CMD_INSTRUCT_A2)){
    //接收帧，按端口分开
    memcpy(&YTSF_rx_frame_port[frame->fport],frame,sizeof(tYTSFRxFrame_t));
  }
	if((frame->fcmd == Ytsf_CMD_INSTRUCT_A1) && (frame->ftype == Ytsf_CMD_TYPE_14)){
    //接收帧，按端口分开
     YTSF_SET_STATE_port(frame->fport,YTSF_STATE_GUN_GET_ZongLeiJi_INIT,STATE_M_MODE_FORCE);
  }
  
	if((frame->fcmd == Ytsf_CMD_INSTRUCT_A1) && (frame->ftype == Ytsf_CMD_TYPE_11)){
    //接收帧，按端口分开
    memcpy(mDevice.port[frame->fport].dangci_frame,sbuf,slen);
    mDevice.port[frame->fport].dangci_lframe = slen;
    YTSF_SET_STATE_port(frame->fport,YTSF_STATE_GUN_GET_DangCi_INIT,STATE_M_MODE_FORCE);
  }
  
	if((frame->fcmd == Ytsf_CMD_INSTRUCT_A5) && (frame->ftype == Ytsf_CMD_TYPE_00)){
    memcpy(mDevice.ytsf_id,frame->fdata,frame->fldata);
		YTSF_DEBUG1("获取英泰赛福模块ID正常，mDevice.ytsf_id=");
		YTSF_DEBUG2(mDevice.ytsf_id,12);
  }
  
  
	ReturnCode = frame->fport;
	return ReturnCode;
}

uint8_t YTSF_GET_STATE(void){
	return mYTSF_state;
}

uint8_t YTSF_SET_STATE(uint8_t s){
	
	if(YTSF_GET_STATE()==YTSF_STATE_IDLE){
		mYTSF_state = s;
		return 0;
	}
	return 1;
}


int16_t YTSF_SET_STATE_port(uint8_t mport,uint8_t s,uint8_t mode){
  static uint8_t status[2][8]={YTSF_STATE_IDLE};
  static uint8_t front=sizeof(status[0]);
  static uint8_t rear=sizeof(status[0]);
  static uint8_t sum=0;
  
	uint8_t f=0;
	uint8_t r=0;
  if((mport != 0)&&(mport != 1))
    return -1;
  
  if(mode == STATE_M_MODE_INIT){                                      //初始化队列
    front=sizeof(status[0]);
    rear=sizeof(status[0]);
    sum=0;
    memset(status,YTSF_STATE_IDLE,sizeof(status));
    return 0;
  }
  
  if(mode == STATE_M_MODE_En){                                      //mode=1入队列(队尾写入)
    if(sum==sizeof(status[0])){ 				                //满队列判断
      return -1;
    }
    r = (rear+1) % (sizeof(status[0]));               //循环存储
    status[mport][r] = s;
    rear = r;     								                    //更新入队标记
    sum++;              //更新总数标记
    return s;
  }
  
  if((mode == STATE_M_MODE_De)&&(mDevice.port[mport].state_m == YTSF_STATE_IDLE)){//mode=2出队列(队首读取)
    if(sum==0){ 				                              //空队列判断
      mDevice.port[mport].state_m = YTSF_STATE_IDLE;
      return -1;
    }
    f = (front+1) % (sizeof(status[0]));              //循环存储
    mDevice.port[mport].state_m = status[mport][f];   //读取队首值
    
    front = f;										                    //更新出队标记
    sum--;     		      //更新总数标记
    return status[mport][f];
  }
  return -1;
  
}


uint8_t YTSF_SN_Compare(uint8_t mport,tDevice_t *device,tYTSFRxFrame_t *frame){
	int8_t i=0;
	for(i=0;i<5;i++){
		if(device->port[mport].mntr_sn[i]!=frame->fdata[i]){
			return 1;
		}
	}
	return 0;
}

uint8_t YTSF_SN_Update(tDevice_t *device,tYTSFRxFrame_t *frame){
	int8_t i=0;
	
	for(i=0;i<5;i++){
		device->port[frame->fport].mntr_sn[i]=frame->fdata[i];
	}
	
	if(frame->fport == Ytsf_PORT_0){
		EE_WriteVariable(CURSET_YTSF_PORT0_SN0,           (frame->fdata[5]<<8)+(frame->fdata[0]));
		EE_WriteVariable(CURSET_YTSF_PORT0_SN1,           (frame->fdata[1]<<8)+(frame->fdata[2]));
		EE_WriteVariable(CURSET_YTSF_PORT0_SN2,           (frame->fdata[3]<<8)+(frame->fdata[4]));
		
		/*
		
		for(i=0;i<(sizeof(CMD_LIST)/sizeof(CMD_LIST[0])-1);i++)
		{
			if((CMD_LIST[i][2]==Ytsf_PORT_0)&&(CMD_LIST[i][3]>Port0_GunTotal))
				CMD_LIST[i][0]=CMD_dn;
		};
		*/
		
	}
	if(frame->fport == Ytsf_PORT_1){
		EE_WriteVariable(CURSET_YTSF_PORT1_SN0,           (frame->fdata[5]<<8)+(frame->fdata[0]));
		EE_WriteVariable(CURSET_YTSF_PORT1_SN1,           (frame->fdata[1]<<8)+(frame->fdata[2]));
		EE_WriteVariable(CURSET_YTSF_PORT1_SN2,           (frame->fdata[3]<<8)+(frame->fdata[4]));
	}
	
	if((frame->fdata[5] >= '0') && (frame->fdata[5] <= '8') )
		YTSF_DEBUG1("税控口%d,芯片厂家为：英泰赛福\r\n",frame->fport);
	if((frame->fdata[5] >= 'A') && (frame->fdata[5] <= 'H') )
		YTSF_DEBUG1("税控口%d,芯片厂家为：拓盛\r\n",frame->fport);
	
	
	switch(frame->fdata[5]){
		case '0':
		case '1':
		case 'A':
		case 'a':
			device->port[frame->fport].gun_max = 1;
			break;
		case '2':
		case '3':
		case 'B':
		case 'b':
			device->port[frame->fport].gun_max = 2;
			break;
		case 'C':
		case 'c':
			device->port[frame->fport].gun_max = 3;
			break;
		case '4':
		case 'D':
		case 'd':
			device->port[frame->fport].gun_max = 4;
			break;
		case '6':
		case 'F':
		case 'f':
			device->port[frame->fport].gun_max = 6;
			break;
		case '8':
		case 'H':
		case 'h':
			device->port[frame->fport].gun_max = 8;
			break;
		default:
			device->port[frame->fport].gun_max = 1;
			break;
			
	}
	
	for(i=0;i<(device->port[frame->fport].gun_max);i++){
		Set_CMD_Enable_ByParm(frame->fport,i,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_14);
	}
	
	for(i=0;i<(sizeof(CMD_LIST)/sizeof(CMD_LIST[0])-1);i++)
	{
		if((CMD_LIST[i][2]==frame->fport)&&(CMD_LIST[i][3]>=device->port[frame->fport].gun_max))
			CMD_LIST[i][0]=CMD_dn;
	};
	
	
	return 0;
}



uint8_t YTSF_CreateMsg_0D(uint8_t mport,tDevice_t *device,tYTSFRxFrame_t *frame,uint8_t *fbuf,uint8_t flen){
	uint16_t index=0;
//	uint16_t temp=0;
	uint8_t check=0;
	uint16_t i=0;
	YTSF_DEBUG1(\
	"deviceReg->port=0x%02X,frame->fport=0x%02X,deviceg->gun=0x%02X,frame->fgun=0x%02X\r\n",\
	frame->fport,frame->fport,device->port[mport].gun_index,frame->fgun);
	if((mport == frame->fport)&&(device->port[mport].gun_index == frame->fgun)){

		device->port[mport].lora_send_msg[index++]=0xFF;			//UDP帧头
		device->port[mport].lora_send_msg[index++]=0xEE;
		device->port[mport].lora_send_msg[index++]=0x00;			//UDP长度(2B)
		device->port[mport].lora_send_msg[index++]=0x00;
		
		device->port[mport].lora_send_msg[index++]=0x0D;      //消息类型
			
		device->port[mport].lora_send_msg[index++]=(device->device_id >> 0)&0xff;//0x4A;			//主板号设备ID(4B),比如01 02 03 04
		device->port[mport].lora_send_msg[index++]=(device->device_id >> 8)&0xff;//0x27;
		device->port[mport].lora_send_msg[index++]=(device->device_id >>16)&0xff;//0x00;
		device->port[mport].lora_send_msg[index++]=(device->device_id >>24)&0xff;//0x00;
		
		
		device->port[mport].lora_send_msg[index++]=mport;			//UDP消息内容，借用通道号的字段(1B),(高4位表示通道编号，第3位表示通道总数，如0x46，意思是共6个通道，本设备编号为第4个通道。
		device->port[mport].lora_send_msg[index++]=device->port[mport].gun_index;//0x01;			//UDP消息内容，枪号(1B)
		
    device->port[mport].lora_send_msg[index++]=device->ytsf_state;//标记加密版还是非加密版，0非加密，1加密（带英泰赛福）
    
    
    //
    if(device->ytsf_state){                                       //加密（带英泰赛福）
      //总累计，油量7字节，金额7字节
      for(i=0;i<14;i++){
        device->port[mport].lora_send_msg[index++]=device->port[mport].gun[device->port[mport].gun_index].ZongLeiJi[i];
      }
      
      //当次加油信息，数据格式来自英泰赛福
      for(i=0;i<flen;i++){
        device->port[mport].lora_send_msg[index++]=fbuf[i];
      }
      //和校验
      device->port[mport].lora_send_msg[index++] = 0x00;
      
      device->port[mport].lora_send_lmsg = index;
      
      //计算UDP帧，帧长度
      device->port[mport].lora_send_msg[2] = ((index-5) >> 0) & 0xff;
      device->port[mport].lora_send_msg[3] = ((index-5) >> 8) & 0xff;
      
      
      check = 0x00;
      //UDP，校验和
      for(i=0;i<index-1;i++)
        {
          check = check ^ device->port[mport].lora_send_msg[i];
        }
      device->port[mport].lora_send_msg[index-1] = check;
      
      YTSF_DEBUG1("UDP_0D_frame=\r\n");
      for(i=0;i<index;i++)
        YTSF_DEBUG("%02X",device->port[mport].lora_send_msg[i]);
      YTSF_DEBUG("\r\n");
        
      YTSF_DEBUG1("\r\n端口号=%d",mport);
      YTSF_DEBUG("枪号=%d\r\n",device->port[mport].gun_index);
      YTSF_DEBUG("总油量=");
      YTSF_DEBUG2(device->port[mport].gun[device->port[mport].gun_index].ZongLeiJi,7);
      YTSF_DEBUG("总金额=");
      YTSF_DEBUG2(device->port[mport].gun[device->port[mport].gun_index].ZongLeiJi+7,7);
      
      YTSF_DEBUG("时间=");
      YTSF_DEBUG2(fbuf+8,3);
      YTSF_DEBUG("油量=");
      YTSF_DEBUG2(fbuf+11,5);
      YTSF_DEBUG("金额=");
      YTSF_DEBUG2(fbuf+16,5);
      YTSF_DEBUG("单价=");
      YTSF_DEBUG2(fbuf+21,3);
      YTSF_DEBUG("\r\n");
        
    }
    else{                                       //非加密
      //总累计，油量7字节，金额7字节
      for(i=0;i<24;i++){
        device->port[mport].lora_send_msg[index++]=device->port[mport].gun[device->port[mport].gun_index].ZongLeiJi[i];
      }
      
      //当次加油信息，数据格式来自英泰赛福
      for(i=0;i<flen;i++){
        device->port[mport].lora_send_msg[index++]=fbuf[i];
      }
      //和校验
      device->port[mport].lora_send_msg[index++] = 0x00;
      
      device->port[mport].lora_send_lmsg = index;
      
      //计算UDP帧，帧长度
      device->port[mport].lora_send_msg[2] = ((index-5) >> 0) & 0xff;
      device->port[mport].lora_send_msg[3] = ((index-5) >> 8) & 0xff;
      
      
      check = 0x00;
      //UDP，校验和
      for(i=0;i<index-1;i++)
        {
          check = check ^ device->port[mport].lora_send_msg[i];
        }
      device->port[mport].lora_send_msg[index-1] = check;
      
      YTSF_DEBUG1("UDP_0D_frame=\r\n");
      for(i=0;i<index;i++)
        YTSF_DEBUG("%02X",device->port[mport].lora_send_msg[i]);
      YTSF_DEBUG("\r\n");
        
        
      YTSF_DEBUG1("\r\n端口号=%d",mport);
      YTSF_DEBUG("枪号=%d\r\n",device->port[mport].gun_index);
      YTSF_DEBUG("总油量=");
      YTSF_DEBUG_SN(device->port[mport].gun[device->port[mport].gun_index].ZongLeiJi,12);
      YTSF_DEBUG("\r\n");
      YTSF_DEBUG("总金额=");
      YTSF_DEBUG_SN(device->port[mport].gun[device->port[mport].gun_index].ZongLeiJi+12,12);
      YTSF_DEBUG("\r\n");
      
      YTSF_DEBUG("时间=");
      YTSF_DEBUG_SN(fbuf+5,6);
      YTSF_DEBUG("\r\n");
      YTSF_DEBUG("油量=");
      YTSF_DEBUG_SN(fbuf+11,6);
      YTSF_DEBUG("\r\n");
      YTSF_DEBUG("金额=");
      YTSF_DEBUG_SN(fbuf+17,6);
      YTSF_DEBUG("\r\n");
      YTSF_DEBUG("单价=");
      YTSF_DEBUG_SN(fbuf+23,4);
      YTSF_DEBUG("\r\n");
        
    }
	}
	
	
	
	
	
	return index;
}

uint8_t YTSF_CreateMsg_0C(tDevice_t *device){
	uint16_t index=0;
	uint8_t check=0;
	uint16_t i=0;

	device->msg[index++]=0xFF;			//UDP帧头
	device->msg[index++]=0xEE;
	device->msg[index++]=0x00;			//UDP长度(2B)
	device->msg[index++]=0x00;
	
	device->msg[index++]=0x0C;      //消息类型
		
	device->msg[index++]=(device->device_id >> 0)&0xff;//0x4A;			//主板号设备ID(4B),比如01 02 03 04
	device->msg[index++]=(device->device_id >> 8)&0xff;//0x27;
	device->msg[index++]=(device->device_id >>16)&0xff;//0x00;
	device->msg[index++]=(device->device_id >>24)&0xff;//0x00;
	
	
	device->msg[index++]=(device->ver >> 0)&0xff;			//版本号
	device->msg[index++]=(device->ver >> 8)&0xff;			//版本号
	
	//和校验
	device->msg[index++] = 0x00;
	
	device->lmsg = index;
	
	//计算UDP帧，帧长度
	device->msg[2] = ((index-5) >> 0) & 0xff;
	device->msg[3] = ((index-5) >> 8) & 0xff;
	
	
	check = 0x00;
	//UDP，校验和
	for(i=0;i<index-1;i++)
		{
			check = check ^ device->msg[i];
		}
	device->msg[index-1] = check;
	
	YTSF_DEBUG1("UDP_0C_frame=\r\n");
	for(i=0;i<index;i++)
		YTSF_DEBUG("%02X",device->msg[i]);
	YTSF_DEBUG("\r\n");
	
	return index;
}



uint8_t Ytsf_UartRx_Process(void){

	uint8_t ReturnCode=1;
	
	
	if(mYTSF_state!=YTSF_STATE_IDLE)
		YTSF_DEBUG1("mYTSF_state=%d\r\n",mYTSF_state);
	
	
		switch(mYTSF_state){
    case YTSF_STATE_IDLE:
			mYTSF_state=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;
    

    case YTSF_STATE_DEVICE_HEARTBEAT_INIT:
			
			mYTSF_state=(YTSF_STATE_DEVICE_HEARTBEAT_RUNNING);
			ReturnCode = 0;
    break;

    case YTSF_STATE_DEVICE_HEARTBEAT_RUNNING:
			YTSF_CreateMsg_0C(&mDevice);
			En_Queue(lora_tx_sq,mDevice.msg,sizeof(mDevice.msg),mDevice.lmsg);
			mYTSF_state=(YTSF_STATE_DEVICE_HEARTBEAT_DONE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_DEVICE_HEARTBEAT_DONE:
			mYTSF_state=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_DEVICE_HEARTBEAT_FAILED:
			mYTSF_state=(YTSF_STATE_IDLE);
			ReturnCode = 1;
    break;
		
		default:
			mYTSF_state=(YTSF_STATE_IDLE);
			ReturnCode = 0;
	}
	
	return ReturnCode;
}


uint8_t Ytsf_UartRx_Process_port(uint8_t mport){

	uint8_t temp =0;
//	static uint8_t sbuf[32];
//	static uint8_t slen=0;
	uint8_t ReturnCode=1;
	
				//mDevice.port = YTSF_rx_frame.fport;
				//mDevice.gun = YTSF_rx_frame.fgun;
	//YTSF_SET_STATE_port(mport,YTSF_STATE_IDLE,STATE_M_MODE_De);
	if(mDevice.port[mport].state_m!=YTSF_STATE_IDLE)
		YTSF_DEBUG1("mDevice.port[%d].state_m=%d\r\n",mport,mDevice.port[mport].state_m);
	
	
	switch(mDevice.port[mport].state_m){
    case YTSF_STATE_IDLE:
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;
		
    case YTSF_STATE_PORT_GET_MONITOR_SN_INIT:
			mDevice.port[mport].state_m=(YTSF_STATE_PORT_GET_MONITOR_SN_RUNNING);
			ReturnCode = 0;
    break;

    case YTSF_STATE_PORT_GET_MONITOR_SN_RUNNING:
			//
      temp=YTSF_SN_Compare(mport,&mDevice,&YTSF_rx_frame_port[mport]);
        if(temp == 0x00){//ok
          mDevice.port[mport].state_m=(YTSF_STATE_PORT_GET_MONITOR_SN_DONE);
        }
        else{//sn changed
          mDevice.port[mport].state_m=(YTSF_STATE_PORT_GET_MONITOR_SN_CHANGED);
        }
			ReturnCode = 0;
    break;

    case YTSF_STATE_PORT_GET_MONITOR_SN_DONE:
      mDevice.port[mport].sn_init_st = 0x88;
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			
			ReturnCode = 0;
    break;

    case YTSF_STATE_PORT_GET_MONITOR_SN_TIMEOUT:
			ReturnCode = 0;
    break;

    case YTSF_STATE_PORT_GET_MONITOR_SN_CHANGED:
			YTSF_SN_Update(&mDevice,&YTSF_rx_frame_port[mport]);
			mDevice.port[mport].state_m=(YTSF_STATE_PORT_GET_MONITOR_SN_DONE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_PORT_GET_MONITOR_SN_FAILED:
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 1;
    break;
    
    case YTSF_STATE_GUN_GET_ZongLeiJi_INIT:
			//todo时间赋值
			mDevice.port[mport].state_m=(YTSF_STATE_GUN_GET_ZongLeiJi_RUNNING);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_ZongLeiJi_RUNNING:		
      //TODO，总累计状态更新
			//YTSF_DEBUG1("mDevice.port=%d,mDevice.gun=%d\r\n",mDevice.port,mDevice.gun);
			if(mDevice.chk_zlj)
				temp = memcmp(mDevice.port[mport].gun[YTSF_rx_frame_port[mport].fgun].ZongLeiJi,YTSF_rx_frame_port[mport].fdata,14);
			else
				temp = 1;
			
			//持续发送数据			
			if(temp!=0)
				mDevice.port[mport].state_m=(YTSF_STATE_GUN_GET_ZongLeiJi_CHANGED);
			else
				mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_ZongLeiJi_DONE:
			mDevice.port[mport].zlj_state = 0x01;
		
			YTSF_DEBUG1("mDevice.port[%d].zlj_state==1,fgun=%d\r\n",mport,YTSF_rx_frame_port[mport].fgun);
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_ZongLeiJi_TIMEOUT:
			//超时判断
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_ZongLeiJi_CHANGED:
			
			memcpy(mDevice.port[mport].gun[YTSF_rx_frame_port[mport].fgun].ZongLeiJi,YTSF_rx_frame_port[mport].fdata,14);
			
			mDevice.port[mport].state_m=(YTSF_STATE_GUN_GET_ZongLeiJi_DONE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_ZongLeiJi_FAILED:
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 1;
    break;

    case YTSF_STATE_GUN_GET_DangCi_INIT:
			mDevice.port[mport].state_m=(YTSF_STATE_GUN_GET_DangCi_RUNNING);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_DangCi_RUNNING:
			YTSF_CreateMsg_0D(mport,&mDevice,&YTSF_rx_frame_port[mport],mDevice.port[mport].dangci_frame,mDevice.port[mport].dangci_lframe);
			if(mDevice.lora_send_state)
				En_Queue(lora_tx_sq,mDevice.port[mport].lora_send_msg,sizeof(mDevice.port[mport].lora_send_msg),mDevice.port[mport].lora_send_lmsg);
			else
				YTSF_DEBUG1("LoRa_Send_En=0\r\n");
      //缓冲区清零
      memset(mDevice.port[mport].lora_send_msg,0,128);
      mDevice.port[mport].lora_send_lmsg=0;
      
			mDevice.port[mport].state_m=(YTSF_STATE_GUN_GET_DangCi_DONE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_DangCi_DONE:
			mDevice.port[mport].zlj_state=0;
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_DangCi_TIMEOUT:
			mDevice.port[mport].zlj_state=0;
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_DangCi_CHANGED:
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_DangCi_FAILED:
			mDevice.port[mport].zlj_state=0;
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 1;
    break;

		
		default:
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
	}
	
	return ReturnCode;
}




void Ytsf_loop_port(uint8_t mport){
	int8_t index=0;

	uint8_t zlj_state=0;
  uint8_t sn_init_st=0;
	uint32_t loop_dc_period=0;
	uint32_t loop_dc_timeout=0;
	uint32_t loop_zlj_period=0;
	uint32_t loop_zlj_timeout=0;
	static uint32_t loop_state_period_port[2];
  
  
	Ytsf_UartRx_Process_port(mport);
	
		if(mDevice.ytsf_state==1){
      sn_init_st = mDevice.port[mport].sn_init_st;
      
      
      //若SN未初始化，则进行初始化
      if((sn_init_st == 0x00)&&(TickCounter - mDevice.port[mport].loop_sn_period > mDevice.port[mport].loop_sn_timeout)){
          mDevice.port[mport].loop_sn_period = TickCounter;
          mDevice.port[mport].zlj_state = 0;
        
					index = Get_CMD_Index_ByParm(mport,0,Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_00);
					YTSF_DEBUG1("index=%d\r\n",index);
					if(index >=0)
						YTSF_CMD_Tx(CMD_LIST[index][1],CMD_LIST[index][2],CMD_LIST[index][3],CMD_LIST[index][4],CMD_LIST[index][5]);
      }
      
      
      //总累计已读取，且当次查询定时时间到
      if(sn_init_st == 0x88){
        zlj_state = mDevice.port[mport].zlj_state;
        
        loop_dc_period = mDevice.port[mport].loop_dc_period;
        loop_dc_timeout = mDevice.port[mport].loop_dc_timeout;
        
        loop_zlj_period = mDevice.port[mport].loop_zlj_period;
        loop_zlj_timeout = mDevice.port[mport].loop_zlj_timeout;
        
        //读当次条件符合后，尝试3次。zlj_state在状态机里更新，如果当次读取成功则zlj_state=0x88;
        if((zlj_state!=0)&&(TickCounter - loop_dc_period >loop_dc_timeout)){
            mDevice.port[mport].loop_dc_period = TickCounter;
            loop_state_period_port[mport] = TickCounter;
          if((zlj_state > 0)&&(zlj_state < 3)){
            mDevice.port[mport].zlj_state++;
            index = Get_CMD_Index_ByParm(mport,mDevice.port[mport].gun_index,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_11);
            YTSF_DEBUG1("index=%d\r\n",index);
            if(index >=0)
              YTSF_CMD_Tx(CMD_LIST[index][1],CMD_LIST[index][2],CMD_LIST[index][3],CMD_LIST[index][4],CMD_LIST[index][5]);
          }
          //当次读取失败或超时，总累计记录清零
          if((zlj_state >= 3) && (zlj_state < 10)){
            memset(mDevice.port[mport].gun[YTSF_rx_frame_port[mport].fgun].ZongLeiJi,0,14);
          }
        }
        //总累计
        if((zlj_state == 0x00)&&(TickCounter - loop_zlj_period > loop_zlj_timeout)){
          mDevice.port[mport].loop_zlj_period = TickCounter;
          mDevice.port[mport].loop_dc_period = TickCounter;
          loop_state_period_port[mport] = TickCounter;
          //轮询
          Ytsf_CMD_polling_port(mport);

          //英泰赛福
          if(mDevice.port[mport].mntr_factory == 1)
            mDevice.port[mport].loop_zlj_timeout = 20*1000;//1小时
          //拓盛
          if(mDevice.port[mport].mntr_factory == 2)
            mDevice.port[mport].loop_zlj_timeout = 20*1000;//20秒
        }
        if((zlj_state != 0x00)&&(TickCounter - loop_state_period_port[mport] > 60*1000)){
          loop_state_period_port[mport] = TickCounter;
          mDevice.port[mport].zlj_state = 0;
        }
      }
      
		}
		

}




void Ytsf_loop(void){
  
	int8_t temp =0;
	static uint8_t sbuf[128];
	static uint8_t slen=0;
  
  if(mDevice.ytsf_state==0)
    return;
  
  if(!Check_Seqeue_Empty(uart4_rx_sq)){
    slen = 0;
    memset(sbuf,0,sizeof(sbuf));
    
    De_Queue(uart4_rx_sq,sbuf,sizeof(sbuf),(uint8_t *)&slen);
    
    temp=Ytsf_CMD_Analysis2(&YTSF_rx_frame,sbuf,slen);
    if(temp == -1){
      YTSF_DEBUG1("Ytsf_CMD_Analysis2 is failed\r\n");
      YTSF_DEBUG2(sbuf,slen);
      
    }
    else{
      YTSF_DEBUG1("Ytsf_CMD_Analysis2 is succeed\r\n");
			//mYTSF_state=(YTSF_STATE_UART_ANALYSIS_DONE);
      if((YTSF_rx_frame.fcmd == Ytsf_CMD_INSTRUCT_A2) && (YTSF_rx_frame.ftype == Ytsf_CMD_TYPE_00)){
        //YTSF_SET_STATE_port(YTSF_rx_frame.fport,YTSF_STATE_PORT_GET_MONITOR_SN_INIT,STATE_M_MODE_En);
        mDevice.port[YTSF_rx_frame.fport].state_m = YTSF_STATE_PORT_GET_MONITOR_SN_INIT;
      }
      if((YTSF_rx_frame.fcmd == Ytsf_CMD_INSTRUCT_A1) && (YTSF_rx_frame.ftype == Ytsf_CMD_TYPE_14)){
        //YTSF_SET_STATE_port(YTSF_rx_frame.fport,YTSF_STATE_GUN_GET_ZongLeiJi_INIT,STATE_M_MODE_En);
        mDevice.port[YTSF_rx_frame.fport].state_m = YTSF_STATE_GUN_GET_ZongLeiJi_INIT;
      }
      if((YTSF_rx_frame.fcmd == Ytsf_CMD_INSTRUCT_A1) && (YTSF_rx_frame.ftype == Ytsf_CMD_TYPE_11)){
        //YTSF_SET_STATE_port(YTSF_rx_frame.fport,YTSF_STATE_GUN_GET_DangCi_INIT,STATE_M_MODE_En);
        mDevice.port[YTSF_rx_frame.fport].state_m = YTSF_STATE_GUN_GET_DangCi_INIT;
      }
    }
  }
  
	Ytsf_loop_port(Ytsf_PORT_0);
	Ytsf_loop_port(Ytsf_PORT_1);
  
	//心跳长时间无数据发送，则产生心跳  
  if(TickCounter - LoRa_SendTimeCouter > LoRa_SendTimeOut){
    LoRa_SendTimeCouter = TickCounter;
    
    YTSF_CreateMsg_0C(&mDevice);
    En_Queue(lora_tx_sq,mDevice.msg,sizeof(mDevice.msg),mDevice.lmsg);
    
    YTSF_DEBUG1("LoRa_SendTimeOut\r\n");
  }
  
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//以下为非加密版

uint8_t TAX_CMD_Tx(uint8_t size,uint8_t port,uint8_t gun,uint8_t instruct,uint8_t type){
	
	int16_t cmd_l=0;
//	uint8_t sout[64]={0};
//	uint8_t lout=0;
//	uint8_t tmp=0;
//	uint16_t i=0;
	//uint8_t result=0;
	
//cmd_l=Get_Ytsf_CMD(Ytsf_CMD_A2_SIZE,Ytsf_PORT_0,Ytsf_CMD_INSTRUCT_A1,Ytsf_CMD_TYPE_00,Ytsf_GUN_NUM_0);
	cmd_l=Get_Ytsf_CMD(size,port,gun,instruct,0x00);
	
	if(cmd_l<0){
    YTSF_DEBUG1("TAX SEND CMD,获取发送指令失败\r\n");
		switch(cmd_l){
			case YTSF_CMD_ERROR_CMD:
				YTSF_DEBUG1("TAX_CMD_ERROR_CMD\r\n");
				break;
			case YTSF_CMD_ERROR_LEN:
				YTSF_DEBUG1("TAX_CMD_ERROR_LEN\r\n");
				break;
			case YTSF_CMD_ERROR_TYPE:
				YTSF_DEBUG1("TAX_CMD_ERROR_TYPE\r\n");
				break;
			case YTSF_CMD_ERROR_SN:
				YTSF_DEBUG1("TAX_CMD_ERROR_SN\r\n");
				break;
			
			default:
				break;
    }
  }
	else if(cmd_l > 100)
	{
    YTSF_DEBUG1("TAX SEND CMD,指令长达太长，>100.\r\n");
	}
	else{
		YTSF_DEBUG1("TAX SEND CMD=");
		YTSF_DEBUG2(Ytsf_CMD_BUF,cmd_l);
    if(port == TAX_PORT_0){
      UART5_SendNByte(Ytsf_CMD_BUF,cmd_l);
			YTSF_PORT0_Send_CNT++;
			YTSF_PORT0_Send_Delay = TickCounter;
      start_led(2,cmd_l,10,30*10);//(led,delay*0.1ms,duty,period*0.1ms)
      }
    if(port == TAX_PORT_1){
      USART1_SendNByte(Ytsf_CMD_BUF,cmd_l);
			YTSF_PORT1_Send_CNT++;
			YTSF_PORT1_Send_Delay = TickCounter;
      start_led(3,cmd_l,10,30*10);//(led,delay*0.1ms,duty,period*0.1ms)
    }
  }
		
		
	
	
	
	return 0;
}

uint8_t TAX_CMD_polling_port(uint8_t mport){
	uint8_t i =0;
	uint16_t *poll;
  if(mport == Ytsf_PORT_0){
    poll = &CMD_LIST_polling_port0;
  }

  if(mport == Ytsf_PORT_1){
    poll = &CMD_LIST_polling_port1;
  }
  
	YTSF_DEBUG1("TAX_CMD_polling_port mport=%d,poll=%d.\r\n",mport,*poll);
  
	if(CMD_LIST[*poll][0]!=CMD_en)
	{
		for(i=0;i<MAX_CMD_LIST;i++)
		{
			if((CMD_LIST[(i+*poll+1) % MAX_CMD_LIST][0]!=CMD_en) || (CMD_LIST[(i+*poll+1) % MAX_CMD_LIST][2]!=mport))
			{
				continue;
			}else{
				*poll=(i+*poll+1) % MAX_CMD_LIST;
				break;
			}
		}
	}

	if((CMD_LIST[*poll][0]==CMD_en)&&(CMD_LIST[*poll][2]==mport))
	{
		YTSF_DEBUG("\r\n\r\n");
		YTSF_DEBUG1("CMD port[%d] index =%d\r\n",mport,*poll);
    mDevice.port[mport].gun_index = CMD_LIST[*poll][3];
		//YTSF_CMD_Tx(Ytsf_CMD_A2_SIZE,		Ytsf_PORT_0,		Ytsf_GUN_NUM_0,				Ytsf_CMD_INSTRUCT_A2,Ytsf_CMD_TYPE_00);
		TAX_CMD_Tx(CMD_LIST[*poll][1],CMD_LIST[*poll][2],CMD_LIST[*poll][3],CMD_LIST[*poll][4],CMD_LIST[*poll][5]);
	}
	*poll = *poll +1;
	*poll = *poll % MAX_CMD_LIST;
	
	return *poll;
}
//mode=1入队列(队尾写入),mode=2出队列(队首读取)
int16_t TAX_SET_STATE_port(uint8_t mport,uint8_t s,uint8_t mode){
  static uint8_t status[2][8]={YTSF_STATE_IDLE};
  static uint8_t front=sizeof(status[0]);
  static uint8_t rear=sizeof(status[0]);
  static uint8_t sum=0;
  
	uint8_t f=0;
	uint8_t r=0;
  if((mport != 0)&&(mport != 1))
    return -1;
  
  if(mode == STATE_M_MODE_INIT){                                      //初始化队列
    front=sizeof(status[0]);
    rear=sizeof(status[0]);
    sum=0;
    memset(status,YTSF_STATE_IDLE,sizeof(status));
    return 0;
  }
  
  if(mode == STATE_M_MODE_En){                                      //mode=1入队列(队尾写入)
    if(sum==sizeof(status[0])){ 				                //满队列判断
      return -1;
    }
    r = (rear+1) % (sizeof(status[0]));               //循环存储
    status[mport][r] = s;
    rear = r;     								                    //更新入队标记
    sum++;              //更新总数标记
    return s;
  }
  
  if((mode == STATE_M_MODE_De)&&(mDevice.port[mport].state_m == YTSF_STATE_IDLE)){//mode=2出队列(队首读取)
    if(sum==0){ 				                              //空队列判断
      mDevice.port[mport].state_m = YTSF_STATE_IDLE;
      return -1;
    }
    f = (front+1) % (sizeof(status[0]));              //循环存储
    mDevice.port[mport].state_m = status[mport][f];   //读取队首值
    
    front = f;										                    //更新出队标记
    sum--;     		      //更新总数标记
    return status[mport][f];
  }
  
  if(mode == STATE_M_MODE_FORCE){                                      //mode=3强制设置状态机
    mDevice.port[mport].state_m =s;             //更新总数标记
    return s;
  }
  return -1;
}
  

uint8_t TAX_SN_Compare(uint8_t mport,tDevice_t *device,tYTSFRxFrame_t *frame){
	int8_t i=0;
	for(i=0;i<10;i++){
		if(device->port[mport].mntr_sn[i]!=frame->fdata[i]){
			return 1;
		}
	}
	return 0;
}

uint8_t TAX_SN_Update(tDevice_t *device,tYTSFRxFrame_t *frame){
	int8_t i=0;
	
	for(i=0;i<10;i++){
		device->port[frame->fport].mntr_sn[i]=frame->fdata[i];
	}
	
	if(frame->fport == Ytsf_PORT_0){
		EE_WriteVariable(CURSET_YTSF_PORT0_SN0,           (frame->fdata[5]<<8)+(frame->fdata[0]));
		EE_WriteVariable(CURSET_YTSF_PORT0_SN1,           (frame->fdata[1]<<8)+(frame->fdata[2]));
		EE_WriteVariable(CURSET_YTSF_PORT0_SN2,           (frame->fdata[3]<<8)+(frame->fdata[4]));
		
		/*
		
		for(i=0;i<(sizeof(CMD_LIST)/sizeof(CMD_LIST[0])-1);i++)
		{
			if((CMD_LIST[i][2]==Ytsf_PORT_0)&&(CMD_LIST[i][3]>Port0_GunTotal))
				CMD_LIST[i][0]=CMD_dn;
		};
		*/
		
	}
	if(frame->fport == Ytsf_PORT_1){
		EE_WriteVariable(CURSET_YTSF_PORT1_SN0,           (frame->fdata[5]<<8)+(frame->fdata[0]));
		EE_WriteVariable(CURSET_YTSF_PORT1_SN1,           (frame->fdata[1]<<8)+(frame->fdata[2]));
		EE_WriteVariable(CURSET_YTSF_PORT1_SN2,           (frame->fdata[3]<<8)+(frame->fdata[4]));
	}
	
	if((frame->fdata[0] >= '0') && (frame->fdata[0] <= '8') )
		YTSF_DEBUG1("税控口%d,芯片厂家为：英泰赛福\r\n",frame->fport);
	if((frame->fdata[0] >= 'A') && (frame->fdata[0] <= 'H') )
		YTSF_DEBUG1("税控口%d,芯片厂家为：拓盛\r\n",frame->fport);
	
	
	switch(frame->fdata[0]){
		case '0':
		case '1':
		case 'A':
		case 'a':
			device->port[frame->fport].gun_max = 1;
			break;
		case '2':
		case '3':
		case 'B':
		case 'b':
			device->port[frame->fport].gun_max = 2;
			break;
		case 'C':
		case 'c':
			device->port[frame->fport].gun_max = 3;
			break;
		case '4':
		case 'D':
		case 'd':
			device->port[frame->fport].gun_max = 4;
			break;
		case '6':
		case 'F':
		case 'f':
			device->port[frame->fport].gun_max = 6;
			break;
		case '8':
		case 'H':
		case 'h':
			device->port[frame->fport].gun_max = 8;
			break;
		default:
			device->port[frame->fport].gun_max = 1;
			break;
			
	}
	
	for(i=0;i<(device->port[frame->fport].gun_max);i++){
		Set_CMD_Enable_ByParm(frame->fport,i,0x89,0x00);
	}
	
	for(i=0;i<(sizeof(CMD_LIST)/sizeof(CMD_LIST[0])-1);i++)
	{
		if((CMD_LIST[i][2]==frame->fport)&&(CMD_LIST[i][3]>=device->port[frame->fport].gun_max))
			CMD_LIST[i][0]=CMD_dn;
	};
	
	
	return 0;
}



int8_t Tax_CMD_Analysis(uint8_t mport,tYTSFRxFrame_t *frame,uint8_t *sbuf,uint8_t slen){

	
	int8_t ReturnCode = -1;
	uint8_t scrc=0x0000;
//	uint8_t tbuf[128];
//	uint8_t tlen = 0;
	int16_t i=0;
	uint8_t check=0;
	
	YTSF_DEBUG1("Rev len=%d,CMD=",slen);
	YTSF_DEBUG2(sbuf,slen);
	
	if(sbuf==NULL)
	{
		YTSF_DEBUG1("error:tbuf==NULL\r\n");
		return ReturnCode;
	}
  
  
	//帧头(1Byte)
	frame->fhead = sbuf[0];
	if(frame->fhead!=0xbb)
	{
		YTSF_DEBUG1("error:frame->fhead != 0xbb,fhead=0x%02X\r\n",frame->fhead);
		return ReturnCode;
	}
	//帧长度(1Byte)
	frame->flen = sbuf[1];
	if(frame->flen>64)
	{
		YTSF_DEBUG1("error:len > 64,frame->flen=0x%02X\r\n",frame->flen);
		return ReturnCode;
	}

	if(frame->flen!=slen-2)
	{
		YTSF_DEBUG1("error:frame->flen!=slen-2,frame->flen=0x%02X,slen=0x%02X\r\n",frame->flen,slen);
		return ReturnCode;
	}
	//和校验
  check = 0;
  for(i=2;i<slen-1;i++)
		{
			check = check ^ sbuf[i];
		}
	scrc = sbuf[slen-1];
	if(check != scrc)
	{
		YTSF_DEBUG1("error:Sum check error!,check0x%02X,scrc=0x%02X\r\n",check,scrc);
		return ReturnCode;
	}
	//税控口编号(1Byte)，0税控口1，1税控口2
	frame->fport 		= mport;
	frame->fcmd 		= sbuf[3];//0x83,0x86,0x89
	frame->fstatus 	= sbuf[4];

  //读取数据(NByte)
  frame->fldata = slen-5;
	memcpy(frame->fdata,sbuf+5,slen-5);
  //
	if(frame->fcmd == 0x83){
    
		if((frame->fdata[0] >= '0') && (frame->fdata[0] <= '8') ){
      mDevice.port[frame->fport].mntr_factory = 1;
			YTSF_DEBUG1("税控口%d,芯片厂家为：英泰赛福\r\n",frame->fport);
    }
		if((frame->fdata[0] >= 'A') && (frame->fdata[0] <= 'H') ){
      mDevice.port[frame->fport].mntr_factory = 2;
			YTSF_DEBUG1("税控口%d,芯片厂家为：拓盛\r\n",frame->fport);
    }
    switch(frame->fdata[5]){
      case '0':
      case '1':
      case 'A':
      case 'a':
        mDevice.port[frame->fport].gun_max = 1;
        break;
      case '2':
      case '3':
      case 'B':
      case 'b':
        mDevice.port[frame->fport].gun_max = 2;
        break;
      case 'C':
      case 'c':
        mDevice.port[frame->fport].gun_max = 3;
        break;
      case '4':
      case 'D':
      case 'd':
        mDevice.port[frame->fport].gun_max = 4;
        break;
      case '6':
      case 'F':
      case 'f':
        mDevice.port[frame->fport].gun_max = 6;
        break;
      case '8':
      case 'H':
      case 'h':
        mDevice.port[frame->fport].gun_max = 8;
        break;
      default:
        mDevice.port[frame->fport].gun_max = 1;
        break;
        
    }
    
  }
  
	memcpy(&YTSF_rx_frame_port[frame->fport],frame,sizeof(tYTSFRxFrame_t));
  
	if(frame->fcmd == 0x89){
    //接收帧，按端口分开
      
      TAX_SET_STATE_port(frame->fport,YTSF_STATE_GUN_GET_ZongLeiJi_INIT,STATE_M_MODE_FORCE);
  }
  
	if(frame->fcmd == 0x86){
    //接收帧，按端口分开
      memcpy(mDevice.port[frame->fport].dangci_frame,sbuf,slen);
      mDevice.port[frame->fport].dangci_lframe = slen;
      TAX_SET_STATE_port(frame->fport,YTSF_STATE_GUN_GET_DangCi_INIT,STATE_M_MODE_FORCE);
  }
  
	ReturnCode = frame->fport;
	return ReturnCode;
}


uint8_t Tax_HeartBeat_Process(void){

	uint8_t ReturnCode=1;
	
	
	if(mYTSF_state!=YTSF_STATE_IDLE)
		YTSF_DEBUG1("mYTSF_state=%d\r\n",mYTSF_state);
	
	
		switch(mYTSF_state){
    case YTSF_STATE_IDLE:
			mYTSF_state=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;
    

    case YTSF_STATE_DEVICE_HEARTBEAT_INIT:
			
			mYTSF_state=(YTSF_STATE_DEVICE_HEARTBEAT_RUNNING);
			ReturnCode = 0;
    break;

    case YTSF_STATE_DEVICE_HEARTBEAT_RUNNING:
			YTSF_CreateMsg_0C(&mDevice);
			En_Queue(lora_tx_sq,mDevice.msg,sizeof(mDevice.msg),mDevice.lmsg);
			mYTSF_state=(YTSF_STATE_DEVICE_HEARTBEAT_DONE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_DEVICE_HEARTBEAT_DONE:
			mYTSF_state=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_DEVICE_HEARTBEAT_FAILED:
			mYTSF_state=(YTSF_STATE_IDLE);
			ReturnCode = 1;
    break;
		
		default:
			mYTSF_state=(YTSF_STATE_IDLE);
			ReturnCode = 0;
	}
	
	return ReturnCode;
}


uint8_t Tax_UartRx_Process_port(uint8_t mport){

	uint8_t temp =0;
	//static uint8_t sbuf[32];
	//static uint8_t slen=0;
	uint8_t ReturnCode=1;
	
  TAX_SET_STATE_port(mport,YTSF_STATE_IDLE,STATE_M_MODE_De);//若当前状态机为，YTSF_STATE_IDLE，则出队列且更新状态。
	
	if(mDevice.port[mport].state_m!=YTSF_STATE_IDLE)
		YTSF_DEBUG1("mDevice.port[%d].state_m=%d\r\n",mport,mDevice.port[mport].state_m);
	
	
	switch(mDevice.port[mport].state_m){
    case YTSF_STATE_IDLE:
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;
		
    case YTSF_STATE_PORT_GET_MONITOR_SN_INIT:
			mDevice.port[mport].state_m=(YTSF_STATE_PORT_GET_MONITOR_SN_RUNNING);
			ReturnCode = 0;
    break;

    case YTSF_STATE_PORT_GET_MONITOR_SN_RUNNING:
			//
      temp=TAX_SN_Compare(mport,&mDevice,&YTSF_rx_frame_port[mport]);
        if(temp == 0x00){//ok
          mDevice.port[mport].state_m=(YTSF_STATE_PORT_GET_MONITOR_SN_DONE);
        }
        else{//sn changed
          mDevice.port[mport].state_m=(YTSF_STATE_PORT_GET_MONITOR_SN_CHANGED);
        }
			ReturnCode = 0;
    break;

    case YTSF_STATE_PORT_GET_MONITOR_SN_DONE:
      mDevice.port[mport].sn_init_st = 0x88;
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			
			ReturnCode = 0;
    break;

    case YTSF_STATE_PORT_GET_MONITOR_SN_TIMEOUT:
			ReturnCode = 0;
    break;

    case YTSF_STATE_PORT_GET_MONITOR_SN_CHANGED:
			TAX_SN_Update(&mDevice,&YTSF_rx_frame_port[mport]);
			mDevice.port[mport].state_m=(YTSF_STATE_PORT_GET_MONITOR_SN_DONE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_PORT_GET_MONITOR_SN_FAILED:
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 1;
    break;
    
    case YTSF_STATE_GUN_GET_ZongLeiJi_INIT:
			//todo时间赋值
			mDevice.port[mport].state_m=(YTSF_STATE_GUN_GET_ZongLeiJi_RUNNING);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_ZongLeiJi_RUNNING:		
      //TODO，总累计状态更新
			//YTSF_DEBUG1("mDevice.port=%d,mDevice.gun=%d\r\n",mDevice.port,mDevice.gun);
			if(mDevice.chk_zlj)
				temp = memcmp(mDevice.port[mport].gun[YTSF_rx_frame_port[mport].fgun].ZongLeiJi,YTSF_rx_frame_port[mport].fdata,24);
			else
				temp = 1;
			
			//持续发送数据			
			if(temp!=0)
				mDevice.port[mport].state_m=(YTSF_STATE_GUN_GET_ZongLeiJi_CHANGED);
			else
				mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_ZongLeiJi_DONE:
			mDevice.port[mport].zlj_state = 0x01;
		
			YTSF_DEBUG1("mDevice.port[%d].zlj_state==1,fgun=%d\r\n",mport,YTSF_rx_frame_port[mport].fgun);
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_ZongLeiJi_TIMEOUT:
			//超时判断
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_ZongLeiJi_CHANGED:
			
			memcpy(mDevice.port[mport].gun[YTSF_rx_frame_port[mport].fgun].ZongLeiJi,YTSF_rx_frame_port[mport].fdata,24);
			
			mDevice.port[mport].state_m=(YTSF_STATE_GUN_GET_ZongLeiJi_DONE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_ZongLeiJi_FAILED:
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 1;
    break;

    case YTSF_STATE_GUN_GET_DangCi_INIT:
			mDevice.port[mport].state_m=(YTSF_STATE_GUN_GET_DangCi_RUNNING);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_DangCi_RUNNING:
			YTSF_CreateMsg_0D(mport,&mDevice,&YTSF_rx_frame_port[mport],mDevice.port[mport].dangci_frame,mDevice.port[mport].dangci_lframe);
			if(mDevice.lora_send_state)
				En_Queue(lora_tx_sq,mDevice.port[mport].lora_send_msg,sizeof(mDevice.port[mport].lora_send_msg),mDevice.port[mport].lora_send_lmsg);
			else
				YTSF_DEBUG1("LoRa_Send_En=0\r\n");
      //缓冲区清零
      memset(mDevice.port[mport].lora_send_msg,0,128);
      mDevice.port[mport].lora_send_lmsg=0;
      
			mDevice.port[mport].state_m=(YTSF_STATE_GUN_GET_DangCi_DONE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_DangCi_DONE:
			mDevice.port[mport].zlj_state=0;
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_DangCi_TIMEOUT:
			mDevice.port[mport].zlj_state=0;
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_DangCi_CHANGED:
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
    break;

    case YTSF_STATE_GUN_GET_DangCi_FAILED:
			mDevice.port[mport].zlj_state=0;
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 1;
    break;

		
		default:
			mDevice.port[mport].state_m=(YTSF_STATE_IDLE);
			ReturnCode = 0;
	}
	
	return ReturnCode;
}

void Tax_loop_port(uint8_t mport){
	int16_t index=0;

	uint8_t zlj_state=0;
  uint8_t sn_init_st=0;
	uint32_t loop_dc_period=0;
	uint32_t loop_dc_timeout=0;
	uint32_t loop_zlj_period=0;
	uint32_t loop_zlj_timeout=0;
	static uint32_t loop_state_period_port[2];
  
  
	Tax_UartRx_Process_port(mport);
	
		if(mDevice.ytsf_state==0){
      sn_init_st = mDevice.port[mport].sn_init_st;
      
      
      //若SN未初始化，则进行初始化
      if((sn_init_st == 0x00)&&(TickCounter - mDevice.port[mport].loop_sn_period > mDevice.port[mport].loop_sn_timeout)){
          mDevice.port[mport].loop_sn_period = TickCounter;
          mDevice.port[mport].zlj_state = 0;
        
					index = Get_CMD_Index_ByParm(mport,0x00,0x83,0x00);
					YTSF_DEBUG1("index=%d\r\n",index);
					if(index >=0)
						TAX_CMD_Tx(CMD_LIST[index][1],CMD_LIST[index][2],CMD_LIST[index][3],CMD_LIST[index][4],CMD_LIST[index][5]);
      }
      
      
      //总累计已读取，且当次查询定时时间到
      if(sn_init_st == 0x88){
        zlj_state = mDevice.port[mport].zlj_state;
        
        loop_dc_period = mDevice.port[mport].loop_dc_period;
        loop_dc_timeout = mDevice.port[mport].loop_dc_timeout;
        
        loop_zlj_period = mDevice.port[mport].loop_zlj_period;
        loop_zlj_timeout = mDevice.port[mport].loop_zlj_timeout;
        
        //读当次条件符合后，尝试3次。zlj_state在状态机里更新，如果当次读取成功则zlj_state=0x88;
        if((zlj_state!=0)&&(TickCounter - loop_dc_period >loop_dc_timeout)){
            mDevice.port[mport].loop_dc_period = TickCounter;
            loop_state_period_port[mport] = TickCounter;
          if((zlj_state > 0)&&(zlj_state < 3)){
            mDevice.port[mport].zlj_state++;
            index = Get_CMD_Index_ByParm(mport,mDevice.port[mport].gun_index,0x86,0x00);
            YTSF_DEBUG1("index=%d\r\n",index);
            if(index >=0)
              TAX_CMD_Tx(CMD_LIST[index][1],CMD_LIST[index][2],CMD_LIST[index][3],CMD_LIST[index][4],CMD_LIST[index][5]);
          }
          //当次读取失败或超时，总累计记录清零
          if((zlj_state >= 3) && (zlj_state < 10)){
            memset(mDevice.port[mport].gun[YTSF_rx_frame_port[mport].fgun].ZongLeiJi,0,24);
          }
        }
        //总累计
        if((zlj_state == 0x00)&&(TickCounter - loop_zlj_period > loop_zlj_timeout)){
          mDevice.port[mport].loop_zlj_period = TickCounter;
          mDevice.port[mport].loop_dc_period = TickCounter;
          loop_state_period_port[mport] = TickCounter;
          //轮询
          TAX_CMD_polling_port(mport);

          //英泰赛福
          if(mDevice.port[mport].mntr_factory == 1)
            mDevice.port[mport].loop_zlj_timeout = 20*1000;//1小时
          //拓盛
          if(mDevice.port[mport].mntr_factory == 2)
            mDevice.port[mport].loop_zlj_timeout = 20*1000;//20秒
        }
        if((zlj_state != 0x00)&&(TickCounter - loop_state_period_port[mport] > 60*1000)){
          loop_state_period_port[mport] = TickCounter;
          mDevice.port[mport].zlj_state = 0;
        }
      }
      
		}
		

}

void Tax_loop(void){

  
	int8_t temp =0;
	static uint8_t sbuf[128];
	static uint8_t slen=0;
  
  if(mDevice.ytsf_state==1)
    return;
  
  if(!Check_Seqeue_Empty(uart5_rx_sq)){
    slen = 0;
    memset(sbuf,0,sizeof(sbuf));
    
    De_Queue(uart5_rx_sq,sbuf,sizeof(sbuf),(uint8_t *)&slen);
    
    temp=Tax_CMD_Analysis(TAX_PORT_0,&Tax_rx_frame[TAX_PORT_0],sbuf,slen);
    if(temp == -1){
      YTSF_DEBUG1("Tax_CMD_Analysis is failed\r\n");
      YTSF_DEBUG2(sbuf,slen);
    }
    else{
      YTSF_DEBUG1("Tax_CMD_Analysis is succeed\r\n");
			//mYTSF_state=(YTSF_STATE_UART_ANALYSIS_DONE);
      if(Tax_rx_frame[TAX_PORT_0].fcmd == 0x83){
        //TAX_SET_STATE_port(YTSF_rx_frame.fport,YTSF_STATE_PORT_GET_MONITOR_SN_INIT,STATE_M_MODE_En);
        mDevice.port[TAX_PORT_0].state_m = YTSF_STATE_PORT_GET_MONITOR_SN_INIT;
      }
      if(Tax_rx_frame[TAX_PORT_0].fcmd == 0x89){
        //TAX_SET_STATE_port(YTSF_rx_frame.fport,YTSF_STATE_GUN_GET_ZongLeiJi_INIT,STATE_M_MODE_En);
        mDevice.port[TAX_PORT_0].state_m = YTSF_STATE_GUN_GET_ZongLeiJi_INIT;
      }
      if(Tax_rx_frame[TAX_PORT_0].fcmd == 0x86){
        //TAX_SET_STATE_port(YTSF_rx_frame.fport,YTSF_STATE_GUN_GET_DangCi_INIT,STATE_M_MODE_En);
        mDevice.port[TAX_PORT_0].state_m = YTSF_STATE_GUN_GET_DangCi_INIT;
      }
    }
  }
  
	Tax_loop_port(TAX_PORT_0);
  
  
  if(!Check_Seqeue_Empty(usart1_rx_sq)){
    slen = 0;
    memset(sbuf,0,sizeof(sbuf));
    
    De_Queue(usart1_rx_sq,sbuf,sizeof(sbuf),(uint8_t *)&slen);
    
    temp=Tax_CMD_Analysis(TAX_PORT_1,&Tax_rx_frame[TAX_PORT_1],sbuf,slen);
    if(temp == -1){
      YTSF_DEBUG1("Tax_CMD_Analysis is failed\r\n");
      YTSF_DEBUG2(sbuf,slen);
    }
    else{
      YTSF_DEBUG1("Tax_CMD_Analysis is succeed\r\n");
			//mYTSF_state=(YTSF_STATE_UART_ANALYSIS_DONE);
      if(Tax_rx_frame[TAX_PORT_1].fcmd == 0x83){
        //TAX_SET_STATE_port(YTSF_rx_frame.fport,YTSF_STATE_PORT_GET_MONITOR_SN_INIT);
        mDevice.port[TAX_PORT_1].state_m = YTSF_STATE_PORT_GET_MONITOR_SN_INIT;
      }
      if(Tax_rx_frame[TAX_PORT_1].fcmd == 0x89){
        //TAX_SET_STATE_port(YTSF_rx_frame.fport,YTSF_STATE_GUN_GET_ZongLeiJi_INIT);
        mDevice.port[TAX_PORT_1].state_m = YTSF_STATE_GUN_GET_ZongLeiJi_INIT;
      }
      if(Tax_rx_frame[TAX_PORT_1].fcmd == 0x86){
        //TAX_SET_STATE_port(YTSF_rx_frame.fport,YTSF_STATE_GUN_GET_DangCi_INIT);
        mDevice.port[TAX_PORT_1].state_m = YTSF_STATE_GUN_GET_DangCi_INIT;
      }
    }
  }
	Tax_loop_port(TAX_PORT_1);
  
	//心跳长时间无数据发送，则产生心跳  
  if(TickCounter - LoRa_SendTimeCouter > LoRa_SendTimeOut){
    LoRa_SendTimeCouter = TickCounter;
    
    YTSF_CreateMsg_0C(&mDevice);
    En_Queue(lora_tx_sq,mDevice.msg,sizeof(mDevice.msg),mDevice.lmsg);
    
    YTSF_DEBUG1("LoRa_SendTimeOut\r\n");
  }
  
}

/**** Copyright (C)2016 sun. All Rights Reserved **** END OF FILE ****/