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]=参数


*/


#define coder_led_yellow(){\
  prot_m4 *m4=protM4();\
  m4->send_data_slot("ledg on");\
  m4->send_data_slot("ledr on");\
}

#define coder_led_green(){\
  prot_m4 *m4=protM4();\
  m4->send_data_slot("ledg on");\
  m4->send_data_slot("ledr off");\
}

#define coder_led_red(){\
  prot_m4 *m4=protM4();\
  m4->send_data_slot("ledg off");\
  m4->send_data_slot("ledr on");\
}

#define coder_led_off(){\
  prot_m4 *m4=protM4();\
  m4->send_data_slot("ledg off");\
  m4->send_data_slot("ledr off");\
}



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);
// 添加一个任务,返回0添加成功
int coder_add_task(myarray &d,const char *name,int slot_index,int task_index,uint16_t params[10]);
// 包装为一个小板的数据,返回0成功
// 包装前需要先添加任务
int coder_slave_pack(myarray &d,int addr);
// 找到指定任务序号的数据
myarray coder_slave_find_ret_data(myarray data,int task_index,int size);


// 赋码仪检测命令
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);
    addrs_num=0;
    for(int i=0;i<20;i++){
      if((addrs&(1<<i))!=0){
        addr_list.append(i+1);
        addrs_num++;
      }
    }
    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;
  int addrs_num;
};






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_code2 : public selfdev_runtask
{
  Q_OBJECT
public:
  cmd_coder_code2():selfdev_runtask(){
    delay=0;
  }
  // 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);
    addrs_num=0;
    for(int i=0;i<20;i++){
      if((addrs&(1<<i))!=0){
        addr_list.append(i+1);
        addrs_num++;
      }
    }
    return addr_list;
  }
  // 从机发起命令
  int cmd_slave(){
    return 0x20;
  }
  // pc收到回复,返回0不回复
  int cmd_pc_recv(){
    return 0x11;
  }
  // 生成接收回复到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 0x91;
  }
  // 从机返回转pc
  myarray ret_slave_to_pc(QList<myarray> data);
protected:
  int addrs;
  int chip_mode;
  int addrs_num;
  uint16_t delay;
  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(){
  }
  ~cmd_checker_check(){
      if(moter_down_cb_fun!=nullptr){
      // 取消电机下降到位回调
      prot_m4 *m4 = protM4();
      if(m4!=nullptr) {
        m4->del_irq_fun(moter_down_cb_fun,"moter ");
      }
    }
  }
  int dolater(int cmd, myarray data);
  // 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);
  virtual int key_press();
protected:
  // int addrs;
  int mode;
  prot_m4_cb moter_down_cb_fun;
signals:
  void send_to_m4_signal(myarray data);
};





// 批检仪检测并读取模块流水号
class cmd_checker_check2 : public cmd_checker_check
{
  Q_OBJECT
public:
  cmd_checker_check2():cmd_checker_check(){
  }
  ~cmd_checker_check2(){
  }
  // pc指令转从机
  myarray cmd_pc_to_slave(myarray data);
  // pc指令生成从机列表
  QList<int> cmd_pc_to_addrs(myarray data){
    return syscfg()->calc_slave_addrs();
  }
  // pc收到回复,返回0不回复
  int cmd_pc_recv(){
    return 0x30;
  }
};




// 批检仪检测不读取流水号
class cmd_checker_check3 : public cmd_checker_check2
{
  Q_OBJECT
public:
  cmd_checker_check3():cmd_checker_check2(){
  }
  ~cmd_checker_check3(){
  }
  // pc收到回复,返回0不回复
  int cmd_pc_recv(){
    return 0x49;
  }
  // pc指令转从机
  myarray cmd_pc_to_slave(myarray data);
};



// 批检仪检测不读取流水号
class cmd_checker_check4 : public cmd_checker_check3
{
  Q_OBJECT
public:
  cmd_checker_check4():cmd_checker_check3(){
  }
  ~cmd_checker_check4(){
  }
  // pc收到回复,返回0不回复
  int cmd_pc_recv(){
    return 0x44;
  }
  int key_press();
};





#endif // CMD_CODER_H