checker_slave/source/task/mod_signals.c

#include "stdlib.h"
#include "signal.h"
#include "commend.h"
#include "handle.h"
#include "handle_for_checker.h"
#include "handle_for_coder.h"
#include "key.h"
#include "log.h"
#include "moter.h"
#include "prot_mcu.h"
#include "prot_uc.h"
#include "tcp.h"
#include "transmit.h"
#include "tran_for_checker.h"
#include "tran_for_coder.h"
#include "tran_for_coder2.h"
#include "udp.h"






void cmd_reply_signal(void *obj,uint8_t cmd,array_def *data)
{
  uint32_t param[2];
  param[0]=(uint32_t)cmd;
  param[1]=(uint32_t)data;
  _signal_emit(obj,cmd_reply_signal,param,2);
}
signal_export(cmd_reply_signal);



void port_send_signal(port_mcu *obj,uint8_t addr,uint8_t cmd,list_def *comp_cmd,array_def *data,int timeout_ms,int retry)
{
  uint32_t param[6];
  param[0]=(uint32_t)addr;
  param[1]=(uint32_t)cmd;
  param[2]=(uint32_t)comp_cmd;
  param[3]=(uint32_t)data;
  param[4]=(uint32_t)timeout_ms;
  param[5]=(uint32_t)retry;
  _signal_emit(obj,port_send_signal,param,6);
}
signal_export(port_send_signal);



void port_end_signal(port_mcu *obj,port_mcu *src,void *data,int ack,char *err_str)
{
  uint32_t param[4];
  param[0]=(uint32_t)src;
  param[1]=(uint32_t)data;
  param[2]=(uint32_t)ack;
  param[3]=(uint32_t)err_str;
  _signal_emit(obj,port_end_signal,param,4);
}
signal_export(port_end_signal);



void key_send_signal(void *obj,uint8_t cmd,array_def *data)
{
  uint32_t param[2];
  param[0]=(uint32_t)cmd;
  param[1]=(uint32_t)data;
  _signal_emit(obj,key_send_signal,param,2);
}
signal_export(key_send_signal);



void moter_end_signal(void *m)
{
  _signal_emit(m,moter_end_signal,0,0);
}
signal_export(moter_end_signal);



void protm_recv_signal(void *obj,uint8_t src,uint8_t cmd,array_def *data,char *err_str)
{
  uint32_t param[4];
  param[0]=(uint32_t)src;
  param[1]=(uint32_t)cmd;
  param[2]=(uint32_t)data;
  param[3]=(uint32_t)err_str;
  _signal_emit(obj,protm_recv_signal,param,4);
}
signal_export(protm_recv_signal);



void protu_recv_signal(void *obj,const char *codec_name,uint8_t cmd,array_def *data,char *err_str)
{
  uint32_t param[4];
  param[0]=(uint32_t)codec_name;
  param[1]=(uint32_t)cmd;
  param[2]=(uint32_t)data;
  param[3]=(uint32_t)err_str;
  _signal_emit(obj,protu_recv_signal,param,4);
}
signal_export(protu_recv_signal);



void tcp_connect_signal(void *obj)
{
  _signal_emit(obj,tcp_connect_signal,0,0);
}
signal_export(tcp_connect_signal);



void tcp_recv_signal(void *obj,array_def *data)
{
  uint32_t param[1];
  param[0]=(uint32_t)data;
  _signal_emit(obj,tcp_recv_signal,param,1);
}
signal_export(tcp_recv_signal);



void tran_reply_signal(tran_def *p,array_def *data)
{
  uint32_t param[1];
  param[0]=(uint32_t)data;
  _signal_emit(p,tran_reply_signal,param,1);
}
signal_export(tran_reply_signal);



void tran_send_signal(tran_def *p,uint8_t cmd,array_def *data)
{
  uint32_t param[2];
  param[0]=(uint32_t)cmd;
  param[1]=(uint32_t)data;
  _signal_emit(p,tran_send_signal,param,2);
}
signal_export(tran_send_signal);



void coder_live_send_signal(void *obj,uint8_t cmd,array_def *data)
{
  uint32_t param[2];
  param[0]=(uint32_t)cmd;
  param[1]=(uint32_t)data;
  _signal_emit(obj,coder_live_send_signal,param,2);
}
signal_export(coder_live_send_signal);



void coder2_live_send_signal(void *obj,uint8_t cmd,array_def *data)
{
  uint32_t param[2];
  param[0]=(uint32_t)cmd;
  param[1]=(uint32_t)data;
  _signal_emit(obj,coder2_live_send_signal,param,2);
}
signal_export(coder2_live_send_signal);



void udp_recv_signal(void *obj,const char *codec_name,uint8_t cmd,array_def *data,char *err_str)
{
  uint32_t param[4];
  param[0]=(uint32_t)codec_name;
  param[1]=(uint32_t)cmd;
  param[2]=(uint32_t)data;
  param[3]=(uint32_t)err_str;
  _signal_emit(obj,udp_recv_signal,param,4);
}
signal_export(udp_recv_signal);