checker_gen1/source/coder/coder_judge.c

#include "coder_judge.h"
#include "dev_flash.h"
#include "string.h"


// 把d插入 a中，不允许重复
static void c_insert(uint8_t *a,uint8_t d)
{
  int len=sizeof(uint8_t [6]);
  for(int i=0;i<len;i++)
  {
    if(a[i]==d)
      return;
  }
  for(int i=0;i<len;i++)
  {
    if(a[i]==0xff){
      a[i]=d;
      return;
    }
  }
}

// 删除a中的值d
static void c_del(uint8_t *a,uint8_t d)
{
  int len=sizeof(uint8_t [6]);
  for(int i=0;i<len;i++)
  {
    if(a[i]==d){
      memcpy(&a[i],&a[i+1],len-i-1);
      return;
    }
  }
}


// 删除a中除d之外的所有值
static void c_only(uint8_t *a,uint8_t d)
{
  int len=sizeof(uint8_t [6]);
  for(int i=0;i<len;i++)
  {
    if(a[i]==d)
    {
      memset(a,0xff,len);
      a[0]=d;
      return;
    }
  }
  // 如果没找到则全部删除
  memset(a,0xff,len);
}

// 初始化a
static void c_init(uint8_t *a)
{
  int len=sizeof(uint8_t [6]);
  memset(a,0xff,len);
}


// 根据taskid找到任务
static const scheme_task_def *find_task_next(int index_now,int taskid)
{
  const scheme_def *s=check_scheme();
  const scheme_task_def *t;
  for(int i=index_now;i<s->task_num;i++)
  {
    t=&s->task[i];
    if(t->taskid==taskid)
      return t;
  }
  return 0;
}





// 计算在taskindex之前有多少个返回值
static int calc_skip_num(int index)
{
  const scheme_def *s=check_scheme();
  const scheme_task_def *t;
  int num=0;
  for(int i=0;i<index;i++)
  {
    t=&s->task[i];
    num+=t->item_num;
  }
  return num;
}


// 获取第index个检测数据
static int get_data(const uint8_t *data,int index)
{
  data+=16;
  return data[index*2]|(data[index*2+1]<<8);
}

// 获取第index个任务是否成功1，失败，0成功
static int get_ack(const uint8_t *data,int index)
{
  if(data[index/8]&(1<<(index%8)))
    return 1;
  else
    return 0;
}


//-- 检测器异常,1
//-- 主电容异常,2
//-- 接触异常,3
//-- 桥丝阻值异常,4
//-- 芯片异常,5
//-- 过流，7
//-- 短路，8

#define  TASK_FIND_NEXT(taskid) {\
  task=find_task_next(index,taskid);\
  if(task==0) return 6; \
  else index+=1;\
}// 找不到方案

#define TASK_DATA(index) get_data(data,calc_skip_num(task->taskindex)+(index))


uint8_t coder_judge(const uint8_t *data)
{
  int temp,temp2;
  int index=0;
  const scheme_task_def *task=0;
  
  // 开总线
  TASK_FIND_NEXT(0);
  {
    if(get_ack(data,0))
    {
      // 上电错误，检测器异常
      return 1;
    }
  }
  
  // 上电充能
  TASK_FIND_NEXT(1);
  {
    temp=TASK_DATA(0);
    if(temp<task->range[0].min)
    {
      // 电压无法上升，检测器异常
      return 1;
    }
    temp=TASK_DATA(1);
    if((temp>39000)||(temp<1)){
      // 充能失败，检测电流
    }
  }
  
  // 检测电流
  TASK_FIND_NEXT(4);
  temp=TASK_DATA(0);
  temp2=TASK_DATA(1);
  if((temp<10)&&(temp2<10))
  {
    // 接触异常
    return 3;
  }
  else if(((temp>task->range[0].max)&&(temp<1500))||
    ((temp2>task->range[0].max)&&(temp2<1500)))
  {
    // 过流
    return 7;
  }else if((temp>1500)&&(temp2>1500))
  {
    // 短路
    return 8;
  }
  
  
  // 检测uid
  TASK_FIND_NEXT(5);
  if(get_ack(data,task->taskindex))
  {
    // 芯片错误
    return 5;
  }
  
  // 检测桥丝
  TASK_FIND_NEXT(6);
  temp=TASK_DATA(0);
  if((temp<task->range[0].min)||(temp>task->range[0].max))
  {
    // 桥丝错误
    return 4;
  }
  
  // 检测电容
  TASK_FIND_NEXT(8);
  temp=TASK_DATA(0);
  if((temp>task->range[0].max)||(temp<task->range[0].min))
  {
    return 2;
  }
  temp=TASK_DATA(1);
  if((temp>task->range[1].max)||(temp<task->range[1].min))
  {
    return 2;
  }
  temp=TASK_DATA(2);
  if((temp>task->range[2].max)||(temp<task->range[2].min))
  {
    return 2;
  }
  
  return 0;
}