checker_host/prot_cmd/cmd_slave.cpp

#include "cmd_slave.h"
#include "base/mycfg.h"
#include "base/check_cfg.h"
#include "QDebug"
#include "base/crc.h"



int slave_check::start(myarray data)
{
  mycfg *cfg_=syscfg();
  check_cfg *ccfg_=check_plan();
  int timeout=ccfg_->get_check_time_out()*1000;
  busy=1;
  cmd=0x0c;
  qDebug("addr %d start check,timeout=%d",addr,timeout);
  send_data(cmd,myarray(),3);
  timeout_start(timeout);
  return 0;
}

void slave_check::timeout()
{
  timeout_stop();
  qWarning("addr %d check timeout.",addr);
  end(1,myarray());
  busy=0;
}

int slave_check::dolater(int cmd, myarray data)
{
  if(cmd!=this->cmd){
    qWarning("addr %d recv err cmd:%02x",addr,cmd);
    return 1;
  }
  timeout_stop_retry();
  if(cmd==0x0c){
    if(data.size()<=16){
      qDebug("addr %d recv first ack.",addr);
    }else{
      qDebug("addr %d recv secend ack.",addr);
      send_data(0x14,myarray(),1);
      end(0,data);
      busy=0;
      timeout_stop();
    }
  }
  return 0;
}





void slave_result::timeout()
{
  timeout_stop();
  qWarning("addr %d result timeout.",addr);
  end(1,myarray());
  busy=0;
}

int slave_result::start(myarray data)
{
  int timeout=2000;
  busy=1;
  cmd=0x02;
  qDebug("addr %d read result,timeout=%d",addr,timeout);
  send_data(cmd,myarray(),10);
  timeout_start(timeout);
  return 0;
}

int slave_result::dolater(int cmd, myarray data)
{
  if(cmd!=this->cmd){
    qWarning("addr %d recv err cmd:%02x",addr,cmd);
    return 1;
  }
  timeout_stop_retry();
  end(0,data);
  busy=0;
  timeout_stop();
  return 0;
}





void slave_sethardver::timeout()
{
  timeout_stop();
  qWarning("addr %d sethardver timeout.",addr);
  end(1,myarray());
  busy=0;
}

int slave_sethardver::start(myarray data)
{
  int timeout=2000;
  busy=1;
  cmd=0x03;
  qDebug("addr %d read sethardver,timeout=%d",addr,timeout);
  send_data(cmd,data,10);
  timeout_start(timeout);
  return 0;
}

int slave_sethardver::dolater(int cmd, myarray data)
{
  if(cmd!=this->cmd){
    qWarning("addr %d recv err cmd:%02x",addr,cmd);
    return 1;
  }
  timeout_stop_retry();
  end(0,data);
  busy=0;
  timeout_stop();
  return 0;
}






void slave_setresver::timeout()
{
  timeout_stop();
  qWarning("addr %d setresver timeout.",addr);
  end(1,myarray());
  busy=0;
}

int slave_setresver::start(myarray data)
{
  int timeout=2000;
  busy=1;
  cmd=0x04;
  qDebug("addr %d read setresver,timeout=%d",addr,timeout);
  send_data(cmd,data,10);
  timeout_start(timeout);
  return 0;
}

int slave_setresver::dolater(int cmd, myarray data)
{
  if(cmd!=this->cmd){
    qWarning("addr %d recv err cmd:%02x",addr,cmd);
    return 1;
  }
  timeout_stop_retry();
  end(0,data);
  busy=0;
  timeout_stop();
  return 0;
}







void slave_resvalue::timeout()
{
  timeout_stop();
  qWarning("addr %d resvalue timeout.",addr);
  end(1,myarray());
  busy=0;
}

int slave_resvalue::start(myarray data)
{
  int timeout=2000;
  busy=1;
  cmd=0x05;
  qDebug("addr %d read resvalue,timeout=%d",addr,timeout);
  send_data(cmd,data,10);
  timeout_start(timeout);
  return 0;
}

int slave_resvalue::dolater(int cmd, myarray data)
{
  if(cmd!=this->cmd){
    qWarning("addr %d recv err cmd:%02x",addr,cmd);
    return 1;
  }
  timeout_stop_retry();
  end(0,data);
  busy=0;
  timeout_stop();
  return 0;
}






// 定义地址宏
// 本程序中程序下载地址不是这个地址，在此用来计算偏移量
#define MCU_APP_ADDR_BASE       0x8004000
#define MCU_TASKID_ADDR_BASE    0x803f000
#define MCU_JWT_ADDR_BASE       0x803B000



void boardcast_updata::timeout()
{
  timeout_stop();
  qWarning("slave updata timeout.");
  end(1,myarray());
  busy=0;
}

int boardcast_updata::start(myarray data)
{
  int timeout=5000;
  busy=1;
  qWarning()<<"addr "<<addr<<" updata start.";
  timeout_start(timeout);
  // 擦除
  step=0;
  this->data=data;
  send_data(0xfe,myarray(),10);
  return 0;
}

int boardcast_updata::dolater(int cmd, myarray data)
{
  timeout_start(5000);
  if(step==0){
    if(send_packet()==true){
      step=1;
    }
  }else if(step==1){
    uint32_t addr_start=MCU_APP_ADDR_BASE;
    uint32_t addr_end=MCU_APP_ADDR_BASE+count_sent;
    uint32_t crc32=crc::crc32(this->data);
    myarray s;
    s.append((addr_start)&0xff);
    s.append((addr_start>>8)&0xff);
    s.append((addr_start>>16)&0xff);
    s.append((addr_start>>24)&0xff);
    s.append((addr_end)&0xff);
    s.append((addr_end>>8)&0xff);
    s.append((addr_end>>16)&0xff);
    s.append((addr_end>>24)&0xff);
    s.append((crc32)&0xff);
    s.append((crc32>>8)&0xff);
    s.append((crc32>>16)&0xff);
    s.append((crc32>>24)&0xff);
    send_data(0xfb,s,10);
    step=2;
  }else if(step==2){
    timeout_stop();
    timeout_stop_retry();
    qDebug("slave updata end.");
    end(0,data);
    busy=0;
  }
  return 0;
}

bool boardcast_updata::send_packet()
{
  if(count_sent<data.size()){
    uint32_t addr=MCU_APP_ADDR_BASE+count_sent;
    int pack_size=236;
    myarray s;
    if(pack_size>data.size()-count_sent){
      pack_size=data.size()-count_sent;
    }
    s.append((addr)&0xff);
    s.append((addr>>8)&0xff);
    s.append((addr>>16)&0xff);
    s.append((addr>>24)&0xff);
    s+=data.mid(count_sent,pack_size);
    count_sent+=pack_size;
    send_data(0xfc,s,10);
    rate(count_sent*100/data.size(),"slave_updata");
  }
  if(count_sent<data.size()){
    return false;
  }else{
    return true;
  }
}








void boardcast_updata_scheme::timeout()
{
  timeout_stop();
  qWarning("slave updata timeout.");
  end(1,myarray());
  busy=0;
}

int boardcast_updata_scheme::start(myarray data)
{
  int timeout=5000;
  busy=1;
  base_addr=MCU_TASKID_ADDR_BASE;
  qWarning()<<"addr "<<addr<<" updata start.";
  timeout_start(timeout);
  // 擦除
  step=0;
  this->data=data;
  send_packet();
  return 0;
}

int boardcast_updata_scheme::dolater(int cmd, myarray data)
{
  timeout_start(5000);
  if(step==0){
    if(send_packet()==true){
      step=1;
    }
  }else if(step==1){
    send_data(0x15,myarray(),10);
    step=2;
  }else if(step==2){
    timeout_stop();
    timeout_stop_retry();
    qDebug("slave updata scheme end.");
    end(0,data);
    busy=0;
  }
  return 0;
}

bool boardcast_updata_scheme::send_packet()
{
  if(count_sent<data.size()){
    uint32_t addr=base_addr+count_sent;
    int pack_size=236;
    myarray s;
    if(pack_size>data.size()-count_sent){
      pack_size=data.size()-count_sent;
    }
    s.append((addr)&0xff);
    s.append((addr>>8)&0xff);
    s.append((addr>>16)&0xff);
    s.append((addr>>24)&0xff);
    s+=data.mid(count_sent,pack_size);
    count_sent+=pack_size;
    send_data(0x11,s,10);
    rate(count_sent*100/data.size(),"slave_updata_scheme");
  }
  if(count_sent<data.size()){
    return false;
  }else{
    return true;
  }
}




int boardcast_updata_jwt::start(myarray data)
{
  int timeout=5000;
  busy=1;
  base_addr=MCU_JWT_ADDR_BASE;
  qWarning()<<"addr "<<addr<<" updata start.";
  timeout_start(timeout);
  // 擦除
  step=0;
  this->data=data;
  send_packet();
  return 0;
}