/*
libxbee - a C library to aid the use of Digi's Series 1 XBee modules
running in API mode (AP=2).
Copyright (C) 2009 Attie Grande (attie@attie.co.uk)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
const char *SVN_REV = "$Id: api.c 508 2011-06-12 23:22:34Z attie@attie.co.uk $";
char svn_rev[128] = "\0";
#include "api.h"
const char *xbee_svn_version(void) {
if (svn_rev[0] == '\0') {
char *t;
sprintf(svn_rev,"r%s",&SVN_REV[11]);
t = strrchr(svn_rev,' ');
if (t) {
t[0] = '\0';
}
}
return svn_rev;
}
const char *xbee_build_info(void) {
return "Built on " __DATE__ " @ " __TIME__ " for " HOST_OS;
}
/* ################################################################# */
/* ### Memory Handling ############################################# */
/* ################################################################# */
/* malloc wrapper function */
static void *Xmalloc2(xbee_hnd xbee, size_t size) {
void *t;
t = malloc(size);
if (!t) {
/* uhoh... thats pretty bad... */
xbee_perror("libxbee:malloc()");
exit(1);
}
return t;
}
/* calloc wrapper function */
static void *Xcalloc2(xbee_hnd xbee, size_t size) {
void *t;
t = calloc(1, size);
if (!t) {
/* uhoh... thats pretty bad... */
xbee_perror("libxbee:calloc()");
exit(1);
}
return t;
}
/* realloc wrapper function */
static void *Xrealloc2(xbee_hnd xbee, void *ptr, size_t size) {
void *t;
t = realloc(ptr,size);
if (!t) {
/* uhoh... thats pretty bad... */
fprintf(stderr,"libxbee:realloc(): Returned NULL\n");
exit(1);
}
return t;
}
/* free wrapper function (uses the Xfree macro and sets the pointer to NULL after freeing it) */
static void Xfree2(void **ptr) {
if (!*ptr) return;
free(*ptr);
*ptr = NULL;
}
/* ################################################################# */
/* ### Helper Functions ############################################ */
/* ################################################################# */
/* #################################################################
returns 1 if the packet has data for the digital input else 0 */
int xbee_hasdigital(xbee_pkt *pkt, int sample, int input) {
int mask = 0x0001;
if (input < 0 || input > 7) return 0;
if (sample >= pkt->samples) return 0;
mask <<= input;
return !!(pkt->IOdata[sample].IOmask & mask);
}
/* #################################################################
returns 1 if the digital input is high else 0 (or 0 if no digital data present) */
int xbee_getdigital(xbee_pkt *pkt, int sample, int input) {
int mask = 0x0001;
if (!xbee_hasdigital(pkt,sample,input)) return 0;
mask <<= input;
return !!(pkt->IOdata[sample].IOdigital & mask);
}
/* #################################################################
returns 1 if the packet has data for the analog input else 0 */
int xbee_hasanalog(xbee_pkt *pkt, int sample, int input) {
int mask = 0x0200;
if (input < 0 || input > 5) return 0;
if (sample >= pkt->samples) return 0;
mask <<= input;
return !!(pkt->IOdata[sample].IOmask & mask);
}
/* #################################################################
returns analog input as a voltage if vRef is non-zero, else raw value (or 0 if no analog data present) */
double xbee_getanalog(xbee_pkt *pkt, int sample, int input, double Vref) {
if (!xbee_hasanalog(pkt,sample,input)) return 0;
if (Vref) return (Vref / 1023) * pkt->IOdata[sample].IOanalog[input];
return pkt->IOdata[sample].IOanalog[input];
}
/* ################################################################# */
/* ### XBee Functions ############################################## */
/* ################################################################# */
static void xbee_logf(xbee_hnd xbee, const char *logformat, const char *file,
const int line, const char *function, char *format, ...) {
char buf[128];
va_list ap;
if (!xbee) return;
if (!xbee->log) return;
va_start(ap,format);
vsnprintf(buf,127,format,ap);
va_end(ap);
fprintf(xbee->log,logformat,file,line,function,buf);
}
void xbee_logitf(char *format, ...) {
char buf[128];
va_list ap;
va_start(ap,format);
vsnprintf(buf,127,format,ap);
va_end(ap);
xbee_logit(buf);
}
void _xbee_logitf(xbee_hnd xbee, char *format, ...) {
char buf[128];
va_list ap;
va_start(ap,format);
vsnprintf(buf,127,format,ap);
va_end(ap);
_xbee_logit(xbee, buf);
}
void xbee_logit(char *str) {
_xbee_logit(default_xbee, str);
}
void _xbee_logit(xbee_hnd xbee, char *str) {
if (!xbee) return;
if (!xbee->log) return;
xbee_mutex_lock(xbee->logmutex);
fprintf(xbee->log,LOG_FORMAT"\n",__FILE__,__LINE__,__FUNCTION__,str);
xbee_mutex_unlock(xbee->logmutex);
}
/* #################################################################
xbee_sendAT - INTERNAL
allows for an at command to be send, and the reply to be captured */
static int xbee_sendAT(xbee_hnd xbee, char *command, char *retBuf, int retBuflen) {
return xbee_sendATdelay(xbee, 0, command, retBuf, retBuflen);
}
static int xbee_sendATdelay(xbee_hnd xbee, int guardTime, char *command, char *retBuf, int retBuflen) {
struct timeval to;
int ret;
int bufi = 0;
/* if there is a guardTime given, then use it and a bit more */
if (guardTime) usleep(guardTime * 1200);
/* get rid of any pre-command sludge... */
memset(&to, 0, sizeof(to));
ret = xbee_select(xbee,&to);
if (ret > 0) {
char t[128];
while (xbee_read(xbee,t,127));
}
/* send the requested command */
xbee_log("sendATdelay: Sending '%s'", command);
xbee_write(xbee,command, strlen(command));
/* if there is a guardTime, then use it */
if (guardTime) {
usleep(guardTime * 900);
/* get rid of any post-command sludge... */
memset(&to, 0, sizeof(to));
ret = xbee_select(xbee,&to);
if (ret > 0) {
char t[128];
while (xbee_read(xbee,t,127));
}
}
/* retrieve the data */
memset(retBuf, 0, retBuflen);
memset(&to, 0, sizeof(to));
if (guardTime) {
/* select on the xbee fd... wait at most 0.2 the guardTime for the response */
to.tv_usec = guardTime * 200;
} else {
/* or 250ms */
to.tv_usec = 250000;
}
if ((ret = xbee_select(xbee,&to)) == -1) {
xbee_perror("libxbee:xbee_sendATdelay()");
exit(1);
}
if (!ret) {
/* timed out, and there is nothing to be read */
xbee_log("sendATdelay: No Data to read - Timeout...");
return 1;
}
/* check for any dribble... */
do {
/* if there is actually no space in the retBuf then break out */
if (bufi >= retBuflen - 1) {
break;
}
/* read as much data as is possible into retBuf */
if ((ret = xbee_read(xbee,&retBuf[bufi], retBuflen - bufi - 1)) == 0) {
break;
}
/* advance the 'end of string' pointer */
bufi += ret;
/* wait at most 150ms for any more data */
memset(&to, 0, sizeof(to));
to.tv_usec = 150000;
if ((ret = xbee_select(xbee,&to)) == -1) {
xbee_perror("libxbee:xbee_sendATdelay()");
exit(1);
}
/* loop while data was read */
} while (ret);
if (!bufi) {
xbee_log("sendATdelay: No response...");
return 1;
}
/* terminate the string */
retBuf[bufi] = '\0';
xbee_log("sendATdelay: Recieved '%s'",retBuf);
return 0;
}
/* #################################################################
xbee_start
sets up the correct API mode for the xbee
cmdSeq = CC
cmdTime = GT */
static int xbee_startAPI(xbee_hnd xbee) {
char buf[256];
if (xbee->cmdSeq == 0 || xbee->cmdTime == 0) return 1;
/* setup the command sequence string */
memset(buf,xbee->cmdSeq,3);
buf[3] = '\0';
/* try the command sequence */
if (xbee_sendATdelay(xbee, xbee->cmdTime, buf, buf, sizeof(buf))) {
/* if it failed... try just entering 'AT' which should return OK */
if (xbee_sendAT(xbee, "AT\r", buf, 4) || strncmp(buf,"OK\r",3)) return 1;
} else if (strncmp(&buf[strlen(buf)-3],"OK\r",3)) {
/* if data was returned, but it wasn't OK... then something went wrong! */
return 1;
}
/* get the current API mode */
if (xbee_sendAT(xbee, "ATAP\r", buf, 3)) return 1;
buf[1] = '\0';
xbee->oldAPI = atoi(buf);
if (xbee->oldAPI != 2) {
/* if it wasnt set to mode 2 already, then set it to mode 2 */
if (xbee_sendAT(xbee, "ATAP2\r", buf, 4) || strncmp(buf,"OK\r",3)) return 1;
}
/* quit from command mode, ready for some packets! :) */
if (xbee_sendAT(xbee, "ATCN\r", buf, 4) || strncmp(buf,"OK\r",3)) return 1;
return 0;
}
/* #################################################################
xbee_end
resets the API mode to the saved value - you must have called xbee_setup[log]API */
int xbee_end(void) {
return _xbee_end(default_xbee);
}
int _xbee_end(xbee_hnd xbee) {
int ret = 1;
xbee_con *con, *ncon;
xbee_pkt *pkt, *npkt;
xbee_hnd xbeet;
ISREADYR(0);
xbee_log("Stopping libxbee instance...");
/* unlink the instance from list... */
xbee_log("Unlinking instance from list...");
xbee_mutex_lock(xbee_hnd_mutex);
if (xbee == default_xbee) {
default_xbee = default_xbee->next;
if (!default_xbee) {
xbee_mutex_destroy(xbee_hnd_mutex);
}
} else {
xbeet = default_xbee;
while (xbeet) {
if (xbeet->next == xbee) {
xbeet->next = xbee->next;
break;
}
xbeet = xbeet->next;
}
}
if (default_xbee) xbee_mutex_unlock(xbee_hnd_mutex);
/* if the api mode was not 2 to begin with then put it back */
if (xbee->oldAPI == 2) {
xbee_log("XBee was already in API mode 2, no need to reset");
ret = 0;
} else {
int to = 5;
con = _xbee_newcon(xbee,'I',xbee_localAT);
con->callback = NULL;
con->waitforACK = 1;
_xbee_senddata(xbee,con,"AP%c",xbee->oldAPI);
pkt = NULL;
while (!pkt && to--) {
pkt = _xbee_getpacketwait(xbee,con);
}
if (pkt) {
ret = pkt->status;
Xfree(pkt);
}
_xbee_endcon(xbee,con);
}
/* xbee_* functions may no longer run... */
xbee->xbee_ready = 0;
/* nullify everything */
/* stop listening for data... either after timeout or next char read which ever is first */
xbee->run = 0;
xbee_thread_cancel(xbee->listent,0);
xbee_thread_join(xbee->listent);
xbee_thread_cancel(xbee->threadt,0);
xbee_thread_join(xbee->threadt);
/* free all connections */
con = xbee->conlist;
xbee->conlist = NULL;
while (con) {
ncon = con->next;
Xfree(con);
con = ncon;
}
/* free all packets */
xbee->pktlast = NULL;
pkt = xbee->pktlist;
xbee->pktlist = NULL;
while (pkt) {
npkt = pkt->next;
Xfree(pkt);
pkt = npkt;
}
/* destroy mutexes */
xbee_mutex_destroy(xbee->conmutex);
xbee_mutex_destroy(xbee->pktmutex);
xbee_mutex_destroy(xbee->sendmutex);
/* close the serial port */
Xfree(xbee->path);
if (xbee->tty) xbee_close(xbee->tty);
/* close log and tty */
if (xbee->log) {
fflush(xbee->log);
xbee_close(xbee->log);
}
xbee_mutex_destroy(xbee->logmutex);
Xfree(xbee);
return ret;
}
/* #################################################################
xbee_setup
opens xbee serial port & creates xbee listen thread
the xbee must be configured for API mode 2
THIS MUST BE CALLED BEFORE ANY OTHER XBEE FUNCTION */
int xbee_setup(char *path, int baudrate) {
return xbee_setuplogAPI(path,baudrate,0,0,0);
}
xbee_hnd _xbee_setup(char *path, int baudrate) {
return _xbee_setuplogAPI(path,baudrate,0,0,0);
}
int xbee_setuplog(char *path, int baudrate, int logfd) {
return xbee_setuplogAPI(path,baudrate,logfd,0,0);
}
xbee_hnd _xbee_setuplog(char *path, int baudrate, int logfd) {
return _xbee_setuplogAPI(path,baudrate,logfd,0,0);
}
int xbee_setupAPI(char *path, int baudrate, char cmdSeq, int cmdTime) {
return xbee_setuplogAPI(path,baudrate,0,cmdSeq,cmdTime);
}
xbee_hnd _xbee_setupAPI(char *path, int baudrate, char cmdSeq, int cmdTime) {
return _xbee_setuplogAPI(path,baudrate,0,cmdSeq,cmdTime);
}
int xbee_setuplogAPI(char *path, int baudrate, int logfd, char cmdSeq, int cmdTime) {
if (default_xbee) return 0;
default_xbee = _xbee_setuplogAPI(path,baudrate,logfd,cmdSeq,cmdTime);
return (default_xbee?0:-1);
}
xbee_hnd _xbee_setuplogAPI(char *path, int baudrate, int logfd, char cmdSeq, int cmdTime) {
int ret;
xbee_hnd xbee = NULL;
/* create a new instance */
xbee = Xcalloc(sizeof(struct xbee_hnd));
xbee->next = NULL;
xbee_mutex_init(xbee->logmutex);
#ifdef DEBUG
if (!logfd) logfd = 2;
#endif
if (logfd) {
xbee->logfd = dup(logfd);
xbee->log = fdopen(xbee->logfd,"w");
if (!xbee->log) {
/* errno == 9 is bad file descriptor (probrably not provided) */
if (errno != 9) xbee_perror("xbee_setup(): Failed opening logfile");
xbee->logfd = 0;
} else {
#ifdef __GNUC__ /* ---- */
/* set to line buffer - ensure lines are written to file when complete */
setvbuf(xbee->log,NULL,_IOLBF,BUFSIZ);
#else /* -------------- */
/* Win32 is rubbish... so we have to completely disable buffering... */
setvbuf(xbee->log,NULL,_IONBF,BUFSIZ);
#endif /* ------------- */
}
}
xbee_logS("---------------------------------------------------------------------");
xbee_logI("libxbee Starting...");
xbee_logI("SVN Info: %s",xbee_svn_version());
xbee_logI("Build Info: %s",xbee_build_info());
xbee_logE("---------------------------------------------------------------------");
/* setup the connection stuff */
xbee->conlist = NULL;
/* setup the packet stuff */
xbee->pktlist = NULL;
xbee->pktlast = NULL;
xbee->pktcount = 0;
xbee->run = 1;
/* setup the mutexes */
if (xbee_mutex_init(xbee->conmutex)) {
xbee_perror("xbee_setup():xbee_mutex_init(conmutex)");
if (xbee->log) xbee_close(xbee->log);
Xfree(xbee);
return NULL;
}
if (xbee_mutex_init(xbee->pktmutex)) {
xbee_perror("xbee_setup():xbee_mutex_init(pktmutex)");
if (xbee->log) xbee_close(xbee->log);
xbee_mutex_destroy(xbee->conmutex);
Xfree(xbee);
return NULL;
}
if (xbee_mutex_init(xbee->sendmutex)) {
xbee_perror("xbee_setup():xbee_mutex_init(sendmutex)");
if (xbee->log) xbee_close(xbee->log);
xbee_mutex_destroy(xbee->conmutex);
xbee_mutex_destroy(xbee->pktmutex);
Xfree(xbee);
return NULL;
}
/* take a copy of the XBee device path */
if ((xbee->path = Xmalloc(sizeof(char) * (strlen(path) + 1))) == NULL) {
xbee_perror("xbee_setup():Xmalloc(path)");
if (xbee->log) xbee_close(xbee->log);
xbee_mutex_destroy(xbee->conmutex);
xbee_mutex_destroy(xbee->pktmutex);
xbee_mutex_destroy(xbee->sendmutex);
Xfree(xbee);
return NULL;
}
strcpy(xbee->path,path);
if (xbee->log) xbee_log("Opening serial port '%s'...",xbee->path);
/* call the relevant init function */
if ((ret = init_serial(xbee,baudrate)) != 0) {
xbee_log("Something failed while opening the serial port...");
if (xbee->log) xbee_close(xbee->log);
xbee_mutex_destroy(xbee->conmutex);
xbee_mutex_destroy(xbee->pktmutex);
xbee_mutex_destroy(xbee->sendmutex);
Xfree(xbee->path);
Xfree(xbee);
return NULL;
}
/* when xbee_end() is called, if this is not 2 then ATAP will be set to this value */
xbee->oldAPI = 2;
xbee->cmdSeq = cmdSeq;
xbee->cmdTime = cmdTime;
if (xbee->cmdSeq && xbee->cmdTime) {
if (xbee_startAPI(xbee)) {
if (xbee->log) {
xbee_log("Couldn't communicate with XBee...");
xbee_close(xbee->log);
}
xbee_mutex_destroy(xbee->conmutex);
xbee_mutex_destroy(xbee->pktmutex);
xbee_mutex_destroy(xbee->sendmutex);
Xfree(xbee->path);
#ifdef __GNUC__ /* ---- */
close(xbee->ttyfd);
#endif /* ------------- */
xbee_close(xbee->tty);
Xfree(xbee);
return NULL;
}
}
/* allow the listen thread to start */
xbee->xbee_ready = -1;
/* can start xbee_listen thread now */
if (xbee_thread_create(xbee->listent, xbee_listen_wrapper, xbee)) {
xbee_perror("xbee_setup():xbee_thread_create(listent)");
if (xbee->log) xbee_close(xbee->log);
xbee_mutex_destroy(xbee->conmutex);
xbee_mutex_destroy(xbee->pktmutex);
xbee_mutex_destroy(xbee->sendmutex);
Xfree(xbee->path);
#ifdef __GNUC__ /* ---- */
close(xbee->ttyfd);
#endif /* ------------- */
xbee_close(xbee->tty);
Xfree(xbee);
return NULL;
}
/* can start xbee_thread_watch thread thread now */
if (xbee_thread_create(xbee->threadt, xbee_thread_watch, xbee)) {
xbee_perror("xbee_setup():xbee_thread_create(threadt)");
if (xbee->log) xbee_close(xbee->log);
xbee_mutex_destroy(xbee->conmutex);
xbee_mutex_destroy(xbee->pktmutex);
xbee_mutex_destroy(xbee->sendmutex);
Xfree(xbee->path);
#ifdef __GNUC__ /* ---- */
close(xbee->ttyfd);
#endif /* ------------- */
xbee_close(xbee->tty);
Xfree(xbee);
return NULL;
}
usleep(500);
while (xbee->xbee_ready != -2) {
usleep(500);
xbee_log("Waiting for xbee_listen() to be ready...");
}
/* allow other functions to be used! */
xbee->xbee_ready = 1;
xbee_log("Linking xbee instance...");
if (!default_xbee) {
xbee_mutex_init(xbee_hnd_mutex);
xbee_mutex_lock(xbee_hnd_mutex);
default_xbee = xbee;
xbee_mutex_unlock(xbee_hnd_mutex);
} else {
xbee_hnd xbeet;
xbee_mutex_lock(xbee_hnd_mutex);
xbeet = default_xbee;
while (xbeet->next) {
xbeet = xbeet->next;
}
xbeet->next = xbee;
xbee_mutex_unlock(xbee_hnd_mutex);
}
xbee_log("libxbee: Started!");
return xbee;
}
/* #################################################################
xbee_con
produces a connection to the specified device and frameID
if a connection had already been made, then this connection will be returned */
xbee_con *xbee_newcon(unsigned char frameID, xbee_types type, ...) {
xbee_con *ret;
va_list ap;
/* xbee_vnewcon() wants a va_list... */
va_start(ap, type);
/* hand it over :) */
ret = _xbee_vnewcon(default_xbee, frameID, type, ap);
va_end(ap);
return ret;
}
xbee_con *_xbee_newcon(xbee_hnd xbee, unsigned char frameID, xbee_types type, ...) {
xbee_con *ret;
va_list ap;
/* xbee_vnewcon() wants a va_list... */
va_start(ap, type);
/* hand it over :) */
ret = _xbee_vnewcon(xbee, frameID, type, ap);
va_end(ap);
return ret;
}
xbee_con *_xbee_vnewcon(xbee_hnd xbee, unsigned char frameID, xbee_types type, va_list ap) {
xbee_con *con, *ocon;
unsigned char tAddr[8];
int t;
int i;
ISREADYR(NULL);
if (!type || type == xbee_unknown) type = xbee_localAT; /* default to local AT */
else if (type == xbee_remoteAT) type = xbee_64bitRemoteAT; /* if remote AT, default to 64bit */
/* if: 64 bit address expected (2 ints) */
if ((type == xbee_64bitRemoteAT) ||
(type == xbee_64bitData) ||
(type == xbee_64bitIO) ||
(type == xbee2_data)) {
t = va_arg(ap, int);
tAddr[0] = (t >> 24) & 0xFF;
tAddr[1] = (t >> 16) & 0xFF;
tAddr[2] = (t >> 8) & 0xFF;
tAddr[3] = (t ) & 0xFF;
t = va_arg(ap, int);
tAddr[4] = (t >> 24) & 0xFF;
tAddr[5] = (t >> 16) & 0xFF;
tAddr[6] = (t >> 8) & 0xFF;
tAddr[7] = (t ) & 0xFF;
/* if: 16 bit address expected (1 int) */
} else if ((type == xbee_16bitRemoteAT) ||
(type == xbee_16bitData) ||
(type == xbee_16bitIO)) {
t = va_arg(ap, int);
tAddr[0] = (t >> 8) & 0xFF;
tAddr[1] = (t ) & 0xFF;
tAddr[2] = 0;
tAddr[3] = 0;
tAddr[4] = 0;
tAddr[5] = 0;
tAddr[6] = 0;
tAddr[7] = 0;
/* otherwise clear the address */
} else {
memset(tAddr,0,8);
}
/* lock the connection mutex */
xbee_mutex_lock(xbee->conmutex);
/* are there any connections? */
if (xbee->conlist) {
con = xbee->conlist;
while (con) {
/* if: looking for a modemStatus, and the types match! */
if ((type == xbee_modemStatus) &&
(con->type == type)) {
xbee_mutex_unlock(xbee->conmutex);
return con;
/* if: looking for a txStatus and frameIDs match! */
} else if ((type == xbee_txStatus) &&
(con->type == type) &&
(frameID == con->frameID)) {
xbee_mutex_unlock(xbee->conmutex);
return con;
/* if: looking for a localAT, and the frameIDs match! */
} else if ((type == xbee_localAT) &&
(con->type == type) &&
(frameID == con->frameID)) {
xbee_mutex_unlock(xbee->conmutex);
return con;
/* if: connection types match, the frameIDs match, and the addresses match! */
} else if ((type == con->type) &&
(frameID == con->frameID) &&
(!memcmp(tAddr,con->tAddr,8))) {
xbee_mutex_unlock(xbee->conmutex);
return con;
}
/* if there are more, move along, dont want to loose that last item! */
if (con->next == NULL) break;
con = con->next;
}
/* keep hold of the last connection... we will need to link it up later */
ocon = con;
}
/* unlock the connection mutex */
xbee_mutex_unlock(xbee->conmutex);
/* create a new connection and set its attributes */
con = Xcalloc(sizeof(xbee_con));
con->type = type;
/* is it a 64bit connection? */
if ((type == xbee_64bitRemoteAT) ||
(type == xbee_64bitData) ||
(type == xbee_64bitIO) ||
(type == xbee2_data)) {
con->tAddr64 = TRUE;
}
con->atQueue = 0; /* queue AT commands? */
con->txDisableACK = 0; /* disable ACKs? */
con->txBroadcastPAN = 0; /* broadcast? */
con->frameID = frameID;
con->waitforACK = 0;
memcpy(con->tAddr,tAddr,8); /* copy in the remote address */
xbee_mutex_init(con->callbackmutex);
xbee_mutex_init(con->callbackListmutex);
xbee_mutex_init(con->Txmutex);
xbee_sem_init(con->waitforACKsem);
if (xbee->log) {
switch(type) {
case xbee_localAT:
xbee_log("New local AT connection!");
break;
case xbee_16bitRemoteAT:
case xbee_64bitRemoteAT:
xbee_logc("New %d-bit remote AT connection! (to: ",(con->tAddr64?64:16));
for (i=0;i<(con->tAddr64?8:2);i++) {
fprintf(xbee->log,(i?":%02X":"%02X"),tAddr[i]);
}
fprintf(xbee->log,")");
xbee_logcf();
break;
case xbee_16bitData:
case xbee_64bitData:
xbee_logc("New %d-bit data connection! (to: ",(con->tAddr64?64:16));
for (i=0;i<(con->tAddr64?8:2);i++) {
fprintf(xbee->log,(i?":%02X":"%02X"),tAddr[i]);
}
fprintf(xbee->log,")");
xbee_logcf();
break;
case xbee_16bitIO:
case xbee_64bitIO:
xbee_logc("New %d-bit IO connection! (to: ",(con->tAddr64?64:16));
for (i=0;i<(con->tAddr64?8:2);i++) {
fprintf(xbee->log,(i?":%02X":"%02X"),tAddr[i]);
}
fprintf(xbee->log,")");
xbee_logcf();
break;
case xbee2_data:
xbee_logc("New Series 2 data connection! (to: ");
for (i=0;i<8;i++) {
fprintf(xbee->log,(i?":%02X":"%02X"),tAddr[i]);
}
fprintf(xbee->log,")");
xbee_logcf();
break;
case xbee_txStatus:
xbee_log("New Tx status connection!");
break;
case xbee_modemStatus:
xbee_log("New modem status connection!");
break;
case xbee_unknown:
default:
xbee_log("New unknown connection!");
}
}
/* lock the connection mutex */
xbee_mutex_lock(xbee->conmutex);
/* make it the last in the list */
con->next = NULL;
/* add it to the list */
if (xbee->conlist) {
ocon->next = con;
} else {
xbee->conlist = con;
}
/* unlock the mutex */
xbee_mutex_unlock(xbee->conmutex);
return con;
}
/* #################################################################
xbee_conflush
removes any packets that have been collected for the specified
connection */
void xbee_purgecon(xbee_con *con) {
_xbee_purgecon(default_xbee, con);
}
void _xbee_purgecon(xbee_hnd xbee, xbee_con *con) {
xbee_pkt *r, *p, *n;
ISREADYP();
/* lock the packet mutex */
xbee_mutex_lock(xbee->pktmutex);
/* if: there are packets */
if ((p = xbee->pktlist) != NULL) {
r = NULL;
/* get all packets for this connection */
do {
/* does the packet match the connection? */
if (xbee_matchpktcon(xbee,p,con)) {
/* if it was the first packet */
if (!r) {
/* move the chain along */
xbee->pktlist = p->next;
} else {
/* otherwise relink the list */
r->next = p->next;
}
xbee->pktcount--;
/* free this packet! */
n = p->next;
Xfree(p);
/* move on */
p = n;
} else {
/* move on */
r = p;
p = p->next;
}
} while (p);
xbee->pktlast = r;
}
/* unlock the packet mutex */
xbee_mutex_unlock(xbee->pktmutex);
}
/* #################################################################
xbee_endcon
close the unwanted connection
free wrapper function (uses the Xfree macro and sets the pointer to NULL after freeing it) */
void xbee_endcon2(xbee_con **con, int alreadyUnlinked) {
_xbee_endcon2(default_xbee, con, alreadyUnlinked);
}
void _xbee_endcon2(xbee_hnd xbee, xbee_con **con, int alreadyUnlinked) {
xbee_con *t, *u;
ISREADYP();
/* lock the connection mutex */
xbee_mutex_lock(xbee->conmutex);
u = t = xbee->conlist;
while (t && t != *con) {
u = t;
t = t->next;
}
if (!t) {
/* this could be true if comming from the destroySelf signal... */
if (!alreadyUnlinked) {
/* invalid connection given... */
if (xbee->log) {
xbee_log("Attempted to close invalid connection...");
}
/* unlock the connection mutex */
xbee_mutex_unlock(xbee->conmutex);
return;
}
} else {
/* extract this connection from the list */
if (t == xbee->conlist) {
xbee->conlist = t->next;
} else {
u->next = t->next;
}
}
/* unlock the connection mutex */
xbee_mutex_unlock(xbee->conmutex);
/* check if a callback thread is running... */
if (t->callback && xbee_mutex_trylock(t->callbackmutex)) {
/* if it is running... tell it to destroy the connection on completion */
xbee_log("Attempted to close a connection with active callbacks... "
"Connection will be destroyed when callbacks have completeted...");
t->destroySelf = 1;
return;
}
/* remove all packets for this connection */
_xbee_purgecon(xbee,t);
/* destroy the callback mutex */
xbee_mutex_destroy(t->callbackmutex);
xbee_mutex_destroy(t->callbackListmutex);
xbee_mutex_destroy(t->Txmutex);
xbee_sem_destroy(t->waitforACKsem);
/* free the connection! */
Xfree(*con);
}
/* #################################################################
xbee_senddata
send the specified data to the provided connection */
int xbee_senddata(xbee_con *con, char *format, ...) {
int ret;
va_list ap;
/* xbee_vsenddata() wants a va_list... */
va_start(ap, format);
/* hand it over :) */
ret = _xbee_vsenddata(default_xbee, con, format, ap);
va_end(ap);
return ret;
}
int _xbee_senddata(xbee_hnd xbee, xbee_con *con, char *format, ...) {
int ret;
va_list ap;
/* xbee_vsenddata() wants a va_list... */
va_start(ap, format);
/* hand it over :) */
ret = _xbee_vsenddata(xbee, con, format, ap);
va_end(ap);
return ret;
}
int xbee_vsenddata(xbee_con *con, char *format, va_list ap) {
return _xbee_vsenddata(default_xbee, con, format, ap);
}
int _xbee_vsenddata(xbee_hnd xbee, xbee_con *con, char *format, va_list ap) {
unsigned char data[128]; /* max payload is 100 bytes... plus a bit of fluff... */
int length;
/* make up the data and keep the length, its possible there are nulls in there */
length = vsnprintf((char *)data, 128, format, ap);
/* hand it over :) */
return _xbee_nsenddata(xbee, con, (char *)data, length);
}
/* returns:
1 - if NAC was recieved
0 - if packet was successfully sent (or just sent if waitforACK is off)
-1 - if there was an error building the packet
-2 - if the connection type was unknown */
int xbee_nsenddata(xbee_con *con, char *data, int length) {
return _xbee_nsenddata(default_xbee, con, data, length);
}
int _xbee_nsenddata(xbee_hnd xbee, xbee_con *con, char *data, int length) {
t_data *pkt;
int i;
unsigned char buf[128]; /* max payload is 100 bytes... plus a bit for the headers etc... */
ISREADYR(-1);
if (!con) return -1;
if (con->type == xbee_unknown) return -1;
if (length > 127) return -1;
if (xbee->log) {
xbee_logS("--== TX Packet ============--");
xbee_logIc("Connection Type: ");
switch (con->type) {
case xbee_unknown: fprintf(xbee->log,"Unknown"); break;
case xbee_localAT: fprintf(xbee->log,"Local AT"); break;
case xbee_remoteAT: fprintf(xbee->log,"Remote AT"); break;
case xbee_16bitRemoteAT: fprintf(xbee->log,"Remote AT (16-bit)"); break;
case xbee_64bitRemoteAT: fprintf(xbee->log,"Remote AT (64-bit)"); break;
case xbee_16bitData: fprintf(xbee->log,"Data (16-bit)"); break;
case xbee_64bitData: fprintf(xbee->log,"Data (64-bit)"); break;
case xbee_16bitIO: fprintf(xbee->log,"IO (16-bit)"); break;
case xbee_64bitIO: fprintf(xbee->log,"IO (64-bit)"); break;
case xbee2_data: fprintf(xbee->log,"Series 2 Data"); break;
case xbee2_txStatus: fprintf(xbee->log,"Series 2 Tx Status"); break;
case xbee_txStatus: fprintf(xbee->log,"Tx Status"); break;
case xbee_modemStatus: fprintf(xbee->log,"Modem Status"); break;
}
xbee_logIcf();
switch (con->type) {
case xbee_localAT: case xbee_remoteAT: case xbee_txStatus: case xbee_modemStatus:
break;
default:
xbee_logIc("Destination: ");
for (i=0;i<(con->tAddr64?8:2);i++) {
fprintf(xbee->log,(i?":%02X":"%02X"),con->tAddr[i]);
}
xbee_logIcf();
}
xbee_logI("Length: %d",length);
for (i=0;i<length;i++) {
xbee_logIc("%3d | 0x%02X ",i,(unsigned char)data[i]);
if ((data[i] > 32) && (data[i] < 127)) {
fprintf(xbee->log,"'%c'",data[i]);
} else{
fprintf(xbee->log," _");
}
xbee_logIcf();
}
xbee_logEf();
}
/* ########################################## */
/* if: local AT */
if (con->type == xbee_localAT) {
/* AT commands are 2 chars long (plus optional parameter) */
if (length < 2) return -1;
if (length > 32) return -1;
/* use the command? */
buf[0] = ((!con->atQueue)?XBEE_LOCAL_ATREQ:XBEE_LOCAL_ATQUE);
buf[1] = con->frameID;
/* copy in the data */
for (i=0;i<length;i++) {
buf[i+2] = data[i];
}
/* setup the packet */
pkt = xbee_make_pkt(xbee, buf, i+2);
/* send it on */
return _xbee_send_pkt(xbee, pkt, con);
/* ########################################## */
/* if: remote AT */
} else if ((con->type == xbee_16bitRemoteAT) ||
(con->type == xbee_64bitRemoteAT)) {
if (length < 2) return -1; /* at commands are 2 chars long (plus optional parameter) */
if (length > 32) return -1;
buf[0] = XBEE_REMOTE_ATREQ;
buf[1] = con->frameID;
/* copy in the relevant address */
if (con->tAddr64) {
memcpy(&buf[2],con->tAddr,8);
buf[10] = 0xFF;
buf[11] = 0xFE;
} else {
memset(&buf[2],0,8);
memcpy(&buf[10],con->tAddr,2);
}
/* queue the command? */
buf[12] = ((!con->atQueue)?0x02:0x00);
/* copy in the data */
for (i=0;i<length;i++) {
buf[i+13] = data[i];
}
/* setup the packet */
pkt = xbee_make_pkt(xbee, buf, i+13);
/* send it on */
return _xbee_send_pkt(xbee, pkt, con);
/* ########################################## */
/* if: 16 or 64bit Data */
} else if ((con->type == xbee_16bitData) ||
(con->type == xbee_64bitData)) {
int offset;
if (length > 100) return -1;
/* if: 16bit Data */
if (con->type == xbee_16bitData) {
buf[0] = XBEE_16BIT_DATATX;
offset = 5;
/* copy in the address */
memcpy(&buf[2],con->tAddr,2);
/* if: 64bit Data */
} else { /* 64bit Data */
buf[0] = XBEE_64BIT_DATATX;
offset = 11;
/* copy in the address */
memcpy(&buf[2],con->tAddr,8);
}
/* copy frameID */
buf[1] = con->frameID;
/* disable ack? broadcast? */
buf[offset-1] = ((con->txDisableACK)?0x01:0x00) | ((con->txBroadcastPAN)?0x04:0x00);
/* copy in the data */
for (i=0;i<length;i++) {
buf[i+offset] = data[i];
}
/* setup the packet */
pkt = xbee_make_pkt(xbee, buf, i+offset);
/* send it on */
return _xbee_send_pkt(xbee, pkt, con);
/* ########################################## */
/* if: I/O */
} else if ((con->type == xbee_64bitIO) ||
(con->type == xbee_16bitIO)) {
/* not currently implemented... is it even allowed? */
if (xbee->log) {
xbee_log("******* TODO ********\n");
}
/* ########################################## */
/* if: Series 2 Data */
} else if (con->type == xbee2_data) {
if (length > 72) return -1;
buf[0] = XBEE2_DATATX;
buf[1] = con->frameID;
/* copy in the relevant address */
memcpy(&buf[2],con->tAddr,8);
buf[10] = 0xFF;
buf[11] = 0xFE;
/* Maximum Radius/hops */
buf[12] = 0x00;
/* Options */
buf[13] = 0x00;
/* copy in the data */
for (i=0;i<length;i++) {
buf[i+14] = data[i];
}
/* setup the packet */
pkt = xbee_make_pkt(xbee, buf, i+14);
/* send it on */
return _xbee_send_pkt(xbee, pkt, con);
}
return -2;
}
/* #################################################################
xbee_getpacket
retrieves the next packet destined for the given connection
once the packet has been retrieved, it is removed for the list! */
xbee_pkt *xbee_getpacketwait(xbee_con *con) {
return _xbee_getpacketwait(default_xbee, con);
}
xbee_pkt *_xbee_getpacketwait(xbee_hnd xbee, xbee_con *con) {
xbee_pkt *p = NULL;
int i = 20;
/* 50ms * 20 = 1 second */
for (; i; i--) {
p = _xbee_getpacket(xbee, con);
if (p) break;
usleep(50000); /* 50ms */
}
return p;
}
xbee_pkt *xbee_getpacket(xbee_con *con) {
return _xbee_getpacket(default_xbee, con);
}
xbee_pkt *_xbee_getpacket(xbee_hnd xbee, xbee_con *con) {
xbee_pkt *l, *p, *q;
ISREADYR(NULL);
/* lock the packet mutex */
xbee_mutex_lock(xbee->pktmutex);
/* if: there are no packets */
if ((p = xbee->pktlist) == NULL) {
xbee_mutex_unlock(xbee->pktmutex);
/*if (xbee->log) {
xbee_log("No packets avaliable...");
}*/
return NULL;
}
l = NULL;
q = NULL;
/* get the first avaliable packet for this connection */
do {
/* does the packet match the connection? */
if (xbee_matchpktcon(xbee, p, con)) {
q = p;
break;
}
/* move on */
l = p;
p = p->next;
} while (p);
/* if: no packet was found */
if (!q) {
xbee_mutex_unlock(xbee->pktmutex);
if (xbee->log) {
struct timeval tv;
xbee_logS("--== Get Packet ==========--");
gettimeofday(&tv,NULL);
xbee_logE("Didn't get a packet @ %ld.%06ld",tv.tv_sec,tv.tv_usec);
}
return NULL;
}
/* if it was the first packet */
if (l) {
/* relink the list */
l->next = p->next;
if (!l->next) xbee->pktlast = l;
} else {
/* move the chain along */
xbee->pktlist = p->next;
if (!xbee->pktlist) {
xbee->pktlast = NULL;
} else if (!xbee->pktlist->next) {
xbee->pktlast = xbee->pktlist;
}
}
xbee->pktcount--;
/* unlink this packet from the chain! */
q->next = NULL;
if (xbee->log) {
struct timeval tv;
xbee_logS("--== Get Packet ==========--");
gettimeofday(&tv,NULL);
xbee_logI("Got a packet @ %ld.%06ld",tv.tv_sec,tv.tv_usec);
xbee_logE("Packets left: %d",xbee->pktcount);
}
/* unlock the packet mutex */
xbee_mutex_unlock(xbee->pktmutex);
/* and return the packet (must be free'd by caller!) */
return q;
}
/* #################################################################
xbee_matchpktcon - INTERNAL
checks if the packet matches the connection */
static int xbee_matchpktcon(xbee_hnd xbee, xbee_pkt *pkt, xbee_con *con) {
/* if: the connection type matches the packet type OR
the connection is 16/64bit remote AT, and the packet is a remote AT response */
if ((pkt->type == con->type) || /* -- */
((pkt->type == xbee_remoteAT) && /* -- */
((con->type == xbee_16bitRemoteAT) ||
(con->type == xbee_64bitRemoteAT)))) {
/* if: is a modem status (there can only be 1 modem status connection) */
if (pkt->type == xbee_modemStatus) return 1;
/* if: the packet is a txStatus or localAT and the frameIDs match */
if ((pkt->type == xbee_txStatus) ||
(pkt->type == xbee_localAT)) {
if (pkt->frameID == con->frameID) {
return 1;
}
/* if: the packet was sent as a 16bit remoteAT, and the 16bit addresss match */
} else if ((pkt->type == xbee_remoteAT) &&
(con->type == xbee_16bitRemoteAT) &&
!memcmp(pkt->Addr16,con->tAddr,2)) {
return 1;
/* if: the packet was sent as a 64bit remoteAT, and the 64bit addresss match */
} else if ((pkt->type == xbee_remoteAT) &&
(con->type == xbee_64bitRemoteAT) &&
!memcmp(pkt->Addr64,con->tAddr,8)) {
return 1;
/* if: the packet is 64bit addressed, and the addresses match */
} else if (pkt->sAddr64 && !memcmp(pkt->Addr64,con->tAddr,8)) {
return 1;
/* if: the packet is 16bit addressed, and the addresses match */
} else if (!pkt->sAddr64 && !memcmp(pkt->Addr16,con->tAddr,2)) {
return 1;
} else if (con->type == pkt->type &&
(con->type == xbee_16bitData || con->type == xbee_64bitData) &&
(pkt->isBroadcastADR || pkt->isBroadcastPAN)) {
unsigned char t[8] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
if ((con->tAddr64 && !memcmp(con->tAddr,t,8)) ||
(!con->tAddr64 && !memcmp(con->tAddr,t,2))) {
return 1;
}
}
}
return 0;
}
/* #################################################################
xbee_parse_io - INTERNAL
parses the data given into the packet io information */
static int xbee_parse_io(xbee_hnd xbee, xbee_pkt *p, unsigned char *d,
int maskOffset, int sampleOffset, int sample) {
xbee_sample *s = &(p->IOdata[sample]);
/* copy in the I/O data mask */
s->IOmask = (((d[maskOffset]<<8) | d[maskOffset + 1]) & 0x7FFF);
/* copy in the digital I/O data */
s->IOdigital = (((d[sampleOffset]<<8) | d[sampleOffset+1]) & 0x01FF);
/* advance over the digital data, if its there */
sampleOffset += ((s->IOmask & 0x01FF)?2:0);
/* copy in the analog I/O data */
if (s->IOmask & 0x0200) {
s->IOanalog[0] = (((d[sampleOffset]<<8) | d[sampleOffset+1]) & 0x03FF);
sampleOffset+=2;
}
if (s->IOmask & 0x0400) {
s->IOanalog[1] = (((d[sampleOffset]<<8) | d[sampleOffset+1]) & 0x03FF);
sampleOffset+=2;
}
if (s->IOmask & 0x0800) {
s->IOanalog[2] = (((d[sampleOffset]<<8) | d[sampleOffset+1]) & 0x03FF);
sampleOffset+=2;
}
if (s->IOmask & 0x1000) {
s->IOanalog[3] = (((d[sampleOffset]<<8) | d[sampleOffset+1]) & 0x03FF);
sampleOffset+=2;
}
if (s->IOmask & 0x2000) {
s->IOanalog[4] = (((d[sampleOffset]<<8) | d[sampleOffset+1]) & 0x03FF);
sampleOffset+=2;
}
if (s->IOmask & 0x4000) {
s->IOanalog[5] = (((d[sampleOffset]<<8) | d[sampleOffset+1]) & 0x03FF);
sampleOffset+=2;
}
if (xbee->log) {
if (s->IOmask & 0x0001)
xbee_logI("Digital 0: %c",((s->IOdigital & 0x0001)?'1':'0'));
if (s->IOmask & 0x0002)
xbee_logI("Digital 1: %c",((s->IOdigital & 0x0002)?'1':'0'));
if (s->IOmask & 0x0004)
xbee_logI("Digital 2: %c",((s->IOdigital & 0x0004)?'1':'0'));
if (s->IOmask & 0x0008)
xbee_logI("Digital 3: %c",((s->IOdigital & 0x0008)?'1':'0'));
if (s->IOmask & 0x0010)
xbee_logI("Digital 4: %c",((s->IOdigital & 0x0010)?'1':'0'));
if (s->IOmask & 0x0020)
xbee_logI("Digital 5: %c",((s->IOdigital & 0x0020)?'1':'0'));
if (s->IOmask & 0x0040)
xbee_logI("Digital 6: %c",((s->IOdigital & 0x0040)?'1':'0'));
if (s->IOmask & 0x0080)
xbee_logI("Digital 7: %c",((s->IOdigital & 0x0080)?'1':'0'));
if (s->IOmask & 0x0100)
xbee_logI("Digital 8: %c",((s->IOdigital & 0x0100)?'1':'0'));
if (s->IOmask & 0x0200)
xbee_logI("Analog 0: %d (~%.2fv)",s->IOanalog[0],(3.3/1023)*s->IOanalog[0]);
if (s->IOmask & 0x0400)
xbee_logI("Analog 1: %d (~%.2fv)",s->IOanalog[1],(3.3/1023)*s->IOanalog[1]);
if (s->IOmask & 0x0800)
xbee_logI("Analog 2: %d (~%.2fv)",s->IOanalog[2],(3.3/1023)*s->IOanalog[2]);
if (s->IOmask & 0x1000)
xbee_logI("Analog 3: %d (~%.2fv)",s->IOanalog[3],(3.3/1023)*s->IOanalog[3]);
if (s->IOmask & 0x2000)
xbee_logI("Analog 4: %d (~%.2fv)",s->IOanalog[4],(3.3/1023)*s->IOanalog[4]);
if (s->IOmask & 0x4000)
xbee_logI("Analog 5: %d (~%.2fv)",s->IOanalog[5],(3.3/1023)*s->IOanalog[5]);
}
return sampleOffset;
}
/* #################################################################
xbee_listen_stop
stops the listen thread after the current packet has been processed */
void xbee_listen_stop(xbee_hnd xbee) {
ISREADYP();
xbee->run = 0;
}
/* #################################################################
xbee_listen_wrapper - INTERNAL
the xbee_listen wrapper. Prints an error when xbee_listen ends */
static void xbee_listen_wrapper(xbee_hnd xbee) {
int ret;
/* just falls out if the proper 'go-ahead' isn't given */
if (xbee->xbee_ready != -1) return;
/* now allow the parent to continue */
xbee->xbee_ready = -2;
#ifdef _WIN32 /* ---- */
/* win32 requires this delay... no idea why */
usleep(1000000);
#endif /* ----------- */
while (xbee->run) {
ret = xbee_listen(xbee);
if (!xbee->run) break;
xbee_log("xbee_listen() returned [%d]... Restarting in 25ms!",ret);
usleep(25000);
}
}
/* xbee_listen - INTERNAL
the xbee xbee_listen thread
reads data from the xbee and puts it into a linked list to keep the xbee buffers free */
static int xbee_listen(xbee_hnd xbee) {
#define LISTEN_BUFLEN 1024
unsigned char c, t, d[LISTEN_BUFLEN];
unsigned int l, i, chksum, o;
int j;
xbee_pkt *p = NULL, *q;
xbee_con *con;
int hasCon;
/* do this forever :) */
while (xbee->run) {
/* clean up any undesired storage */
if (p) Xfree(p);
/* wait for a valid start byte */
if ((c = xbee_getrawbyte(xbee)) != 0x7E) {
if (xbee->log) xbee_log("***** Unexpected byte (0x%02X)... *****",c);
continue;
}
if (!xbee->run) return 0;
xbee_logSf();
if (xbee->log) {
struct timeval tv;
xbee_logI("--== RX Packet ===========--");
gettimeofday(&tv,NULL);
xbee_logI("Got a packet @ %ld.%06ld",tv.tv_sec,tv.tv_usec);
}
/* get the length */
l = xbee_getbyte(xbee) << 8;
l += xbee_getbyte(xbee);
/* check it is a valid length... */
if (!l) {
if (xbee->log) {
xbee_logI("Recived zero length packet!");
}
continue;
}
if (l > 100) {
if (xbee->log) {
xbee_logI("Recived oversized packet! Length: %d",l - 1);
}
}
if (l > LISTEN_BUFLEN) {
if (xbee->log) {
xbee_logI("Recived packet larger than buffer! Discarding...");
}
continue;
}
if (xbee->log) {
xbee_logI("Length: %d",l - 1);
}
/* get the packet type */
t = xbee_getbyte(xbee);
/* start the checksum */
chksum = t;
/* suck in all the data */
for (i = 0; l > 1 && i < LISTEN_BUFLEN; l--, i++) {
/* get an unescaped byte */
c = xbee_getbyte(xbee);
d[i] = c;
chksum += c;
if (xbee->log) {
xbee_logIc("%3d | 0x%02X | ",i,c);
if ((c > 32) && (c < 127)) fprintf(xbee->log,"'%c'",c); else fprintf(xbee->log," _ ");
if ((t == XBEE_LOCAL_AT && i == 4) ||
(t == XBEE_REMOTE_AT && i == 14) ||
(t == XBEE_64BIT_DATARX && i == 10) ||
(t == XBEE_16BIT_DATARX && i == 4) ||
(t == XBEE_64BIT_IO && i == 13) ||
(t == XBEE_16BIT_IO && i == 7)) {
/* mark the beginning of the 'data' bytes */
fprintf(xbee->log," <-- data starts");
} else if (t == XBEE_64BIT_IO) {
if (i == 10) fprintf(xbee->log," <-- sample count");
else if (i == 11) fprintf(xbee->log," <-- mask (msb)");
else if (i == 12) fprintf(xbee->log," <-- mask (lsb)");
} else if (t == XBEE_16BIT_IO) {
if (i == 4) fprintf(xbee->log," <-- sample count");
else if (i == 5) fprintf(xbee->log," <-- mask (msb)");
else if (i == 6) fprintf(xbee->log," <-- mask (lsb)");
}
xbee_logIcf();
}
}
i--; /* it went up too many times!... */
/* add the checksum */
chksum += xbee_getbyte(xbee);
/* check if the whole packet was recieved, or something else occured... unlikely... */
if (l>1) {
if (xbee->log) {
xbee_logE("Didn't get whole packet... :(");
}
continue;
}
/* check the checksum */
if ((chksum & 0xFF) != 0xFF) {
if (xbee->log) {
chksum &= 0xFF;
xbee_logE("Invalid Checksum: 0x%02X",chksum);
}
continue;
}
/* make a new packet */
p = Xcalloc(sizeof(xbee_pkt));
q = NULL;
p->datalen = 0;
/* ########################################## */
/* if: modem status */
if (t == XBEE_MODEM_STATUS) {
if (xbee->log) {
xbee_logI("Packet type: Modem Status (0x8A)");
xbee_logIc("Event: ");
switch (d[0]) {
case 0x00: fprintf(xbee->log,"Hardware reset"); break;
case 0x01: fprintf(xbee->log,"Watchdog timer reset"); break;
case 0x02: fprintf(xbee->log,"Associated"); break;
case 0x03: fprintf(xbee->log,"Disassociated"); break;
case 0x04: fprintf(xbee->log,"Synchronization lost"); break;
case 0x05: fprintf(xbee->log,"Coordinator realignment"); break;
case 0x06: fprintf(xbee->log,"Coordinator started"); break;
}
fprintf(xbee->log,"... (0x%02X)",d[0]);
xbee_logIcf();
}
p->type = xbee_modemStatus;
p->sAddr64 = FALSE;
p->dataPkt = FALSE;
p->txStatusPkt = FALSE;
p->modemStatusPkt = TRUE;
p->remoteATPkt = FALSE;
p->IOPkt = FALSE;
/* modem status can only ever give 1 'data' byte */
p->datalen = 1;
p->data[0] = d[0];
/* ########################################## */
/* if: local AT response */
} else if (t == XBEE_LOCAL_AT) {
if (xbee->log) {
xbee_logI("Packet type: Local AT Response (0x88)");
xbee_logI("FrameID: 0x%02X",d[0]);
xbee_logI("AT Command: %c%c",d[1],d[2]);
xbee_logIc("Status: ");
if (d[3] == 0x00) fprintf(xbee->log,"OK");
else if (d[3] == 0x01) fprintf(xbee->log,"Error");
else if (d[3] == 0x02) fprintf(xbee->log,"Invalid Command");
else if (d[3] == 0x03) fprintf(xbee->log,"Invalid Parameter");
fprintf(xbee->log," (0x%02X)",d[3]);
xbee_logIcf();
}
p->type = xbee_localAT;
p->sAddr64 = FALSE;
p->dataPkt = FALSE;
p->txStatusPkt = FALSE;
p->modemStatusPkt = FALSE;
p->remoteATPkt = FALSE;
p->IOPkt = FALSE;
p->frameID = d[0];
p->atCmd[0] = d[1];
p->atCmd[1] = d[2];
p->status = d[3];
/* copy in the data */
p->datalen = i-3;
for (;i>3;i--) p->data[i-4] = d[i];
/* ########################################## */
/* if: remote AT response */
} else if (t == XBEE_REMOTE_AT) {
if (xbee->log) {
xbee_logI("Packet type: Remote AT Response (0x97)");
xbee_logI("FrameID: 0x%02X",d[0]);
xbee_logIc("64-bit Address: ");
for (j=0;j<8;j++) {
fprintf(xbee->log,(j?":%02X":"%02X"),d[1+j]);
}
xbee_logIcf();
xbee_logIc("16-bit Address: ");
for (j=0;j<2;j++) {
fprintf(xbee->log,(j?":%02X":"%02X"),d[9+j]);
}
xbee_logIcf();
xbee_logI("AT Command: %c%c",d[11],d[12]);
xbee_logIc("Status: ");
if (d[13] == 0x00) fprintf(xbee->log,"OK");
else if (d[13] == 0x01) fprintf(xbee->log,"Error");
else if (d[13] == 0x02) fprintf(xbee->log,"Invalid Command");
else if (d[13] == 0x03) fprintf(xbee->log,"Invalid Parameter");
else if (d[13] == 0x04) fprintf(xbee->log,"No Response");
fprintf(xbee->log," (0x%02X)",d[13]);
xbee_logIcf();
}
p->type = xbee_remoteAT;
p->sAddr64 = FALSE;
p->dataPkt = FALSE;
p->txStatusPkt = FALSE;
p->modemStatusPkt = FALSE;
p->remoteATPkt = TRUE;
p->IOPkt = FALSE;
p->frameID = d[0];
p->Addr64[0] = d[1];
p->Addr64[1] = d[2];
p->Addr64[2] = d[3];
p->Addr64[3] = d[4];
p->Addr64[4] = d[5];
p->Addr64[5] = d[6];
p->Addr64[6] = d[7];
p->Addr64[7] = d[8];
p->Addr16[0] = d[9];
p->Addr16[1] = d[10];
p->atCmd[0] = d[11];
p->atCmd[1] = d[12];
p->status = d[13];
p->samples = 1;
if (p->status == 0x00 && p->atCmd[0] == 'I' && p->atCmd[1] == 'S') {
/* parse the io data */
xbee_logI("--- Sample -----------------");
xbee_parse_io(xbee, p, d, 15, 17, 0);
xbee_logI("----------------------------");
} else {
/* copy in the data */
p->datalen = i-13;
for (;i>13;i--) p->data[i-14] = d[i];
}
/* ########################################## */
/* if: TX status */
} else if (t == XBEE_TX_STATUS) {
if (xbee->log) {
xbee_logI("Packet type: TX Status Report (0x89)");
xbee_logI("FrameID: 0x%02X",d[0]);
xbee_logIc("Status: ");
if (d[1] == 0x00) fprintf(xbee->log,"Success");
else if (d[1] == 0x01) fprintf(xbee->log,"No ACK");
else if (d[1] == 0x02) fprintf(xbee->log,"CCA Failure");
else if (d[1] == 0x03) fprintf(xbee->log,"Purged");
fprintf(xbee->log," (0x%02X)",d[1]);
xbee_logIcf();
}
p->type = xbee_txStatus;
p->sAddr64 = FALSE;
p->dataPkt = FALSE;
p->txStatusPkt = TRUE;
p->modemStatusPkt = FALSE;
p->remoteATPkt = FALSE;
p->IOPkt = FALSE;
p->frameID = d[0];
p->status = d[1];
/* never returns data */
p->datalen = 0;
/* check for any connections waiting for a status update */
/* lock the connection mutex */
xbee_mutex_lock(xbee->conmutex);
xbee_logI("Looking for a connection that wants a status update...");
con = xbee->conlist;
while (con) {
if ((con->frameID == p->frameID) &&
(con->ACKstatus == 0xFF)) {
xbee_logI("Found @ 0x%08X!",con);
con->ACKstatus = p->status;
xbee_sem_post(con->waitforACKsem);
}
con = con->next;
}
/* unlock the connection mutex */
xbee_mutex_unlock(xbee->conmutex);
/* ########################################## */
/* if: 16 / 64bit data recieve */
} else if ((t == XBEE_64BIT_DATARX) ||
(t == XBEE_16BIT_DATARX)) {
int offset;
if (t == XBEE_64BIT_DATARX) { /* 64bit */
offset = 8;
} else { /* 16bit */
offset = 2;
}
if (xbee->log) {
xbee_logI("Packet type: %d-bit RX Data (0x%02X)",((t == XBEE_64BIT_DATARX)?64:16),t);
xbee_logIc("%d-bit Address: ",((t == XBEE_64BIT_DATARX)?64:16));
for (j=0;j<offset;j++) {
fprintf(xbee->log,(j?":%02X":"%02X"),d[j]);
}
xbee_logIcf();
xbee_logI("RSSI: -%ddB",d[offset]);
if (d[offset + 1] & 0x02) xbee_logI("Options: Address Broadcast");
if (d[offset + 1] & 0x04) xbee_logI("Options: PAN Broadcast");
}
p->isBroadcastADR = !!(d[offset+1] & 0x02);
p->isBroadcastPAN = !!(d[offset+1] & 0x04);
p->dataPkt = TRUE;
p->txStatusPkt = FALSE;
p->modemStatusPkt = FALSE;
p->remoteATPkt = FALSE;
p->IOPkt = FALSE;
if (t == XBEE_64BIT_DATARX) { /* 64bit */
p->type = xbee_64bitData;
p->sAddr64 = TRUE;
p->Addr64[0] = d[0];
p->Addr64[1] = d[1];
p->Addr64[2] = d[2];
p->Addr64[3] = d[3];
p->Addr64[4] = d[4];
p->Addr64[5] = d[5];
p->Addr64[6] = d[6];
p->Addr64[7] = d[7];
} else { /* 16bit */
p->type = xbee_16bitData;
p->sAddr64 = FALSE;
p->Addr16[0] = d[0];
p->Addr16[1] = d[1];
}
/* save the RSSI / signal strength
this can be used with printf as:
printf("-%ddB\n",p->RSSI); */
p->RSSI = d[offset];
p->status = d[offset + 1];
/* copy in the data */
p->datalen = i-(offset + 1);
for (;i>offset + 1;i--) p->data[i-(offset + 2)] = d[i];
/* ########################################## */
/* if: 16 / 64bit I/O recieve */
} else if ((t == XBEE_64BIT_IO) ||
(t == XBEE_16BIT_IO)) {
int offset,i2;
if (t == XBEE_64BIT_IO) { /* 64bit */
p->type = xbee_64bitIO;
p->sAddr64 = TRUE;
p->Addr64[0] = d[0];
p->Addr64[1] = d[1];
p->Addr64[2] = d[2];
p->Addr64[3] = d[3];
p->Addr64[4] = d[4];
p->Addr64[5] = d[5];
p->Addr64[6] = d[6];
p->Addr64[7] = d[7];
offset = 8;
p->samples = d[10];
} else { /* 16bit */
p->type = xbee_16bitIO;
p->sAddr64 = FALSE;
p->Addr16[0] = d[0];
p->Addr16[1] = d[1];
offset = 2;
p->samples = d[4];
}
if (p->samples > 1) {
p = Xrealloc(p, sizeof(xbee_pkt) + (sizeof(xbee_sample) * (p->samples - 1)));
}
if (xbee->log) {
xbee_logI("Packet type: %d-bit RX I/O Data (0x%02X)",((t == XBEE_64BIT_IO)?64:16),t);
xbee_logIc("%d-bit Address: ",((t == XBEE_64BIT_IO)?64:16));
for (j = 0; j < offset; j++) {
fprintf(xbee->log,(j?":%02X":"%02X"),d[j]);
}
xbee_logIcf();
xbee_logI("RSSI: -%ddB",d[offset]);
xbee_logI("Samples: %d",d[offset + 2]);
}
i2 = offset + 5;
/* never returns data */
p->datalen = 0;
p->dataPkt = FALSE;
p->txStatusPkt = FALSE;
p->modemStatusPkt = FALSE;
p->remoteATPkt = FALSE;
p->IOPkt = TRUE;
/* save the RSSI / signal strength
this can be used with printf as:
printf("-%ddB\n",p->RSSI); */
p->RSSI = d[offset];
p->status = d[offset + 1];
/* each sample is split into its own packet here, for simplicity */
for (o = 0; o < p->samples; o++) {
if (i2 >= i) {
xbee_logI("Invalid I/O data! Actually contained %d samples...",o);
p = Xrealloc(p, sizeof(xbee_pkt) + (sizeof(xbee_sample) * ((o>1)?o:1)));
p->samples = o;
break;
}
xbee_logI("--- Sample %3d -------------", o);
/* parse the io data */
i2 = xbee_parse_io(xbee, p, d, offset + 3, i2, o);
}
xbee_logI("----------------------------");
/* ########################################## */
/* if: Series 2 Transmit status */
} else if (t == XBEE2_TX_STATUS) {
if (xbee->log) {
xbee_logI("Packet type: Series 2 Transmit Status (0x%02X)", t);
xbee_logI("FrameID: 0x%02X",d[0]);
xbee_logI("16-bit Delivery Address: %02X:%02X",d[1],d[2]);
xbee_logI("Transmit Retry Count: %02X",d[3]);
xbee_logIc("Delivery Status: ");
if (d[4] == 0x00) fprintf(xbee->log,"Success");
else if (d[4] == 0x02) fprintf(xbee->log,"CCA Failure");
else if (d[4] == 0x15) fprintf(xbee->log,"Invalid Destination");
else if (d[4] == 0x21) fprintf(xbee->log,"Network ACK Failure");
else if (d[4] == 0x22) fprintf(xbee->log,"Not Joined to Network");
else if (d[4] == 0x23) fprintf(xbee->log,"Self-Addressed");
else if (d[4] == 0x24) fprintf(xbee->log,"Address Not Found");
else if (d[4] == 0x25) fprintf(xbee->log,"Route Not Found");
else if (d[4] == 0x74) fprintf(xbee->log,"Data Payload Too Large"); /* ??? */
fprintf(xbee->log," (0x%02X)",d[4]);
xbee_logIcf();
xbee_logIc("Discovery Status: ");
if (d[5] == 0x00) fprintf(xbee->log,"No Discovery Overhead");
else if (d[5] == 0x01) fprintf(xbee->log,"Address Discovery");
else if (d[5] == 0x02) fprintf(xbee->log,"Route Discovery");
else if (d[5] == 0x03) fprintf(xbee->log,"Address & Route Discovery");
fprintf(xbee->log," (0x%02X)",d[5]);
xbee_logIcf();
}
p->type = xbee2_txStatus;
p->sAddr64 = FALSE;
p->dataPkt = FALSE;
p->txStatusPkt = TRUE;
p->modemStatusPkt = FALSE;
p->remoteATPkt = FALSE;
p->IOPkt = FALSE;
p->frameID = d[0];
p->status = d[4];
/* never returns data */
p->datalen = 0;
/* ########################################## */
/* if: Series 2 data recieve */
} else if (t == XBEE2_DATARX) {
int offset;
offset = 10;
if (xbee->log) {
xbee_logI("Packet type: Series 2 Data Rx (0x%02X)", t);
xbee_logIc("64-bit Address: ");
for (j=0;j<8;j++) {
fprintf(xbee->log,(j?":%02X":"%02X"),d[j]);
}
xbee_logIcf();
xbee_logIc("16-bit Address: ");
for (j=0;j<2;j++) {
fprintf(xbee->log,(j?":%02X":"%02X"),d[j+8]);
}
xbee_logIcf();
if (d[offset] & 0x01) xbee_logI("Options: Packet Acknowledged");
if (d[offset] & 0x02) xbee_logI("Options: Packet was a broadcast packet");
if (d[offset] & 0x20) xbee_logI("Options: Packet Encrypted"); /* ??? */
if (d[offset] & 0x40) xbee_logI("Options: Packet from end device"); /* ??? */
}
p->dataPkt = TRUE;
p->txStatusPkt = FALSE;
p->modemStatusPkt = FALSE;
p->remoteATPkt = FALSE;
p->IOPkt = FALSE;
p->type = xbee2_data;
p->sAddr64 = TRUE;
p->Addr64[0] = d[0];
p->Addr64[1] = d[1];
p->Addr64[2] = d[2];
p->Addr64[3] = d[3];
p->Addr64[4] = d[4];
p->Addr64[5] = d[5];
p->Addr64[6] = d[6];
p->Addr64[7] = d[7];
p->Addr16[0] = d[8];
p->Addr16[1] = d[9];
p->status = d[offset];
/* copy in the data */
p->datalen = i - (offset + 1);
for (;i>offset;i--) {
p->data[i-(offset + 1)] = d[i];
}
/* ########################################## */
/* if: Unknown */
} else {
xbee_logE("Packet type: Unknown (0x%02X)",t);
continue;
}
p->next = NULL;
/* lock the connection mutex */
xbee_mutex_lock(xbee->conmutex);
hasCon = 0;
if (p->isBroadcastADR || p->isBroadcastPAN) {
unsigned char t[8] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
/* if the packet was broadcast, search for a broadcast accepting connection */
con = xbee->conlist;
while (con) {
if (con->type == p->type &&
(con->type == xbee_16bitData || con->type == xbee_64bitData) &&
((con->tAddr64 && !memcmp(con->tAddr,t,8)) ||
(!con->tAddr64 && !memcmp(con->tAddr,t,2)))) {
hasCon = 1;
xbee_logI("Found broadcasting connection @ 0x%08X",con);
break;
}
con = con->next;
}
}
if (!hasCon || !con) {
con = xbee->conlist;
while (con) {
if (xbee_matchpktcon(xbee, p, con)) {
hasCon = 1;
break;
}
con = con->next;
}
}
/* unlock the connection mutex */
xbee_mutex_unlock(xbee->conmutex);
/* if the packet doesn't have a connection, don't add it! */
if (!hasCon) {
xbee_logE("Connectionless packet... discarding!");
continue;
}
/* if the connection has a callback function then it is passed the packet
and the packet is not added to the list */
if (con && con->callback) {
t_callback_list *l, *q;
xbee_mutex_lock(con->callbackListmutex);
l = con->callbackList;
q = NULL;
while (l) {
q = l;
l = l->next;
}
l = Xcalloc(sizeof(t_callback_list));
l->pkt = p;
if (!con->callbackList || q == NULL) {
con->callbackList = l;
} else {
q->next = l;
}
xbee_mutex_unlock(con->callbackListmutex);
xbee_logI("Using callback function!");
xbee_logI(" info block @ 0x%08X",l);
xbee_logI(" function @ 0x%08X",con->callback);
xbee_logI(" connection @ 0x%08X",con);
xbee_logE(" packet @ 0x%08X",p);
/* if the callback thread not still running, then start a new one! */
if (!xbee_mutex_trylock(con->callbackmutex)) {
xbee_thread_t t;
int ret;
t_threadList *p, *q;
t_CBinfo info;
info.xbee = xbee;
info.con = con;
xbee_log("Starting new callback thread!");
if ((ret = xbee_thread_create(t,xbee_callbackWrapper,&info)) != 0) {
xbee_mutex_unlock(con->callbackmutex);
/* this MAY help with future attempts... */
xbee_sem_post(xbee->threadsem);
xbee_logS("An error occured while starting thread (%d)... Out of resources?", ret);
xbee_logE("This packet has been lost!");
continue;
}
xbee_log("Started thread 0x%08X!", t);
xbee_mutex_lock(xbee->threadmutex);
p = xbee->threadList;
q = NULL;
while (p) {
q = p;
p = p->next;
}
p = Xcalloc(sizeof(t_threadList));
if (q == NULL) {
xbee->threadList = p;
} else {
q->next = p;
}
p->thread = t;
p->next = NULL;
xbee_mutex_unlock(xbee->threadmutex);
} else {
xbee_logE("Using existing callback thread... callback has been scheduled.");
}
/* prevent the packet from being free'd */
p = NULL;
continue;
}
/* lock the packet mutex, so we can safely add the packet to the list */
xbee_mutex_lock(xbee->pktmutex);
/* if: the list is empty */
if (!xbee->pktlist) {
/* start the list! */
xbee->pktlist = p;
} else if (xbee->pktlast) {
/* add the packet to the end */
xbee->pktlast->next = p;
} else {
/* pktlast wasnt set... look for the end and then set it */
i = 0;
q = xbee->pktlist;
while (q->next) {
q = q->next;
i++;
}
q->next = p;
xbee->pktcount = i;
}
xbee->pktlast = p;
xbee->pktcount++;
/* unlock the packet mutex */
xbee_mutex_unlock(xbee->pktmutex);
xbee_logI("--========================--");
xbee_logE("Packets: %d",xbee->pktcount);
p = q = NULL;
}
return 0;
}
static void xbee_callbackWrapper(t_CBinfo *info) {
xbee_hnd xbee;
xbee_con *con;
xbee_pkt *pkt;
t_callback_list *temp;
xbee = info->xbee;
con = info->con;
/* dont forget! the callback mutex is already locked... by the parent thread :) */
xbee_mutex_lock(con->callbackListmutex);
while (con->callbackList) {
/* shift the list along 1 */
temp = con->callbackList;
con->callbackList = temp->next;
xbee_mutex_unlock(con->callbackListmutex);
/* get the packet */
pkt = temp->pkt;
xbee_logS("Starting callback function...");
xbee_logI(" info block @ 0x%08X",temp);
xbee_logI(" function @ 0x%08X",con->callback);
xbee_logI(" connection @ 0x%08X",con);
xbee_logE(" packet @ 0x%08X",pkt);
Xfree(temp);
if (con->callback) {
con->callback(con,pkt);
xbee_log("Callback complete!");
if (!con->noFreeAfterCB) Xfree(pkt);
} else {
xbee_pkt *q;
int i;
xbee_log("Callback function was removed! Appending packet to main list...");
/* lock the packet mutex, so we can safely add the packet to the list */
xbee_mutex_lock(xbee->pktmutex);
/* if: the list is empty */
if (!xbee->pktlist) {
/* start the list! */
xbee->pktlist = pkt;
} else if (xbee->pktlast) {
/* add the packet to the end */
xbee->pktlast->next = pkt;
} else {
/* pktlast wasnt set... look for the end and then set it */
i = 0;
q = xbee->pktlist;
while (q->next) {
q = q->next;
i++;
}
q->next = pkt;
xbee->pktcount = i;
}
xbee->pktlast = pkt;
xbee->pktcount++;
/* unlock the packet mutex */
xbee_mutex_unlock(xbee->pktmutex);
}
xbee_mutex_lock(con->callbackListmutex);
}
xbee_mutex_unlock(con->callbackListmutex);
xbee_log("Callback thread ending...");
/* releasing the thread mutex is the last thing we do! */
xbee_mutex_unlock(con->callbackmutex);
if (con->destroySelf) {
_xbee_endcon2(xbee,&con,1);
}
xbee_sem_post(xbee->threadsem);
}
/* #################################################################
xbee_thread_watch - INTERNAL
watches for dead threads and tidies up */
static void xbee_thread_watch(xbee_hnd xbee) {
#ifdef _WIN32 /* ---- */
/* win32 requires this delay... no idea why */
usleep(1000000);
#endif /* ----------- */
xbee_mutex_init(xbee->threadmutex);
xbee_sem_init(xbee->threadsem);
while (xbee->run) {
t_threadList *p, *q, *t;
xbee_mutex_lock(xbee->threadmutex);
p = xbee->threadList;
q = NULL;
while (p) {
t = p;
p = p->next;
if (!(xbee_thread_tryjoin(t->thread))) {
xbee_log("Joined with thread 0x%08X...",t->thread);
if (t == xbee->threadList) {
xbee->threadList = t->next;
} else if (q) {
q->next = t->next;
}
free(t);
} else {
q = t;
}
}
xbee_mutex_unlock(xbee->threadmutex);
xbee_sem_wait(xbee->threadsem);
usleep(100000); /* 100ms to allow the thread to end before we try to join */
}
xbee_mutex_destroy(xbee->threadmutex);
xbee_sem_destroy(xbee->threadsem);
}
/* #################################################################
xbee_getbyte - INTERNAL
waits for an escaped byte of data */
static unsigned char xbee_getbyte(xbee_hnd xbee) {
unsigned char c;
/* take a byte */
c = xbee_getrawbyte(xbee);
/* if its escaped, take another and un-escape */
if (c == 0x7D) c = xbee_getrawbyte(xbee) ^ 0x20;
return (c & 0xFF);
}
/* #################################################################
xbee_getrawbyte - INTERNAL
waits for a raw byte of data */
static unsigned char xbee_getrawbyte(xbee_hnd xbee) {
int ret;
unsigned char c = 0x00;
/* the loop is just incase there actually isnt a byte there to be read... */
do {
/* wait for a read to be possible */
if ((ret = xbee_select(xbee,NULL)) == -1) {
xbee_perror("libxbee:xbee_getrawbyte()");
exit(1);
}
if (!xbee->run) break;
if (ret == 0) continue;
/* read 1 character */
if (xbee_read(xbee,&c,1) == 0) {
/* for some reason no characters were read... */
if (xbee_ferror(xbee) || xbee_feof(xbee)) {
xbee_log("Error or EOF detected");
fprintf(stderr,"libxbee:xbee_read(): Error or EOF detected\n");
exit(1); /* this should have something nicer... */
}
/* no error... try again */
usleep(10);
continue;
}
} while (0);
return (c & 0xFF);
}
/* #################################################################
_xbee_send_pkt - INTERNAL
sends a complete packet of data */
static int _xbee_send_pkt(xbee_hnd xbee, t_data *pkt, xbee_con *con) {
int retval = 0;
/* lock connection mutex */
xbee_mutex_lock(con->Txmutex);
/* lock the send mutex */
xbee_mutex_lock(xbee->sendmutex);
/* write and flush the data */
xbee_write(xbee,pkt->data,pkt->length);
/* unlock the mutex */
xbee_mutex_unlock(xbee->sendmutex);
xbee_logSf();
if (xbee->log) {
int i,x,y;
/* prints packet in hex byte-by-byte */
xbee_logIc("TX Packet:");
for (i=0,x=0,y=0;i<pkt->length;i++,x--) {
if (x == 0) {
fprintf(xbee->log,"\n 0x%04X | ",y);
x = 0x8;
y += x;
}
if (x == 4) {
fprintf(xbee->log," ");
}
fprintf(xbee->log,"0x%02X ",pkt->data[i]);
}
xbee_logIcf();
}
xbee_logEf();
if (con->waitforACK &&
((con->type == xbee_16bitData) ||
(con->type == xbee_64bitData))) {
con->ACKstatus = 0xFF; /* waiting */
xbee_log("Waiting for ACK/NAK response...");
xbee_sem_wait1sec(con->waitforACKsem);
switch (con->ACKstatus) {
case 0: xbee_log("ACK recieved!"); break;
case 1: xbee_log("NAK recieved..."); break;
case 2: xbee_log("CCA failure..."); break;
case 3: xbee_log("Purged..."); break;
case 255: default: xbee_log("Timeout...");
}
if (con->ACKstatus) retval = 1; /* error */
}
/* unlock connection mutex */
xbee_mutex_unlock(con->Txmutex);
/* free the packet */
Xfree(pkt);
return retval;
}
/* #################################################################
xbee_make_pkt - INTERNAL
adds delimiter field
calculates length and checksum
escapes bytes */
static t_data *xbee_make_pkt(xbee_hnd xbee, unsigned char *data, int length) {
t_data *pkt;
unsigned int l, i, o, t, x, m;
char d = 0;
/* check the data given isnt too long
100 bytes maximum payload + 12 bytes header information */
if (length > 100 + 12) return NULL;
/* calculate the length of the whole packet
start, length (MSB), length (LSB), DATA, checksum */
l = 3 + length + 1;
/* prepare memory */
pkt = Xcalloc(sizeof(t_data));
/* put start byte on */
pkt->data[0] = 0x7E;
/* copy data into packet */
for (t = 0, i = 0, o = 1, m = 1; i <= length; o++, m++) {
/* if: its time for the checksum */
if (i == length) d = M8((0xFF - M8(t)));
/* if: its time for the high length byte */
else if (m == 1) d = M8(length >> 8);
/* if: its time for the low length byte */
else if (m == 2) d = M8(length);
/* if: its time for the normal data */
else if (m > 2) d = data[i];
x = 0;
/* check for any escapes needed */
if ((d == 0x11) || /* XON */
(d == 0x13) || /* XOFF */
(d == 0x7D) || /* Escape */
(d == 0x7E)) { /* Frame Delimiter */
l++;
pkt->data[o++] = 0x7D;
x = 1;
}
/* move data in */
pkt->data[o] = ((!x)?d:d^0x20);
if (m > 2) {
i++;
t += d;
}
}
/* remember the length */
pkt->length = l;
return pkt;
}