rpacket_t rpk_create_by_other(struct packet *p)
{
if(MSG_TYPE(p) == MSG_RPACKET)
return rpk_create_by_rpacket((rpacket_t)p);
else if(MSG_TYPE(p) == MSG_WPACKET)
return rpk_create_by_wpacket((wpacket_t)p);
return NULL;
}
static int setdir_fun(int sockfd,msg_head_t *pMsgHead,char *msg_data){
int res = -1;
char cmd[1024],basebool;
utab_t *utab;
char *mode[] ={
"snb","swb","dnb","swb"
};
if(!msg_data || !pMsgHead) return ERR;
if(pMsgHead->msg_type != MSG_TYPE(CATEGORY_CONFIG,DIRSET)){
logi("msg_type(A%d,%d) wrong\n",MSG_CATEGORY(pMsgHead->msg_type),
MSG_OPCODE(pMsgHead->msg_type));
return -1;
}
utab = (utab_t*)msg_data;
basebool = utab->baseline == 0.0 ? 0 : 1;
if(basebool) sprintf(cmd,"set %s %f\r\n",mode[utab->type+basebool],utab->baseline);
else sprintf(cmd,"set %s\r\n",mode[utab->type+basebool]);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return -1;
}
return OK;
}
static int setrov_fun( int sockfd, msg_head_t *pMsgHead, char *msg_data )
{
printf("setrov\n");
int res = -1;
char *cmd = "fix none\r\n";
if ( !pMsgHead )
{
return ERR;
}
if ( pMsgHead->msg_type != MSG_TYPE( CATEGORY_CONFIG,SETROV) )
{
logi( "msg_type( %d, %d ) wrong\n", MSG_CATEGORY( pMsgHead->msg_type ),
MSG_OPCODE( pMsgHead->msg_type ) );
return ERR;
}
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
// cmd_response_massage(sockfd,pMsgHead,"ok",strlen("ok"));
#if 0
printf("setrov successfully\n");
#endif
return OK;
}
static void
process_interrupt_messages (void)
{
/* Reads all of the interrupts out of the interrupt queue, and sets
the corresponding bits in the interrupt word. */
while (1)
{
msg_t * message = (read_subqueue (OS2_interrupt_qid_local));
if (message == 0)
break;
switch (MSG_TYPE (message))
{
case mt_console_interrupt:
tty_set_next_interrupt_char (SM_CONSOLE_INTERRUPT_CODE (message));
break;
case mt_timer_event:
request_timer_interrupt ();
break;
default:
OS2_logic_error ("Illegal message type in interrupt queue.");
break;
}
OS2_destroy_message (message);
}
}
static int state_fun( int sockfd, msg_head_t *pMsgHead, char *msg_data )
{
int res = -1;
char *cmd = "log oemstatus ontime 1\r\n";
#if 0
struct tm *timer;
#endif
if ( !pMsgHead )
{
return ERR;
}
if ( pMsgHead->msg_type != MSG_TYPE( CATEGORY_GUIDE,STATE ) )
{
logi( "msg_type( %d, %d ) wrong\n", MSG_CATEGORY( pMsgHead->msg_type ),
MSG_OPCODE( pMsgHead->msg_type ) );
return ERR;
}
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
pthread_mutex_lock(&lock);
msg_head[0] = *pMsgHead;
sock = sockfd;
pthread_mutex_unlock(&lock);
return OK;
}
static inline rpacket_t rpk_create_by_wpacket(struct wpacket *w)
{
rpacket_t r = (rpacket_t)ALLOC(rpacket_allocator,sizeof(*r));
r->binbuf = NULL;
r->binbufpos = 0;
PACKET_BUF(r) = buffer_acquire(NULL,PACKET_BUF(w));
r->readbuf = buffer_acquire(NULL,PACKET_BUF(w));
PACKET_BEGINPOS(r) = PACKET_BEGINPOS(w);
MSG_NEXT(r) = NULL;
MSG_TYPE(r) = MSG_RPACKET;
PACKET_RAW(r) = PACKET_RAW(w);
if(PACKET_RAW(r))
{
r->len = w->data_size;
r->rpos =PACKET_BEGINPOS(w);
}
else
{
//这里的len只记录构造时wpacket的len,之后wpacket的写入不会影响到rpacket的len
r->len = w->data_size - sizeof(r->len);
r->rpos = (PACKET_BEGINPOS(r) + sizeof(r->len))%PACKET_BUF(r)->capacity;
if(r->rpos < PACKET_BEGINPOS(r))//base->begin_pos)
r->readbuf = buffer_acquire(r->readbuf,r->readbuf->next);
}
r->data_remain = r->len;
return r;
}
static int action_fun( int sockfd, msg_head_t *pMsgHead, char *msg_data )
{
int res = -1;
char *cmd = "log satinfo ontime 1\r\n";
if ( !pMsgHead )
{
return ERR;
}
if ( pMsgHead->msg_type != MSG_TYPE( CATEGORY_GUIDE,ACTION) )
{
logi( "msg_type( %d, %d ) wrong\n", MSG_CATEGORY( pMsgHead->msg_type ),
MSG_OPCODE( pMsgHead->msg_type ) );
return ERR;
}
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
pthread_mutex_lock(&lock);
msg_head[1] = *pMsgHead;
sock = sockfd;
pthread_mutex_unlock(&lock);
return OK;
}
rpacket_t rpk_create_skip(rpacket_t other,uint32_t skipsize)
{
if(!other || PACKET_RAW(other) || other->len <= skipsize)
return NULL;
rpacket_t r = (rpacket_t)ALLOC(rpacket_allocator,sizeof(*r));
PACKET_RAW(r) = 0;
//首先要到正确的读位置
uint32_t move_size = skipsize+sizeof(r->len);
buffer_t buf = PACKET_BUF(other);
uint32_t pos = PACKET_BEGINPOS(other);
while(move_size){
uint32_t s = buf->size - pos;
if(s > move_size) s = move_size;
move_size -= s;
pos += s;
if(pos >= buf->size){
buf = buf->next;
pos = 0;
}
}
r->binbuf = NULL;
r->binbufpos = 0;
PACKET_BUF(r) = buffer_acquire(NULL,buf);
r->readbuf = buffer_acquire(NULL,buf);
r->len = other->len-skipsize;
r->data_remain = r->len;
r->rpos = PACKET_BEGINPOS(r) = pos;
MSG_NEXT(r) = NULL;
MSG_TYPE(r) = MSG_RPACKET;
return r;
}
rpacket_t rpk_create(buffer_t b,
uint32_t pos,
uint32_t pk_len,
uint8_t is_raw)
{
rpacket_t r = (rpacket_t)ALLOC(rpacket_allocator,sizeof(*r));
struct packet *base = (struct packet*)r;
r->binbuf = NULL;
r->binbufpos = 0;
PACKET_BUF(r) = buffer_acquire(NULL,b);
r->readbuf = buffer_acquire(NULL,b);
r->len = pk_len;
r->data_remain = r->len;
PACKET_BEGINPOS(r) = pos;
MSG_NEXT(r) = NULL;
MSG_TYPE(r) = MSG_RPACKET;
if(is_raw)
r->rpos = pos;
else
r->rpos = (pos + sizeof(r->len))%base->buf->capacity;
if(r->rpos < base->begin_pos)
r->readbuf = buffer_acquire(r->readbuf,r->readbuf->next);
base->raw = is_raw;
return r;
}
msg_t *
OS2_wait_for_message (qid_t qid, msg_type_t reply_type)
{
msg_t * reply = (OS2_receive_message (qid, 1, 0));
if (OS2_error_message_p (reply))
OS2_handle_error_message (reply);
if ((MSG_TYPE (reply)) != reply_type)
OS2_logic_error ("Incorrect reply message type.");
return (reply);
}
static int setio_fun(int sockfd,msg_head_t *pMsgHead,char *msg_data){
int res = -1,i,cmdn = 0;
char cmd[10][1024];
data_t *data;
char *raw[4][10] = {
{ "ranged","gpsephemb","bdsephemb","gloephemb"},
{ "rtcm1033","rtcm1005","rtcm1006","rtcm1004b",
"rtcm1104b","rtcm1012b" },
{ "rtcm1033","rtcm1005","rtcm1006","rtcm1074b",
"rtcm1124b","rtcm1084b" },
{ "gpgga","gpgsv","gprmc","gpgsr","gpgsa",
"gputa","gpgll","gpzda","gpvtg","gpgst"}
};
#if 0
char buff[1024]; int len;
#endif
if(!msg_data || !pMsgHead) return ERR;
if(pMsgHead->msg_type != MSG_TYPE(CATEGORY_CONFIG,IOSET)){
logi("msg_type(A%d,%d) wrong\n",MSG_CATEGORY(pMsgHead->msg_type),
MSG_OPCODE(pMsgHead->msg_type));
return -1;
}
data = (data_t*)msg_data;
if(data->clientbool){
sprintf(cmd[0],"setclient %s\r\n",data->ipport);
if((res = write(cmdfd,cmd[0],strlen(cmd[0]))) == -1){
logi("write error");
return -1;
}
}
for(i = 0;i < 10;i++)
if(data->datatime[i] != 0)
sprintf(cmd[cmdn++],"log %s ontime %f\r\n",raw[(int)data->datatype][i],
data->datatime[i]);
for(i = 0;i < cmdn;i++)
if((res = write(cmdfd,cmd[i],strlen(cmd[i]))) == -1){
logi("write error");
return -1;
}
#if 0
while((len=read(profd,buff,1024)) > 0){
buff[len] = '\0';
printf("%s\n",buff);
}
#endif
return OK;
}
void Connector::messageReceived( util::Buffer *m ) {
util::BYTE type = MSG_TYPE(m->buffer());
// printf( "[Connector (%p)] Received a message: type=%d\n", this, type );
Handlers::iterator cb = _handlers.find( (messages::type)type );
if (cb != _handlers.end()) {
//printf( "[Connector (%p)] Dispatching to handler\n", this );
(*cb).second->process( m );
} else {
printf( "[Connector (%p)] Warning: Received unhandled message type: type=%02x\n", this, type );
}
}
static int setchannel_fun(int sockfd,msg_head_t *pMsgHead,char *msg_data){
int res = -1,i;
char cmd[1024],*s;
char *fre[8] = {
"L1","L2","L3","B1","B2","B3","GL1","GL2"
},*sys[] = {
"gps","gln","gal","bds","sbas"
};
channelset_t *channelset;
if(!msg_data || !pMsgHead) return ERR;
if ( pMsgHead->msg_type != MSG_TYPE( CATEGORY_CONFIG,CHANNELSET) ){
logi( "msg_type( %d, %d ) wrong\n", MSG_CATEGORY( pMsgHead->msg_type ),
MSG_OPCODE( pMsgHead->msg_type ) );
return ERR;
}
channelset = (channelset_t *)msg_data;
for(i = 0;i < 5;i++) if(channelset->closesys[i] != 0){
s = channelset->closesys[i] == 1 ? "closesys" : "unclosesys";
sprintf(cmd,"%s %s\r\n",s,sys[i]);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
}
for(i = 0;i < 8;i++)
if(channelset->closefre[i] != 0){
s =channelset->closefre[i] == 1 ? "close" : "unclose";
sprintf(cmd,"%s %s\r\n",s,fre[i]);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
}
for(i = 0;i < MAXPIPE;i++)
if(channelset->channel[i] != 0){
s =channelset->channel[i] == 1 ? "close" : "unclose";
sprintf(cmd,"%s %d\r\n",s,i);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
}
return OK;
}
static inline rpacket_t rpk_create_by_rpacket(rpacket_t other)
{
rpacket_t r = (rpacket_t)ALLOC(rpacket_allocator,sizeof(*r));
r->binbuf = NULL;
r->binbufpos = 0;
PACKET_BUF(r) = buffer_acquire(NULL,PACKET_BUF(other));
r->readbuf = buffer_acquire(NULL,other->readbuf);
r->len = other->len;
r->data_remain = other->data_remain;
PACKET_BEGINPOS(r) = PACKET_BEGINPOS(other);
MSG_NEXT(r) = NULL;
MSG_TYPE(r) = MSG_RPACKET;
PACKET_RAW(r) = PACKET_RAW(other);
r->rpos = other->rpos;
return r;
}
msg_t *
OS2_create_message_1 (msg_type_t type, msg_length_t extra)
{
/* Do allocation carefully to prevent infinite loop when signalling
"out of memory" condition. */
msg_t * message =
(OS2_malloc_noerror (((unsigned long) (OS2_message_type_length (type)))
+ extra));
if (message == 0)
if ((type == mt_syscall_error)
&& ((SM_SYSCALL_ERROR_CODE (message)) == ERROR_NOT_ENOUGH_MEMORY)
&& ((SM_SYSCALL_ERROR_NAME (message)) == syscall_malloc))
OS2_logic_error ("Unable to allocate memory for error message.");
else
OS2_error_system_call (ERROR_NOT_ENOUGH_MEMORY, syscall_malloc);
(MSG_TYPE (message)) = type;
return (message);
}
int demo_get_password_fun( int sockfd, msg_head_t *pMsgHead, char *msg_data )
{
if ( !pMsgHead )
{
return ERR;
}
if ( pMsgHead->msg_type != MSG_TYPE( CATEGORY_DEMO, OP_CODE_DEMO__GET_PASSWORD ) )
{
logi( "msg_type( %d, %d ) wrong\n", MSG_CATEGORY( pMsgHead->msg_type ),
MSG_OPCODE( pMsgHead->msg_type ) );
return ERR;
}
logi( "get user( %s ) password now\n", msg_data );
cmd_response_massage( sockfd, pMsgHead, "ok", strlen( "ok" ) );
return OK;
}
static int setele_fun(int sockfd,msg_head_t *pMsgHead,char *msg_data){
int res = -1;
char cmd[1024];
float *data;
if(!msg_data || !pMsgHead) return ERR;
if ( pMsgHead->msg_type != MSG_TYPE( CATEGORY_CONFIG,ELESET) ){
logi( "msg_type( %d, %d ) wrong\n", MSG_CATEGORY( pMsgHead->msg_type ),
MSG_OPCODE( pMsgHead->msg_type ) );
return ERR;
}
data = (float*)msg_data;
sprintf(cmd,"ecutoff %f\r\n",*data);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
return OK;
}
static int setan_fun(int sockfd,msg_head_t *pMsgHead,char *msg_data){
int res = -1;
char cmd[1024],*s;
if(!msg_data || !pMsgHead) return ERR;
if(pMsgHead->msg_type != MSG_TYPE(CATEGORY_CONFIG,ANTNSET)){
logi("msg_type(A%d,%d) wrong\n",MSG_CATEGORY(pMsgHead->msg_type),
MSG_OPCODE(pMsgHead->msg_type));
return -1;
}
s = *msg_data == 1 ? "antn1":"antn2";
sprintf(cmd,"set %s\r\n",s);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return -1;
}
return OK;
}
static int setnet_fun(int sockfd,msg_head_t *pMsgHead,char *msg_data){
int res = -1;
char cmd[1024];
net_t *net;
if(!msg_data || !pMsgHead) return ERR;
if(pMsgHead->msg_type != MSG_TYPE(CATEGORY_CONFIG,NETSET)){
logi("msg_type(A%d,%d) wrong\n",MSG_CATEGORY(pMsgHead->msg_type),
MSG_OPCODE(pMsgHead->msg_type));
return -1;
}
net = (net_t*)msg_data;
sprintf(cmd,"setip %s %s %s %s\r\n",net->ip,net->gateway,net->netmask,net->dns);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return -1;
}
return OK;
}
static int setsat_fun(int sockfd,msg_head_t *pMsgHead,char *msg_data){
int res = -1,i,j;
char cmd[1024],*s;
locksat_t *locksat;
char *sys[] = {
"gps","gln","gal","bds","sbas"
};
if(!msg_data || !pMsgHead) return ERR;
if ( pMsgHead->msg_type != MSG_TYPE( CATEGORY_CONFIG,SATSET) ){
logi( "msg_type( %d, %d ) wrong\n", MSG_CATEGORY( pMsgHead->msg_type ),
MSG_OPCODE( pMsgHead->msg_type ) );
return ERR;
}
locksat = (locksat_t*)msg_data;
for(i = 0;i < 5;i++) if(locksat->locksys[i] != 0){
s = locksat->locksys[i] == 1 ? "lockout" : "unlockout";
sprintf(cmd,"%s %s\r\n",s,sys[i]);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
}
for(j = 0;j < 5;j++){
for(i = 0;i < MAXSAT;i++)
if(locksat->lockprn[j][i] != 0){
s = locksat->lockprn[j][i] == 1 ? "lockout" : "unlockout";
sprintf(cmd,"%s %s %d\r\n",s,sys[j],i);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
}
}
return OK;
}
static int setbasepos_fun(int sockfd,msg_head_t *pMsgHead,char *msg_data){
int res = -1;
char cmd[1024];
basepos_t *basepos;
printf("set base pos\n");
if(!msg_data || !pMsgHead) return ERR;
if ( pMsgHead->msg_type != MSG_TYPE( CATEGORY_CONFIG,SETBASEPOS) ){
logi( "msg_type( %d, %d ) wrong\n", MSG_CATEGORY( pMsgHead->msg_type ),
MSG_OPCODE( pMsgHead->msg_type ) );
return ERR;
}
basepos = (basepos_t*)msg_data;
sprintf(cmd,"fix position %.9f %.9f %.4f\r\n",basepos->lat,basepos->lon,basepos->hgt);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
return OK;
}
static int setengine_fun(int sockfd,msg_head_t *pMsgHead,char *msg_data){
int res = -1;
char cmd[1024];
char *postype[] ={
"single","rtk","sbasspp","sbasppp",
"ssrspp","ssrppp"
};
if(!msg_data || !pMsgHead) return ERR;
if ( pMsgHead->msg_type != MSG_TYPE( CATEGORY_CONFIG,ENGINESET) ){
logi( "msg_type( %d, %d ) wrong\n", MSG_CATEGORY( pMsgHead->msg_type ),
MSG_OPCODE( pMsgHead->msg_type ) );
return ERR;
}
sprintf(cmd,"setpvt %s\\n",postype[(int)*msg_data]);
if((res = write(cmdfd,cmd,strlen(cmd))) == -1){
logi("write error");
return ERR;
}
return OK;
}
void dump_message(const HALMsg *msg, const char *prefix){
if (current_log_level >= DUMP){
if (prefix){
fprintf(stderr, "%s", prefix);
}
fprintf(stderr,
"#%c%-3hhu: command=%02hhx, type=%c%c, rid=%hhu, len=%hhu chk=%d\n",
(IS_ARDUINO_SEQ(msg->seq) ? 'A' : 'D'),
ABSOLUTE_SEQ(msg->seq),
msg->cmd,
MSG_TYPE(msg), MSG_IS_CHANGE(msg) ? '!' : '?',
msg->rid,
msg->len,
msg->chk);
for (int i=0; i<16 && 16*i<msg->len; i++){
for (int j=0; j<16 && 16*i+j < msg->len; j++){
fprintf(stderr, " %02hhx", msg->data[16*i+j]);
}
fprintf(stderr, "\n");
}
}
}
static AJ_Status ParseIsAt(AJ_IOBuffer* rxBuf, const char* prefix, AJ_Service* service)
{
AJ_Status status = AJ_ERR_NO_MATCH;
size_t preLen = strlen(prefix);
NSHeader* hdr = (NSHeader*)rxBuf->readPtr;
uint32_t len = AJ_IO_BUF_AVAIL(rxBuf);
uint8_t* p = rxBuf->readPtr + 4;
uint8_t* eod = (uint8_t*)hdr + len;
AJ_InfoPrintf(("ParseIsAt(rxbuf=0x%p, prefix=\"%s\", service=0x%p)\n", rxBuf, prefix, service));
service->addrTypes = 0;
/*
* Silently ignore versions we don't know how to parse
*/
if (MSG_VERSION(hdr->version) != MSG_V1) {
return status;
}
/*
* Questions come in first - we currently ignore them
*/
while (hdr->qCount--) {
uint8_t flags = *p++;
uint8_t nameCount = *p++;
/*
* Questions must be WHO_HAS messages
*/
if (MSG_TYPE(flags) != WHO_HAS_MSG) {
AJ_InfoPrintf(("ParseIsAt(): AJ_ERR_INVALID\n"));
return AJ_ERR_INVALID;
}
while (nameCount--) {
uint8_t sz = *p++;
p += sz;
if (p > eod) {
AJ_InfoPrintf(("ParseIsAt(): AJ_ERR_END_OF_DATA\n"));
status = AJ_ERR_END_OF_DATA;
goto Exit;
}
}
}
/*
* Now the answers - this is what we are looking for
*/
while (hdr->aCount--) {
uint8_t flags = *p++;
uint8_t nameCount = *p++;
/*
* Answers must be IS_AT messages
*/
if (MSG_TYPE(flags) != IS_AT_MSG) {
AJ_InfoPrintf(("ParseIsAt(): AJ_ERR_INVALID\n"));
return AJ_ERR_INVALID;
}
/*
* Must be reliable IPV4 or IPV6
*/
if (!(flags & (R4_FLAG | R6_FLAG))) {
return status;
}
/*
* Get transport mask
*/
service->transportMask = (p[0] << 8) | p[1];
p += 2;
/*
* Decode addresses
*/
if (flags & R4_FLAG) {
memcpy(&service->ipv4, p, sizeof(service->ipv4));
p += sizeof(service->ipv4);
service->ipv4port = (p[0] << 8) | p[1];
p += 2;
service->addrTypes |= AJ_ADDR_IPV4;
}
if (flags & U4_FLAG) {
p += sizeof(service->ipv4) + 2;
}
if (flags & R6_FLAG) {
memcpy(&service->ipv6, p, sizeof(service->ipv6));
p += sizeof(service->ipv6);
service->ipv6port = (p[0] << 8) | p[1];
p += 2;
service->addrTypes |= AJ_ADDR_IPV6;
}
if (flags & U6_FLAG) {
p += sizeof(service->ipv6) + 2;
}
/*
* Skip guid if it's present
*/
if (flags & G_FLAG) {
uint8_t sz = *p++;
len -= 1 + sz;
p += sz;
}
if (p >= eod) {
AJ_InfoPrintf(("ParseIsAt(): AJ_ERR_END_OF_DATA\n"));
return AJ_ERR_END_OF_DATA;
}
/*
* Iterate over the names
*/
while (nameCount--) {
uint8_t sz = *p++;
{
char sav = p[sz];
p[sz] = 0;
AJ_InfoPrintf(("ParseIsAt(): Found \"%s\" IP 0x%x\n", p, service->addrTypes));
p[sz] = sav;
}
if ((preLen <= sz) && (memcmp(p, prefix, preLen) == 0)) {
status = AJ_OK;
goto Exit;
}
p += sz;
if (p > eod) {
status = AJ_ERR_END_OF_DATA;
AJ_InfoPrintf(("ParseIsAt(): AJ_ERR_END_OF_DATA\n"));
goto Exit;
}
}
}
Exit:
return status;
}
void demo_commands_init()
{
#if 1
if(pthread_create(&tid,NULL,send2cgi,NULL) != 0){
logi("create thread error!\n");
exit(1);
}
pthread_mutex_init(&lock,NULL);
#endif
register_msg_process_fun( MSG_TYPE( CATEGORY_DEMO, OP_CODE_DEMO__GET_PASSWORD ),
demo_get_password_fun );
register_msg_process_fun( MSG_TYPE( CATEGORY_GUIDE, STATE),
state_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_GUIDE, ACTION),
action_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_GUIDE, POSITION),
pos_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_GUIDE, TRACETABLE),
trace_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG, SETROV),
setrov_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG, SETBASEPOS),
setbasepos_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG, GETPOS),
getpos_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG, ENGINESET),
setengine_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG,ELESET),
setele_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG,SATSET),
setsat_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG,CHANNELSET),
setchannel_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG,NETSET),
setnet_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG,DIRSET),
setdir_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG,ANTNSET),
setan_fun);
register_msg_process_fun( MSG_TYPE( CATEGORY_CONFIG,IOSET),
setio_fun);
}
#include "lighttest2.h"
#include "../HALMsg.h"
TEST(checksum, {
HALMsg msg;
memset(&msg, 0, sizeof(msg));
msg.cmd = VERSION;
ASSERT(MSG_TYPE(&msg) == VERSION);
ASSERT(! MSG_IS_CHANGE(&msg));
ASSERT(HALMsg_checksum(&msg) == VERSION);
msg.data[0] = 1;
ASSERT(HALMsg_checksum(&msg) == VERSION); //len is zero -> dont check data
msg.len = 1;
ASSERT(HALMsg_checksum(&msg) == VERSION+2); //+len +data
})
SUITE(
ADDTEST(checksum))
