广播命令已接收的回复不再触发回调

检测命令0x0c只能使用单播方式，广播方式因为不能即时回复停止信号，回复会出错
  添加电阻测试命令，添加自检命令

ReadMe.txt

@@ -12,4 +12,9 @@
   批检仪检测流程验证成功
 2023.12.8
   广播命令可以接收各个从机的返回数据，计划将所有命令转化为广播命令
-
+2023.12.12
+  添加蜂鸣器
+2023.12.13
+  广播命令已接收的回复不再触发回调
+  检测命令0x0c只能使用单播方式，广播方式因为不能即时回复停止信号，回复会出错
+  添加电阻测试命令，添加自检命令

base/beep.cpp

@@ -0,0 +1,131 @@
+#include "beep.h"
+#include "QTimer"
+#include "QThread"
+beep::beep(QObject *parent) : QObject(parent)
+{
+  /* 开发板的 LED 控制接口 */
+  file.setFileName("/sys/devices/platform/leds/leds/beep/brightness");
+  if (!file.exists())
+  {
+    qWarning()<<"beep init Fail!!"<<endl;
+    return ;
+  }
+  
+  set_state(false);
+  state = get_state();
+  
+  // 在启动此对象时自动鸣叫两次
+  delay_on_ms = 100;
+  delay_off_ms =100;
+  ticks = 2;
+  is_run = true;
+}
+
+
+
+bool beep::get_state()
+{
+    if(!file.exists())
+        return  false;
+    if(!file.open(QIODevice::ReadWrite))
+        qWarning()<<file.errorString();
+    QTextStream in(&file);
+
+    QString buf = in.readLine();
+
+    file.close();
+    if(buf == "1")
+    {
+        state = true;
+    }
+    else
+    {
+        state = false;
+    }
+    return false;
+}
+
+
+// 控制蜂鸣器，用户程序一般不直接调用
+bool beep::set_state(bool state)
+{
+    if (!file.exists())
+        return false;
+    if(!file.open(QIODevice::ReadWrite))
+        qWarning()<<file.errorString();
+    if(state)
+    {
+        file.write("1");
+        this->state = true;
+    }
+    else
+    {
+        file.write("0");
+        this->state = false;
+    }
+    file.close();
+
+    return true;
+}
+
+
+void beep::start()
+{
+    QTimer::singleShot(0,this, &beep::run_cb);
+}
+
+
+bool beep::stop()
+{
+    QMutexLocker locker(&lock);
+    is_run = false;
+    return true;
+}
+
+
+// 用户程序调用这个函数开启蜂鸣器
+void beep::set_beep(int delay_on_ms,int delay_off_ms,int ticks)
+{
+
+    this->delay_on_ms = delay_on_ms;
+    this->delay_off_ms =delay_off_ms;
+    this->ticks = ticks;
+}
+
+
+// 执行线程
+void beep::run_cb()
+{
+    while(is_run)
+    {
+        QMutexLocker locker(&lock);
+        while(ticks>0)
+        {
+            ticks--;
+            set_state(true);
+            QThread::msleep(delay_on_ms);
+            set_state(false);
+            QThread::msleep(delay_off_ms);
+        }
+
+    }
+}
+
+
+
+beep *Beep(){
+  static beep *b=nullptr;
+  static QThread thread;
+  if(b==nullptr){
+    b=new beep();
+    b->moveToThread(&thread);
+    thread.start();
+    b->start();
+  }
+  return b;
+}
+
+
+
+
+

base/beep.h

@@ -0,0 +1,45 @@
+#ifndef BEEP_H
+#define BEEP_H
+
+#include <QFile>
+#include <QDebug>
+#include <QObject>
+#include <QThread>
+#include <QMutexLocker>
+#include <QMutex>
+class beep : public QObject
+{
+  Q_OBJECT
+public:
+  explicit beep(QObject *parent = nullptr);
+  
+    bool stop();
+    void start();
+    // 用户程序调用这个函数开启蜂鸣器
+    void set_beep(int delay_on_ms,int delay_off_ms,int ticks);
+private:
+    bool get_state();
+    bool set_state(bool state);
+private:
+    bool is_run;
+    bool state;
+
+    int delay_on_ms;
+    int delay_off_ms;
+    int ticks;
+
+    QMutex lock;
+    QFile file;
+
+private slots:
+    void run_cb();
+  
+};
+
+
+
+beep *Beep();
+
+
+
+#endif // BEEP_H

checker_host.pro

@@ -21,6 +21,7 @@ DEFINES += QT_DEPRECATED_WARNINGS
 
 SOURCES += \
     base/base.cpp \
+    base/beep.cpp \
     base/check_cfg.cpp \
     base/crc.cpp \
     base/debug.cpp \
@@ -48,6 +49,7 @@ SOURCES += \
 
 HEADERS += \
     base/base.h \
+    base/beep.h \
     base/check_cfg.h \
     base/crc.h \
     base/debug.h \
@@ -83,3 +85,7 @@ TRANSLATIONS += \
 qnx: target.path = /tmp/$${TARGET}/bin
 else: unix:!android: target.path = /opt/$${TARGET}/bin
 !isEmpty(target.path): INSTALLS += target
+
+DISTFILES += \
+  ReadMe.txt \
+  ReadMe.txt

complier_info.h

@@ -6,7 +6,7 @@
 
 
 
-#define BUILD_DATE  "2023-12-08 10:04:55"
+#define BUILD_DATE  "2023-12-13 17:50:37"
 
 
 

info.json

@@ -1,5 +1,5 @@
 {
-  "build_date": "2023-12-08 10:04:55",
+  "build_date": "2023-12-13 17:50:37",
   "hard_version": "MHPZ2_V1.00",
   "private": [
     "info.json",

interface/if_can.cpp

@@ -231,7 +231,7 @@ void can_host::recv_data_cb()
 
 int can_host::write(int dst,myarray data)
 {
-  // qDebug()<<"can send to:"<<dst<<data.toHex(' ');
+  qDebug()<<"can send to:"<<dst<<data.toHex(' ');
   append(dst, 1, data);
   // qDebug("can send end.");
   return data.size();

main.cpp

@@ -13,7 +13,7 @@
 #include "prot/prot_cmdline.h"
 #include "base/debug.h"
 #include "prot_cmd/cmd_m4.h"
-
+#include "base/beep.h"
 
 
 
@@ -23,6 +23,7 @@ int main(int argc, char *argv[])
   QApplication app(argc, argv);
   MainWindow w;
   // w.show();
+  Beep();
   mydebug_init();
   mycfg *cfg=syscfg();
   if(cfg->log_redirect=="file"){

prot/prot_slave.cpp

@@ -24,12 +24,16 @@ void prot_slave::init()
           qWarning("slave addr err:%d",src);
         }else{
           if((broadcast_!=nullptr)&&(broadcast_->busy)){
-            broadcast_->addr_response|=1<<(src-1);
-            // 存储从机的数据
-            broadcast_->ret_data[src-1]=data;
-            if(broadcast_->check_response()==true){
-              // broadcast_->dolater(broadcast_->cmd,data);
-              emit boardcast_dolater_signal(broadcast_->cmd,data);
+            if(cmd==broadcast_->cmd){
+              if((broadcast_->addr_response&(1<<(src-1)))==0){
+                broadcast_->addr_response|=1<<(src-1);
+                // 存储从机的数据
+                broadcast_->ret_data[src-1]=data;
+                if(broadcast_->check_response()==true){
+                  // broadcast_->dolater(broadcast_->cmd,data);
+                  emit boardcast_dolater_signal(broadcast_->cmd,data);
+                }
+              }
             }
           }else{
             handle=slaves[src-1];

prot_cmd/cmd_pc.cpp

@@ -126,6 +126,8 @@ static myarray tran_slave_to_selfdev_check(myarray &data)
   int paramerr_num=(return_num+7)/8;
   // 每个通道占用的长度
   int len_for_each=1+8+paramerr_num+return_num*2;
+  // 去掉应答位
+  data.remove(0,1);
   myarray r;
   if(data.size()<17){
     r.append(char(208));
@@ -169,6 +171,77 @@ protpc_export(0x30, get_selfdev_check);
 
 
 
+// 自研批检仪检测
+int selfdev_check2::dolater(int cmd, myarray data)
+{
+  prot_m4 *m4 = protM4();
+  prot_slave *slave=protSlave();
+  mycfg *cfg=syscfg();
+  busy=1;
+  connect(this, &selfdev_check2::send_to_m4_signal, m4, &prot_m4::send_data_slot);
+  moter_down_cb_fun=[=](myarray data)
+  {
+    m4->del_irq_fun(moter_down_cb_fun,"moter down");
+    {
+      // 这里开始检测
+      qDebug("start check.");
+      emit send_data_signal(cmd,myarray(1,0));
+      QList<int> addrs=cfg->calc_slave_addrs();
+      HandleBoardCast *s=new slave_check2();
+      bool ack=slave->set_boardcast_handle(addrs,s);
+      if(ack==false){
+        qWarning("handle is busy.");
+      }else{
+        connect(s,&HandleBoardCast::end_signal,this,&selfdev_check2::slave_end_slot);
+        s->start(myarray());
+      }
+    }
+  };
+  myarray moter_cmd=moter_ctrl("down");
+  if(moter_cmd.size()==0){
+    busy=0;
+    qWarning("moter failed.");
+  }else{
+    m4->set_irq_fun(moter_down_cb_fun,"moter down");
+    emit send_to_m4_signal(moter_cmd);
+  }
+  slave_acked.clear();
+  for(int i=0;i<cfg->slave_num;i++){
+    slave_acked.append(myarray());
+  }
+  slave_acked_num=0;
+  return 0;
+}
+
+void selfdev_check2::timeout()
+{
+  busy=0;
+}
+void selfdev_check2::slave_end_slot(int addr,int ack, slave_data data)
+{
+  for(int i=0;i<data.size();i++){
+    slave_ret slave=data.at(i);
+    slave_acked.replace(slave.addr-1,slave.data);
+    slave_acked_num++;
+  }
+  myarray r;
+  r.append(char(0));
+  for(int i=0;i<slave_acked.size();i++){
+    r.append(tran_slave_to_selfdev_check(slave_acked[i]));
+  }
+  emit send_data_signal(0x31,r);
+  busy=0;
+}
+
+//static HandlePc *get_selfdev_check2(){
+//  return new selfdev_check2();
+//}
+//protpc_export(0x30, get_selfdev_check2);
+
+
+
+
+
 
 
 // 检测结束 电机上升
@@ -274,7 +347,7 @@ void selfdev_slaveupdate::timeout(){
 
 void selfdev_slaveupdate::slave_end_slot(int addr,int ack, slave_data data)
 {
-  qDebug("slave update end,ack=%d",ack);
+  qDebug("slave update end,ack=%s",ack?"failed":"success");
   busy=0;
 }
 
@@ -331,7 +404,8 @@ int selfdev_update_scheme::dolater(int cmd, myarray data)
             busy=0;
           }else{
             connect(b,&HandleBoardCast::end_signal,this,&selfdev_update_scheme::slave_end_slot);
-            b->start(data);
+            myarray scheme=myarray((const char *)ccfg_->check_scheme(),ccfg_->check_scheme_size());
+            b->start(scheme);
           }
         }
         else{
@@ -350,7 +424,7 @@ void selfdev_update_scheme::timeout(){
 
 void selfdev_update_scheme::slave_end_slot(int addr,int ack, slave_data data)
 {
-  qDebug("slave update end,ack=%d",ack);
+  qDebug("slave update end,ack=%s",ack?"failed":"success");
   busy=0;
 }
 
@@ -449,24 +523,23 @@ protpc_export(0x27, get_selfdev_jwtupdate);
 int selfdev_bootinfo::dolater(int cmd, myarray data)
 {
   prot_slave *slave=protSlave();
-  mycfg *cfg=syscfg();
+  mycfg *cfg_=syscfg();
   busy=1;
   // 这里开始检测
   qDebug("get bootinfo.");
   emit send_data_signal(cmd,myarray(1,0));
-  QList<int> addrs=cfg->calc_slave_addrs();
-  foreach(int addr, addrs){
-    HandleSlave *s=new slave_check();
-    bool ack=slave->set_slave_handle(addr,s);
-    if(ack==false){
-      qWarning("addr %d handle is busy.",addr);
-    }else{
-      connect(s,&HandleSlave::end_signal,this,&selfdev_bootinfo::slave_end_slot);
-      s->start(myarray());
-    }
+  HandleBoardCast *b=new slave_cmd();
+  bool ack=slave->set_boardcast_handle(cfg_->calc_slave_addrs(),b);
+  if(ack==false){
+    qWarning("handle is busy.");
+    busy=0;
+  }else{
+    connect(b,&HandleBoardCast::end_signal,this,&selfdev_bootinfo::slave_end_slot);
+    b->cmd=0x13;
+    b->start(data);
   }
   slave_acked.clear();
-  for(int i=0;i<cfg->slave_num;i++){
+  for(int i=0;i<cfg_->slave_num;i++){
     slave_acked.append(myarray());
   }
   slave_acked_num=0;
@@ -523,12 +596,13 @@ myarray bootinfo_fill_local(void)
   QStringList iplist;
   mycfg *cfg_=syscfg();
   check_cfg *ccfg_=check_plan();
-  uint8_t *d=(uint8_t *)calloc(1,sizeof(local_bootinfo));
-  memcpy(d,cfg_->build_date.toLocal8Bit(),cfg_->build_date.size()+1);d+=20;
-  memcpy(d,cfg_->soft_version.toLocal8Bit(),cfg_->soft_version.size()+1);d+=8;
+  uint8_t *d=(uint8_t *)calloc(1,sizeof(local_bootinfo)+1);
+  uint8_t *d_free=d;
+  memcpy(d,cfg_->build_date.data(),cfg_->build_date.size()+1);d+=20;
+  memcpy(d,cfg_->soft_version.data(),cfg_->soft_version.size()+1);d+=8;
   memcpy(d,&tick,4);d+=4;
   memcpy(d,&wdog,1);d+=1;
-  memcpy(d,cfg_->device_type.toLocal8Bit(),cfg_->device_type.size()+1);d+=12;
+  memcpy(d,cfg_->device_type.data(),cfg_->device_type.size()+1);d+=12;
   iplist=cfg_->local_ip.split('.');
   ip[0]=iplist[0].toInt();
   ip[1]=iplist[1].toInt();
@@ -552,60 +626,44 @@ myarray bootinfo_fill_local(void)
     temp32|=1<<i;
   }
   memcpy(d,&temp32,4);d+=4;
-  myarray arry((char *)d,sizeof(local_bootinfo));
-  free(d);
+  myarray arry((char *)d_free,sizeof(local_bootinfo));
+  free(d_free);
+  qDebug()<<"local data="<<arry.toHex(' ');
   return arry;
 }
 
 
 static myarray slave_to_bootinfo_byte(myarray data){
-  data.append(sizeof(bootinfo_data)-data.size(),0);
+  data.remove(0,1);
+  int size_slave=sizeof(bootinfo_data);
+  int data_size=data.size();
+  if(size_slave>data_size){
+    data.append(size_slave-data_size,0);
+  }
   return data;
 }
 
-//void selfdev_bootinfo::slave_end_slot(int addr,int ack, slave_data data)
-//{
-//  if(addr<=0||addr>slave_acked.size()){
-//    qWarning("slave addr err:%d",addr);
-//    return;
-//  }
-//  for(int i=0;i<data.size();i++){
-//    slave_ret slave=data.at(i);
-//    slave_acked.replace(slave.addr-1,slave.data);
-//    slave_acked_num++;
-//    myarray r;
-//    r.append(char(0));
-//    r+=bootinfo_fill_local();
-//    for(int i=0;i<slave_acked.size();i++){
-//      r.append(slave_to_bootinfo_byte(slave_acked[i]));
-//    }
-//    emit send_data_signal(0x34,r);
-//    busy=0;
-//  }
-//}
-
-void selfdev_bootinfo::slave_end_slot(int addr,int ack, myarray data)
+void selfdev_bootinfo::slave_end_slot(int addr,int ack, slave_data data)
 {
-  if(addr<=0||addr>slave_acked.size()){
-    qWarning("slave addr err:%d",addr);
-    return;
+  qDebug("selfdev get bootinfo end.");
+  myarray r;
+  r.append(char(0));
+  r+=bootinfo_fill_local();
+  for(int i=0;i<data.size();i++){
+    slave_ret slave=data.at(i);
+    slave_acked.replace(slave.addr-1,slave.data);
+    slave_acked_num++;
   }
-  slave_acked.replace(addr-1,data);
-  slave_acked_num++;
-  if(slave_acked_num>=slave_acked.size()){
-    myarray r;
-    r.append(char(0));
-    r+=bootinfo_fill_local();
-    for(int i=0;i<slave_acked.size();i++){
-      r.append(slave_to_bootinfo_byte(slave_acked[i]));
-    }
-    emit send_data_signal(0x34,r);
-    busy=0;
+  for(int i=0;i<slave_acked.size();i++){
+    r.append(slave_to_bootinfo_byte(slave_acked[i]));
   }
+  emit send_data_signal(0x35,r);
+  busy=0;
 }
 
 
 
+
 static HandlePc *get_selfdev_bootinfo(){
   return new selfdev_bootinfo();
 }
@@ -617,3 +675,137 @@ protpc_export(0x34, get_selfdev_bootinfo);
 
 
 
+// 测量电阻
+int selfdev_measure_rescv::dolater(int cmd, myarray data)
+{
+  prot_m4 *m4 = protM4();
+  prot_slave *slave=protSlave();
+  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)
+  {
+    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();
+      bool ack=slave->set_boardcast_handle(addrs,s);
+      if(ack==false){
+        qWarning("handle is busy.");
+      }else{
+        connect(s,&HandleBoardCast::end_signal,this,&selfdev_measure_rescv::slave_end_slot);
+        s->cmd=0x05;
+        s->start(data);
+      }
+    }
+  };
+  myarray moter_cmd=moter_ctrl("down");
+  if(moter_cmd.size()==0){
+    busy=0;
+    qWarning("moter failed.");
+  }else{
+    m4->set_irq_fun(moter_down_cb_fun,"moter down");
+    emit send_to_m4_signal(moter_cmd);
+  }
+  slave_acked.clear();
+  for(int i=0;i<cfg->slave_num;i++){
+    slave_acked.append(myarray());
+  }
+  slave_acked_num=0;
+  return 0;
+}
+
+void selfdev_measure_rescv::timeout()
+{
+  busy=0;
+}
+
+void selfdev_measure_rescv::slave_end_slot(int addr,int ack, slave_data data)
+{
+  qDebug("selfdev measure_rescv end.");
+  emit send_to_m4_signal(moter_ctrl("up"));
+  myarray r;
+  r.append(char(0));
+  for(int i=0;i<data.size();i++){
+    slave_ret slave=data.at(i);
+    slave_acked.replace(slave.addr-1,slave.data);
+    slave_acked_num++;
+  }
+  for(int i=0;i<slave_acked.size();i++){
+    r.append(char(i+1));
+    r.append(slave_acked[i].right(2));
+  }
+  QTimer::singleShot(0, this, [=](){
+    emit send_data_signal(0x42,r);
+  });
+  busy=0;
+}
+
+
+
+
+static HandlePc *get_selfdev_measure_rescv(){
+  return new selfdev_measure_rescv();
+}
+protpc_export(0x42, get_selfdev_measure_rescv);
+
+
+
+
+
+
+
+// 设置电阻校准
+int selfdev_set_rescv::dolater(int cmd, myarray data)
+{
+  prot_slave *slave=protSlave();
+  mycfg *cfg_=syscfg();
+  busy=1;
+  // 这里开始检测
+  qDebug("set_rescv.");
+  emit send_data_signal(cmd,myarray(1,0));
+  HandleBoardCast *b=new slave_cmd();
+  bool ack=slave->set_boardcast_handle(cfg_->calc_slave_addrs(),b);
+  if(ack==false){
+    qWarning("handle is busy.");
+    busy=0;
+  }else{
+    connect(b,&HandleBoardCast::end_signal,this,&selfdev_set_rescv::slave_end_slot);
+    // 广播设置校准值，需使用新增命令
+    b->cmd=0x13;
+    b->start(data);
+  }
+  slave_acked.clear();
+  for(int i=0;i<cfg_->slave_num;i++){
+    slave_acked.append(myarray());
+  }
+  slave_acked_num=0;
+  return 0;
+}
+
+void selfdev_set_rescv::timeout()
+{
+  busy=0;
+}
+
+void selfdev_set_rescv::slave_end_slot(int addr,int ack, slave_data data)
+{
+  qDebug("selfdev set_rescv end.");
+  myarray r;
+  r.append(char(0));
+  emit send_data_signal(0x41,r);
+  busy=0;
+}
+
+static HandlePc *get_selfdev_set_rescv(){
+  return new selfdev_set_rescv();
+}
+protpc_export(0x41, get_selfdev_set_rescv);
+
+
+
+
+
+

prot_cmd/cmd_pc.h

@@ -38,6 +38,40 @@ signals:
 
 
 
+
+// 检测 自研批检仪 广播形式
+class selfdev_check2 : public HandlePc
+{
+  Q_OBJECT
+public:
+  selfdev_check2() : HandlePc() {
+    slave_acked_num=0;
+    moter_down_cb_fun=nullptr;
+  }
+  ~selfdev_check2() {
+    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);
+  void timeout();
+public slots:
+  void slave_end_slot(int addr,int ack, slave_data data);
+protected:
+  QList<myarray> slave_acked;
+  int slave_acked_num;
+  prot_m4_cb moter_down_cb_fun;
+signals:
+  void send_to_m4_signal(myarray data);
+};
+
+
+
+
 // 检测结束 自研批检仪
 class selfdev_checkend : public HandlePc
 {
@@ -148,8 +182,7 @@ public:
   int dolater(int cmd, myarray data);
   void timeout();
 public slots:
-//  void slave_end_slot(int addr,int ack, slave_data data);
-  void slave_end_slot(int addr,int ack, myarray data);
+  void slave_end_slot(int addr,int ack, slave_data data);
 protected:
   QList<myarray> slave_acked;
   int slave_acked_num;
@@ -160,4 +193,62 @@ protected:
 
 
 
+
+// 测量电阻
+class selfdev_measure_rescv : public HandlePc
+{
+  Q_OBJECT
+public:
+  selfdev_measure_rescv() : HandlePc() {
+    slave_acked_num=0;
+  }
+  ~selfdev_measure_rescv() {
+    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);
+  void timeout();
+public slots:
+  void slave_end_slot(int addr,int ack, slave_data data);
+protected:
+  QList<myarray> slave_acked;
+  int slave_acked_num;
+  prot_m4_cb moter_down_cb_fun;
+signals:
+  void send_to_m4_signal(myarray data);
+};
+
+
+
+
+// 设置电阻校准
+class selfdev_set_rescv : public HandlePc
+{
+  Q_OBJECT
+public:
+  selfdev_set_rescv() : HandlePc() {
+    slave_acked_num=0;
+  }
+  ~selfdev_set_rescv() {
+  }
+  int dolater(int cmd, myarray data);
+  void timeout();
+public slots:
+  void slave_end_slot(int addr,int ack, slave_data data);
+protected:
+  QList<myarray> slave_acked;
+  int slave_acked_num;
+signals:
+  void send_to_m4_signal(myarray data);
+};
+
+
+
+
+
 #endif

prot_cmd/cmd_slave.cpp

@@ -76,6 +76,7 @@ void slave_check2::timeout()
 
 int slave_check2::dolater(int cmd, myarray data)
 {
+  this->addr_response=0;
   timeout_stop_retry();
   if(cmd==0x0c){
     if(data.size()<=16){
@@ -449,7 +450,7 @@ int slave_bootinfo::start(myarray data)
 void slave_bootinfo::timeout()
 {
   timeout_stop();
-  qWarning("addr %d get bootinfo.",addr);
+  qWarning("addr %d get bootinfo timeout.",addr);
   end(1,myarray());
   busy=0;
 }
@@ -460,6 +461,8 @@ int slave_bootinfo::dolater(int cmd, myarray data)
     qWarning("addr %d recv err cmd:%02x",addr,cmd);
     return 1;
   }
+  qWarning("addr %d get bootinfo success.",addr);
+  timeout_stop();
   timeout_stop_retry();
   end(0,data);
   busy=0;
@@ -470,3 +473,42 @@ int slave_bootinfo::dolater(int cmd, myarray data)
 
 
 
+int slave_cmd::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_cmd::timeout()
+{
+  timeout_stop();
+  qWarning("addr %d timeout.",addr);
+  end(1,ret_data);
+  busy=0;
+}
+
+int slave_cmd::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;
+}
+
+
+
+
+
+
+

prot_cmd/cmd_slave.h

@@ -137,10 +137,23 @@ public:
 class slave_bootinfo:public HandleSlave
 {
 public:
-    slave_bootinfo():HandleSlave(){}
-    int start(myarray data);
-    int dolater(int cmd, myarray data);
-    void timeout();
+  slave_bootinfo():HandleSlave(){}
+  int start(myarray data);
+  int dolater(int cmd, myarray data);
+  void timeout();
+};
+
+
+
+
+// 获取命令数据，使用前先设置cmd
+class slave_cmd:public HandleBoardCast
+{
+public:
+  slave_cmd():HandleBoardCast(){}
+  int start(myarray data);
+  int dolater(int cmd, myarray data);
+  void timeout();
 };