checker_slave/source/task/tran_for_broadcast.c

#include "tran_for_broadcast.h"
#include "debug.h"
#include "mymisc.h"
#include "mystdlib.h"
#include "board.h"
#include "dev_flash.h"
#include "prot_uc.h"
#include "coder_lib.h"
#include "JQ_PSDGenerate.h"
#include "mystring.h"
#include "coder_judge.h"
#include "JQ_UIDGenerate.h"
#include "transmit.h"
#include "elec_det.h"
#include "crc.h"
#include "dev_backup.h"
#include "elec_task_slot.h"




/*

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

数据域格式
[0]=小板地址，[1]=数据长度，[2...n]=数据

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



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


*/


typedef struct{
  ucport_def u;
  rt_timer_t timer;
  array_def *data;
  int pack_all;
  int pack_curr;
}slave_def;




static slave_def *slave_creat(void)
{
  slave_def *u=calloc(1,sizeof(slave_def));
  return u;
}



static void slave_del(ucport_def *u)
{
  slave_def *s=(slave_def *)u;
  CHECK_DO(s->timer,rt_timer_delete);
  CHECK_DO(s->data,arr_delete);
  free(u);
}


// 找到自己的数据
static void slave_get_self(slave_def *s)
{
  int len=arr_length(s->data);
  int off=0;
  int addr,slave_len;
  array_def *expat=arr_creat();
  uint8_t *d;
  while(off<len){
    addr=arr_get(s->data,off);
    slave_len=arr_get(s->data,off+1);
    if(addr==elec_local_addr()){
      d=arr_data(s->data)+off+2;
      arr_appends(expat,d,slave_len);
      break;
    }
    off+=slave_len+2;
  }
  arr_delete(s->data);
  s->data=expat;
}


// 添加任务
static void slave_adds(slave_def *s)
{
  task_def *t=calloc(1,sizeof(task_def));
  void *slot=0;
  int off=0;
  int len=arr_length(s->data);
  task_slot_delete();
  slot=task_slot_init();
  while(off<len){
    t->slot_index=arr_get(s->data,0);
    t->task_id=arr_get(s->data,1);
    t->par_count=arr_get(s->data,2);
    t->ret_count=arr_get(s->data,3);
    t->errcode=arr_get(s->data,4);
    t->task_index=arr_get(s->data,5);
    memcpy(t->params,arr_data(s->data)+6,t->par_count*2);
    task_slot_add_item(slot,t);
    off+=6+t->par_count*2;
  }
  free(t);
}



// 生成返回数据
static array_def *slave_creat_retdata(slave_def *s,array_def *r)
{
  void *slot=task_slot_init();
  task_def *t=0;
  while(t=task_slot_next_item(slot),t!=0)
  {
    arr_append(r,t->task_index);
    arr_append(r,t->ret_count);
    arr_appends(r,t->rets,t->ret_count*2);
  }
  return r;
}



// 执行任务
static int run_task_dolater(ucport_def *u,uint8_t cmd,array_def *data,char *err_str)
{
  slave_def *s=(slave_def *)u;
  int pack_curr=0,pack_all=0;
  array_def *r=0;
  array_def *check=0;
  uint8_t *d;
  pack_all=arr_get(data,0);
  pack_curr=arr_get(data,1);
  s->pack_all=pack_all;
  if(pack_curr==1){
    // 第一个数据包重置接收
    CHECK_DO(s->data,arr_delete);
    s->data=arr_creat();
  }
  if(pack_curr==s->pack_curr+1){
    s->pack_curr++;
    d=arr_data(data)+2;
    arr_appends(s->data,d,arr_length(data)-2);
    if(s->pack_curr<s->pack_all){
      r=arr_creat();
      arr_append(r,0);
      emit tran_reply_signal(u->p,arr_temp(r));
    }else{
      // 接收完成后执行命令
      r=arr_creat();
      slave_get_self(s);
      slave_adds(s);
      check=elec_check_with_scheme(0);
      arr_append(r,arr_get(check,0));
      slave_creat_retdata(s,r);
      emit tran_reply_signal(u->p,arr_temp(r));
    }
  }
  return 0;
}
static ucport_def *run_task(tran_def *t, uint8_t cmd,array_def *data)
{
  int ret=0;
  slave_def *u=slave_creat();
  u->u.p=t;
  u->u.del=slave_del;
  u->u.dolater=run_task_dolater;
  u->u.dolater(&u->u,cmd,data,"ok");
  return (ucport_def *)u;
}
transmit_export(ym_slave,0x20,run_task)