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

任务执行命令验证写入电阻校准值成功

Browse Source
This commit is contained in:
ranchuan
2023-12-20 18:24:00 +08:00
parent bf4b4b45ea
commit af964ad733
8 changed files with 607 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
ReadMe.txt
View File

@@ -20,3 +20,6 @@
添加电阻测试命令，添加自检命令 添加电阻测试命令，添加自检命令
2023.12.19 2023.12.19
制定任务执行命令 制定任务执行命令
2023.12.20
任务执行命令验证写入电阻校准值成功

2
complier_info.h
View File

@@ -6,7 +6,7 @@
#define BUILD_DATE "2023-12-19 18:08:48" #define BUILD_DATE "2023-12-20 17:13:21"

2
info.json
View File

@@ -1,5 +1,5 @@
{ {
"build_date": "2023-12-19 18:08:48", "build_date": "2023-12-20 17:13:21",
"hard_version": "MHPZ2_V1.00", "hard_version": "MHPZ2_V1.00",
"private": [ "private": [
"info.json", "info.json",

441
prot_cmd/cmd_coder.cpp
View File

@@ -1,117 +1,194 @@
#include "cmd_coder.h" #include "cmd_coder.h"
#include "QDebug"
static const char *g_ew_task_table[]={
"电源准备",
"延时等待",
"桥丝电阻测试",
"上电充能", // task_id,errcode,par_count,ret_count
"设置总线电压", static const task_def g_ew_task_table[]={
"获取总线电流", {"电源准备",0,1,10,0},
"使能MTP", {"延时等待",1,1,2,1},
"扫描UID", {"桥丝电阻测试",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},
"缓存数据写入MTP", {"时钟校准",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},
nullptr, {"重新执行任务",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},
{nullptr,0,0,0,0},
}; };
static const char *g_jq_task_table[]={ // 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},
"扫描UID", {"获取总线电流",3,1,0,2},
"密码验证", {"扫描UID",4,5,2,8},
"读取芯片代码", {"密码验证",5,5,1,0},
"OTP检测", {"读取芯片代码",6,5,0,1},
"工厂测试检测", {"OTP检测",7,5,3,0},
"读取状态", {"工厂测试检测",8,5,0,0},
"写工厂信息", {"读取状态",9,5,1,0},
"充能统计", {"写工厂信息",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},
"写OTP", {"获取通讯末电流",22,1,0,1},
"读OTP", {"写OTP",23,5,6,0},// opt_addr,len,[data]
"清除起爆计数", {"读OTP",24,5,2,10},// 这个任务根据参数1得到实际读取长度
"关总线", {"清除起爆计数",25,5,0,0},
"将缓存区数据写入OTP", {"关总线",26,1,0,0},
"三码写入错误", {"将缓存区数据写入OTP",27,5,3,0},
"三码验证错误", {"写入三码数据",28,5,0,0},
"测量电容压差", {"验证三码数据",29,5,0,0},
"测量桥丝阻值", {"测量电容压差",30,2,1,1},
"使能OTP写", {"测量桥丝阻值",31,4,1,1},
"写模块版本", {"使能OTP写",32,5,0,0},
"读取版本号", {"写模块版本",33,5,1,0},
"写缓存数据", {"读取版本号",34,5,0,1},
"验证缓存数据", {"写缓存数据",35,5,3,0},
"读取延时值和OTP数据相比", {"验证缓存数据",36,5,3,0},
"切换总线极性", {"验证延时时间",37,5,0,0},
"计算异常", {"切换总线极性",38,5,2,0},
"重新执行任务", {"计算异常",39,0,10,0},
"配置三码数据到小板", {"重新执行任务",40,0,1,0},
"任务插槽", {"配置三码数据到小板",41,1,10,0},
nullptr, {"任务插槽",42,1,1,0},
{"设置电阻校准值",43,1,1,0},
{nullptr,0,0,0,0},
}; };
// 根据字符找到任务id,失败返回-1 // task_id,errcode,par_count,ret_count
int coder_find_task_id(const char *str) 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()); int chip=elec_extract_chip(check_plan()->get_plan_id());
const char **table=nullptr; const task_def *table=nullptr;
table=g_ext_task_table;
for(int i=0;i<100;i++){
if(qstrcmp(str,table[i].name)==0){
return &table[i];
}
}
table=nullptr;
if(chip==0){ if(chip==0){
table=g_jq_task_table; table=g_jq_task_table;
}else if(chip==2){ }else if(chip==2){
table=g_ew_task_table; table=g_ew_task_table;
} }
if(table==nullptr){ if(table==nullptr){
return -1; return nullptr;
} }
for(int i=0;i<100;i++){ for(int i=0;i<100;i++){
if(qstrcmp(str,table[i])==0){ if(qstrcmp(str,table[i].name)==0){
return i; return &table[i];
} }
} }
return -1;
return nullptr;
}
// 返回芯片类型
char coder_chip_type()
{
int chip=elec_extract_chip(check_plan()->get_plan_id());
const char table[]="JXW";
if(chip>=0&&chip<=2){
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){
return -1;
}
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));
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;
} }
@@ -122,3 +199,189 @@ int coder_find_task_id(const char *str)
// 检测任务需要读取模块工厂信息
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=i+syscfg()->slave_addr_start;
r.append(uint8_t(addr));
r.append(sdata[0]);
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;
int chip=elec_extract_chip(check_plan()->get_plan_id());
const task_def *table=nullptr;
if(chip==0){
uint16_t params[10]={20,4};
coder_add_task(d,"读OTP",1,1,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));
r.append(uint8_t(coder_chip_type()));
for (int i=0;i<data.size();i++)
{
}
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};
for (int i=0;i<addrs;i++){
myarray d;
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,返回异常代码和任务插槽数据
d.insert(0,uint8_t(1));
return d;
}
// 把从机回复的数据转化为上位机能理解的格式
myarray cmd_coder_code::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));
r.append(uint8_t(coder_chip_type()));
for (int i=0;i<data.size();i++)
{
}
return r;
}
static HandlePc *get_coder_code(){
return new cmd_coder_code();
}
protpc_export(0x02, get_coder_code);
// 设置电阻 校准值
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);

190
prot_cmd/cmd_coder.h
View File

@@ -14,7 +14,13 @@
[4...n]=数据 [4...n]=数据
数据域格式 数据域格式
[0]=小板地址，[1]=数据长度，[2...n]=数据 [0]=检测模式0,只检测,返回原始检测结果;模式1,检测并添加任务插槽,只返回异常代码和任务插槽数据;
模式2,检测并执行任务插槽,返回原始检测数据和任务插槽数据;
模式3,只执行任务插槽,返回异常代码和插槽数据
[1...n]小板数据
小板数据格式
[0]=小板地址(0x1f时为通用数据,每个小板都可以使用)，[1]=数据长度，[2...n]=数据
单个任务数据格式 单个任务数据格式
[0]=插槽序号，[1]=任务id，[2]=参数个数(u16) [0]=插槽序号，[1]=任务id，[2]=参数个数(u16)
@@ -30,7 +36,20 @@
*/ */
int coder_find_task_id(const char *str);
typedef struct{
const char *name;
int task_id;
int errcode;
int par_count;
int ret_count;
}task_def;
const task_def *coder_find_task(const char *str);
// 赋码仪检测命令 // 赋码仪检测命令
@@ -41,9 +60,60 @@ public:
cmd_coder_check():selfdev_runtask(){ cmd_coder_check():selfdev_runtask(){
} }
// pc指令转从机 // pc指令转从机
myarray cmd_pc_to_slave(myarray data){ myarray cmd_pc_to_slave(myarray data);
// pc指令生成从机列表
QList<int> cmd_pc_to_addrs(myarray data){
QList<int> addr_list;
addrs=data[0];
mode=data[1];
if(addrs<=0||addrs>20){
return addr_list;
}
for(int i=0;i<addrs;i++){
addr_list.append(i+1);
}
return addr_list;
} }
// 从机发起命令
int cmd_slave(){
return 0x20;
}
// pc收到回复,返回0不回复
int cmd_pc_recv(){
return 0x01;
}
// 生成接收回复到pc
myarray cmd_pc_recv_to_pc(){
myarray r;
r.append(uint8_t(addrs));
r.append(uint8_t(mode));
r.append(uint8_t(0));
return r;
}
// pc回复命令,返回0不回复
int cmd_pc_ret(){
return 0x81;
}
// 从机返回转pc
myarray ret_slave_to_pc(QList<myarray> data);
protected:
int addrs;
int mode;
};
// 赋码仪新检测命令
class cmd_coder_check2 : public selfdev_runtask
{
Q_OBJECT
public:
cmd_coder_check2():selfdev_runtask(){
}
// pc指令转从机
myarray cmd_pc_to_slave(myarray data);
// pc指令生成从机列表 // pc指令生成从机列表
QList<int> cmd_pc_to_addrs(myarray data){ QList<int> cmd_pc_to_addrs(myarray data){
QList<int> addr_list; QList<int> addr_list;
@@ -77,9 +147,7 @@ public:
return 0x90; return 0x90;
} }
// 从机返回转pc // 从机返回转pc
myarray ret_slave_to_pc(QList<myarray> data){ myarray ret_slave_to_pc(QList<myarray> data);
}
protected: protected:
int addrs; int addrs;
}; };
@@ -88,4 +156,112 @@ protected:
// 赋码仪赋码命令
class cmd_coder_code : public selfdev_runtask
{
Q_OBJECT
public:
cmd_coder_code():selfdev_runtask(){
}
// pc指令转从机
myarray cmd_pc_to_slave(myarray data);
// pc指令生成从机列表
QList<int> cmd_pc_to_addrs(myarray data){
QList<int> addr_list;
addrs=data[0];
if(addrs<=0||addrs>20){
return addr_list;
}
for(int i=0;i<addrs;i++){
addr_list.append(i+1);
}
return addr_list;
}
// 从机发起命令
int cmd_slave(){
return 0x20;
}
// pc收到回复,返回0不回复
int cmd_pc_recv(){
return 0x02;
}
// 生成接收回复到pc
myarray cmd_pc_recv_to_pc(){
myarray r;
r.append(uint8_t(addrs));
r.append(uint8_t(0));
return r;
}
// pc回复命令,返回0不回复
int cmd_pc_ret(){
return 0x82;
}
// 从机返回转pc
myarray ret_slave_to_pc(QList<myarray> data);
protected:
int addrs;
};
// 设置电阻校准值
class cmd_coder_setrtv : public selfdev_runtask
{
Q_OBJECT
public:
cmd_coder_setrtv():selfdev_runtask(){
}
// pc指令转从机
myarray cmd_pc_to_slave(myarray data);
// pc指令生成从机列表
QList<int> cmd_pc_to_addrs(myarray data){
QList<int> addr_list;
addrs=0;
int len=data.size();
for(int i=0;i<len;i+=3){
addr_list.append(data[i]);
addrs|=1<<(data[i]-1);
}
return addr_list;
}
// 从机发起命令
int cmd_slave(){
return 0x20;
}
// pc收到回复,返回0不回复
int cmd_pc_recv(){
return 0;
}
// 生成接收回复到pc
myarray cmd_pc_recv_to_pc(){
myarray r;
return r;
}
// pc回复命令,返回0不回复
int cmd_pc_ret(){
return 0x41;
}
// 从机返回转pc
myarray ret_slave_to_pc(QList<myarray> data);
protected:
int addrs;
};
#endif // CMD_CODER_H #endif // CMD_CODER_H

12
prot_cmd/cmd_pc.cpp
View File

@@ -528,7 +528,7 @@ int selfdev_bootinfo::dolater(int cmd, myarray data)
// 这里开始检测 // 这里开始检测
qDebug("get bootinfo."); qDebug("get bootinfo.");
emit send_data_signal(cmd,myarray(1,0)); emit send_data_signal(cmd,myarray(1,0));
HandleBoardCast *b=new slave_cmd(); HandleBoardCast *b=new slave_cmd2();
bool ack=slave->set_boardcast_handle(cfg_->calc_slave_addrs(),b); bool ack=slave->set_boardcast_handle(cfg_->calc_slave_addrs(),b);
if(ack==false){ if(ack==false){
qWarning("handle is busy."); qWarning("handle is busy.");
@@ -683,14 +683,14 @@ int selfdev_measure_rescv::dolater(int cmd, myarray data)
mycfg *cfg=syscfg(); mycfg *cfg=syscfg();
busy=1; busy=1;
connect(this, &selfdev_measure_rescv::send_to_m4_signal, m4, &prot_m4::send_data_slot); connect(this, &selfdev_measure_rescv::send_to_m4_signal, m4, &prot_m4::send_data_slot);
moter_down_cb_fun=[=](myarray data) moter_down_cb_fun=[=](myarray str)
{ {
m4->del_irq_fun(moter_down_cb_fun,"moter down"); m4->del_irq_fun(moter_down_cb_fun,"moter down");
{ {
// 这里开始检测 // 这里开始检测
qDebug("start check."); qDebug("start check.");
QList<int> addrs=cfg->calc_slave_addrs(); QList<int> addrs=cfg->calc_slave_addrs();
HandleBoardCast *s=new slave_cmd(); HandleBoardCast *s=new slave_cmd2();
bool ack=slave->set_boardcast_handle(addrs,s); bool ack=slave->set_boardcast_handle(addrs,s);
if(ack==false){ if(ack==false){
qWarning("handle is busy."); qWarning("handle is busy.");
@@ -757,7 +757,7 @@ protpc_export(0x42, get_selfdev_measure_rescv);
// 设置电阻校准 // 设置电阻校准,这个只能每个板子设置一样的校准值
int selfdev_set_rescv::dolater(int cmd, myarray data) int selfdev_set_rescv::dolater(int cmd, myarray data)
{ {
prot_slave *slave=protSlave(); prot_slave *slave=protSlave();
@@ -766,7 +766,7 @@ int selfdev_set_rescv::dolater(int cmd, myarray data)
// 这里开始检测 // 这里开始检测
qDebug("set_rescv."); qDebug("set_rescv.");
emit send_data_signal(cmd,myarray(1,0)); emit send_data_signal(cmd,myarray(1,0));
HandleBoardCast *b=new slave_cmd(); HandleBoardCast *b=new slave_cmd2();
bool ack=slave->set_boardcast_handle(cfg_->calc_slave_addrs(),b); bool ack=slave->set_boardcast_handle(cfg_->calc_slave_addrs(),b);
if(ack==false){ if(ack==false){
qWarning("handle is busy."); qWarning("handle is busy.");
@@ -802,7 +802,7 @@ void selfdev_set_rescv::slave_end_slot(int addr,int ack, slave_data data)
static HandlePc *get_selfdev_set_rescv(){ static HandlePc *get_selfdev_set_rescv(){
return new selfdev_set_rescv(); return new selfdev_set_rescv();
} }
protpc_export(0x41, get_selfdev_set_rescv); //protpc_export(0x41, get_selfdev_set_rescv);

43
prot_cmd/cmd_slave.cpp
View File

@@ -475,9 +475,15 @@ int slave_bootinfo::dolater(int cmd, myarray data)
int slave_cmd::start(myarray data) int slave_cmd::start(myarray data)
{ {
int timeout; int timeout=5000;
busy=1; busy=1;
timeout=check_plan()->get_check_time_out()*1000; if(data.size()==0){
qWarning("data size is 0.");
busy=0;
end(0,ret_data);
return 0;
}
// timeout=check_plan()->get_check_time_out()*1000;
qDebug("addr %d start ,timeout=%d",addr,timeout); qDebug("addr %d start ,timeout=%d",addr,timeout);
this->data=data; this->data=data;
send_pack_num=0; send_pack_num=0;
@@ -540,5 +546,38 @@ int slave_cmd::dolater(int cmd, myarray data)
int slave_cmd2::start(myarray data)
{
int timeout=5000;
busy=1;
qDebug("addr %d start ,timeout=%d",addr,timeout);
send_data(cmd,data,3);
timeout_start(timeout);
return 0;
}
void slave_cmd2::timeout()
{
timeout_stop();
qWarning("addr %d timeout.",addr);
end(1,ret_data);
busy=0;
}
int slave_cmd2::dolater(int cmd, myarray data)
{
this->addr_response=0;
timeout_stop_retry();
if(cmd==this->cmd){
qDebug("cmd end success.");
busy=0;
end(0,ret_data);
timeout_stop();
}else{
qWarning("cmd:%02x err.",cmd);
}
return 0;
}

20
prot_cmd/cmd_slave.h
View File

@@ -166,5 +166,25 @@ protected:
// 获取命令数据，使用前先设置cmd
class slave_cmd2:public HandleBoardCast
{
public:
slave_cmd2():HandleBoardCast(){
send_bytes=0;
send_pack_num=0;
}
int start(myarray data);
int dolater(int cmd, myarray data);
void timeout();
bool send_next();
protected:
int send_bytes;
int send_pack_num;
myarray data;
};
#endif // CMD_SLAVE_H #endif // CMD_SLAVE_H