andy/checker_slave
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

移植与电子模块通信相关代码

Browse Source
This commit is contained in:
andy
2023-10-06 18:47:05 +08:00
parent bf440a35bc
commit 8e3a140bec
77 changed files with 13331 additions and 1168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1530
source/elec_det/driver/EWDriver.c Normal file
View File

File diff suppressed because it is too large Load Diff

326
source/elec_det/driver/EWDriver.h Normal file
View File

@@ -0,0 +1,326 @@
#ifndef EWDRIVER_H
#define EWDRIVER_H
#include "base/define.h"
#define EW_DMODE_FRAME_SIZE 16
#
typedef enum {
SINGLE_MOD = (uint8_t)0,
DIFF_MOD = (uint8_t)1,
OFF_MOD = (uint8_t)2,
} EWBus_Mod_en;
typedef enum{
BEGIN_FRAME = (uint8_t)0,
END_FRAME = (uint8_t)1,
DATA_FRAME = (uint8_t)2,
COMPLETE_FRAME = (uint8_t)3,
}EW_SINGLE_FRAME_TYPE_en;
#pragma pack(1)
//系统运行时配置
typedef union {
struct{
uint8_t fire_mos_sw : 2;//起爆mos开关选择 0 内部 1 外部 （默认0）
uint8_t vbus_rx_sg : 2;//接收数据信号 1 vbuss_rxh 2 vbuss_rxl 3 vbusd_rx (默认 3)
uint8_t vbus_mode : 2;//通讯类型判断 01 差分 10 单端。00 11 根据总线电压判断 （默认 01）
uint8_t reserve01 : 2;//保留
uint8_t reset_run_step : 3;//打点周期 0 不打点 1 5ms 2 10ms 3 20ms 4 50ms 5 100ms 6 150ms 7 200ms(默认 0)
uint8_t uid_len : 3;//uid长度 uid_len + 7(默认 1)
uint8_t pwd_len : 2;//密码长度 pwd_len + 4（默认0）
uint8_t version : 5;//模块版本
uint8_t reserve02 : 3;//保留
uint8_t crc8 : 8;//校验位
} runcfg_st;
uint32_t run_param;
uint8_t run_cfg_buf[4];
}RunCfg_un;
typedef union{
//系统状态标志结构体
volatile struct
{
uint8_t timeramend_flag : 1; //时钟校准标志 0
uint8_t saveinfo_flag : 1; //保存延时设置信息 1
uint8_t pswd_flag : 1; //密码验证完成标志 2
uint8_t delay_time : 1; //延时设置完成标志 3
uint8_t addr_set : 1; //网络地址已设置
uint8_t set_super_t : 1; //开启软件复位 5
uint8_t erprom_error : 1; //系统存储错误 6
uint8_t sys_error : 1; //系统运行异常 7
uint8_t charge_8v : 1; //充电电压大于8V 8
uint8_t charge_16V : 1; //充电电压大于16V标志 9
uint8_t charge_20v : 1; //充电电压大于20V 10
uint8_t fireline_flag : 1; //桥丝检测 11
uint8_t charge_ctrl_flag : 1; //充放电开关检测 12
uint8_t mosfet_flag : 1; //MOS开关检测标志 13
uint8_t charge_cmd : 1; //已经发送充电命令 14
uint8_t fire_flag : 1; //已点火 15
uint8_t comm_frame : 1; //通讯帧结束标志
uint8_t factory_check : 1; //工厂自检
uint8_t comm_mode : 1; //通讯模式
uint8_t vbusd_invert : 1; //VBUSD 的极性
uint8_t comm_timeout : 1; //通信超时
uint8_t reserve10 : 1;
uint8_t reserve09 : 1;
uint8_t reserve08 : 1;
uint8_t reserve07 : 1;
uint8_t reserve06 : 1;
uint8_t reserve05 : 1;
uint8_t reserve04 : 1;
uint8_t reserve03 : 1;
uint8_t reserve02 : 1;
uint8_t reserve01 : 1;
uint8_t reserve00 : 1;
} State_st;
volatile uint32_t data;
volatile uint16_t us_data[2];
volatile uint8_t datas[4];
}System_State_un;
#pragma pack()
#define EW_WA_CFG_WRITE 20 //写配置寄存器（掉电不保存）
#define EW_WA_SET_COMMADDR 21 //设置网络地址
#define EW_WA_FAST_CFG 22 //快速配置地址，延时，密码验证
#define EW_WA_SET_DELAY 23 //设置延时
#define EW_RA_VERIFY_PWD 24 //密码验证
#define EW_W_ON_FIRE 25 //起爆
#define EW_W_CHARGE 26 //充电
#define EW_W_DISCHARGE 27 //放电
#define EW_RA_GET_STATE 28 //读状态
#define EW_W_AMEND 29 //时钟校准
#define EW_RA_INSPECT 30 //巡检
#define EW_RA_CHECK_CFG 31 //配置区验证
#define EW_R_ELECT_TEST 32 //电性能检测
#define EW_W_SAVE_FIRE_SET 33 //保存起爆测试
#define EW_RA_READ_DELAY 34 //读延时
#define EW_R_TX_CFG 35 //反码配置
#define EW_WR_UPDATE_ADDR 36 //更新网络地址
#define EW_RA_AMEND_VALUE 37 //读校准值
#define EW_RA_CFG_INFO 38 //读配置信息
#define EW_W_AUTO_ADDR 39 //自动分配地址
#define EW_EN_MTP 40 //使失能MTP
#define EW_RA_UID 41 //读UID
#define EW_COMM_TEST 60 //通信测试没问题
#define EW_BOOTLOADER_RUN 61 //运行bootloader
#define EW_RA_REGISTER 62 //读MTP
#define EW_WA_REGISTER 63 //写MTP
/*
@brief 单端第二版，差分接收数据
@param *buf 数据缓存指针
@param len 读取数据长度
@param time_out 超时脉冲数（约1bit数据时间）
@rtv 0 成功 否则失败
*/
uint8_t DMod_FireBusReadDatasV2(uint8_t* buf, uint8_t len, uint32_t time_out);
/*
@brief 差分模式数据发送
@param buf 发送数据缓存
@param len 发送长度
@param pre 数据脉冲周期
*/
void DMod_SendBytes(uint8_t* buf, uint8_t len, uint16_t pre,uint8_t rw_flag);
void DMod_SendBytesXor(uint8_t* buf, uint8_t len, uint8_t rw_flag);
uint8_t DMod_ReadBytesXor(uint8_t* buf, uint8_t len,uint16_t retry_times);
/*
@breif 通信测试
*/
uint8_t EW_CommTest(uint8_t* buf,uint16_t len,uint16_t cycle);
/*
@brief 使能MTP写
@param addr 通信地址
@param 使能开关
@rtv 执行结果
*/
uint8_t EW_EnWriteMTP(uint16_t addr ,uint8_t en_flag);
/*
@brief 读MTP
@param addr 通信地址
@param mtpaddr MTP地址/4
@param buf 写入数据的缓存
@param len 数据长度
*/
uint8_t EW_WriteMTP(uint16_t addr,uint8_t mtpaddr,uint8_t* buf,uint8_t len);
/*
@brief 读MTP
@param addr 通信地址
@param mtpaddr MTP地址/4
@param buf 读出数据的缓存
@param len 数据长度
*/
uint8_t EW_ReadMTP(uint16_t addr,uint8_t mtpaddr,uint8_t* buf,uint8_t len);
/*
@brief 运行BootLoader程序
@param addr 通信地址
@param reboot 仅重启标准 1 有效
@rtv 返回执行结果 0 成功
*/
uint8_t EW_RunBootLoader(uint16_t addr,uint8_t reboot);
/*
@brief 写运行配置，写入MTP中
@param addr 通信地址
@param runcfg 配置结构体
@rtv 返回执行结果
*/
uint8_t EW_WriteRunCfg(uint16_t addr,RunCfg_un* runcfg);
/*
@brief 快速分配通信地址
@param 通信地址
@param UID
@param uid_len UID长度
@param ack_data 应答数据 包括2bytes延时和2bytes状态
@rtv 执行结果
*/
uint8_t EW_SetAddrByUID(uint16_t addr,uint8_t* uid,uint8_t uid_len,uint8_t* ack_data);
/*
@brief 快速分配通信地址
@param 通信地址
@param 设置延时
@param UID
@param UID长度
@param 应答数据 包括2bytes延时和2bytes状态
@rtv 执行结果
*/
uint8_t EW_FastSetByUID(uint16_t addr,uint16_t delay, uint8_t pwd_flag,uint8_t* uid,uint8_t uid_len,uint8_t* ack_data);
/*
@brief 设置延时
@param addr 通信地址
@param 延期时间
@rtv 返回执行结果
*/
uint8_t EW_SetDelay(uint16_t addr,uint16_t delay);
/*
@brief 密码验证
@param addr 通信地址
@param 密码数据
@param 密码长度
@rtv 返回执行结果
*/
uint8_t EW_VerfyPWD(uint16_t addr,uint8_t* pwd,uint8_t pwd_len);
/*
@brief 密码验证
@param addr 通信地址
@param 延迟起爆时间*50ms
@rtv 返回执行结果
*/
uint8_t EW_Boom(uint16_t addr,uint8_t delay_count);
/*
@brief 分组充电
@param addr 通信地址
@param 充电挡位 0：直通 1 ：16V 2:20V 3：2.5V
@param 分组挡位 addr = group*4 大于addr的可以充电
@rtv 返回执行结果
*/
uint8_t EW_Charge(uint16_t addr,uint8_t chg_class,uint8_t group);
/*
@brief 放电
@param addr 通信地址
*/
uint8_t EW_DisCharge(uint16_t addr);
/*
@brief 读状态信息
@param addr 通信地址
@param *delay 返回延时数据
@param *state 返回状态码
@param len 数据长度
*/
uint8_t EW_ReadState(uint16_t addr,uint8_t* state);
/*
@brief 校准地址
@param addr 通信地址
@param cycle 校准周期 us
@param plus_count 脉冲个数
*/
uint8_t EW_ClkAmend(uint16_t addr ,uint16_t cycle,uint16_t plus_count);
/*
@brief 巡检
@param addr 通信地址
@param cycle 校准周期 us
@param plus_count 脉冲个数
*/
uint8_t EW_Inspect(uint16_t bgaddr ,uint16_t endaddr,uint16_t state,uint8_t* buf);
/*
@brief 配置验证
@param addr 通信地址
@param cfg_mask 源掩码信息
@param 比较信息 (EW_Cfg & cfg_mask) == cfg_state
@param 反码状态 0 比较通过不反码 1 比较通过反码
@param
*/
uint8_t EW_CheckRunCfg(uint16_t addr,uint32_t cfg_mask ,uint16_t cfg_state,uint8_t* rtv);
/*
@brief 配置验证
@param addr 通信地址
@param check_class 检测模式 0 基本自检 1 起爆开关检测 2 电容检测 4 读电容检测时间
@param *buf 读出测试结果
*/
uint8_t EW_ChecSelf(uint16_t addr,uint8_t check_class,uint8_t* buf);
/*
@brief 保持起爆配置信息和使能起爆
*/
uint8_t EW_SaveFireInfo(uint16_t addr);
/*
@brief 读延时和状态值
@param addr 通信地址
@param delay 返回延时
*/
uint8_t EW_ReadDelay(uint16_t addr,uint16_t* delay);
/*
@brief 通信反码配置
@param addr 通信地址
@param speed 通信挡位 0:10K 1:7K 2:5K 3:4.5K 4: 4K 4+n:4-0.5*n
@param cur 电流挡位 0：1mA 1:2mA 2:4mA 3:8mA
*/
uint8_t EW_SetReportCfg(uint8_t speed,uint8_t cur);
/*
@brief 更新网络地址
@param addr 通信地址
@param new_addr 新地址
*/
uint8_t EW_UpdateCommAddr(uint8_t addr,uint16_t new_addr);
/*
@brief 读校准值
@param addr 通信地址
@param clk_amend 校准信息
*/
uint8_t EW_ReadClkAmend(uint16_t addr,uint32_t* clk_amend);
/*
@brief 读校准值
@param addr 通信地址
@param clk_amend 校准信息
*/
uint8_t EW_ReadRunCfgVersion(uint16_t addr,uint8_t* run_cfg,uint16_t* version);
/*
@brief 自动分配地址
@param max_addr 分配的最大地址
@param fac_addr 分配因子
*/
uint8_t EW_AutoSetAddr(uint16_t max_addr,uint16_t fac_addr);
#endif

642
source/elec_det/driver/JQDriver.c Normal file
View File

@@ -0,0 +1,642 @@
#include "JQDriver.h"
#include "base/delay.h"
#include "hardware/adc_cfg.h"
#include "base/utility.h"
#include "hardware/power.h"
#include "hardware/timer_cfg.h"
#include "hardware/power.h"
static uint16_t jq_idle_current;
#define JQ_IDLE_NOISE 100
#if JQ_Read_AD_Sample_C > FIREBUS_ADC_BUF_LEN
#error "JQDriver.c Firbus AD Sample BUFFER SIZE LIMIT"
#else
volatile uint16_t* JQ_Read_AD_V = FireBus_ADC_Buf;
#endif
static uint16_t jq_ad_last_sample;
static volatile CurrentSample_Range_eu buscurrent_range = Current_Max;
uint16_t JQ_FreeBack_MaxCur;
uint16_t JQ_FreeBack_MaxTime;
uint16_t JQ_FreeBack_MinCur;
uint16_t JQ_FreeBack_MinTime;
uint16_t JQ_CommEnd_MaxCur = 0;
uint8_t JQ_CommEnd_CurEn = 0;
uint16_t JQ_EnFreeBack_Test = 0;
static void JQ_CommBegin()
{
CurrentSampleR_Def;
WaitDelayEnd(200);//20ms
}
static void JQ_CommEnd()
{
uint16_t us_temp;
StartDelayTime();
if(JQ_CommEnd_CurEn > 0)
{
delay_os_ms(10);
us_temp = ADC_Comm1p6mA_EndCur();
if(us_temp > JQ_CommEnd_MaxCur)
{
JQ_CommEnd_MaxCur = us_temp;
}
}
CurrentSampleR_Def;
}
/*
@brief 采样总线反馈数据
@param sample_count 采样次数
*/
static void JQ_Sample(uint16_t sample_count)
{
uint16_t us_adv = 0;
uint16_t ul_count = 0;
jq_ad_last_sample = GetADC_Fast(ADC_CURR_DE);
for(ul_count = 0;ul_count < sample_count; ul_count++)
{
us_adv = GetADC_Fast(ADC_CURR_DE);
JQ_Read_AD_V[ul_count] = us_adv;
jq_ad_last_sample = us_adv;
}
}
/*
@brief 通信反码信息初始化
*/
void JQ_FreeBack_Prapare(uint8_t enable_flag)
{
JQ_FreeBack_MaxCur = 0;
JQ_FreeBack_MaxTime = 0;
JQ_FreeBack_MinCur = 0xFFFF;
JQ_FreeBack_MinTime = 0xFFFF;
JQ_EnFreeBack_Test = enable_flag;
}
//@brief 采样空闲电流
void JQ_SampleIdleCurrent()
{
uint16_t sample_count;
uint32_t ul_adc_v = 0;
JQBUS_W_1;
delay_ms(1);
JQ_Sample(JQ_Read_AD_Sample_C_IDLE);
Bubble_Sort_u16((uint16_t*)JQ_Read_AD_V,JQ_Read_AD_Sample_C_IDLE);
sample_count = 15;
while(sample_count < 25)
{
ul_adc_v +=JQ_Read_AD_V[sample_count++];
}
jq_idle_current = ul_adc_v/10 + JQ_IDLE_NOISE;
delay_us(200);
JQBUS_W_0
delay_us(2000);
}
/*
@brief 读取1bit数据
@rtv 返回读取结果
*/
uint16_t JQDriver_SAMPLE_Time;
uint8_t JQ_ReadBit(void)
{
uint16_t sample_count = 0;
uint32_t ul_adv_sum = 0;
uint8_t uc_bit = 0;
uint16_t uc_mincur_index = 0;
JQBUS_W_1;
delay_us(150);
Get1usCount();
JQ_Sample(JQ_Read_AD_Sample_C);
JQDriver_SAMPLE_Time = Get1usCount();
JQBUS_W_0;
while(sample_count < JQ_Read_AD_Sample_C)
{
if(JQ_Read_AD_V[sample_count] > jq_idle_current )
{
uc_bit++;
ul_adv_sum += JQ_Read_AD_V[sample_count] ;
}else if(uc_bit < 2)//连续两个大于2启动检测
{
uc_bit = 0;
ul_adv_sum = 0;
}
sample_count++;
}
if(uc_bit > 10)
{
/***************记录反码信息*************************/
ul_adv_sum = ul_adv_sum / uc_bit;
if( JQ_EnFreeBack_Test > 0 )
{
if(JQ_FreeBack_MaxCur == 0)
{
JQ_FreeBack_MaxCur = JQ_FreeBack_MinCur = ul_adv_sum;
}else if(ul_adv_sum > JQ_FreeBack_MaxCur){
JQ_FreeBack_MaxCur = ul_adv_sum;
}else if(ul_adv_sum < JQ_FreeBack_MinCur){
JQ_FreeBack_MinCur = ul_adv_sum;
}
if(JQ_FreeBack_MaxTime == 0)
{
JQ_FreeBack_MaxTime = JQ_FreeBack_MinTime = uc_bit;
}else if(uc_bit > JQ_FreeBack_MaxTime)
{
JQ_FreeBack_MaxTime = uc_bit;
}else if(uc_bit < JQ_FreeBack_MinCur){
JQ_FreeBack_MinTime = uc_bit;
}
}
delay_us(1100);
return 1;
}else{
delay_us(350);
return 0;
}
}
/*
@brief 发送不读反馈信号的命令
@param buf 命令字节缓存区
@param len 缓存区数据长度
*/
void JQ_SendBroadCast(uint8_t* buf,uint16_t len)
{
uint8_t uc_data;
uint8_t uc_bitcount;
JQ_CommBegin();
JQBUS_W_0;
delay_ms(2);
while(len > 0)
{
uc_bitcount = 0;
uc_data = *buf;
while(uc_bitcount < 8){
if((uc_data & 0x80) > 0)
{
JQBUS_W_1;
delay_us(JQBUS_H_PLUS);
JQBUS_W_0;
delay_us(JQBUS_L_PLUS);
}else{
JQBUS_W_1;
delay_us(JQBUS_L_PLUS);
JQBUS_W_0;
delay_us(JQBUS_H_PLUS);
}
uc_bitcount++;
uc_data <<= 1;
}
len--;
buf++;
}
JQBUS_IDLE;
JQ_CommEnd();
}
//@breif 发送读取命令
static void JQ_SendReadCmd(uint8_t* cmd_buf,uint16_t w_len)
{
uint8_t uc_data;
uint8_t uc_bitcount;
JQBUS_W_0;
delay_ms(2);
while(w_len > 0)
{
uc_bitcount = 0;
uc_data = *cmd_buf;
while(uc_bitcount < 8){
if((uc_data & 0x80) > 0)
{
JQBUS_W_1;
delay_us(JQBUS_H_PLUS);
JQBUS_W_0;
delay_us(JQBUS_L_PLUS);
}else{
JQBUS_W_1;
delay_us(JQBUS_L_PLUS);
JQBUS_W_0;
delay_us(JQBUS_H_PLUS);
}
uc_bitcount++;
uc_data <<= 1;
}
w_len--;
cmd_buf++;
}
JQBUS_RWIDLE;
}
/*
@brief 发送待反馈的命令
@param cmd_buf 命令数据缓存区
@param read_buf 数据反馈缓存区
@param w_len 发送缓冲区数据长度
@param r_len =0 读取1bit应答信号 > 0,读取数据长度
@rtv 应答ACK
*/
uint8_t JQ_SendRead(uint8_t* cmd_buf, uint8_t* read_buf,uint16_t w_len,uint16_t r_len)
{
uint8_t uc_data;
uint8_t ack = 0;
uint8_t uc_bitcount;
JQ_CommBegin();
if(w_len > 0)
{
JQ_SendReadCmd(cmd_buf,w_len);
}
Power_SetSampleRange_Seep(JQDriver_Sample_R,ADC_SPEED_HIGH);
JQ_SampleIdleCurrent();
while(r_len > 0)
{
uc_data = 0;
uc_bitcount = 0;
while(uc_bitcount < 8)
{
uc_data <<= 1;
uc_data |= (JQ_ReadBit() & 0x01);
uc_bitcount++;
}
*read_buf = uc_data;
r_len--;
read_buf++;
}
ack = JQ_ReadBit();
JQBUS_IDLE;
Power_SetSampleCurrentRange(Current_Max);
JQ_CommEnd();
return ack;
}
/*
@breif 起爆命令
@param cmd_count 起爆命令发送次数
@param read_buf 读取ACK数据，1bit代表一个网络号
@param run_type 0 不读取应答信号 =1 读取应答信号 >1 读取应答信号，且强制反馈收到应答
*/
void JQ_BoomCmd(uint8_t cmd_count,uint8_t* read_buf,uint8_t run_type)
{
static uint8_t JQBoomcmd[2]={0xA9,0xB5};
static uint8_t JQBoomEnCmd[2] = {0x7A,0xB7};
uint16_t us_pluscount = 0;
uint8_t uc_data,uc_bitcount,send_count;
send_count = 0;
while(send_count < cmd_count)
{
JQ_SendBroadCast(JQBoomEnCmd,2);
delay_os_ms(20);
send_count++;
}
if(run_type == 0)
{
while(cmd_count > 0)
{
//JQ_SendBroadCast(JQBoomcmd,2);
delay_os_ms(20);
JQ_SendRead(JQBoomcmd,&uc_data,2,0);
cmd_count--;
}
us_pluscount = 0;
while(us_pluscount < 680)
{
JQBUS_W_1
delay_us(1000);
JQBUS_W_0
delay_us(400);
us_pluscount++;
}
}else{
while(cmd_count > 0)
{
delay_os_ms(20);
JQ_SendRead(JQBoomcmd,&uc_data,2,0);
cmd_count--;
}
Power_SetSampleRange_Seep(JQDriver_Sample_R,ADC_SPEED_HIGH);
JQ_SampleIdleCurrent();
while(us_pluscount < 680)
{
uc_data = 0;
uc_bitcount = 0;
while(uc_bitcount < 8)
{
uc_data <<= 1;
uc_data |= (JQ_ReadBit() & 0x01);
if((run_type > 1) && (uc_data& 0x01) < 1)
{
delay_us(750);
}
uc_bitcount++;
us_pluscount++;
}
*read_buf = uc_data;
read_buf++;
}
}
Power_SetSampleCurrentRange(Current_Max);
JQBUS_IDLE;
JQ_CommEnd();
}
/*
@breif 起爆使能
*/
void JQ_CheckerEnBoomCmd()
{
static uint8_t JQBoomEnCmd[2] = {0x7A,0xB7};
JQ_SendBroadCast(JQBoomEnCmd,2);
}
/*
@breif 起爆命令
@param plus_count 巡检脉冲个数
@rtv 巡检应答Ack 的脉冲个数
*/
uint16_t JQ_CheckerBoomCmd(uint16_t plus_count,uint16_t* us_shake)
{
static uint8_t JQBoomcmd[2]={0xA9,0xB5};
uint16_t us_pluscount = 0;
uint16_t us_ack_plus = 0;
uint16_t sample_count = 0;
uint16_t us_bitcount = 0;
uint16_t us_temp_shake;
uint16_t us_max,us_min;
JQ_CheckerEnBoomCmd();
delay_ms(20);
JQ_SendBroadCast(JQBoomcmd,2);
Power_SetSampleRange_Seep(JQDriver_Sample_R,ADC_SPEED_HIGH);
JQ_SampleIdleCurrent();
*us_shake = JQ_Read_AD_V[JQ_Read_AD_Sample_C_IDLE-2] - JQ_Read_AD_V[2];
while(us_pluscount < plus_count)
{
JQBUS_W_1;
delay_us(100);
//700us 延时
JQ_Sample(JQ_Read_AD_Sample_C);
GetMaxAndMinValue((uint16_t*)JQ_Read_AD_V,JQ_Read_AD_Sample_C,&us_max,&us_min);
us_min = us_max - us_min;
JQBUS_W_0;
sample_count = 0;
while(sample_count < JQ_Read_AD_Sample_C)
{
if(JQ_Read_AD_V[sample_count] > jq_idle_current )
{
us_bitcount++;
}else if(us_bitcount < 2)
{
us_bitcount = 0;
}
sample_count++;
}
if(us_bitcount > 6)
{
if(us_ack_plus == 0)
{
us_ack_plus = us_pluscount;
}
else{
us_ack_plus = ~0;
}
delay_us(50);
us_bitcount = 3;
}else{
if(us_min > *us_shake)
{
*us_shake = us_min;
}
delay_us(100);
us_bitcount = 3;
}
while(us_bitcount > 0)
{
JQ_Sample(JQ_Read_AD_Sample_C>>1);
GetMaxAndMinValue((uint16_t*)JQ_Read_AD_V,JQ_Read_AD_Sample_C>>1,&us_max,&us_min);
us_min = us_max - us_min;
if(us_min > *us_shake)
{
*us_shake = us_min;
}
us_bitcount--;
}
us_pluscount++;
}
JQBUS_IDLE;
JQ_CommEnd();
return us_ack_plus;
}
static uint16_t amend_endflag = 0;
//@brief 总线波形翻转
void JQ_TriggerPlus(uint8_t flag)
{
if(flag == 1)
{
JQBUS_W_0;
}else if(flag > 1){
JQBUS_W_1;
}
amend_endflag = flag;
}
//@brief 时钟校准
void JQ_TimeAmend(uint16_t cycle,uint16_t delayMs)
{
static uint8_t cmd_buf = 0x34;
JQ_SendBroadCast(&cmd_buf,1);
delay_os_ms(2);
FireBus_ClkAmend(cycle, cycle/2, delayMs+100,JQ_TriggerPlus);
while(amend_endflag != 3)
{
delay_ms(10);
}
JQBUS_IDLE;
delay_os_ms(20);
}
//@breif 巡检
void JQ_Inspect(uint16_t maxcount,uint8_t* buf,uint8_t state)
{
static uint8_t cmd_buf[]={0x97,0x00,0x00,0x00};
cmd_buf[3] = state;
JQ_SendRead(cmd_buf,buf,4,(maxcount+7)/8);
}
//@brief 启动UID扫描
void JQ_ScanUIDBegin()
{
static uint8_t start_readuid_cmd = 0x54;
JQ_SendBroadCast(&start_readuid_cmd,1);
}
//@brief 扫描模式读取UID
uint8_t JQ_ScanReadUID(uint16_t begnet,uint8_t* uidbuf)
{
static uint8_t scan_uid_cmd[]={0x59,0x00,0x00};
uint8_t time_out = 3;
uint8_t*p_buf = uidbuf;
uint8_t ack;
rt_memset(p_buf,0,8);
while(time_out > 0)
{
scan_uid_cmd[1] = (begnet >> 8);
scan_uid_cmd[2] = begnet,
ack = JQ_SendRead(scan_uid_cmd,p_buf,3,8);
if(ack > 0)
{
return ack;
}else{
delay_os_ms(20);
time_out--;
}
}
return 0;
}
//@brief 读延时
uint8_t JQ_ReadDelay(uint16_t netid,uint16_t* delaybuf)
{
static uint8_t cmd_buf[3]={0x63,0x00,0x00};
cmd_buf[1] = (netid >> 8);
cmd_buf[2] = netid;
return JQ_SendRead(cmd_buf,(uint8_t*)delaybuf,3,2);
}
//@brief 写延时
void JQ_WriteDelay(uint16_t netid,uint16_t delay)
{
static uint8_t cmd_buf[5]={0x68};
cmd_buf[1] = (netid >> 8);
cmd_buf[2] = netid;
cmd_buf[3] = (delay >> 8);
cmd_buf[4] = delay;
JQ_SendBroadCast(cmd_buf,5);
}
//@brief 验证密码
void JQ_VerifyPWD(uint8_t* pwd)
{
static uint8_t cmd_buf[5] = {0x76};
rt_memcpy(&cmd_buf[1],pwd,4);
JQ_SendBroadCast(cmd_buf,5);
}
//@brief 使能起爆
void JQ_BoomActive(void)
{
static uint8_t cmd_buf[] = {0x7A,0xB7};
JQ_SendBroadCast(cmd_buf,2);
}
//@brief 设置充电检测判线
void JQ_ChargJudge(uint8_t dac)
{
static uint8_t cmd_buf[] = {0x82,0x00};
cmd_buf[1] = dac;
JQ_SendBroadCast(cmd_buf,2);
}
//@brief 充电
void JQ_Chage(uint16_t bgnet)
{
static uint8_t cmd_buf[3] = {0x89};
cmd_buf[1] = bgnet>>8;
cmd_buf[2] = bgnet;
JQ_SendBroadCast(cmd_buf,3);
}
//@brief 放电
void JQ_DisChage(void)
{
static uint8_t cmd_buf[1] = {0x8A};
JQ_SendBroadCast(cmd_buf,1);
}
//@brief 快速放电
void JQ_FastDisChage(uint8_t sw)
{
static uint8_t cmd_buf[2] = {0x8B};
cmd_buf[1] = sw;
JQ_SendBroadCast(cmd_buf,2);
}
//@brief 复位
void JQ_Reset(void)
{
static uint8_t cmd_buf[2] = {0x55,0xAA};
JQ_SendBroadCast(cmd_buf,2);
}
//@breif 读芯片ID
uint8_t JQ_ReadChipID(uint16_t netid,uint16_t* chipid)
{
static uint8_t cmd_buf[3] = {0x23};
cmd_buf[1] = netid>>8;
cmd_buf[2] = netid;
return JQ_SendRead(cmd_buf,(uint8_t*)chipid,3,2);
}
//@brief 读OTP
uint8_t JQ_ReadOTP(uint16_t netid,uint8_t otp_bgaddr,uint8_t read_count,uint8_t* readbuf)
{
static uint8_t cmd_buf[4] = {0x2A};
uint8_t otp_endaddr = otp_bgaddr+ read_count;
cmd_buf[1] = netid>>8;
cmd_buf[2] = netid;
cmd_buf[3] = otp_bgaddr;
while(otp_bgaddr < otp_endaddr)
{
cmd_buf[3] = otp_bgaddr;
if(JQ_SendRead(cmd_buf,readbuf,4,1) == 0)
{
break;
}
delay_os_ms(20);
readbuf++;
otp_bgaddr++;
}
return read_count - (otp_endaddr - otp_bgaddr);
}
//@brief 写OTP
uint8_t JQ_WriteOTP(uint8_t otp_bgaddr,uint8_t write_count,uint8_t* writebuf)
{
static uint8_t cmd_buf[3] = {0x1A};
uint8_t otp_endaddr = otp_bgaddr+ write_count;
while(otp_bgaddr < otp_endaddr)
{
cmd_buf[1] = otp_bgaddr;
cmd_buf[2] = *writebuf;
JQ_SendBroadCast(cmd_buf,3);
delay_os_ms(20);
writebuf++;
otp_bgaddr++;
}
return write_count - (otp_endaddr - otp_bgaddr);
}
//写OTP使能
void JQ_EnWOTP(void)
{
static uint8_t cmd_buf[2] = {0x1E,0xC9};
JQ_SendBroadCast(cmd_buf,2);
}
//@breif 读取单发状态
uint8_t JQ_ReadState(uint16_t netid,uint8_t* state)
{
static uint8_t cmd_buf[3] = {0x91};
cmd_buf[1] = netid>>8;
cmd_buf[2] = netid;
return JQ_SendRead(cmd_buf,state,3,1);
}
//@braief 设置通信电压模式
uint8_t JQ_SetPowerMode(uint16_t h_vol,uint16_t m_vol)
{
return 0;
}

82
source/elec_det/driver/JQDriver.h Normal file
View File

@@ -0,0 +1,82 @@
#ifndef JQDRIVER_H_
#define JQDRIVER_H_
#include "base/define.h"
#include "hardware/gpio_cfg.h"
#include "hardware/adc_cfg.h"
#include "base/delay.h"
#define JQBUS_IDLE JQBUS_W_1
#define JQBUS_RWIDLE JQBUS_W_1
#define JQBUS_H_PLUS 300
#define JQBUS_L_PLUS 700
#define JQ_Read_AD_Sample_C 140
#define JQ_Read_AD_Sample_C_IDLE 80
extern uint16_t JQ_FreeBack_MaxCur;
extern uint16_t JQ_FreeBack_MaxTime;
extern uint16_t JQ_FreeBack_MinCur;
extern uint16_t JQ_FreeBack_MinTime;
extern uint16_t JQ_CommEnd_MaxCur ;
extern uint8_t JQ_CommEnd_CurEn ;
//@brief 读OTP
uint8_t JQ_ReadOTP(uint16_t netid,uint8_t otp_bgaddr,uint8_t read_count,uint8_t* readbuf);
//@breif 读取单发状态
uint8_t JQ_ReadState(uint16_t netid,uint8_t* state);
//@brief 写延时
void JQ_WriteDelay(uint16_t netid,uint16_t delay);
//@brief 读延时
uint8_t JQ_ReadDelay(uint16_t netid,uint16_t* delaybuf);
//@brief 启动UID扫描
void JQ_ScanUIDBegin(void);
//@brief 扫描模式读取UID
uint8_t JQ_ScanReadUID(uint16_t begnet,uint8_t* uidbuf);
//@brief 充电
void JQ_Chage(uint16_t bgnet);
//@brief 放电
void JQ_DisChage(void);
//@brief 复位
void JQ_Reset(void);
//@brief 使能起爆
void JQ_BoomActive(void);
//@brief 时钟校准
void JQ_TimeAmend(uint16_t cycle,uint16_t delay_ms);
//写OTP使能
void JQ_EnWOTP(void);
//@brief 写OTP
uint8_t JQ_WriteOTP(uint8_t otp_bgaddr,uint8_t write_count,uint8_t* writebuf);
/*
@breif 起爆命令
@param cmd_count 起爆命令发送次数
@param read_buf 读取ACK数据，1bit代表一个网络号
@param run_type 0 不读取应答信号 =1 读取应答信号 >1 读取应答信号，且强制反馈收到应答
*/
void JQ_BoomCmd(uint8_t cmd_count,uint8_t* read_buf,uint8_t run_type);
/*
@breif 起爆命令
@param plus_count 巡检脉冲个数
@rtv 巡检应答Ack 的脉冲个数
*/
uint16_t JQ_CheckerBoomCmd(uint16_t plus_count,uint16_t* us_shake);
//@breif 巡检
void JQ_Inspect(uint16_t maxcount,uint8_t* buf,uint8_t state);
//@brief 设置充电检测判线
void JQ_ChargJudge(uint8_t dac);
//@brief 验证密码
void JQ_VerifyPWD(uint8_t* pwd);
//@breif 读芯片ID
uint8_t JQ_ReadChipID(uint16_t netid,uint16_t* chipid);
//@brief 快速放电
void JQ_FastDisChage(uint8_t sw);
/*
@brief 通信反码信息初始化
*/
void JQ_FreeBack_Prapare(uint8_t enable_flag);
#endif

356
source/elec_det/driver/LGDriver.c Normal file
View File

@@ -0,0 +1,356 @@
//-------------------------------------------------------------------------------------------------------
//本文件是雷管驱动的底层程序，不对外
//-------------------------------------------------------------------------------------------------------
#include "LGDriverAPI.h"
#include "LGDriver.h"
#include "board.h"
#define Long_Time 650
#define Short_Time 400
//============================================================================
//接收波形转换
//============================================================================
static void LG_Receive_Switch(void)
{
LGDRV_PHA_H();
Lib_delay_us(1000);
LGDRV_PHA_L();
Lib_delay_us(1000);
}
static u8 LG_ReceiveBit() //扫描用接收位
{
u8 ReturnBit = 0, ValueCnt = 0;
u16 OffsetTime = 0;
LGDRV_PHA_H();
ValueCnt = Lib_CountFeedBackData(&OffsetTime);
LGDRV_PHA_L(); //这个放到了Lib_CountFeedBackData里面了
if(ValueCnt > 0)
{
ReturnBit = 1;
PA11_1();
// if(950 > OffsetTime)
// Lib_delay_us(950 - OffsetTime);
// else
// Lib_delay_us(950);
Lib_delay_us(950);
PA11_0();
}
else
{
ReturnBit = 0;
// if(500 > OffsetTime)
// Lib_delay_us(500 - OffsetTime);
// else
// Lib_delay_us(500);
Lib_delay_us(500);
}
return ReturnBit;
}
//============================================================================
//发送一个字节
//输入参数：要发送的数据
//============================================================================
static void LG_SendByte(u8 dat)
{
u8 i;
u16 time_h, time_l;
for(i = 0; i < 8; i++)
{
if(dat & 0x80)
{
time_h = Short_Time;
time_l = Long_Time;
}
else
{
time_h = Long_Time;
time_l = Short_Time;
}
LGDRV_PHA_H();
Lib_delay_us(time_h);
LGDRV_PHA_L();
Lib_delay_us(time_l);
dat <<= 1;
}
}
//============================================================================
//发送一个字节 校时专用，仅高低时间和通用发送有差异
//输入参数：要发送的数据
//============================================================================
static void LG_SendByte_CaliTime(u16 dat)
{
u16 i;
//u16 time_h = 496 - Close_Pmos_Delay * 2, time_l = 496 - Open_Pmos_Delay * 2; //150ms=150ms 1000=1000.07 12000=12000.70
for(i = 0; i < dat; i++)
{
LGDRV_PHA_H();
Lib_delay_us(496);
LGDRV_PHA_L();
Lib_delay_us(Lib_SetDelayData(Lib_CaliTime));
Lib_ResetWdg();
}
}
//============================================================================
//接收一个字节
//返回值：接收到的数据
//============================================================================
static u8 LG_ReceiveByte(void)
{
u8 BitValue, ReturnData = 0, i;
for (i = 0; i < 8; i++)
{
BitValue = LG_ReceiveBit();
ReturnData <<= 1;
ReturnData += BitValue;
}
return ReturnData;
}
//============================================================================
//接收参数
//返回值：接收到的数据
//============================================================================
u8 LG_ReceiveParameter(u8 *Parameter, u8 Length)
{
u8 i = 0;
u8 ret = 0;
//OUTA输出高低电压标志 1:输出电压 0:输出高电压
Lib_SetPowerOutAhSwitch(1);
//接收转换
LG_Receive_Switch();
for(i = 0; i < Length; i++)
{
Parameter[i] = LG_ReceiveByte();
}
ret = LG_ReceiveBit();
//OUTA输出高低电压标志 1:输出电压 0:输出高电压
Lib_SetPowerOutAhSwitch(0);
LGDRV_PHA_H();
return ret;
}
//接收单bitAck
u8 LG_ReceiveAck(void)
{
u8 ret = 0;
u8 i;
//OUTA输出高低电压标志 1:输出电压 0:输出高电压
Lib_SetPowerOutAhSwitch(1);
//接收转换
LG_Receive_Switch();
for(i = 0; i < 1; i++)
{
ret += LG_ReceiveBit();
}
//OUTA输出高低电压标志 1:输出电压 0:输出高电压
Lib_SetPowerOutAhSwitch(0);
LGDRV_PHA_H();
return ret;
}
//接收单bit数据
u16 LG_ReceiveSingleBit(u8 *Parameter, u16 Length, u8 bit)
{
u16 i;
u8 j = 0;
u16 ret = 0;
//OUTA输出高低电压标志 1:输出电压 0:输出高电压
Lib_SetPowerOutAhSwitch(1);
//接收转换
LG_Receive_Switch();
for(i = 0; i < Length; i++)
{
j = LG_ReceiveBit();
if(j > 0)
{
Parameter[i] |= bit;
ret++;
}
else
{
Parameter[i] &= ~bit;
}
}
//OUTA输出高低电压标志 1:输出电压 0:输出高电压
Lib_SetPowerOutAhSwitch(0);
LGDRV_PHA_H();
return ret;
}
//延时起爆波形:总计发送660个波形，雷管数量状态位+补发波形 总计660个波形 雷管累计到652个波形会起爆
u16 LG_ReceiveDetBomming(u8 *pStatus, u16 Length, u8 allow)
{
u16 j = 0;
u16 i = 0;
u16 ret = 0, tmp = 0;
//OUTA输出高低电压标志 1:输出电压 0:输出高电压
Lib_SetPowerOutAhSwitch(0);
//接收转换
LG_Receive_Switch();
//按实际雷管数据接收数据位
for(i = 0; i < (Length + 1); i++)
{
j = LG_ReceiveBit();
if(j > 0)
{
tmp++;
//记录起爆反馈状态
pStatus[i] |= 0x04; //cBoomStatus
}
else
{
//记录起爆反馈状态
pStatus[i] &= ~0x04; //~cBoomStatus
}
}
//存储实际雷管数量
ret = tmp;
//OUTA输出高低电压标志 1:输出电压 0:输出高电压
Lib_SetPowerOutAhSwitch(0);
//起爆数量不对 且 不允许起爆，JQ版本
#if 0
//直接起爆，不判断数量，YM版本
if((Length > tmp) && ((Length - tmp) > allow))
{
//中止起爆，主循环查询更新状态
LGDRV_PHA_H();
return ret;
}
#endif
//预留2 0：正常模式，真实对码，真实起爆；1：真实对码，模拟起爆；2：全0对码，真实起爆；3：全0对码，模拟起爆
if((1 == ConfigData.Reserved2) || (3 == ConfigData.Reserved2))
{
if(0xFF == allow)
{
LGDRV_PHA_H();
return ret;
}
}
for(i = 0; i < (660 - (Length + 1)); i++) //必爆651 发送660
{
LGDRV_PHA_H();
Lib_delay_us(600);
LGDRV_PHA_L();
Lib_delay_us(400);
Lib_ResetWdg();
}
LGDRV_PHA_H();
return ret;
}
//发送延时起爆用来清除波形计数--接收1个bit
void LG_CleanWave_Receive(void)
{
//接收转换
LG_Receive_Switch();
LG_ReceiveBit();
}
//============================================================================
//发送功能指令
//输入参数：要发送的功能码数据
//============================================================================
void LG_SendCommand(u8 Function, u8 *Parameter, u8 Length)
{
u8 i = 0;
LGDRV_PHA_H();
Lib_delay_ms(11);
/*******开始信号********/
LGDRV_PHA_L();
Lib_delay_us(1500);
LGDRV_PHA_H();
/***********************/
LG_SendByte(Function);//发送指令
for(i = 0; i < Length; i++)
{
LG_SendByte(Parameter[i]);//发送参数
}
LGDRV_PHA_H();
}
//校时指令
void LG_SendCorrectTimeCommand(u8 Function, u16 time)
{
LGDRV_PHA_H();
Lib_delay_ms(11);
LGDRV_PHA_L();
Lib_delay_us(1500);
LGDRV_PHA_H();
LG_SendByte(Function);
time += 100;
LG_SendByte_CaliTime(time);
LGDRV_PHA_H();
}

21
source/elec_det/driver/LGDriver.h Normal file
View File

@@ -0,0 +1,21 @@
#ifndef __LGDRIVER_H
#define __LGDRIVER_H
//--------------------static------------------------------------
void LG_Receive_Switch(void);
u8 LG_ReceiveBit(void);
void LG_SendByte(u8 dat);
void LG_SendByte_CaliTime(u16 dat);
u8 LG_ReceiveByte(void);
//--------------------static------------------------------------
//接收单bitAck
u8 LG_ReceiveAck(void);
u8 LG_ReceiveParameter(u8 *Parameter, u8 Length); //接收参数
u16 LG_ReceiveSingleBit(u8 *Parameter, u16 Length, u8 bit); //接收单bit数据
u16 LG_ReceiveDetBomming(u8 *pStatus, u16 Length, u8 allow); //延时放电
void LG_SendCommand(u8 Function, u8 *Parameter, u8 Length); //发送功能指令
void LG_SendCorrectTimeCommand(u8 Function, u16 time); //校时指令
//发送延时起爆用来清除波形计数--接收1个bit
void LG_CleanWave_Receive(void);
#endif

1268
source/elec_det/driver/XTDriver.c Normal file
View File

File diff suppressed because it is too large Load Diff

187
source/elec_det/driver/XTDriver.h Normal file
View File

@@ -0,0 +1,187 @@
#ifndef XTDRIVER_H
#define XTDRIVER_H
#include "base/define.h"
#include "hardware/gpio_cfg.h"
#include "hardware/adc_cfg.h"
#include "base/delay.h"
#include "hardware/power.h"
#include <rtthread.h>
#define XTBUS_IDLE XTBUS_W_1
#define XTBUS_RWIDLE XTBUS_WR_1
#define XT_Read_AD_Sample_C 120
#define XT_ADC_SAMPLE_TIME 589u //采样 XT_Read_AD_Sample_C 所需时间
#define XTREGISTERVOLTAGE 80
#define XTCOMMHIGHVOLTAGE 100 //10V 1200米干线可以，1400米干线电压不够
#define XTCHARGEINSTRUCTIONVOLTAGE 160
#define XTCOMMMEDIUMVOLTAGE 80
#define XTCHARGEVOLTAGE 260 //充电20V 1200米电压不够， 充电18V 1200米分档充能充满
#define XTBIT0 0
#define XTBIT1 1
#define XTFIRSTDELAY 138
#define XTFIRSTCYCLE 108
#define XTSECONDDELAY 128
#define XTSECONDCYCLE 118
#define XTTHRIDDELAY 123
#define XTTHRIDCYCLE 118
#define XTOTHERDELAY 123
#define XTOTHERCYCLE 113
#define XT_DAT_PLUS_T 100
#define XT_BIT_DELAY 180
#define XT_TRIM_DELAY 293
#define XTTRIMCYCLE 693
//#define XTFIRSTDELAY 140 //1200米低温可能芯片识别不出来指令
//#define XTFIRSTCYCLE 140
//#define XTSECONDDELAY 110
//#define XTSECONDCYCLE 110
//#define XTTHRIDDELAY 110
//#define XTTHRIDCYCLE 110
//#define XTOTHERDELAY 110
//#define XTOTHERCYCLE 110
//#define XTBITDELAY 180
//#define XTTRIMDELAY 293
//#define XTTRIMCYCLE 693
#define XTCmdAndSquareUs 700 //指令与方波的时间间隔
#define XTTimOverflowUs 100 //TIM定时器溢出时间
#define XTSquareLowTimNum 12 //方波低电平TIM溢出数 这个时间让电容充电 100us后才会开始充电 //原值7 越长反馈幅度越大，最大15
#define XTSquareCollectTimNum 1 //方波高电平内采样TIM溢出数
#define XTSquareHighTimNum 7 //方波高电平TIM溢出数 确保比芯片反馈完多100us，最小7，最大15，短点好
#define XTCollectResistance 2 //2 - R10_4ma_54ma_MC 3-R1_33ma_540ma_MC
#define XTCollectADCChannel AN_MAL_CH //AN_UA_CH AN_MAL_CH
#define XTCollectIncrementValue 150 //最小200mV 低温下扫描间隔长一点70ms，300ms一个，短了电压会不够 抢反馈
#define XTCollectSumValue 1500
#define XTSingleCollectAckValue 800 //单发检测
#define XTConfirmAckCount 10
#define XTCollectTimerPrescaler 72 //1us
#define XTCollectTimerOverflowUs 600 //600us //450us //要将反馈全部包进去，反馈开始时间最晚在边沿后350us
#define XTSingleCollectTimerPrescaler 7200 //0.1ms
#define XTSingleCollectTimerOverflowMs 500 //50ms
#define XTSingleCollectAckTimerOverflowCnt 20000 //2s //单发充电完成
#define XTWriteBitTimerOverflowCnt 500 //50ms 指令应答超时
#define XT_ADC_BUF_LEN 140
//************************************************************************//
#define XT_CMDA_WRITE_FIELD 0xEC //写现场值
#define XT_CMDA_READ_FIELD 0xEF //读现场值
#define XT_CMDA_READ_SHELL 0xF4 //读管壳码
#define XT_CMDA_READ_PARAM 0xF1 //读测量参数值
#define XT_CMDA_MEASURE_RES 0xF8 //测量药头电阻
#define XT_CMDA_MEASURE_CAP 0xDB //测量储能电容
#define XT_CMDA_CHARGE 0xDD //单发充电
#define XT_CMDB_CLEAR_READH 0x1F //清除已读状态高8位
#define XT_CMDB_CLEAR_READL 0x2A //清除已读状态低8位
#define XT_CMDB_FIREH 0x3C //起爆高8位
#define XT_CMDB_FIREL 0xC8 //起爆低8位
#define XT_CMDB_INITH 0x1A //初始化寄存器高8位
#define XT_CMDB_INITL 0x61 //初始化寄存器低8位
#define XT_CMDB_RESETH 0x19 //软件复位高8位
#define XT_CMDB_RESETL 0x66 //软件复位低8位
#define XT_CMDB_READ_UIDH 0x33 //扫描高8位
#define XT_CMDB_READ_UIDL 0x34 //扫描低8位
#define XT_CMDB_TRIM_FASTH 0x2E //快速延期标定高8位
#define XT_CMDB_TRIM_FASTL 0x2D //快速延期标定低8位
#define XT_CMDB_TRIM_COMPLETEH 0x2D //完整延期标定高8位
#define XT_CMDB_TRIM_COMPLETEL 0x33 //完整延期标定低8位
#define XT_CMDB_CHECK_ONLINEH 0x2B //在线检测高8位
#define XT_CMDB_CHECK_ONLINEL 0x4B //在线检测低8位
#define XT_CMDB_CHECK_BMIDH 0x28 //验证起爆密码高8位
#define XT_CMDB_CHECK_BMIDL 0x7F //验证起爆密码低8位
#define XT_CMDB_CHECK_FIRE_ALLH 0x27 //获取全部验证状态高8位
#define XT_CMDB_CHECK_FIRE_ALLL 0x52 //获取全部验证状态低8位
#define XT_CMDB_CHECK_FIRE_EACHH 0x24 //获取逐发验证状态高8位
#define XT_CMDB_CHECK_FIRE_EACHL 0x55 //获取逐发验证状态低8位
#define XT_CMDB_SET_CURRENTH 0x42 //设置反馈电流大小
#define XT_CMDB_CHARGE 0x41 //广播充电
#define XT_CMDB_CHECK_CONFIG 0x70 //检查配置区
#define XT_CMDC_WRITE_UID 0x1E //写UID
#define XT_CMDC_WRITE_BMID 0x1D //写起爆密码
#define XT_CMDC_WRITE_SHELL 0x1B //写管壳码
#define XT_CMDC_WRITE_FIELD 0x18 //写现场值_C
#define XT_CMDC_WRITE_CONFIG 0x14 //写配置区
#define XT_CMDC_WRITE_PARAM 0x12 //写测量参数值
#define XT_CMDC_MEASURE_CAP 0x11 //测量储能电容_C
#define XT_CMDC_LOCK 0x3E //锁定
#define XT_CMDC_READ_PARAM 0x37 //读测量参数值_C
#define XT_CMDC_READ_CONFIG 0x34 //读配置区
#define XT_CMDC_READ_SHELL 0x2C //读管壳码_C
#define XT_CMDC_MEASURE_RES 0x2F //测量药头电阻_C
extern uint16_t XT_FreeBackMaxCur,XT_FreeBackMinCur,XT_FreeBackMaxTime,XT_FreeBackMinTime,XT_CommEndMaxCur;
extern uint8_t XT_EnFreeBack_Test,XT_CommEnd_CurEn;
//************************************************************************//
/*
@brief 通信反码信息初始化
*/
void XT_FreeBack_Prapare(uint8_t enable_flag);
void XT_SendSquare(uint32_t num);
uint8_t XT_Power_Init(void);
void XT_BUS_CTRL( uint8_t NewState );
uint8_t XT_Write_Field(uint8_t *uid, uint8_t uidlen, uint8_t *field);
uint8_t XT_Read_Field(uint8_t *uid, uint8_t uidlen, uint8_t *field);
uint8_t XT_Read_Shell(uint8_t *uid, uint8_t uidlen, uint8_t *shell);
uint8_t XT_Read_Param(uint8_t *uid, uint8_t uidlen, uint8_t *param);
uint8_t XT_Measure_Res(uint8_t *uid, uint8_t uidlen, uint8_t *adcvalue);
uint8_t XT_Measure_Cap(uint8_t *uid, uint8_t uidlen, uint8_t level, uint32_t *chargetime);
uint8_t XT_Charge_One(uint8_t *uid,uint8_t uidlen, uint8_t level,uint16_t busvoltage, uint8_t isgetack);
void XT_Clear_Read(void);
void XT_Fire(void);
uint8_t XT_FireandCheck(uint8_t *delay);
uint8_t XT_MeasureFire(uint32_t *delay) ;
void XT_Init(uint8_t regdata);
void XT_Reset(void);
uint8_t XT_Read_Uid(uint8_t *uid, uint8_t uidlen);
void XT_Trim_Fast(void);
void XT_Trim_Faset_Cycle(uint16_t cycle,uint16_t duty);
void XT_Trim_Complete(uint32_t delay_max);
void XT_Trim_Complete_Cycle(uint16_t cycle,uint16_t duty, uint32_t delay_max);
uint8_t XT_Check_Online(uint16_t index_max, uint8_t *online);
uint8_t XT_Check_Bmid(uint8_t *bmid, uint8_t bmidlen);
uint8_t XT_Check_Fire_All(void);
uint8_t XT_Check_Fire_Each(uint32_t index_max, uint8_t *check);
void XT_Set_Current(uint8_t level);
void XT_Charge_All(uint8_t level);
uint8_t XT_Check_Config(uint8_t *config);
uint8_t XT_Write_Uid(uint8_t *uid, uint8_t uidlen);
uint8_t XT_Write_Bmid(uint8_t *bmid, uint8_t bmidlen);
uint8_t XT_Write_Shell(uint8_t *shell);
uint8_t XT_Write_Field_All(uint8_t *field);
uint8_t XT_Write_Config(uint8_t *config);
uint8_t XT_Write_Param(uint8_t *param);
uint8_t XT_Measure_Cap_All(uint8_t level, uint32_t *chargetime);
void XT_Lock(void);
uint8_t XT_Read_Param_All(uint8_t *param);
uint8_t XT_Read_Config(uint8_t *config);
uint8_t XT_Read_Shell_All(uint8_t *shell);
uint8_t XT_Measure_Res_All(uint8_t *adcvalue);
uint8_t XT_Get_UID_R(uint8_t *uid, uint8_t uidlen);
uint8_t XT_Get_R(void);
uint8_t XT_Get_UID_C(uint8_t *uid, uint8_t uidlen, uint8_t level, uint32_t time_out,float *CapacitanceValue) ;
uint8_t XT_Get_C(uint8_t level, uint32_t time_out, float *CapacitanceValue);
#endif