
#include "base/delay.h"
#include "hardware/adc_cfg.h"
#include "base/utility.h"
#include "hardware/power.h"
#include "driver/XTDriver.h"
#include "XTChecker.h"
#include "hardware/timer_cfg.h"
#define XT_CHECKER_RUN_BUF 56
uint8_t XT_Test_UID[13]="123456789ACDE";
uint8_t XT_Test_PWD[8]="FBCDabcd";
uint8_t XT_RunBuf[XT_CHECKER_RUN_BUF];
/*
@brief 注码检测
@rtv 0 已经注码，1 不能注码 2 需要注码
*/
static uint8_t XT_Test_CheckeThreeCode(void);
/*
@brief 三码绑定验证
*/
static uint8_t XT_Test_UID_PWD_Verify_(void);
/*
@brief 统计模块的上电充能，具有电压设置功能,采集档位 R10_0p1mA_1p6mA_UC
@param0 总线电压
@param1 超时时间 0.1ms
@param2 充电结束时的AD值
@rtv1   返回总线电流低于设置AD值的时间
*/
void XT_Test_PowerOn(void)
{
	uint8_t uc_rtv = 0;
	uint16_t us_rsult[2];
	uint16_t us_max;
	uint16_t us_shake;
	XTBUS_OFF;
	uc_rtv = PowerCalibration_set(checker_runcfg.params[0],checker_runcfg.params[0]-1);
	Power_SetSampleRange_Seep(Checker_PowerOn_Sample_R,ADC_SPEED_HIGH);
	//POWER_ON
	delay_os_ms(100);
	XTBUS_ON;
	delay_us(20);
	us_rsult[1] =  AD_GetChgEnergy(checker_runcfg.params[1],checker_runcfg.params[2], &us_max,&us_shake);
	delay_os_ms(100);
	us_rsult[0] = Power_GetBousV();
	Checker_SetRtv(us_rsult,checker_runcfg.rtv_count);
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	XT_Init(0x78);
}

/*
@brief 设置总线电压
@param1 总线电压
@rtv1   总线电压
*/
void XT_Test_SetBusV(void)
{
	uint8_t uc_rtv = 0;
	uint16_t us_h_v,us_m_v;
	us_h_v = checker_runcfg.params[0];
	if(us_h_v < 55)
	{
		uc_rtv = 1;

	}else{
		us_m_v  = 50;
		uc_rtv |= PowerCalibration_set(us_h_v,us_m_v);
		XTBUS_ON
//		if(checker_runcfg.params[1] == 0)
//		{
//			XTBUS_ON;
//		}else{
//			HMOS_SWITCH_RW_1;
//		}		
		us_m_v = ((us_h_v/80)+2)*60;
		delay_ms(us_m_v);		
		us_h_v = Power_GetBousV();
		Checker_SetRtv(&us_h_v,checker_runcfg.rtv_count);
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	
}

/*
@brief 测量总线基本电压
@rtv1 返回总线电流 单位0.01uA
*/
void XT_Test_BaseCur(void)
{
	uint16_t ul_cur[2];
	XTBUS_W_1
	delay_ms(200);
	ul_cur[0] = ADC_GetBaseStableCur();
	XTBUS_W_0
	delay_ms(100);
	ul_cur[1] = ADC_GetBaseStableCur();
	XTBUS_W_1
	delay_ms(50);
//	if(ul_cur[0] < 100 || ul_cur[1] < 100)
//	{
//		__disable_irq();
//		while(1){};
//	}
	Checker_MaskResult(0,checker_runcfg.task_info.runindex);
	Checker_SetRtv(ul_cur,checker_runcfg.rtv_count);
}

/*
@brief 扫描总线上的电子模块 1发
@param0 UID长度
@param1 使能或失能 UID对比
*/

void XT_Test_ScanUID(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_count = 0;
	uint16_t us_temp[12];
	XT_Clear_Read();
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	if(checker_runcfg.params[0] == 0)
	{
		checker_runcfg.params[0] = checker_runcfg.uid_len;
		if(checker_runcfg.params[0] == 0)
		{
			checker_runcfg.params[0] = 7;
		}
	}
	
	uc_rtv = XT_Read_Uid(XT_RunBuf,checker_runcfg.params[0]);
	
	if(checker_runcfg.params[1] > 0)
	{
		for(uc_count = 0; uc_count < checker_runcfg.params[0];uc_count++)
		{
			if(checker_runcfg.writeuid[uc_count] != XT_RunBuf[uc_count])
			{
				uc_rtv |= 0x01;
			}
		}
	}
	uc_count = 0;
	if(uc_rtv == 0)
	{
		checker_runcfg.uid_len = checker_runcfg.params[0];
		memcpy(checker_runcfg.writeuid,XT_RunBuf,checker_runcfg.uid_len);
		uc_count = (checker_runcfg.params[0]+8+1)/2;
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	memcpy(us_temp,XT_RunBuf,24);
	Checker_SetRtv(us_temp,checker_runcfg.rtv_count);
}
/*
@brief 写芯片配置
@param0 UID长度
@param1 密码长度
@param2 反馈电流挡位
@param4 版本标识
*/
void XT_Test_WriteChipCfg(void)
{
	uint8_t uc_rtv = 0;
	XT_RunBuf[0] = (((checker_runcfg.params[0] & 0x0F)-7) << 4) & 0xF0;
	XT_RunBuf[0] += ((checker_runcfg.params[1] - 4) & 0x0F) ;
	XT_RunBuf[1] = 0x8C;//((checker_runcfg.params[2] & 0x0F) << 2) & 0xF0;
	XT_RunBuf[2] = checker_runcfg.params[3];
	uc_rtv = XT_Write_Config(XT_RunBuf);
	checker_runcfg.uid_len = (uint8_t)checker_runcfg.params[0];
	checker_runcfg.pwd_len = (uint8_t)checker_runcfg.params[1];
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}
/*
@brief 芯片配置并比对
@param0 UID长度
@param1 密码长度
@param2 反馈电流挡位
@param4 版本标识
*/
void XT_Test_CheckChipCfg(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_count = 0;
	memset(XT_RunBuf,0,10);
	XT_RunBuf[0] = (((checker_runcfg.params[0] & 0x0F)-7) << 4) & 0xF0;
	XT_RunBuf[0] += ((checker_runcfg.params[1] - 4) & 0x0F) ;
	XT_RunBuf[1] = 0x8C;//((checker_runcfg.params[2] & 0x0F) << 2) & 0xF0;
	XT_RunBuf[2] = checker_runcfg.params[3];
	uc_rtv = XT_Read_Config(XT_RunBuf+5);
	for(uc_count = 0; uc_count < 3; uc_count++)
	{
		if(XT_RunBuf[uc_count] != XT_RunBuf[6+uc_count])
		{
			uc_rtv |= 0x01;
		}
	}
	XT_RunBuf[1] = XT_RunBuf[2];//验证密码/UID 和版本号
	if(XT_Check_Config(XT_RunBuf) == 0)
	{
		checker_runcfg.uid_len = (uint8_t)checker_runcfg.params[0];
		checker_runcfg.pwd_len = (uint8_t)checker_runcfg.params[1];
	}else{
		uc_rtv |= 0x01;
	}
	
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	
}


/*
@brief 模拟注码,优先写入配置项
*/
void XT_Test_BindTestCode(void)
{
	uint8_t uc_rtv = 0;
	if(checker_runcfg.uid_len == 0)
	{
		checker_runcfg.uid_len = 7;
	}
	memcpy(XT_RunBuf,XT_Test_UID,checker_runcfg.uid_len);
	uc_rtv = XT_Write_Uid(XT_RunBuf, checker_runcfg.uid_len);
	if(uc_rtv == 0)
	{
		memcpy(checker_runcfg.writeuid,XT_RunBuf,checker_runcfg.uid_len);
	}
	if(checker_runcfg.pwd_len == 0)
	{
		checker_runcfg.pwd_len = 7;
	}
	memcpy(XT_RunBuf,XT_Test_PWD,checker_runcfg.pwd_len);
	uc_rtv |= XT_Write_Bmid(XT_RunBuf, checker_runcfg.pwd_len);
	if(uc_rtv == 0)
	{
		memcpy(checker_runcfg.writepwd,XT_RunBuf,checker_runcfg.pwd_len);
	}
	
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}

/*
@brief 充能统计
@param0 充电挡位
@param1 充电电流判线值,AD值
@param2 充电末电流结束值，单位0.1uA
@param3 充电最长时间,单位100ms
@param4 充电高压保持时间，单位0.1s

@rtv0 充能值 单位0.1ms
@rtv1 充末电流 单位0.1uA
@rtv2 充电最大电流 单位0.1Ma
@rtv3 充电抖动幅值 adv
*/

void XT_Test_ChgEnergy(void)
{
	uint8_t uc_charge_class = checker_runcfg.params[0];
	uint16_t us_sample_timeout =     checker_runcfg.params[1];
	uint16_t us_adend =     checker_runcfg.params[2];
	uint16_t us_chgend_cur = checker_runcfg.params[3];
	uint16_t us_timeout = checker_runcfg.params[4];
	uint32_t ul_holdtime =  checker_runcfg.params[5];
	
	uint16_t us_array[4];
	uint16_t us_energy = 0;
	uint16_t us_end_cur = 2000;
	uint16_t us_max_cur = 0;
	uint16_t us_shake = 65535;
	uint32_t ul_temp;
	uint8_t uc_rtv = 0;
	

	XT_Init(0x78);
	XT_Charge_All(uc_charge_class);
	if(us_adend > 10)
	{
		Power_SetSampleRange_Seep(XTChecker_ChgEnger_Sample_R,ADC_SPEED_HIGH);
		delay_ms(1);
		us_energy = AD_GetChgEnergy(us_sample_timeout,us_adend,&us_max_cur,&us_shake);
		us_max_cur =   (  Power_ConvCur(us_max_cur,XTChecker_ChgEnger_Sample_R) /100+5)/10;    
		ADC_CurChnnelSet(AN_MAL_CH, ADC_SPEED_MIDLE);
		ul_temp = AD_CurMonitor(ul_holdtime*1000);
		if(ul_temp > us_shake)
		{
			us_shake = ul_temp;
		}
	}else{
		us_shake = 0;
		us_max_cur = 0;
		us_energy = 0;
	}
	
	
	us_timeout++;
	us_array[0] = ADC_GetBaseStableCur();
	us_array[1] =  ADC_GetBaseStableCur();
	us_array[2] =  ADC_GetBaseStableCur();
	while(us_timeout > 0)
	{
		us_array[3] =  ADC_GetBaseStableCur();
		Bubble_Sort_u16(us_array,3);
		
		us_end_cur = us_array[0];
		
		if(us_end_cur < us_chgend_cur )
		{
			break;
		}
		us_timeout--;
	}
//	if(us_end_cur > us_chgend_cur)
//	{
//		uc_rtv = 1;
//	}
	CurrentSampleR_Def;
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	us_array[0] = us_energy;
	us_array[1] = us_end_cur;
	us_array[2] = us_max_cur;
	us_array[3] = us_shake;
	
	Checker_SetRtv(us_array,checker_runcfg.rtv_count);
}

/*
@brief 写现场值,如果UID已经写入，会将现场值读取进行比对
@param 0 编号
@param 1 延时
@param 2 孔号
*/

void XT_Test_WriteRunField(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_count = 0;
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	XT_RunBuf[0] = 0xFF & (checker_runcfg.params[0] >> 8);
	XT_RunBuf[1] = 0xFF & (checker_runcfg.params[0]);
	XT_RunBuf[2] = 0;
	XT_RunBuf[3] =  0xFF & (checker_runcfg.params[1] >> 8);
	XT_RunBuf[4] = 0xFF & (checker_runcfg.params[1]);
	XT_RunBuf[5] = 0xFF & (checker_runcfg.params[2] >> 8);
	XT_RunBuf[6] = 0xFF & (checker_runcfg.params[2]);
	
	if(checker_runcfg.uid_len > 0)
	{
		uc_rtv = XT_Write_Field(checker_runcfg.writeuid,checker_runcfg.uid_len,XT_RunBuf);
		delay_os_ms(40);
		uc_rtv |= XT_Read_Field(checker_runcfg.writeuid,checker_runcfg.uid_len,XT_RunBuf+10);
		for(uc_count = 0;  uc_count < 7; uc_count++)
		{
			if(XT_RunBuf[uc_count] != XT_RunBuf[uc_count+10])
			{
				uc_rtv |= 0x01;
			}
		}
	}else{
		uc_rtv = XT_Write_Field_All(XT_RunBuf);
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}
/*
@brief 比对现场值
@param0 比对网络号
@param1 比对延时
@param2 比对孔位
@param3 1使能或 0失能通信反码信息采集
@rtv1 最大反馈电流
@rtv2 最大反馈时间
@rtv3 最小反馈电流
@rtv4 最小反馈时间
*/

void XT_Test_CheckRunField(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_count = 0;
	uint16_t aus_temp[4];
	uint32_t ul_temp;
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);

	XT_RunBuf[0] = 0xFF & (checker_runcfg.params[0] >> 8);
	XT_RunBuf[1] = 0xFF & (checker_runcfg.params[0]);
	XT_RunBuf[2] = 0;
	XT_RunBuf[3] =  0xFF & (checker_runcfg.params[1] >> 8);
	XT_RunBuf[4] = 0xFF & (checker_runcfg.params[1]);
	XT_RunBuf[5] = 0xFF & (checker_runcfg.params[2] >> 8);
	XT_RunBuf[6] = 0xFF & (checker_runcfg.params[2]);
	
	
	if(checker_runcfg.uid_len == 0)
	{
		memset(aus_temp,0,8);
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
  	Checker_SetRtv(aus_temp,checker_runcfg.rtv_count);
		return;
	}
	if(checker_runcfg.params[3] > 0)
	{
		XT_FreeBack_Prapare(1);
	}
	uc_rtv |= XT_Read_Field(checker_runcfg.writeuid,checker_runcfg.uid_len,XT_RunBuf+10);
	
	ul_temp = Power_ConvCur(XT_FreeBackMaxCur, XTDriver_Sample_R);   //通信电流
	ul_temp = (ul_temp / 10+4)/10;//0.01mA
	
	aus_temp[0] = ul_temp ;
	aus_temp[1] = (uint16_t)((((XT_ADC_SAMPLE_TIME*1000)*XT_FreeBackMaxTime)/XT_Read_AD_Sample_C+400)/1000) ;
	ul_temp = Power_ConvCur(XT_FreeBackMinCur, XTDriver_Sample_R);  //通信电流
	ul_temp = (ul_temp / 10+4)/10;//0.01mA
	aus_temp[2] = ul_temp;
	aus_temp[3] =  (uint16_t)((((XT_ADC_SAMPLE_TIME*1000)*XT_FreeBackMinTime)/XT_Read_AD_Sample_C+400)/1000)  ;
	
	if(uc_rtv == 0)
	{
		for(uc_count = 0; uc_count < 7; uc_count++)
		{
			if(XT_RunBuf[uc_count] != XT_RunBuf[10+uc_count])
			{
				uc_rtv |= 0x01;
			}
		}
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	Checker_SetRtv(aus_temp,checker_runcfg.rtv_count);
}

/*
@brief 桥丝通断检测,如果测试器有uid，将采用uid方式通信
*/
void XT_Test_Resister(void)
{
	uint16_t us_rtv = 0;
	if(checker_runcfg.uid_len > 0)
	{
		us_rtv = XT_Get_UID_R(checker_runcfg.writeuid,checker_runcfg.uid_len);
	}else{
		us_rtv = XT_Get_R();
	}
	Checker_MaskResult(0,checker_runcfg.task_info.runindex);
	Checker_SetRtv(&us_rtv,checker_runcfg.rtv_count);
}
/*
@brief 电容容量检测,如果测试器有uid，将采用uid方式通信
@param0  检测电压参数
@param1 超时时间
@rtv0		电容容量 0.1uF
*/
void XT_Test_Cap(void)
{
	uint8_t uc_rtv = 0;
	uint16_t us_temp;
	uint32_t ul_time_out = checker_runcfg.params[1] ;
	float f_cap = 0.0f;
	if(checker_runcfg.params[0] == 0)
	{
		checker_runcfg.params[0] = 0x11;//默认1V挡位
	}
	if(ul_time_out == 0)
	{
		ul_time_out = XTSingleCollectAckTimerOverflowCnt;
	}
	if(checker_runcfg.uid_len > 0)
	{
		uc_rtv = XT_Get_UID_C(checker_runcfg.writeuid,checker_runcfg.uid_len,checker_runcfg.params[0],ul_time_out,&f_cap);
	}else{
		uc_rtv = XT_Get_C(checker_runcfg.params[0],ul_time_out,&f_cap);
	}
	
	XT_Charge_All(0x00);
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	us_temp = (uint16_t)(f_cap*10);
	Checker_SetRtv(&us_temp,checker_runcfg.rtv_count);
}

/*
@brief 写管壳码 如果测试器有uid，将采用uid方式通信
@param 命令缓存参数的起始
@param 写入数据长度
*/
void XT_Test_WriteShell(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_count = 0;
	if(0 != Checker_FacBufCheck())
	{
		uc_rtv = 1;
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
		return;
	}
	//管壳号最长 13个字节
	if((checker_runcfg.params[0] + checker_runcfg.params[1] > CHECKER_WRITE_BUF) || checker_runcfg.params[1] > 13)
	{
		uc_rtv = 2;
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
		return;
	}
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	memcpy(XT_RunBuf,&Checker_FacBuf[2]+checker_runcfg.params[0],checker_runcfg.params[1]);
	uc_rtv |= XT_Write_Shell(XT_RunBuf);
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}

/*
@brief 写UID
@param 命令缓存参数的起始
@param 写入数据长度
*/
void XT_Test_WriteUID(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_count = 0;
	if((checker_runcfg.params[0] + checker_runcfg.params[1] > CHECKER_WRITE_BUF))
	{
		uc_rtv = 1;
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
		return;
	}
	if(CheckCRC_8(&Checker_FacBuf[2],Checker_FacBuf[0]) != Checker_FacBuf[1])
	{
		uc_rtv = 1;
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
		return;
	}
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	if(checker_runcfg.params[1] > 13)
	{
		checker_runcfg.params[1] = 13;
	}
	memcpy(XT_RunBuf,&Checker_FacBuf[2]+checker_runcfg.params[0],checker_runcfg.params[1]);
	
	uc_rtv = XT_Write_Uid(XT_RunBuf,checker_runcfg.params[1]);
	XT_Clear_Read();
	uc_rtv |= XT_Read_Uid(XT_RunBuf+16,checker_runcfg.params[1]);
	if(uc_rtv == 0)
	{
		for(uc_count = 0; uc_count < checker_runcfg.params[1];uc_count++)
		{
			if(XT_RunBuf[uc_count] != XT_RunBuf[16+uc_count])
			{
				uc_rtv |= 0x01;
			}
		}
	}
	if(uc_rtv == 0)
	{
		checker_runcfg.uid_len = checker_runcfg.params[1];
		memcpy(checker_runcfg.writeuid,XT_RunBuf,checker_runcfg.uid_len);
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}

/*
@brief 写密码
@param 命令缓存参数的起始
@param 写入数据长度
*/
void XT_Test_WritePWD(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_state;
	if((checker_runcfg.params[0] + checker_runcfg.params[1] > CHECKER_WRITE_BUF))
	{
		uc_rtv = 1;
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
		return;
	}
	if(CheckCRC_8(&Checker_FacBuf[2],Checker_FacBuf[0]) != Checker_FacBuf[1])
	{
		uc_rtv = 1;
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
		return;
	}
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	if(checker_runcfg.params[1] > 13)
	{
		checker_runcfg.params[1] = 13;
	}
	memcpy(XT_RunBuf,&Checker_FacBuf[2]+checker_runcfg.params[0],checker_runcfg.params[1]);
	
	uc_rtv = XT_Write_Bmid(XT_RunBuf,checker_runcfg.params[1]);
	uc_rtv |= XT_Check_Bmid(XT_RunBuf,checker_runcfg.params[1]);
	if(checker_runcfg.uid_len > 0)
	{
		memset(XT_RunBuf+16,0,8);
		uc_rtv |= XT_Read_Field(checker_runcfg.writeuid,checker_runcfg.uid_len,XT_RunBuf+16);
		uc_state = XT_RunBuf[16+7];
		if( (uc_state & 0x20) == 0)
		{
			 uc_rtv = 0x01;
		}
	}

	if(uc_rtv == 0)
	{
		checker_runcfg.pwd_len = checker_runcfg.params[1];
		memcpy(checker_runcfg.writepwd,XT_RunBuf,checker_runcfg.pwd_len);
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}
/*
@brief 备份区标记检测,备份区用于存储检测标记
@param0 0备份区标记 或 1比对
@param1 备份区数据掩码 1Bytes
@param1 备份区写入数据 1Bytes

*/

void XT_Test_CheckBackFlag(void)
{
	uint8_t uc_rtv = 0;
	uint16_t us_temp1;
	if(checker_runcfg.uid_len > 0)
	{
		uc_rtv = XT_Read_Param(checker_runcfg.writeuid,checker_runcfg.uid_len,XT_RunBuf);
	}else{
		uc_rtv = XT_Read_Param_All(XT_RunBuf);
	}
	if(uc_rtv != 0)
	{
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
		return;
	}
	us_temp1 = XT_RunBuf[1];
	if(checker_runcfg.params[0] == 0)
	{
		us_temp1 &= (~checker_runcfg.params[1]);
		us_temp1 |= checker_runcfg.params[2];
		XT_RunBuf[1] = 0x0FF & us_temp1;
		uc_rtv |= XT_Write_Param(XT_RunBuf);
	}
	else{
		us_temp1 = us_temp1 & checker_runcfg.params[1] ;
		if(us_temp1 !=   checker_runcfg.params[2])
		{
			uc_rtv = 1;
		}
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}
/*
@brief 读取备份区数据
@rtv0  备份区2字节
@rtv0  备份区2字节
*/
void XT_Test_ReadBackFlag(void)
{
	uint8_t uc_rtv = 0;
	uint16_t us_temp[2];
	if(checker_runcfg.uid_len > 0)
	{
		uc_rtv = XT_Read_Param(checker_runcfg.writeuid,checker_runcfg.uid_len,XT_RunBuf);
	}else{
		uc_rtv = XT_Read_Param_All(XT_RunBuf);
	}
	memcpy(us_temp,XT_RunBuf,4);
	
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	Checker_SetRtv(us_temp,checker_runcfg.rtv_count);
}

/*
@brief 时钟校准
@param0 校准模式 1 快速 0 全
@param1 校准周期
@param2 校准时长
*/
void XT_Test_Trim(void)
{
	uint8_t uc_rtv = 0;
	if(checker_runcfg.params[0] > 0)
	{
		XT_Trim_Faset_Cycle(checker_runcfg.params[1],checker_runcfg.params[1]>>1);
	}else{
		XT_Trim_Complete_Cycle(checker_runcfg.params[1],checker_runcfg.params[1]>>1,checker_runcfg.params[2]);
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}

/*
@brief 放电
*/
void XT_Test_Discharge(void)
{
	uint8_t uc_rtv = 0;
	XT_Charge_All(0x00);
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}

/*
@brief 失能通信末电流采集
*/
void XT_Test_EnCommEndCur(void)
{
	XT_CommEndMaxCur = 0;
	XT_CommEnd_CurEn = 1;
	Checker_MaskResult(0,checker_runcfg.task_info.runindex);
}

/*
@brief 获取通信末电流
*/
void XT_Test_GetCommEndCur(void)
{
	XT_CommEnd_CurEn = 0;
	Checker_SetRtv((uint16_t *)&XT_CommEndMaxCur,checker_runcfg.rtv_count);
	Checker_MaskResult(0,checker_runcfg.task_info.runindex);
}

/*
@brief 在线检测
@param 检测网络号
*/
void XT_Test_OneLineCheck(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_temp;
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	uc_rtv = XT_Check_Online(400,XT_RunBuf);
	if(checker_runcfg.params[0] > 400)
	{
		checker_runcfg.params[0] = 400;
	}
	if(checker_runcfg.params[1] > 400)
	{
		checker_runcfg.params[1] = 400;
	}
	if(checker_runcfg.params[0] > 0)
		checker_runcfg.params[0]--;
	uc_temp = checker_runcfg.params[0] >> 3;
	uc_temp = XT_RunBuf[uc_temp] << (checker_runcfg.params[0] & 0x07);
	if(uc_temp != 0x80)
	{
		uc_rtv = 0x01;
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}

/*
@brief 状态检测,如果UID已经存在，使用UID读取。否则通过扫描的方式
@param0 状态比较掩码
@rtv0  与掩码后的状态值
*/
void XT_Test_CheckState(void)
{
	uint8_t uc_rtv = 0;
	uint16_t us_state = 0;
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	if(checker_runcfg.uid_len > 0)
	{
		uc_rtv = XT_Read_Field(checker_runcfg.writeuid,checker_runcfg.uid_len,XT_RunBuf);
		us_state = XT_RunBuf[7];
		if((us_state & checker_runcfg.params[0]) != checker_runcfg.params[1])
		{
			uc_rtv = 1;
		}
	}else{
		uc_rtv = 1;
		us_state = 0;
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	Checker_SetRtv(&us_state,checker_runcfg.rtv_count);
}

/*
@brief 起爆
@param 起爆超时
@param 巡检脉冲个数
*/
void XT_Test_Boom(void)
{
	uint8_t uc_rtv,uc_temp;
	uint16_t us_index = 0;
	uint16_t us_count = 0;
	uint16_t us_res[2];
	uint32_t ul_maxdelay = checker_runcfg.params[0];
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	if(checker_runcfg.params[1] == 0)
	{
		checker_runcfg.params[1] = 400;
	}
	uc_rtv = XT_Check_Fire_Each(checker_runcfg.params[1],XT_RunBuf);
	for(us_index = 0; us_index < XT_CHECKER_RUN_BUF;us_index++)
	{
		if(XT_RunBuf[us_index] != 0)
		{
			uc_temp = XT_RunBuf[us_index];
			us_res[1] = us_index*8;
			while(uc_temp > 0)
			{
				us_res[1]++;
				if((uc_temp & 0x80) > 0)
				{
					us_count++;
				}
				uc_temp <<= 1;
			}
		}
	}
	if(us_count != 1)
	{
		uc_rtv = 1;
	}
	uc_rtv |= XT_Check_Fire_All();
	uc_rtv |= XT_MeasureFire(&ul_maxdelay);
	us_res[0] = (uint16_t)ul_maxdelay;
	
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	Checker_SetRtv(us_res,checker_runcfg.rtv_count);
	
	
}
/*
@brief 复位
*/
void XT_Test_Reset(void)
{
	uint8_t uc_rtv = 0;
	XT_Reset();
	delay_os_ms(40);
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}
/*
@brief 关总线
*/
void XT_Test_PowerOFF(void)
{
	uint8_t uc_rtv = 0;
	XT_Charge_All(0x00);
	delay_os_ms(100);
	XTBUS_OFF;
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}
/*
@brief 芯片锁存
*/
void XT_Test_LockCmdC(void)
{
	uint8_t uc_rtv = 0;
	XT_Lock();
	delay_ms(20);
	XT_Clear_Read();
	if(0 != XT_Read_Uid(XT_RunBuf,checker_runcfg.uid_len))
	{
    uc_rtv = 0x01;
	}
	else{
		if((XT_RunBuf[checker_runcfg.uid_len+7] & 0x80) != 0x80)//锁存后是bit7 = 1;
		{
			 uc_rtv = 0x01;
		}
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}

/*
@brief 赋码设备失能
*/

void XT_Test_CodeBindEn(void)
{
	uint8_t uc_rtv = 0;
	checker_runcfg.uid_pwd_bind_flag = 0xAA;
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}

static uint8_t XT_Test_InputChek_(uint16_t us_count )
{
	uint8_t uc_rtv = 0;
	uint8_t uc_flag = 0;
	uint32_t ul_timeout,ul_time;
	Power_SetSampleRange_Seep(Checker_OnLine_Sample_R,ADC_SPEED_MIDLE);
	
	ul_timeout = us_count;
	ul_timeout *= 100;
	ul_time = 0;
	Get10usCount();
	while(ul_time <= ul_timeout )
	{
		ul_time += Get10usCount();
		if(ADC_GetCurADCFast() > 25)
		{
			uc_flag++;
			if(uc_flag > 50)
			{
				if( ADC_GetBaseStableCur() > 120)
				{
					Power_SetSampleCurrentRange(Current_Max)	;
					delay_ms(2);
					ul_time += Get10usCount();
					XT_Clear_Read();
					if( 0 == XT_Read_Uid(XT_RunBuf,checker_runcfg.uid_len))
					{
						break;
					}else{
            ul_time += 250000;
            Get10usCount();//XT通信超时定时器也是使用tim2，产生通信后需要请您
						Power_SetSampleRange_Seep(Checker_OnLine_Sample_R,ADC_SPEED_MIDLE);
						delay_ms(1);
					}
					
				}else{
						Power_SetSampleRange_Seep(Checker_OnLine_Sample_R,ADC_SPEED_MIDLE);
						delay_ms(1);
				}
			}else{
        delay_ms(1);
      }
			continue;
		}else{
       delay_ms(1);
    }
		uc_flag = 0;
	}
	uc_rtv = 1;
	if(uc_flag > 50)
	{
		uc_rtv = 0;
	}
	return uc_rtv;
}

/*
@brief 接入检测
@param0 上电电压
@param1 超时次数
*/

void XT_Test_InputCheck(void)
{
	uint8_t uc_rtv = 0;
	uint16_t us_h_v = checker_runcfg.params[0];
	uint16_t us_count = checker_runcfg.params[1];
	us_h_v = checker_runcfg.params[0];
	if(us_h_v < 55)
	{
		uc_rtv = 1;
	}else{
		uc_rtv |= PowerCalibration_set(us_h_v,50);
		XTBUS_ON;
		delay_ms(100);
		us_h_v = Power_GetBousV();
	}
	uc_rtv = XT_Test_InputChek_(us_count);
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	Checker_SetRtv(&us_h_v,checker_runcfg.rtv_count);
		
}
/*
@brief 密码验证
*/

void XT_Test_CheckPWD(void)
{
	uint8_t uc_rtv = 0;
	if(checker_runcfg.pwd_len == 0)
	{
		checker_runcfg.pwd_len = 7;
	}
	uc_rtv = XT_Check_Bmid(checker_runcfg.writepwd,checker_runcfg.pwd_len);
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}

/*
@brief 加载配置参数
@rtv UID长度
@rtv 密码长度
@rtv 版本号
@rtv 反码数据
*/
void XT_Test_LoadChipCfg(void)
{
	uint8_t uc_rtv = 0;
	uint16_t us_temp[4];
	memset(XT_RunBuf,0,10);
	memset(us_temp,0,8);
	uc_rtv = XT_Read_Config(XT_RunBuf);
	if(uc_rtv == 0)
	{
		us_temp[0] = ((XT_RunBuf[1] >> 4) & 0x0F)+7;
		us_temp[1] = (XT_RunBuf[1] & 0x0F)+4;
		us_temp[2] = XT_RunBuf[3];
		us_temp[3] = (XT_RunBuf[2] >> 2) & 0x0F;
		checker_runcfg.uid_len = us_temp[0];
		checker_runcfg.pwd_len = us_temp[1];
	}
	
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	Checker_SetRtv(us_temp,checker_runcfg.rtv_count);
}

/*
@breif 测量电容电压差
@param0 两次测量间隔 0.1s
@rtv0   电压差值
*/
void XT_Test_CapVoltage(void)
{
	uint16_t us_capv1;
	POWER_OFF;
	Power_SetSampleCurrentRange(Checker_OnLine_Sample_R);
	HMOS_FAST_DISCHG;
	HMOS_SWITCH_GND;
	delay_os_ms(1000);
	us_capv1 = AD_SampleCap(checker_runcfg.params[0]);
	POWER_ON;
	delay_os_ms(500);
	XTBUS_ON
	Power_SetSampleCurrentRange(Current_Max);
	Checker_MaskResult(0,checker_runcfg.task_info.runindex);
	Checker_SetRtv(&us_capv1,checker_runcfg.rtv_count);
}
/*
@brief 注码检测
@rtv 0 已经注码，1 不能注码 2 需要注码
*/
static uint8_t XT_Test_CheckeThreeCode(void)
{
	uint8_t uc_index;
	/*
		已经注码验证
	*/
	XT_Check_Bmid(checker_runcfg.writepwd,checker_runcfg.pwd_len);//密码验证
	XT_Clear_Read();
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	XT_Read_Uid(XT_RunBuf,checker_runcfg.uid_len);//扫描UID
	uc_index = XT_RunBuf[checker_runcfg.uid_len+7];
	if((uc_index & 0x80) == 0x80)//已经上锁
	{
		if((uc_index & 0xA0) != 0xA0)//已经上锁，密码验证失败
		{
			return 0x01;
		}
		//已经上锁，但UID比对错误
		if(rt_memcmp(checker_runcfg.writeuid,XT_RunBuf,checker_runcfg.uid_len) != 0)
		{
			return 0x01;
		}
		//已经上锁，比对成功
		XTBUS_OFF;
		return 0;		
	}	
	return 2;
}

/*
@brief 写入三码数据
*/
void XT_Test_UID_PWD_Bind(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_ack;
	uint8_t uc_count = 0;
	uint8_t uc_optbuf[16];
	uint32_t ul_write_mask = 0;
	
	if(JQXT_Test_IsNeedBind() == 0)
	{
		Checker_MaskResult(0,checker_runcfg.task_info.runindex);
	}
	uc_rtv = XT_Test_CheckeThreeCode();
	if(uc_rtv != 2)
	{
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	}
	uc_rtv = XT_Write_Uid(checker_runcfg.writeuid,checker_runcfg.uid_len);
	delay_ms(40);
  
  uc_rtv |= XT_Write_Bmid(checker_runcfg.writepwd,checker_runcfg.pwd_len);
	
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}
/*
@brief 三码绑定验证
@rtv 0 验证通过  1 UID验证不通过 2 密码验证不通过
*/
static uint8_t XT_Test_UID_PWD_Verify_(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_state;
	XT_Check_Bmid(checker_runcfg.writepwd,checker_runcfg.pwd_len);	
	XT_Clear_Read();
  memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	XT_Read_Uid(XT_RunBuf,checker_runcfg.uid_len);
	uc_rtv = rt_memcmp(checker_runcfg.writeuid , XT_RunBuf,checker_runcfg.uid_len);	
	if(uc_rtv != 0)
	{
		return 0x01;
	}
	uc_state = XT_RunBuf[checker_runcfg.uid_len+7];
	if((uc_state & 0x20) == 0)
	{
    uc_rtv = 0x02;
	}
	return uc_rtv;
}

/*
@brief 三码绑定验证
*/
void XT_Test_UID_PWD_Verify(void)
{
	uint8_t uc_rtv = XT_Test_UID_PWD_Verify_();
	if(uc_rtv != 0)
	{
    uc_rtv = 0x01;
	}
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
}


/* 
@breif 在线检测 并扫描通信
@param0 总线电压
@param1 超时时间1ms 最大6S
@param2 UID长度
*/

void XT_OnLine_SCAN(void)
{
	uint16_t us_h_v;
	uint8_t uc_rtv = 0;
	PowerCalibration_set(checker_runcfg.params[0],50);
	XTBUS_ON;
	delay_os_ms(100);
	us_h_v = Power_GetBousV();
	if((us_h_v > (checker_runcfg.params[0]+5)) || (us_h_v < (checker_runcfg.params[0]-5)))
	{
		XTBUS_OFF;
		Checker_MaskResult(1,checker_runcfg.task_info.runindex);
		Checker_SetRtv(&us_h_v,checker_runcfg.rtv_count);
	}
	if(0 != XT_Test_InputChek_(checker_runcfg.params[1]))
	{
		XTBUS_OFF;
		Checker_MaskResult(1,checker_runcfg.task_info.runindex);
		Checker_SetRtv(&us_h_v,checker_runcfg.rtv_count);
	}
	delay_ms(10);
	XT_Init(0x78);
	XT_Clear_Read();
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	if(checker_runcfg.params[2] == 0)
	{
		Checker_MaskResult(0,checker_runcfg.task_info.runindex);
		Checker_SetRtv(&us_h_v,checker_runcfg.rtv_count);
		return;
	}
	uc_rtv = XT_Read_Uid(XT_RunBuf,checker_runcfg.params[2]);
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	Checker_SetRtv(&us_h_v,checker_runcfg.rtv_count);
	
}

/*
@brief 芯片离线检测
@param0 超时时间 1ms
@param1 离线电流 0.1uA
@param2 稳定次数
*/

void XT_OFFLine_SCAN(void)
{
	uint32_t ul_timeout =  checker_runcfg.params[0];
	uint16_t us_cur = checker_runcfg.params[1];
	uint16_t us_count = checker_runcfg.params[2];
	uint16_t us_temp = 0,ul_time = 0;
	ul_timeout *= 1000;
	Get1usCount();
	while((us_temp < us_count) && (ul_time < ul_timeout))
	{
		ul_time += Get1usCount();
		if(us_cur >= ADC_GetBaseStableCur())
		{
			us_temp++;
			continue;
		}
		us_temp = 0;
	}
	if(us_temp >= us_count)
	{
		Checker_MaskResult(0,checker_runcfg.task_info.runindex);
	}
	Checker_MaskResult(1,checker_runcfg.task_info.runindex);
}

/*
@brief 芯片离线检测
@param0 充电使能
@param1 采样周期 10ms
@param2 采样次数
*/

void XT_CurMonitor(void)
{
	uint16_t us_charge_en = checker_runcfg.params[0];
	uint32_t ul_timeout =  checker_runcfg.params[1];
	uint16_t us_count = checker_runcfg.params[2];
	uint16_t us_temp = 0,ul_time = 0;
	uint32_t ul_runTimer = 0,ul_cur,ul_1sCount;
	ul_timeout *= 1000;
	if(us_charge_en > 0)
	{
		XT_Charge_All(us_charge_en);
	}
	while(us_count > 0)
	{
		Get1usCount();
	//	ul_cur = Power_GetCurrent();
		 ul_cur = (uint32_t) (Get_Temperature()*100);
		printf("CurM %d\r\n",ul_cur);
		ul_runTimer= Get1usCount();
		
		if((ul_runTimer+5) > ul_timeout)
		{
			continue;
		}
		ul_runTimer = ul_timeout - ul_timeout -5;
		ul_1sCount = ul_runTimer / 1000000;
		ul_runTimer = ul_runTimer - ul_1sCount*1000000;
		while(ul_1sCount > 0)
		{
			delay_us(1000000);
		}
		delay_us(ul_runTimer);
	}
	Checker_MaskResult(0,checker_runcfg.task_info.runindex);
}

/*
@brief 验证壳码 如果测试器有uid，将采用uid方式通信
@param 命令缓存参数的起始
@param 验证数据长度
*/
void XT_Test_VerfyShell(void)
{
	uint8_t uc_rtv = 0;
	uint8_t uc_count = 0;
	uint8_t uc_index = 0;
	uint16_t us_temp[7];
	if(0 != Checker_FacBufCheck())
	{
		uc_rtv = 1;
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
		return;
	}
	//管壳号最长 13个字节
	if((checker_runcfg.params[0] + checker_runcfg.params[1] > CHECKER_WRITE_BUF) || checker_runcfg.params[1] > 13)
	{
		uc_rtv = 2;
		Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
		return;
	}
	memset(XT_RunBuf,0,XT_CHECKER_RUN_BUF);
	if(checker_runcfg.uid_len > 0)
	{
		uc_rtv=XT_Read_Shell(checker_runcfg.writeuid,checker_runcfg.uid_len,XT_RunBuf);
    if(uc_rtv) uc_rtv =3;
	}else{
		uc_rtv=XT_Read_Shell_All(XT_RunBuf);
    if(uc_rtv) uc_rtv =4;
	}
	uc_index = checker_runcfg.params[0]+2;
	for(uc_count = 0; uc_count < checker_runcfg.params[1];uc_count++)
	{
		if(Checker_FacBuf[uc_index++] != XT_RunBuf[uc_count])
		{
			uc_rtv =5;
			break;
		}
	}
	if(checker_runcfg.rtv_count > 7)
	{
		checker_runcfg.rtv_count = 7;
	}
	memcpy(us_temp,XT_RunBuf,checker_runcfg.rtv_count<<1);
	Checker_MaskResult(uc_rtv,checker_runcfg.task_info.runindex);
	Checker_SetRtv(us_temp,checker_runcfg.rtv_count);
}

CheckerTask xttaskArray[CHECKER_MAXID_COUNT] ={
Checker_PowerPrapare,	//0 电源准备  
XT_Test_PowerOn,			//1 上电充能
XT_Test_SetBusV,			//2 设置总线电压
XT_Test_BaseCur,			//3 获取总线电流
XT_Test_ScanUID,			//4 扫描UID
XT_Test_WriteChipCfg,	//5 写配置参数
XT_Test_CheckChipCfg,	//6 验证配置
XT_Test_BindTestCode, //7 模拟注码
XT_Test_ChgEnergy,		//8 充能统计
XT_Test_WriteRunField,//9 写现场值 网络id 延时
XT_Test_CheckRunField,//10比对现场值
XT_Test_Resister			,//11 桥丝通断检测
XT_Test_Cap						,//12 电容容量统计
Checker_WaitDelay			,//13 延时等待
XT_Test_WriteShell		,//14 写管壳号/工厂信息
XT_Test_WriteUID			,//15 写UID
XT_Test_WritePWD			,//16 写密码
XT_Test_CheckBackFlag	,//17 写入/检测备份区标志
XT_Test_ReadBackFlag	,//18 读取备份区数据
XT_Test_Trim					,//19 校准
XT_Test_EnCommEndCur	,//20 使能通讯末电流采集
XT_Test_GetCommEndCur	,//21 获取通讯末电流
XT_Test_Discharge			,//22 放电
XT_Test_OneLineCheck	,//23	在线检测
XT_Test_CheckState		,//24 状态检测
XT_Test_Boom					,//25 起爆
XT_Test_Reset					,//26 复位
XT_Test_PowerOFF			,//27 关总线	
XT_Test_LockCmdC			,//28 芯片锁存
XT_Test_CodeBindEn		,//29 使能赋码设备
XT_Test_InputCheck		,//30 在线检测
XT_Test_CheckPWD			,//31 密码验证
XT_Test_LoadChipCfg		,//32 加载芯片配置
XT_Test_CapVoltage		,//33 电容压差测试
Checker_ResistorSample,//34 桥丝电阻测试
XT_Test_UID_PWD_Bind	,//35 检测过程中注码
XT_Test_UID_PWD_Verify,//36 验证注码
XT_OnLine_SCAN        ,//37 模块在线检测
XT_Test_VerfyShell    ,//38 验证管壳码
(void*)0							//数组结束
};

/*
@brief 三码写入
@rtv 0 执行成功
		 1 电压设置失败
		 3 UID写入失败
		 4 密码写入失败
		 5 获取UID失败
		 6 UID写入失败
		 7 锁存失败
		 8 等待接入超时
		 9 已经其他数据
*/

uint8_t XT_UID_PWD_Bind(void)
{
	uint16_t us_h_v;
	uint8_t uc_index = 0, uc_rtv = 0;
  // 雷管厂代码为0时不锁定
  uint8_t lock=checker_runcfg.writeuid[1];
  uint8_t stat_check=0x20;
	ThreeBindResult_flag = 0x00;
	if(checker_runcfg.uid_pwd_bind_flag != 0xAA)
	{
		PowerCalibration_set(Checker_First_Set_Voltage,50);
		XTBUS_ON;
		delay_os_ms(100);
		us_h_v = Power_GetBousV();
		if((us_h_v > (Checker_First_Set_Voltage+5)) || (us_h_v < (Checker_First_Set_Voltage-5)))
		{
      XTBUS_OFF;
			return 1;
		}
		
		if(0 != XT_Test_InputChek_(2000))
		{
      XTBUS_OFF;
			return 8;
		}
		delay_ms(10);
		XT_Init(0x78);
		delay_ms(10);
	}
	/*
		已经注码验证
	*/
	uc_rtv = XT_Test_CheckeThreeCode();
	if(uc_rtv == 0)
	{
		XTBUS_OFF;
		ThreeBindResult_flag = 0x55;
		return 0x55;
	}
	else if(uc_rtv == 1)
	{
		XTBUS_OFF;
		return 0x09;
	}
			
	XT_Write_Uid(checker_runcfg.writeuid,checker_runcfg.uid_len);
	delay_ms(40);
  
  XT_Write_Bmid(checker_runcfg.writepwd,checker_runcfg.pwd_len);
  delay_ms(40);
  
	uc_rtv = XT_Test_UID_PWD_Verify_();
	if(uc_rtv == 0x01)
	{
		
     XTBUS_OFF;
		return 2;
	}else if(uc_rtv == 0x02)
	{
		XTBUS_OFF;
		return 4;
	}
  
  
  if(lock){
    //设置电流挡位0x11 1档。锁定前必须执行该命令
    XT_Set_Current(0x11);
    delay_ms(30);
    XT_Lock();
    delay_ms(40);
    stat_check=0xa0;//锁存后是0xa0
  }
	XT_Clear_Read();
	if(0 != XT_Read_Uid(XT_RunBuf,checker_runcfg.uid_len))
	{
    XTBUS_OFF;
		return 5;//扫描UID不存在
	}
	uc_rtv = rt_memcmp(checker_runcfg.writeuid,XT_RunBuf,checker_runcfg.uid_len);
	if(uc_rtv != 0)
	{
		XTBUS_OFF;
		return 6;
	}
	uc_index = XT_RunBuf[checker_runcfg.uid_len+7];
	if((uc_index & stat_check) != stat_check)
	{
    XTBUS_OFF;
		return 7;
	}
	ThreeBindResult_flag = 0x55;
  XTBUS_OFF;
	return 0x55;
}
