842 lines
20 KiB
C++
842 lines
20 KiB
C++
#include "cmd_coder.h"
|
|
#include "QDebug"
|
|
#include "elec/elec_judge.h"
|
|
#include "elec/coder_lib.h"
|
|
#include "elec/JQ_PSDGenerate.h"
|
|
#include "elec/JQ_UIDGenerate.h"
|
|
#include "elec/PSDGenerate.h"
|
|
#include "prot_cmd/cmd_m4.h"
|
|
|
|
|
|
|
|
|
|
// task_id,errcode,par_count,ret_count
|
|
static const task_def g_ew_task_table[]={
|
|
{"电源准备",0,1,10,0},
|
|
{"延时等待",1,1,2,1},
|
|
{"桥丝电阻测试",2,4,1,1},
|
|
{"上电充能",3,2,3,2},
|
|
{"设置总线电压",4,1,1,1},
|
|
{"获取总线电流",5,1,0,2},
|
|
{"使能MTP",6,5,1,0},
|
|
{"扫描UID",7,5,3,8},
|
|
{"写配置参数",8,5,7,0},
|
|
{"检测配置",9,5,7,0},
|
|
{"验证配置",10,5,4,0},
|
|
{"模拟注码",11,5,0,0},
|
|
{"验证模拟注码",12,5,0,0},
|
|
{"芯片自检",13,5,2,1},
|
|
{"状态检测",14,5,2,2},
|
|
{"充电",15,5,2,0},
|
|
{"放电",16,5,0,0},
|
|
{"写延时",17,5,1,0},
|
|
{"读延时",18,5,0,1},
|
|
{"时钟校准",19,5,2,1},
|
|
{"设置通信地址",20,5,3,1},
|
|
{"状态巡检",21,5,3,1},
|
|
{"起爆使能",22,5,0,0},
|
|
{"起爆检测",23,5,3,1},
|
|
{"缓存数据写入MTP",24,5,3,0},
|
|
{"验证缓存数据",25,5,3,0},
|
|
{"关总线",26,1,0,0},
|
|
{"升级",27,5,4,1},
|
|
{"充能统计",28,2,6,4},
|
|
{"计算异常",29,0,10,0},
|
|
{"重新执行任务",30,0,1,0},
|
|
{"写入三码数据",31,5,0,0},
|
|
{"验证三码数据",32,5,0,0},
|
|
{"配置三码数据到小板",33,1,10,0},
|
|
{"任务插槽",34,0,1,0},
|
|
{"读MTP",35,5,2,8},
|
|
{"写MTP",36,5,10,0},
|
|
{"设置电阻校准值",37,1,1,0},
|
|
{"读取流水号",38,5,2,2},
|
|
{"写入流水号",39,5,2,0},
|
|
{"写固定延时",40,5,1,0},
|
|
{nullptr,0,0,0,0},
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// task_id,errcode,par_count,ret_count
|
|
static const task_def g_jq_task_table[]={
|
|
{"电源准备",0,1,10,0},
|
|
{"上电充能",1,2,3,2},
|
|
{"设置总线电压",2,1,1,1},
|
|
{"获取总线电流",3,1,0,2},
|
|
{"扫描UID",4,5,2,8},
|
|
{"密码验证",5,5,1,0},
|
|
{"读取芯片代码",6,5,0,1},
|
|
{"OTP检测",7,5,3,0},
|
|
{"工厂测试检测",8,5,0,0},
|
|
{"读取状态",9,5,1,1},
|
|
{"写工厂信息",10,5,2,0},
|
|
{"充能统计",11,5,5,4},
|
|
{"充电电压检测",12,5,2,1},
|
|
{"延时等待",13,1,2,1},
|
|
{"写延时",14,5,1,0},
|
|
{"读延时",15,5,0,1},
|
|
{"时钟校准",16,5,2,1},
|
|
{"放电",17,5,2,0},
|
|
{"复位",18,5,0,0},
|
|
{"起爆使能",19,5,0,0},
|
|
{"起爆充能",20,5,3,3},
|
|
{"使能通讯末电流采集",21,1,0,0},
|
|
{"获取通讯末电流",22,1,0,1},
|
|
{"写OTP",23,5,6,0},// opt_addr,len,[data]
|
|
{"读OTP",24,5,2,10},// 这个任务根据参数1得到实际读取长度
|
|
{"清除起爆计数",25,5,0,0},
|
|
{"关总线",26,1,0,0},
|
|
{"将缓存区数据写入OTP",27,5,3,0},
|
|
{"写入三码数据",28,5,0,0},
|
|
{"验证三码数据",29,5,0,0},
|
|
{"测量电容压差",30,2,1,1},
|
|
{"测量桥丝阻值",31,4,1,1},
|
|
{"使能OTP写",32,5,0,0},
|
|
{"写模块版本",33,5,1,0},
|
|
{"读取版本号",34,5,0,1},
|
|
{"写缓存数据",35,5,3,0},
|
|
{"验证缓存数据",36,5,3,0},
|
|
{"验证延时时间",37,5,0,0},
|
|
{"切换总线极性",38,5,2,0},
|
|
{"计算异常",39,0,10,0},
|
|
{"重新执行任务",40,0,1,0},
|
|
{"配置三码数据到小板",41,1,10,0},
|
|
{"任务插槽",42,1,1,0},
|
|
{"设置电阻校准值",43,1,1,0},
|
|
{"写入流水号",44,5,2,0},
|
|
{"读取流水号",45,5,2,2},
|
|
{"写固定延时",46,5,1,0},
|
|
{nullptr,0,0,0,0},
|
|
};
|
|
|
|
|
|
// task_id,errcode,par_count,ret_count
|
|
static const task_def g_ext_task_table[]={
|
|
{"计算异常",100,0,10,0},
|
|
{"重新执行任务",101,0,1,0},
|
|
{"配置三码数据到小板",102,1,10,0},
|
|
{"任务插槽",103,1,1,0},
|
|
{"设置电阻校准值",104,1,1,0},
|
|
{nullptr,0,0,0,0},
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// 根据字符找到任务,失败返回nullptr
|
|
const task_def *coder_find_task(const char *str)
|
|
{
|
|
int chip=elec_extract_chip(check_plan()->get_plan_id());
|
|
const task_def *table=nullptr;
|
|
|
|
// qDebug("find task in ext_table.");
|
|
table=g_ext_task_table;
|
|
for(int i=0;i<100;i++){
|
|
if(table[i].name==nullptr){
|
|
break;
|
|
}
|
|
if(qstrcmp(str,table[i].name)==0){
|
|
return &table[i];
|
|
}
|
|
}
|
|
table=nullptr;
|
|
if(chip==0){
|
|
table=g_jq_task_table;
|
|
// qDebug("find task in jq_table.");
|
|
}else if(chip==2){
|
|
table=g_ew_task_table;
|
|
// qDebug("find task in ew_table.");
|
|
}
|
|
if(table==nullptr){
|
|
return nullptr;
|
|
}
|
|
for(int i=0;i<100;i++){
|
|
if(table[i].name==nullptr){
|
|
break;
|
|
}
|
|
if(qstrcmp(str,table[i].name)==0){
|
|
// qDebug("find task index=%d.",i);
|
|
return &table[i];
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
// 返回芯片类型
|
|
char coder_chip_type(uint8_t states=0xff)
|
|
{
|
|
int chip=elec_extract_chip(check_plan()->get_plan_id());
|
|
const char table[]="JXWQ";
|
|
if(states&&((states&0x04)==0)) chip=3;
|
|
if(chip>=0&&chip<=3){
|
|
return table[chip];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// 添加一个任务,返回0添加成功
|
|
int coder_add_task(myarray &d,const char *name,int slot_index,int task_index,uint16_t params[10])
|
|
{
|
|
const task_def *task=nullptr;
|
|
task=coder_find_task(name);
|
|
if(task==nullptr){
|
|
qWarning("can not find task with %s.",name);
|
|
return -1;
|
|
}else{
|
|
// qDebug("task_name:%s,task_id=%d,par_count=%d,ret_count=%d,err=%d",name,task->task_id,
|
|
// task->par_count,task->ret_count,task->errcode);
|
|
}
|
|
char *par=(char *)params;
|
|
d.append(uint8_t(slot_index));
|
|
d.append(uint8_t(task->task_id));
|
|
d.append(uint8_t(task->par_count));
|
|
d.append(uint8_t(task->ret_count));
|
|
d.append(uint8_t(task->errcode));
|
|
d.append(uint8_t(task_index));
|
|
if(task->par_count*2>0){
|
|
d.append(par,task->par_count*2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// 添加一个任务失败不报错,返回0添加成功
|
|
int coder_add_task_noerr(myarray &d,const char *name,int slot_index,int task_index,uint16_t params[10])
|
|
{
|
|
const task_def *task=nullptr;
|
|
task=coder_find_task(name);
|
|
if(task==nullptr){
|
|
qWarning("can not find task with %s.",name);
|
|
return -1;
|
|
}else{
|
|
// qDebug("task_name:%s,task_id=%d,par_count=%d,ret_count=%d,err=%d",name,task->task_id,
|
|
// task->par_count,task->ret_count,task->errcode);
|
|
}
|
|
char *par=(char *)params;
|
|
d.append(uint8_t(slot_index));
|
|
d.append(uint8_t(task->task_id));
|
|
d.append(uint8_t(task->par_count));
|
|
d.append(uint8_t(task->ret_count));
|
|
d.append(uint8_t(0));
|
|
d.append(uint8_t(task_index));
|
|
if(task->par_count*2>0){
|
|
d.append(par,task->par_count*2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
// 包装为一个小板的数据,返回0成功
|
|
// 包装前需要先添加任务
|
|
int coder_slave_pack(myarray &d,int addr)
|
|
{
|
|
int len=d.size();
|
|
d.insert(0,uint8_t(len));
|
|
d.insert(0,uint8_t(addr));
|
|
return 0;
|
|
}
|
|
|
|
|
|
// 找到指定任务序号的数据
|
|
myarray coder_slave_find_ret_data(myarray data,int task_index,int size)
|
|
{
|
|
myarray r;
|
|
int task_len;
|
|
// qDebug()<<"find data,task_index="<<task_index<<"src="<<data.toHex(' ');
|
|
for(int i=0;i<data.size();)
|
|
{
|
|
task_len=data[i+1]*2;
|
|
if(data[i]==task_index){
|
|
r=data.mid(i+2,task_len);
|
|
break;
|
|
}
|
|
i+=2+task_len;
|
|
}
|
|
if(r.size()>=size){
|
|
r=r.left(size);
|
|
}else{
|
|
int len=size-r.size();
|
|
r.append(len,uint8_t(0));
|
|
qWarning("can not find data,task_index=%d.",task_index);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
myarray cmd_coder_check::cmd_pc_to_slave(myarray data)
|
|
{
|
|
myarray d;
|
|
// 检测模式0,返回原始检测结果
|
|
d.insert(0,uint8_t(0));
|
|
return d;
|
|
}
|
|
|
|
// 把从机回复的数据转化为上位机能理解的格式
|
|
myarray cmd_coder_check::ret_slave_to_pc(QList<myarray> data)
|
|
{
|
|
myarray r;
|
|
r.append(uint8_t(addrs));
|
|
r.append(uint8_t(mode));
|
|
for (int i=0;i<data.size();i++)
|
|
{
|
|
myarray &sdata=data[i];
|
|
int addr=sdata[0]-1+syscfg()->slave_addr_start;
|
|
sdata.remove(0,1);
|
|
r.append(uint8_t(addr));
|
|
if(sdata.size()>0){
|
|
r.append(sdata[0]);
|
|
}else{
|
|
r.append(uint8_t(0xd0));
|
|
}
|
|
r.append(4,uint8_t(0));
|
|
}
|
|
return r;
|
|
}
|
|
|
|
|
|
static HandlePc *get_coder_check(){
|
|
return new cmd_coder_check();
|
|
}
|
|
protpc_export(0x01, get_coder_check);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 新检测任务需要读取模块工厂信息
|
|
myarray cmd_coder_check2::cmd_pc_to_slave(myarray data)
|
|
{
|
|
myarray d;
|
|
const task_def *table=nullptr;
|
|
int chip=elec_extract_chip(check_plan()->get_plan_id());
|
|
if(chip==0){
|
|
uint16_t params[10]={20,4};
|
|
coder_add_task(d,"读OTP",1,1,params);
|
|
params[0]=0;
|
|
coder_add_task(d,"读取状态",1,2,params);
|
|
}else if(chip==2){
|
|
uint16_t params[10]={9,4};
|
|
coder_add_task(d,"读MTP",1,1,params);
|
|
}
|
|
coder_slave_pack(d,0x1f);
|
|
// 检测模式1,返回异常代码和任务插槽数据
|
|
d.insert(0,uint8_t(1));
|
|
return d;
|
|
}
|
|
|
|
// 把从机回复的数据转化为上位机能理解的格式
|
|
myarray cmd_coder_check2::ret_slave_to_pc(QList<myarray> data)
|
|
{
|
|
myarray r;
|
|
r.append(uint8_t(addrs&0xff));
|
|
r.append(uint8_t((addrs>>8)&0xff));
|
|
r.append(uint8_t((addrs>>16)&0xff));
|
|
for (int i=0;i<data.size();i++)
|
|
{
|
|
myarray &sdata=data[i];
|
|
int addr=sdata[0]-1+syscfg()->slave_addr_start;
|
|
sdata.remove(0,1);
|
|
myarray sret=coder_slave_find_ret_data(sdata.mid(1),1,4);
|
|
myarray state=coder_slave_find_ret_data(sdata.mid(1),2,1);
|
|
r.append(uint8_t(addr));
|
|
if(sdata.size()==0){
|
|
r.append(uint8_t(0xd0));
|
|
r.append(9,uint8_t(0));
|
|
}else{
|
|
r.append(sdata[0]);
|
|
r.append(uint8_t(coder_chip_type(state[0])));
|
|
r.append(sret);
|
|
r.append(4,uint8_t(0));
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
|
|
static HandlePc *get_coder_check2(){
|
|
return new cmd_coder_check2();
|
|
}
|
|
protpc_export(0x10, get_coder_check2);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 赋码任务需要写入uid
|
|
myarray cmd_coder_code::cmd_pc_to_slave(myarray data)
|
|
{
|
|
myarray ret;
|
|
const task_def *table=nullptr;
|
|
uint16_t params[10]={0};
|
|
chip_mode=elec_extract_chip(check_plan()->get_plan_id());
|
|
char year[10]={0};
|
|
memcpy(year,data.mid(1,4).data(),4);
|
|
qDebug("tran pc data to slave");
|
|
for (int i=0;i<addrs;i++){
|
|
myarray d;
|
|
uid_code uid={{0},{0},{0},{0}};
|
|
memcpy(uid.shell,data.mid(5+i*14+1,13).data(),13);
|
|
if(check_shell_code(uid.shell)==1){
|
|
// 只有管壳码验证通过时才计算uid和密码
|
|
if(chip_mode!=0){
|
|
coder_shell_to_uid(year,uid.shell,uid.uid);
|
|
// 生成存储码
|
|
coder_uid_to_save(uid.uid,(uint8_t *)uid.uid_psw);
|
|
// 生成密码
|
|
GetPasswordByUidCode((uint8_t *)uid.uid,(uint8_t *)&uid.uid_psw[8]);
|
|
// 生成密码字符串
|
|
sprintf(uid.psw,"%02X%02X%02X%02X",uid.uid_psw[8],
|
|
uid.uid_psw[9],uid.uid_psw[10],uid.uid_psw[11]);
|
|
}else{
|
|
coder_shell_to_uid_jq(year,uid.shell,uid.uid);
|
|
// 生成存储码
|
|
UidCode_YM2JQ((PST_JQUID_TYPEDEF)uid.uid_psw,(PST_YMUID_TYPEDEF)uid.uid);
|
|
// 生成密码
|
|
JQ_GetPasswordByUidCode((uint8_t *)uid.uid,(uint8_t *)&uid.uid_psw[8]);
|
|
// 生成密码字符串
|
|
sprintf(uid.psw,"%02X%02X%02X%02X",uid.uid_psw[11],
|
|
uid.uid_psw[10],uid.uid_psw[9],uid.uid_psw[8]);
|
|
}
|
|
}
|
|
uid_codes.append(uid);
|
|
params[0]=(8)|(4<<8);
|
|
memcpy(¶ms[1],uid.uid_psw,12);
|
|
coder_add_task(d,"配置三码数据到小板",1,1,params);
|
|
// coder_add_task(d,"写入三码数据",1,2,params);
|
|
// coder_add_task(d,"验证三码数据",2,3,params);
|
|
coder_slave_pack(d,i+1);
|
|
ret+=d;
|
|
}
|
|
// 检测模式1,返回异常代码和任务插槽数据
|
|
ret.insert(0,uint8_t(1));
|
|
qDebug("tran pc data to slave end");
|
|
return ret;
|
|
}
|
|
|
|
// 把从机回复的数据转化为上位机能理解的格式
|
|
myarray cmd_coder_code::ret_slave_to_pc(QList<myarray> data)
|
|
{
|
|
myarray r;
|
|
r.append(uint8_t(addrs));
|
|
for (int i=0;i<data.size();i++)
|
|
{
|
|
myarray &sdata=data[i];
|
|
int addr=sdata[0]-1+syscfg()->slave_addr_start;
|
|
sdata.remove(0,1);
|
|
r.append(uint8_t(addr));
|
|
if(sdata.size()>0){
|
|
r.append(sdata[0]);
|
|
}else{
|
|
r.append(uint8_t(0xd0));
|
|
}
|
|
r.append(uid_codes[i].shell,13);
|
|
if(chip_mode==0){
|
|
r.append(uid_codes[i].uid,15);
|
|
}else{
|
|
r.append(uid_codes[i].uid,16);
|
|
}
|
|
r.append(uid_codes[i].psw,8);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
|
|
static HandlePc *get_coder_code(){
|
|
return new cmd_coder_code();
|
|
}
|
|
protpc_export(0x02, get_coder_code);
|
|
|
|
|
|
|
|
|
|
// 赋码任务需要写入uid
|
|
myarray cmd_coder_code2::cmd_pc_to_slave(myarray data)
|
|
{
|
|
myarray ret;
|
|
const task_def *table=nullptr;
|
|
uint16_t params[10]={0};
|
|
chip_mode=elec_extract_chip(check_plan()->get_plan_id());
|
|
char year[10]={0};
|
|
delay=data[3]|(data[4]<<8);
|
|
qDebug("code delay=%d",delay);
|
|
// 移除前4个字节使数据对齐
|
|
data.remove(0,4);
|
|
memcpy(year,data.mid(1,4).data(),4);
|
|
qDebug("tran pc data to slave");
|
|
for (int i=0;i<addrs_num;i++){
|
|
myarray d;
|
|
uid_code uid={{0},{0},{0},{0}};
|
|
memcpy(uid.shell,data.mid(5+i*14+1,13).data(),13);
|
|
if(check_shell_code(uid.shell)==1){
|
|
// 只有管壳码验证通过时才计算uid和密码
|
|
if(chip_mode!=0){
|
|
coder_shell_to_uid(year,uid.shell,uid.uid);
|
|
// 生成存储码
|
|
coder_uid_to_save(uid.uid,(uint8_t *)uid.uid_psw);
|
|
// 生成密码
|
|
GetPasswordByUidCode((uint8_t *)uid.uid,(uint8_t *)&uid.uid_psw[8]);
|
|
// 生成密码字符串
|
|
sprintf(uid.psw,"%02X%02X%02X%02X",uid.uid_psw[8],
|
|
uid.uid_psw[9],uid.uid_psw[10],uid.uid_psw[11]);
|
|
}else{
|
|
coder_shell_to_uid_jq(year,uid.shell,uid.uid);
|
|
// 生成存储码
|
|
UidCode_YM2JQ((PST_JQUID_TYPEDEF)uid.uid_psw,(PST_YMUID_TYPEDEF)uid.uid);
|
|
// 生成密码
|
|
JQ_GetPasswordByUidCode((uint8_t *)uid.uid,(uint8_t *)&uid.uid_psw[8]);
|
|
// 生成密码字符串
|
|
sprintf(uid.psw,"%02X%02X%02X%02X",uid.uid_psw[11],
|
|
uid.uid_psw[10],uid.uid_psw[9],uid.uid_psw[8]);
|
|
}
|
|
}
|
|
uid_codes.append(uid);
|
|
params[0]=(8)|(4<<8);
|
|
memcpy(¶ms[1],uid.uid_psw,12);
|
|
coder_add_task(d,"配置三码数据到小板",1,1,params);
|
|
params[0]=delay;
|
|
coder_add_task(d,"写固定延时",1,2,params);
|
|
coder_add_task(d,"读延时",2,3,params);
|
|
if(chip_mode==0){
|
|
uint16_t params[10]={20,4};
|
|
coder_add_task(d,"读OTP",2,4,params);
|
|
params[0]=0;
|
|
coder_add_task(d,"读取状态",2,5,params);
|
|
}else if(chip_mode==2){
|
|
uint16_t params[10]={9,4};
|
|
coder_add_task(d,"读MTP",2,4,params);
|
|
}
|
|
coder_slave_pack(d,i+1);
|
|
ret+=d;
|
|
}
|
|
// 检测模式1,返回异常代码和任务插槽数据
|
|
ret.insert(0,uint8_t(1));
|
|
qDebug("tran pc data to slave end");
|
|
// qDebug()<<"slave_data:"<<ret.toHex(' ');
|
|
return ret;
|
|
}
|
|
|
|
// 把从机回复的数据转化为上位机能理解的格式
|
|
myarray cmd_coder_code2::ret_slave_to_pc(QList<myarray> data)
|
|
{
|
|
myarray r;
|
|
r.append(uint8_t(addrs&0xff));
|
|
r.append(uint8_t((addrs>>8)&0xff));
|
|
r.append(uint8_t((addrs>>16)&0xff));
|
|
// coder_return_mode 1是完整模式,协议0是完整模式
|
|
if(syscfg()->coder_return_mode){
|
|
r.append(uint8_t(0));
|
|
r.append(13);
|
|
if(chip_mode==0){
|
|
r.append(15);
|
|
}else{
|
|
r.append(16);
|
|
}
|
|
}else{
|
|
r.append(uint8_t(1));
|
|
}
|
|
r.append(8);
|
|
for (int i=0;i<data.size();i++)
|
|
{
|
|
myarray &sdata=data[i];
|
|
uint8_t err=0;
|
|
int addr=sdata[0]-1+syscfg()->slave_addr_start;
|
|
sdata.remove(0,1);
|
|
r.append(uint8_t(addr));
|
|
if(sdata.size()>0){
|
|
err=sdata[0];
|
|
}else{
|
|
err=uint8_t(0xd0);
|
|
}
|
|
sdata.remove(0,1);
|
|
// 如果延时不对,则失败
|
|
myarray sret=coder_slave_find_ret_data(sdata,3,2);
|
|
uint16_t sdelay=sret[0]|(sret[1]<<8);
|
|
qDebug("index:%d,delay=%d",i,sdelay);
|
|
if(sdelay!=delay){
|
|
if(err==0){
|
|
err=10;
|
|
}
|
|
}
|
|
r.append(err);
|
|
// 添加工厂信息
|
|
sret=coder_slave_find_ret_data(sdata,4,4);
|
|
myarray state=coder_slave_find_ret_data(sdata,5,1);
|
|
r.append(uint8_t(coder_chip_type(state[0])));
|
|
r.append(sret);
|
|
// 完整模式
|
|
if(syscfg()->coder_return_mode){
|
|
r.append(uid_codes[i].shell,13);
|
|
// r.append(13,i+'0');
|
|
if(chip_mode==0){
|
|
r.append(uid_codes[i].uid,15);
|
|
}else{
|
|
r.append(uid_codes[i].uid,16);
|
|
}
|
|
}
|
|
r.append(uid_codes[i].psw,8);
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
|
|
static HandlePc *get_coder_code2(){
|
|
return new cmd_coder_code2();
|
|
}
|
|
protpc_export(0x11, get_coder_code2);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 设置电阻 校准值
|
|
myarray cmd_coder_setrtv::cmd_pc_to_slave(myarray data)
|
|
{
|
|
myarray ret;
|
|
const task_def *table=nullptr;
|
|
uint16_t params[10]={0};
|
|
int len=data.size();
|
|
for(int i=0;i<len;i+=3){
|
|
myarray d;
|
|
params[0]=data[i+1]|(data[i+2]<<8);
|
|
coder_add_task(d,"设置电阻校准值",1,1,params);
|
|
coder_slave_pack(d,data[i]);
|
|
ret+=d;
|
|
}
|
|
// 检测模式3,返回异常代码和任务插槽数据
|
|
ret.insert(0,uint8_t(3));
|
|
qDebug()<<"set rtv,data="<<ret.toHex(' ');
|
|
return ret;
|
|
}
|
|
|
|
// 把从机回复的数据转化为上位机能理解的格式
|
|
myarray cmd_coder_setrtv::ret_slave_to_pc(QList<myarray> data)
|
|
{
|
|
myarray r;
|
|
r.append(uint8_t(0));
|
|
return r;
|
|
}
|
|
|
|
|
|
static HandlePc *get_coder_setrtv(){
|
|
return new cmd_coder_setrtv();
|
|
}
|
|
protpc_export(0x41, get_coder_setrtv);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 批检仪检测并写入流水号,控制电机需要重载此函数
|
|
int cmd_checker_check::dolater(int cmd, myarray data)
|
|
{
|
|
prot_slave *slave=protSlave();
|
|
mycfg *cfg_=syscfg();
|
|
prot_m4 *m4 = protM4();
|
|
busy=1;
|
|
connect(this, &cmd_checker_check::send_to_m4_signal, m4, &prot_m4::send_data_slot);
|
|
addrs=cmd_pc_to_addrs(data);
|
|
moter_down_cb_fun=[=](myarray str)
|
|
{
|
|
m4->del_irq_fun(moter_down_cb_fun,"moter down");
|
|
{
|
|
// 这里开始检测
|
|
qDebug("runtask.");
|
|
HandleBoardCast *b=new slave_cmd();
|
|
bool ack=slave->set_boardcast_handle(addrs,b);
|
|
if(ack==false){
|
|
qWarning("handle is busy.");
|
|
busy=0;
|
|
}else{
|
|
connect(b,&HandleBoardCast::end_signal,this,&selfdev_runtask::slave_end_slot);
|
|
// 广播设置校准值，需使用新增命令
|
|
b->cmd=cmd_slave();
|
|
b->start(cmd_pc_to_slave(data));
|
|
if(cmd_pc_recv()!=0){
|
|
emit send_data_signal(cmd_pc_recv(),cmd_pc_recv_to_pc());
|
|
}
|
|
}
|
|
}
|
|
};
|
|
slave_acked.clear();
|
|
for(int i=0;i<addrs.size();i++){
|
|
slave_acked.append(myarray());
|
|
}
|
|
slave_acked_num=0;
|
|
if(key_press()!=0){
|
|
}else{
|
|
busy=0;
|
|
qWarning("key not pressed,check will not start.");
|
|
return 2;
|
|
}
|
|
myarray moter_cmd=moter_ctrl("down");
|
|
if(moter_cmd.size()==0){
|
|
busy=0;
|
|
qWarning("moter failed.");
|
|
return 1;
|
|
}else{
|
|
m4->set_irq_fun(moter_down_cb_fun,"moter down");
|
|
emit send_to_m4_signal(moter_cmd);
|
|
}
|
|
return 0;
|
|
}
|
|
int cmd_checker_check::key_press(){
|
|
if(syscfg()->auto_test==0){
|
|
return cmd_m4_key_pressed();
|
|
}else{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
|
|
// 批检仪检测并写入流水号
|
|
myarray cmd_checker_check::cmd_pc_to_slave(myarray data)
|
|
{
|
|
myarray ret;
|
|
const task_def *table=nullptr;
|
|
uint16_t params[10]={0};
|
|
int len=data.size();
|
|
for(int i=0;i<len;i+=5){
|
|
myarray d;
|
|
params[0]=data[i+1]|(data[i+2]<<8);
|
|
params[1]=data[i+3]|(data[i+4]<<8);
|
|
coder_add_task(d,"写入流水号",1,1,params);
|
|
coder_add_task(d,"读取流水号",2,2,params);
|
|
coder_slave_pack(d,data[i]);
|
|
ret+=d;
|
|
}
|
|
|
|
// 检测模式2,返回原始检测结果和槽数据
|
|
ret.insert(0,uint8_t(2));
|
|
// qDebug()<<"checker check pack data:"<<ret.toHex(' ');
|
|
return ret;
|
|
}
|
|
|
|
// 把从机回复的数据转化为上位机能理解的格式
|
|
myarray cmd_checker_check::ret_slave_to_pc(QList<myarray> data)
|
|
{
|
|
myarray r;
|
|
check_cfg *ccfg_=check_plan();
|
|
r.append(char(0));
|
|
for(int i=0;i<data.size();i++){
|
|
myarray &sdata=data[i];
|
|
int addr=sdata[0]-1+syscfg()->slave_addr_start;
|
|
sdata.remove(0,1);
|
|
qDebug()<<"checker check ret data:"<<sdata.toHex(' ');
|
|
// 返回值个数
|
|
int return_num=ccfg_->get_return_num();
|
|
myarray check_data=sdata.left(1+16+return_num*2);
|
|
r.append(tran_slave_to_selfdev_check(check_data));
|
|
r.append(coder_slave_find_ret_data(sdata.mid(1+16+return_num*2),2,4));
|
|
|
|
}
|
|
return r;
|
|
}
|
|
|
|
|
|
static HandlePc *get_checker_check(){
|
|
return new cmd_checker_check();
|
|
}
|
|
protpc_export(0x48, get_checker_check);
|
|
|
|
|
|
|
|
|
|
|
|
// 批检仪检测并读取流水号
|
|
myarray cmd_checker_check2::cmd_pc_to_slave(myarray data)
|
|
{
|
|
myarray ret;
|
|
const task_def *table=nullptr;
|
|
uint16_t params[10]={0};
|
|
for(int i=0;i<addrs.size();i++){
|
|
myarray d;
|
|
coder_add_task(d,"读取流水号",2,2,params);
|
|
coder_slave_pack(d,addrs[i]);
|
|
ret+=d;
|
|
}
|
|
|
|
// 检测模式2,返回原始检测结果和槽数据
|
|
ret.insert(0,uint8_t(2));
|
|
return ret;
|
|
}
|
|
static HandlePc *get_checker_check2(){
|
|
return new cmd_checker_check2();
|
|
}
|
|
protpc_export(0x30, get_checker_check2);
|
|
|
|
|
|
|
|
|
|
|
|
// 0x49 检测不读取流水号
|
|
myarray cmd_checker_check3::cmd_pc_to_slave(myarray data)
|
|
{
|
|
myarray ret;
|
|
const task_def *table=nullptr;
|
|
// 检测模式0,返回原始检测结果
|
|
ret.insert(0,uint8_t(0));
|
|
return ret;
|
|
}
|
|
|
|
static HandlePc *get_checker_check3(){
|
|
return new cmd_checker_check3();
|
|
}
|
|
protpc_export(0x49, get_checker_check3);
|
|
|
|
|
|
|
|
|
|
// 0x44 自动检测不读取流水号
|
|
int cmd_checker_check4::key_press(){
|
|
return 1;
|
|
}
|
|
|
|
static HandlePc *get_checker_check4(){
|
|
return new cmd_checker_check4();
|
|
}
|
|
protpc_export(0x44, get_checker_check4);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|