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

2023-12-20 18:24:00 +08:00
parent bf4b4b45ea
commit af964ad733
8 changed files with 607 additions and 106 deletions
--- a/ReadMe.txt
+++ b/ReadMe.txt
@@ -20,3 +20,6 @@
  添加电阻测试命令，添加自检命令
 2023.12.19
  制定任务执行命令
+2023.12.20
+  任务执行命令验证写入电阻校准值成功
+  
--- a/complier_info.h
+++ b/complier_info.h
@@ -6,7 +6,7 @@



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



--- a/info.json
+++ b/info.json
@@ -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",
  "private": [
    "info.json",
--- a/prot_cmd/cmd_coder.cpp
+++ b/prot_cmd/cmd_coder.cpp
@@ -1,117 +1,194 @@
 #include "cmd_coder.h"
+#include "QDebug"



-static const char *g_ew_task_table[]={
-"电源准备",
-"延时等待",
-"桥丝电阻测试",
-"上电充能",
-"设置总线电压",
-"获取总线电流",
-"使能MTP",
-"扫描UID",
-"写配置参数",
-"检测配置",
-"验证配置",
-"模拟注码",
-"验证模拟注码",
-"芯片自检",
-"状态检测",
-"充电",
-"放电",
-"写延时",
-"读延时",
-"时钟校准",
-"设置通信地址",
-"状态巡检",
-"起爆使能",
-"起爆检测",
-"缓存数据写入MTP",
-"验证缓存数据",
-"关总线",
-"升级",
-"充能统计",
-"计算异常",
-"重新执行任务",
-"写入三码数据",
-"验证三码数据",
-"配置三码数据到小板",
-"任务插槽",
-nullptr,
+
+
+
+
+// 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},
+{nullptr,0,0,0,0},
 };





-static const char *g_jq_task_table[]={
-"电源准备",
-"上电充能",
-"设置总线电压",
-"获取总线电流",
-"扫描UID",
-"密码验证",
-"读取芯片代码",
-"OTP检测",
-"工厂测试检测",
-"读取状态",
-"写工厂信息",
-"充能统计",
-"充电电压检测",
-"延时等待",
-"设置延时",
-"读取延时",
-"时钟校准",
-"放电",
-"复位",
-"起爆使能",
-"起爆充能",
-"使能通讯末电流采集",
-"获取通讯末电流",
-"写OTP",
-"读OTP",
-"清除起爆计数",
-"关总线",
-"将缓存区数据写入OTP",
-"三码写入错误",
-"三码验证错误",
-"测量电容压差",
-"测量桥丝阻值",
-"使能OTP写",
-"写模块版本",
-"读取版本号",
-"写缓存数据",
-"验证缓存数据",
-"读取延时值和OTP数据相比",
-"切换总线极性",
-"计算异常",
-"重新执行任务",
-"配置三码数据到小板",
-"任务插槽",
-nullptr,
+// 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,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},
+{"获取通讯末电流",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},
+{nullptr,0,0,0,0},
 };


-// 根据字符找到任务id,失败返回-1
-int coder_find_task_id(const char *str)
+// 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 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){
    table=g_jq_task_table;
  }else if(chip==2){
    table=g_ew_task_table;
  }
  if(table==nullptr){
-    return -1;
+    return nullptr;
  }
  for(int i=0;i<100;i++){
-    if(qstrcmp(str,table[i])==0){
-      return i;
+    if(qstrcmp(str,table[i].name)==0){
+      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);
+
+
+
+
+
+
+
+
--- a/prot_cmd/cmd_coder.h
+++ b/prot_cmd/cmd_coder.h
@@ -14,7 +14,13 @@
 [4...n]=数据

 数据域格式
-[0]=小板地址，[1]=数据长度，[2...n]=数据
+[0]=检测模式0,只检测,返回原始检测结果;模式1,检测并添加任务插槽,只返回异常代码和任务插槽数据;
+模式2,检测并执行任务插槽,返回原始检测数据和任务插槽数据;
+模式3,只执行任务插槽,返回异常代码和插槽数据
+[1...n]小板数据
+
+小板数据格式
+[0]=小板地址(0x1f时为通用数据,每个小板都可以使用)，[1]=数据长度，[2...n]=数据

 单个任务数据格式
 [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(){
  }
  // 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指令生成从机列表
  QList<int> cmd_pc_to_addrs(myarray data){
    QList<int> addr_list;
@@ -77,9 +147,7 @@ public:
    return 0x90;
  }
  // 从机返回转pc
-  myarray ret_slave_to_pc(QList<myarray> data){
-  
-  }
+  myarray ret_slave_to_pc(QList<myarray> data);
 protected:
  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
--- a/prot_cmd/cmd_pc.cpp
+++ b/prot_cmd/cmd_pc.cpp
@@ -528,7 +528,7 @@ int selfdev_bootinfo::dolater(int cmd, myarray data)
  // 这里开始检测
  qDebug("get bootinfo.");
  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);
  if(ack==false){
    qWarning("handle is busy.");
@@ -683,14 +683,14 @@ int selfdev_measure_rescv::dolater(int cmd, myarray data)
  mycfg *cfg=syscfg();
  busy=1;
  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");
    {
      // 这里开始检测
      qDebug("start check.");
      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);
      if(ack==false){
        qWarning("handle is busy.");
@@ -757,7 +757,7 @@ protpc_export(0x42, get_selfdev_measure_rescv);



-// 设置电阻校准
+// 设置电阻校准,这个只能每个板子设置一样的校准值
 int selfdev_set_rescv::dolater(int cmd, myarray data)
 {
  prot_slave *slave=protSlave();
@@ -766,7 +766,7 @@ int selfdev_set_rescv::dolater(int cmd, myarray data)
  // 这里开始检测
  qDebug("set_rescv.");
  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);
  if(ack==false){
    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(){
  return new selfdev_set_rescv();
 }
-protpc_export(0x41, get_selfdev_set_rescv);
+//protpc_export(0x41, get_selfdev_set_rescv);



--- a/prot_cmd/cmd_slave.cpp
+++ b/prot_cmd/cmd_slave.cpp
@@ -475,9 +475,15 @@ int slave_bootinfo::dolater(int cmd, myarray data)

 int slave_cmd::start(myarray data)
 {
-  int timeout;
+  int timeout=5000;
  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);
  this->data=data;
  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;
+}
+


--- a/prot_cmd/cmd_slave.h
+++ b/prot_cmd/cmd_slave.h
@@ -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