checker_host/prot_cmd/cmd_coder.h

#ifndef CMD_CODER_H
#define CMD_CODER_H

#include <QObject>
#include "prot_cmd/cmd_pc.h"
#include "base/check_cfg.h"
#include "elec/elec_judge.h"


/*

执行任务命令格式
[0...1]=总字节数，[2]=当前包数(0开始),[3]=当前包字节数
[4...n]=数据

数据域格式
[0]=检测模式0,只检测,返回原始检测结果;模式1,检测并添加任务插槽,只返回异常代码和任务插槽数据;
模式2,检测并执行任务插槽,返回原始检测数据和任务插槽数据;
模式3,只执行任务插槽,返回异常代码和插槽数据
[1...n]小板数据

小板数据格式
[0]=小板地址(0x1f时为通用数据,每个小板都可以使用)，[1]=数据长度，[2...n]=数据

单个任务数据格式
[0]=插槽序号，[1]=任务id，[2]=参数个数(u16)
[3]=返回值个数(u16)，[4]=异常代码，[5]=任务序号
[6...n]=参数



返回数据域格式
[0]=任务序号，[1]=返回数据长度(u16)
[2...n]=参数


*/


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);


// 赋码仪检测命令
class cmd_coder_check : public selfdev_runtask
{
  Q_OBJECT
public:
  cmd_coder_check():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];
    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指令生成从机列表
  QList<int> cmd_pc_to_addrs(myarray data){
    QList<int> addr_list;
    addrs=data[0]|(data[1]<<8)|(data[2]<<16);
    for(int i=0;i<20;i++){
      if((addrs&(1<<i))!=0){
        addr_list.append(i+1);
      }
    }
    return addr_list;
  }
  // 从机发起命令
  int cmd_slave(){
    return 0x20;
  }
  // pc收到回复,返回0不回复
  int cmd_pc_recv(){
    return 0x10;
  }
  // 生成接收回复到pc
  myarray cmd_pc_recv_to_pc(){
    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(0));
    return r;
  }
  // pc回复命令,返回0不回复
  int cmd_pc_ret(){
    return 0x90;
  }
  // 从机返回转pc
  myarray ret_slave_to_pc(QList<myarray> data);
protected:
  int addrs;
};






typedef struct{
  char shell[20];
  char uid[20];
  char psw[20];
  char uid_psw[20];
}uid_code;


// 赋码仪赋码命令
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;
  int chip_mode;
  QList<uid_code> uid_codes;
};









// 设置电阻校准值
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;
};






// 批检仪检测并设置模块流水号
class cmd_checker_check : public selfdev_runtask
{
  Q_OBJECT
public:
  cmd_checker_check():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+=5){
        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 0x48;
  }
  // 生成接收回复到pc
  myarray cmd_pc_recv_to_pc(){
    myarray r;
    r.append(uint8_t(0));
    return r;
  }
  // pc回复命令,返回0不回复
  int cmd_pc_ret(){
    return 0x31;
  }
  // 从机返回转pc
  myarray ret_slave_to_pc(QList<myarray> data);
protected:
  int addrs;
  int mode;
};








#endif // CMD_CODER_H