checker_gen1/source/task/prot_uc.c

#include "stdio.h"
#include "rtthread.h"
#include "board.h"
#include "mystdlib.h"
#include "list.h"
#include "mystring.h"
#include "signal.h"
#include "prot_uc.h"
#include "buff.h"
#include "bytearray.h"
#include "debug.h"
#include "crc.h"
#include "dev_flash.h"





// 接收buff大小
#define RECV_BUFF_SIZE  300















static void recv_irq(void *t,uint8_t d)
{
  protu_def *p=t;
  p->buff[p->buff_index]=d;
  p->buff_index++;
  switch(p->buff_index){
    case 2:
      if(p->buff[0]==0x59&&p->buff[1]==0x6d)
      {
        p->is_big_data=0;
        p->num_to_recv=4;
      }else{
        p->buff[0]=p->buff[1];
        p->num_to_recv=0;
      }
      break;
    case 4:
      {
        int len=p->buff[2]|(p->buff[3]<<8);
        if(len<65535){
          p->is_big_data=0;
          p->num_to_recv+=len+2;
        }else{
          p->is_big_data=1;
          p->num_to_recv=11;
        }
      }
      break;
    case 11:
      {
        if(p->is_big_data==1)
        {
          int len=p->buff[7]|(p->buff[8]<<8)|(p->buff[9]<<16)|(p->buff[10]<<24);
          p->num_to_recv=4+len+2;
        }
      }
      break;
    default:
      break;
  }
  // 此时一帧数据已完成
  if(p->num_to_recv>0&&p->num_to_recv==p->buff_index)
  {
    //DBG_LOG("recv:%s",str_temp(arr_string(p->buff)));
    rt_sem_release(p->sem);
  }
}


static void recv_end_irq(void *t,uint32_t len)
{
  protu_def *p=t;
  p->num_to_recv=len;
  p->buff_index=len;
  rt_sem_release(p->sem);
}

array_def *protu_decode_str(protu_def *p,array_def *data);
array_def *protu_encode_str(protu_def *p,array_def *data);


// 查找指定解码器
codec_item *protu_find_codec(const char *name)
{
  extern const int codecstruct$$Base;
  extern const int codecstruct$$Limit;
  codec_item *start=(codec_item *)&codecstruct$$Base;
  codec_item *end=(codec_item *)&codecstruct$$Limit;
  for(codec_item *t=start;t<end;t++)
  {
    if(strcmp(t->name,name)==0)
    {
      return t;
    }
  }
  return 0;
}
// 返回正在使用的解码器
codec_item *protu_codec_inuse(protu_def *p)
{
  return p->codec;
}
void protu_codec_set(protu_def *p,codec_item *c)
{
  p->codec=c;
}


// 尝试解码
static array_def *protu_try_decode(protu_def *p,array_def *data)
{
  array_def *decode_data=0;
  if(p->codec==0||p->codec->decode==protu_decode_str||
    (decode_data=p->codec->decode(p,data),strcmp(p->str_err,"ok")!=0))
  {
    CHECK_DO(decode_data,arr_delete);
    extern const int codecstruct$$Base;
    extern const int codecstruct$$Limit;
    codec_item *start=(codec_item *)&codecstruct$$Base;
    codec_item *end=(codec_item *)&codecstruct$$Limit;
    for(codec_item *t=start;t<end;t++)
    {
      decode_data=t->decode(p,data);
      if(strcmp(p->str_err,"ok")==0)
      {
        p->codec=t;
        break;
      }
      else{
        arr_delete(decode_data);
      }
    }
  }
  if(decode_data==0)
    decode_data=arr_creat();
  return decode_data;
}




static void protu_run(void *t)
{
  protu_def *p=t;
  array_def *data;
  array_def *decode_data;
  while(p->run)
  {
    rt_sem_take(p->sem,RT_WAITING_FOREVER);
    //DBG_LOG("protu run");
    data=arr_creat();
    arr_appends(data,p->buff,p->buff_index);
    p->num_to_recv=0;
    p->buff_index=0;
    DBG_LOG("recv:%s",str_temp(arr_string(data)));
    decode_data=protu_try_decode(p,data);
    //DBG_LOG("decode:%s",str_temp(arr_string(decode_data)));
    if(p->codec)
      emit protu_recv_signal(p,p->codec->name, p->cmd,arr_temp(decode_data),str_temp(str_duplicate(p->str_err)));
    arr_delete(data);
    irq_disable();
    p->num_to_recv=0;
    irq_enable();
  }
}



// 根据设备类型初始化编解码指针
static void protu_set_endecode_fun(protu_def *u)
{
  const sys_param_def *par=sys_param();
  if(strcmp(par->device_type,"coder")==0)
  {
  }
  else if(strcmp(par->device_type,"checker")==0)
  {
  }
}




static int protu_init(void)
{
  const sys_param_def *par=sys_param();
  const char *name="uart4";
  if(strcmp((par->host_if),"utcp")==0)
    name="utcp";
  protu_def *protu=protu_creat(dev_get(name));
  app_variable("protu",protu,0);
  
  // 如果通信接口不是用的串口，则增加一个串口的通信
  if(strcmp(par->host_if,"uart4")==0)
  {
    app_variable("protu2",protu,0);
  }else
  {
    protu_def *protu2=protu_creat(dev_get("uart4"));
    app_variable("protu2",protu2,0);
  }
  return 0;
}
app_init_export(protu_init)



protu_def *protu_creat(uart_def *uart)
{
  static uint16_t count=0;
  char name[20]={0};
  protu_def *p=calloc(1,sizeof(protu_def));
  param_check(p);
  p->uart=uart;
  sprintf(name,"protu_sem#%d",count);
  p->sem=rt_sem_create(name,0,RT_IPC_FLAG_FIFO);
  p->buff=malloc(RECV_BUFF_SIZE);
  p->run=1;
  p->cmd=0xff;// 命令字不可能是0xff
  protu_set_endecode_fun(p);
  sprintf(name,"protu_t#%d",count);
  rt_thread_t rt_t=rt_thread_create(name,protu_run,p,2048,5,20);
  rt_thread_startup(rt_t);
  int bsp=sys_param()->uartbsp;
  if(bsp==9600)
    p->uart->init(p->uart,9600);
  else
    p->uart->init(p->uart,0);
  //p->uart->set_irq(p->uart,recv_irq,p);
  p->uart->set_end_irq(p->uart,p->buff,RECV_BUFF_SIZE,recv_end_irq,p);
  
  count++;
  return p;
}





int protu_send(protu_def *p,array_def *data)
{
  DBG_LOG("send:%s",str_temp(arr_string(data)));
  return p->uart->write(p->uart,arr_data(data),arr_length(data));
}


// 槽函数，回复上位机
void protu_reply_call(protu_def *p,array_def *data)
{
  param_check(p);
  array_def *t=0;
  if(p->codec)
    t=p->codec->encode(p,data);
  // DBG_LOG("send encode:%s",arr_string(t));
  if(t){
    protu_send(p,t);
    arr_delete(t);
  }
}


// 槽函数，主动上发
void protu_send_call(protu_def *p,uint8_t cmd,array_def *data)
{
  array_def *t=0;
  if(cmd!=0){
    p->cmd=cmd;
    p->cmd_no++;
    if(p->codec)
      t=p->codec->encode(p,data);
  }else if(p->cmd==0)
  {
    // 命令字为0是字符串
    t=protu_encode_str(p,data);
  }
  if(t){
    protu_send(p,t);
    arr_delete(t);
  }
}













// 字符串解码
array_def *protu_decode_str(protu_def *p,array_def *data)
{
  array_def *r=arr_creat();
  param_check(r);
  DBG_LOG("decode for command");
  str_set(p->str_err,"ok");
  p->cmd=0;
  if(str_is_print_str((const char *)arr_data(data),arr_length(data))==1)
  {
    arr_append(data,0);
    arr_appends_from(r,data);
  }else{
    DBG_WARN("data not a string");
    str_set(p->str_err,"not string");
    //arr_remove(data,arr_length(data)-1,1);
  }
  return r;
}



// 字符串编码
array_def *protu_encode_str(protu_def *p,array_def *data)
{
  array_def *t=arr_creat();
  param_check(t);
  arr_appends_from(t,data);
  return t;
}


protuc_codec_export(string,protu_decode_str,protu_encode_str);