int main (int argc, char *argv[])
{
char buffer[128];
char buffer2[128];
int v,cnt,i,corrupt;
if (argc != 3) {
printf ("Usage: server port\n");
exit (1);
}
v=slipstream_open(argv[1],atoi(argv[2]),NONBLOCKING);
printf( "Connecting to server: %s on port %d\n",argv[1], atoi(argv[2]));
cnt=0;
while (1) {
sprintf (buffer, "This is a sample slip string: Count %d\n", cnt);
v=slipstream_send(buffer,strlen(buffer)+1);
cnt++;
if (v == 0) printf( "Error sending\n" );
else printf( "Sent: %s",buffer );
// Spin on reply message. If you continue to send messages without a reply, the message will
// queue up on the SLIPstream-server and become out of sync
do {
v=slipstream_receive( buffer2 );
corrupt=0;
if (v > 0) {
printf ("Got: ");
for (i = 0; i < v; i++)
{
if(i<v && buffer[i]!=buffer2[i] ) corrupt=1;
printf ("%c", buffer2[i]);
}
}
if(corrupt==1) printf( "Packet Corrupt\n" );
} while(v<=0);
// Pause for 1 second
//sleep (1);
}
}
int main (int argc, char *argv[])
{
char buffer[128];
int v, cnt, i, size, socket, state;
uint32_t target_mac;
PKT_T my_pkt;
time_t ts;
if (argc < 5) {
printf ("Usage: server port mac-addr state [-v]\n");
printf (" mac-addr: mac address in hex (0xff is broadcast)\n");
printf (" state: 0 for off, 1 for wakeup, 2 for sleep\n");
printf (" Example: ./node-sleep localhost 5000 0x1 1\n");
exit (1);
}
state = 0;
verbose=0;
if(argc==6)
{
if(strcmp(argv[5],"-v")==0) { printf( "Verbose on\n" ); verbose=1; }
}
//target_mac=atoi(argv[3]);
sscanf( argv[3],"%x",&target_mac );
state=atoi(argv[4]);
v = slipstream_open (argv[1], atoi (argv[2]), BLOCKING);
//v = send_ping ();
if(verbose) printf ("Sending an sleep command [mac=0x%x socket %d, state %d]\n",target_mac,socket,state);
// Enable outlet 0 on node 0x01
node_sleep (target_mac, state);
}
int main (int argc, char *argv[])
{
FILE *fp;
uint8_t tx_buf[128];
uint8_t rx_buf[128];
TRANSDUCER_PKT_T tran_pkt;
TRANSDUCER_MSG_T tran_msg;
int32_t v,cnt,i,len,j;
uint8_t nav_time_secs, reply_time_secs;
int32_t tmp;
time_t reply_timeout,nav_timeout,t;
uint8_t cmd,error;
char buf[1024];
char mbuf[128];
uint8_t num_msgs,p2p_mode,echo;
FF_POWER_ACTUATE_PKT ff_pwr_actuate[10];
uint8_t ff_pwr_actuate_mac[10];
uint8_t ff_pwr_actuate_ack[10];
debug_txt_flag=0;
p2p_mode=0;
if (argc < 6 ) {
printf ("Usage: server port num-msgs [mac-addr socket state] [-m or p]\n");
printf (" ex: %s localhost 5000 1 0x000000f0 1 on\n",argv[0]);
printf (" mac-addr MAC address of node to actuate\n");
printf (" socket 0 or 1\n");
printf (" state on or off\n");
printf (" -d debug mode\n");
printf (" -m multi-cast\n");
printf (" -p P2P packet mode\n");
exit (1);
}
for(i=0; i<argc; i++ )
{
// Grab dash command line options
if(strstr(argv[i],"-d")!=NULL )
debug_txt_flag=1;
if(strcmp(argv[i],"-p")==0)
p2p_mode=1;
if(strcmp(argv[i],"-m")==0)
p2p_mode=0;
}
sscanf( argv[3],"%d",&tmp);
num_msgs=tmp;
if(p2p_mode==1 && num_msgs!=1 )
{
printf( "Error: Can't send multi-cast p2p message\n" );
return -1;
}
if(num_msgs>9 ) { printf( "Sorry, too many messages...\n" ); return 0; }
if(debug_txt_flag==1)
printf( "Composing %d actuation msgs\n", num_msgs );
for(i=0; i<num_msgs; i++ )
{
sscanf( argv[(i*3)+4],"%x",&tmp );
subnet_3=(tmp&0xff000000) >> 24;
subnet_2=(tmp&0xff0000) >> 16;
subnet_1=(tmp&0xff00) >> 8;
ff_pwr_actuate_mac[i]=(tmp & 0xff);
ff_pwr_actuate_ack[i]=0;
if(debug_txt_flag==1) printf( "MAC_ADDR: 0x%x ",ff_pwr_actuate_mac[i]);
sscanf( argv[(i*3)+5],"%d",&tmp );
if(debug_txt_flag==1)
printf( " socket 0 " );
ff_pwr_actuate[i].socket0_state=SOCKET_HOLD;
ff_pwr_actuate[i].socket1_state=SOCKET_HOLD;
if( strstr(argv[(i*3)+6],"on")!=NULL )
{
if(tmp==0) ff_pwr_actuate[i].socket0_state=SOCKET_ON;
else ff_pwr_actuate[i].socket1_state=SOCKET_ON;
}
else
{
if(tmp==0) ff_pwr_actuate[i].socket0_state=SOCKET_OFF;
else ff_pwr_actuate[i].socket1_state=SOCKET_OFF;
}
if(debug_txt_flag==1)
{
printf( "Socket MAC %d\n",ff_pwr_actuate_mac[i] );
printf( " Socket 0: %d\n",ff_pwr_actuate[i].socket0_state );
printf( " Socket 1: %d\n",ff_pwr_actuate[i].socket1_state );
}
}
v=slipstream_open(argv[1],atoi(argv[2]),NONBLOCKING);
nav_time_secs=25;
cnt = 0;
while (1) {
error=0;
cmd=0;
retry:
// Setup the packet to send out to the network
if(!p2p_mode)
{
// These values setup the internal data structure and probably don't
// need to be changed
ds_pkt.payload_len=0;
ds_pkt.buf=tx_buf;
ds_pkt.buf_len=DS_PAYLOAD_START;
ds_pkt.payload_start=DS_PAYLOAD_START;
ds_pkt.payload=&(tx_buf[DS_PAYLOAD_START]);
// These are parameters that can be adjusted for different packets
//ds_pkt.pkt_type=PING_PKT;
ds_pkt.pkt_type=TRANSDUCER_PKT;
ds_pkt.ctrl_flags= DS_MASK | DEBUG_FLAG | ENCRYPT;
//srand(time(NULL));
//ds_pkt.seq_num=rand()%255; // Use the gateway's spiffy auto-cnt when set to 0
ds_pkt.seq_num=0; // Use the gateway's spiffy auto-cnt when set to 0
if(debug_txt_flag==1)
printf( "rand seq-num=%d\n",ds_pkt.seq_num );
ds_pkt.priority=0;
ds_pkt.ack_retry=10;
ds_pkt.subnet_mac[0]=subnet_1;
ds_pkt.subnet_mac[1]=subnet_2;
ds_pkt.subnet_mac[2]=subnet_3;
ds_pkt.hop_cnt=0; // Starting depth, always keep at 0
ds_pkt.hop_max=5; // Max tree depth
ds_pkt.delay_per_level=0; // Reply delay per level in seconds
ds_pkt.nav=0; // Time in seconds until next message to be sent
ds_pkt.mac_check_rate=100; // B-mac check rate in ms
ds_pkt.rssi_threshold=-45; // Reply RSSI threshold
ds_pkt.last_hop_mac=0;
ds_pkt.mac_filter_num=0; // Increase if MAC_FILTER is active
ds_pkt.aes_ctr[0]=0; // Encryption AES counter
ds_pkt.aes_ctr[1]=0;
ds_pkt.aes_ctr[2]=0;
ds_pkt.aes_ctr[3]=0;
} else
{
// These values setup the internal data structure and probably don't
// need to be changed
p2p_pkt.payload_len=0;
p2p_pkt.buf=tx_buf;
p2p_pkt.buf_len=P2P_PAYLOAD_START;
p2p_pkt.payload_start=P2P_PAYLOAD_START;
p2p_pkt.payload=&(tx_buf[P2P_PAYLOAD_START]);
// These are parameters that can be adjusted for different packets
//p2p_pkt.pkt_type=PING_PKT;
p2p_pkt.pkt_type=TRANSDUCER_PKT;
p2p_pkt.ctrl_flags= MOBILE_MASK | LINK_ACK | DEBUG_FLAG | ENCRYPT;
p2p_pkt.seq_num=0; // Use the gateway's spiffy auto-cnt when set to 0
//p2p_pkt.seq_num=rand()%255; // Use the gateway's spiffy auto-cnt when set to 0
if(debug_txt_flag==1)
printf( "rand seq-num=%d\n",p2p_pkt.seq_num );
p2p_pkt.priority=0;
p2p_pkt.hop_cnt=0;
p2p_pkt.ttl=5;
p2p_pkt.ack_retry=10;
p2p_pkt.src_subnet_mac[0]=0;
p2p_pkt.src_subnet_mac[1]=0;
p2p_pkt.src_subnet_mac[2]=0;
p2p_pkt.src_mac=0;
p2p_pkt.last_hop_mac=0;
p2p_pkt.next_hop_mac=BROADCAST;
p2p_pkt.dst_subnet_mac[0] = subnet_1;
p2p_pkt.dst_subnet_mac[1] = subnet_2;
p2p_pkt.dst_subnet_mac[2] = subnet_3;
p2p_pkt.dst_mac = ff_pwr_actuate_mac[0];
p2p_pkt.check_rate=100; // B-mac check rate in ms
}
// At the top level you have a SAMPL packet (ds_pkt)
// For transducers, this holds a single transducer pkt (tran_pkt)
// Each transducer packet contains multiple transducer messages (tran_msg)
// Transducers typically have helper functions used to pack the transducer messages.
// Setup Transducer Packet
tran_pkt.num_msgs=0;
tran_pkt.checksum=0;
tran_pkt.msgs_payload=buf;
for(i=0; i<num_msgs; i++ )
{
// Setup Transducer Message
tran_msg.mac_addr = ff_pwr_actuate_mac[i];
tran_msg.type = TRAN_POWER_PKT;
tran_msg.len = 0;
tran_msg.payload = mbuf;
// Pack application specifc message into transducer message
tran_msg.len=ff_power_actuate_pack(mbuf, &(ff_pwr_actuate[i]));
// Add the transducer message to the transducer packet
len=transducer_msg_add( &tran_pkt, &tran_msg);
// printf( "payload = " );
// for(j=0; j<len; j++ )
// printf( "%d ",ds_pkt.payload[j] );
// printf( "\n" );
}
if(!p2p_mode)
{
// Add the packet to the payload
ds_pkt.payload_len = transducer_pkt_pack(&tran_pkt, ds_pkt.payload);
// This takes the structure and packs it into the raw
// array that is sent using SLIP
pack_downstream_packet( &ds_pkt);
// Add MAC filter entries below
// downstream_packet_add_mac_filter( &ds_pkt, 0x07 );
// downstream_packet_add_mac_filter( &ds_pkt, 3 );
// downstream_packet_add_mac_filter( &ds_pkt, 4 );
// downstream_packet_add_mac_filter( &ds_pkt, 5 );
// Print your packet on the screen
if(debug_txt_flag==1)
print_ds_packet(&ds_pkt );
if(error==0)
v=slipstream_send(ds_pkt.buf,ds_pkt.buf_len);
//nav_time_secs=ds_pkt.nav;
nav_time_secs=5;
reply_time_secs=ds_pkt.delay_per_level * ds_pkt.hop_max;
}
else {
p2p_pkt.payload_len =
transducer_pkt_pack(&tran_pkt,p2p_pkt.payload);
// This takes the structure and packs it into the raw
// array that is sent using SLIP
pack_peer_2_peer_packet( &p2p_pkt);
if(error==0)
v=slipstream_send(p2p_pkt.buf,p2p_pkt.buf_len);
if(debug_txt_flag==1)
{
if (v == 0) printf( "Error sending\n" );
else printf( "Sent request %d\n",p2p_pkt.seq_num);
}
nav_time_secs=10;
reply_time_secs=10;
}
if(debug_txt_flag==1)
{
if (v == 0) printf( "Error sending\n" );
else printf( "Sent request %d\n",cnt);
}
t=time(NULL);
reply_timeout=t+reply_time_secs+1;
nav_timeout=t+nav_time_secs;
echo=0;
while (nav_timeout > time (NULL)) {
v = slipstream_receive (rx_buf);
if (v > 0) {
if (check_for_ack(rx_buf,v, ff_pwr_actuate_mac[0], p2p_pkt.seq_num)==1 ) { printf( "ACK\n" ); return 1; }
}
usleep (1000);
}
cnt++;
if(cnt>2) break;
}
printf( "NCK\n" );
return 0;
}
int main (int argc, char *argv[])
{
FILE *fp;
uint8_t tx_buf[128];
uint8_t rx_buf[128];
TRANSDUCER_PKT_T tran_pkt;
TRANSDUCER_MSG_T tran_msg;
int32_t v,cnt,i,len,j;
uint8_t nav_time_secs, reply_time_secs;
int32_t tmp;
time_t reply_timeout,nav_timeout,t;
uint8_t cmd,error;
char buf[1024];
char mbuf[128];
uint8_t num_msgs;
FF_POWER_RQST_PKT ff_pwr_rqst;
uint8_t ff_pwr_mac[10];
SAMPL_GATEWAY_PKT_T gw_pkt;
debug_txt_flag=0;
if (argc < 4 ) {
printf ("Usage: server port num-msgs [mac-addr] [-d]\n");
printf (" ex: ./jigo-ctrl localhost 5000 1 0x000000f0\n");
printf (" mac-addr MAC address of node to request read\n");
printf (" d Debug Output\n");
exit (1);
}
for(i=0; i<argc; i++ )
{
// Grab dash command line options
if(strstr(argv[i],"-d")!=NULL )
{
debug_txt_flag=1;
}
}
sscanf( argv[3],"%d", &tmp);
num_msgs=tmp;
if(num_msgs>9 ) { printf( "Sorry, too many messages...\n" ); return 0; }
if(debug_txt_flag==1)
printf( "Composing %d actuation msgs\n", num_msgs );
for(i=0; i<num_msgs; i++ )
{
sscanf( argv[i+4],"%x",&tmp );
subnet_3=(tmp&0xff000000) >> 24;
subnet_2=(tmp&0xff0000) >> 16;
subnet_1=(tmp&0xff00) >> 8;
ff_pwr_mac[i]=(tmp & 0xff);
if(debug_txt_flag==1) printf( "MAC_ADDR: 0x%x ",ff_pwr_mac[i]);
}
v=slipstream_open(argv[1],atoi(argv[2]),NONBLOCKING);
nav_time_secs=25;
cnt = 0;
while (1) {
error=0;
cmd=0;
// Setup the packet to send out to the network
// These values setup the internal data structure and probably don't
// need to be changed
ds_pkt.payload_len=0;
ds_pkt.buf=tx_buf;
ds_pkt.buf_len=DS_PAYLOAD_START;
ds_pkt.payload_start=DS_PAYLOAD_START;
ds_pkt.payload=&(tx_buf[DS_PAYLOAD_START]);
// These are parameters that can be adjusted for different packets
//ds_pkt.pkt_type=PING_PKT;
ds_pkt.pkt_type=TRANSDUCER_PKT;
ds_pkt.ctrl_flags= DS_MASK | DEBUG_FLAG | ENCRYPT;
ds_pkt.seq_num=0; // Use the gateway's spiffy auto-cnt when set to 0
ds_pkt.priority=0;
ds_pkt.ack_retry=10;
ds_pkt.subnet_mac[0]=subnet_1;
ds_pkt.subnet_mac[1]=subnet_2;
ds_pkt.subnet_mac[2]=subnet_3;
ds_pkt.hop_cnt=0; // Starting depth, always keep at 0
ds_pkt.hop_max=5; // Max tree depth
ds_pkt.delay_per_level=1; // Reply delay per level in seconds
ds_pkt.nav=0; // Time in seconds until next message to be sent
ds_pkt.mac_check_rate=100; // B-mac check rate in ms
ds_pkt.rssi_threshold=-45; // Reply RSSI threshold
ds_pkt.last_hop_mac=0;
ds_pkt.mac_filter_num=0; // Increase if MAC_FILTER is active
ds_pkt.aes_ctr[0]=0; // Encryption AES counter
ds_pkt.aes_ctr[1]=0;
ds_pkt.aes_ctr[2]=0;
ds_pkt.aes_ctr[3]=0;
// At the top level you have a SAMPL packet (ds_pkt)
// For transducers, this holds a single transducer pkt (tran_pkt)
// Each transducer packet contains multiple transducer messages (tran_msg)
// Transducers typically have helper functions used to pack the transducer messages.
// Setup Transducer Packet
tran_pkt.num_msgs=0;
tran_pkt.checksum=0;
tran_pkt.msgs_payload=buf;
ff_pwr_rqst.socket=0;
ff_pwr_rqst.pkt_type=DEBUG_PKT;
for(i=0; i<num_msgs; i++ )
{
// Setup Transducer Message
tran_msg.mac_addr = ff_pwr_mac[i];
tran_msg.type = TRAN_POWER_PKT;
tran_msg.len = 0;
tran_msg.payload = mbuf;
printf( "calling pack on mac %d\n",ff_pwr_mac[i] );
// Pack application specifc message into transducer message
tran_msg.len=ff_power_rqst_pack(mbuf, &ff_pwr_rqst);
printf( "calling add\n" );
// Add the transducer message to the transducer packet
len=transducer_msg_add( &tran_pkt, &tran_msg);
printf( "done with add payload len=%d\n",len );
// printf( "payload = " );
// for(j=0; j<len; j++ )
// printf( "%d ",ds_pkt.payload[j] );
// printf( "\n" );
}
// Add the packet to the payload
ds_pkt.payload_len = transducer_pkt_pack(&tran_pkt, ds_pkt.payload);
// This takes the structure and packs it into the raw
// array that is sent using SLIP
pack_downstream_packet( &ds_pkt);
// Add MAC filter entries below
// downstream_packet_add_mac_filter( &ds_pkt, 0x07 );
// downstream_packet_add_mac_filter( &ds_pkt, 3 );
// downstream_packet_add_mac_filter( &ds_pkt, 4 );
// downstream_packet_add_mac_filter( &ds_pkt, 5 );
// Print your packet on the screen
if(debug_txt_flag==1)
print_ds_packet(&ds_pkt );
cnt++;
for(i=0; i<ds_pkt.buf_len; i++ )
{
printf( "%02x",ds_pkt.buf[i] );
}
printf( "\n" );
if(error==0)
v=slipstream_send(ds_pkt.buf,ds_pkt.buf_len);
if(debug_txt_flag==1)
{
if (v == 0) printf( "Error sending\n" );
else printf( "Sent request %d\n",ds_pkt.seq_num);
}
//nav_time_secs=ds_pkt.nav;
nav_time_secs=5;
reply_time_secs=ds_pkt.delay_per_level * ds_pkt.hop_max+3;
t=time(NULL);
reply_timeout=t+reply_time_secs+1;
nav_timeout=t+nav_time_secs;
// Collect Reply packets
while(reply_timeout>time(NULL))
{
v=slipstream_receive( rx_buf);
if (v > 0) {
gw_pkt.buf=rx_buf;
gw_pkt.buf_len=v;
print_gw_packet_elements(&gw_pkt);
}
usleep(1000);
}
// What for NAV and service incoming messages
// This is the time window when the network is idle and can
// be used for asynchronous communications.
while(nav_timeout>time(NULL))
{
v=slipstream_receive( rx_buf);
if (v > 0) {
// Check for mobile/p2p packets
gw_pkt.buf=rx_buf;
gw_pkt.buf_len=v;
print_gw_packet_elements(&gw_pkt);
}
usleep(1000);
}
// only run once
break;
}
}
int main (int argc, char *argv[])
{
FILE *fp;
uint8_t tx_buf[128];
uint8_t rx_buf[128];
TRANSDUCER_PKT_T tran_pkt;
TRANSDUCER_MSG_T tran_msg;
int32_t v,cnt,i,len,j;
uint8_t nav_time_secs, reply_time_secs;
int32_t tmp;
time_t reply_timeout,nav_timeout,t;
uint8_t cmd,error;
char buf[1024];
char mbuf[128];
uint8_t p2p_mode, retry_flag;
uint8_t node_mac_addr;
char* lcd_msg; // Message to send to LCD
debug_txt_flag=0;
p2p_mode=1;
retry_flag=0;
if(argc < 5 || argc > 7)
{
printf("Usage: %s server port mac-addr \'message\' [-p] [-d]\n", argv[0]);
printf("Example: %s localhost 5000 0x00000001 \'Hello\\nWorld!\' -p\n", argv[0]);
printf(" mac-addr MAC address of node to display LCD message\n");
printf(" -p Use P2P packet mode\n");
printf(" -m Multi-cast\n");
printf(" -d Display debugging output\n");
printf(" -r Local Retry, don't use with slip mirror gateway\n");
printf(" -l Use Link ACK routing\n");
exit(1);
}
// Grab dash command line options
if(argc > 5)
{
for(i = 5; i < argc; i++)
{
if(strcmp(argv[i], "-p") == 0)
{
p2p_mode = 1;
printf("*P2P Mode Enabled\n");
}
if(strcmp(argv[i], "-m") == 0)
{
p2p_mode = 0;
printf("*Multi-cast Mode Enabled\n");
}
else if(strcmp(argv[i], "-d") == 0)
{
debug_txt_flag = 1;
printf("*Debug Mode Enabled\n");
}
else if(strcmp(argv[i], "-r") == 0)
{
retry_flag= 1;
printf("*Retry Enabled\n");
}
}
}
if (strlen (argv[3]) != 8 && strlen (argv[3]) != 10) {
printf ("Invalid MAC address\n");
exit(1);
}
v = sscanf (argv[3], "%x", &tmp);
if (v != 1) {
printf ("Invalid MAC address\n");
exit(1);
}
subnet_3=(tmp&0xff000000) >> 24;
subnet_2=(tmp&0xff0000) >> 16;
subnet_1=(tmp&0xff00) >> 8;
node_mac_addr = tmp & 0xff;
v = slipstream_open (argv[1], atoi (argv[2]), NONBLOCKING);
// Set pointer to message
lcd_msg = (char*)argv[4];
nav_time_secs = 25;
cnt = 0;
while (1) {
error=0;
cmd=0;
retry:
// Setup the packet to send out to the network
if(!p2p_mode)
{
// These values setup the internal data structure and probably don't
// need to be changed
ds_pkt.payload_len=0;
ds_pkt.buf=tx_buf;
ds_pkt.buf_len=DS_PAYLOAD_START;
ds_pkt.payload_start=DS_PAYLOAD_START;
ds_pkt.payload=&(tx_buf[DS_PAYLOAD_START]);
// These are parameters that can be adjusted for different packets
//ds_pkt.pkt_type=PING_PKT;
ds_pkt.pkt_type=TRANSDUCER_PKT;
ds_pkt.ctrl_flags= DS_MASK | DEBUG_FLAG | ENCRYPT;
//srand(time(NULL));
//ds_pkt.seq_num=rand()%255; // Use the gateway's spiffy auto-cnt when set to 0
ds_pkt.seq_num=0; // Use the gateway's spiffy auto-cnt when set to 0
if(debug_txt_flag==1)
printf( "rand seq-num=%d\n",ds_pkt.seq_num );
ds_pkt.priority=0;
ds_pkt.ack_retry=10;
ds_pkt.subnet_mac[0]=subnet_1;
ds_pkt.subnet_mac[1]=subnet_2;
ds_pkt.subnet_mac[2]=subnet_3;
ds_pkt.hop_cnt=0; // Starting depth, always keep at 0
ds_pkt.hop_max=7; // Max tree depth
ds_pkt.delay_per_level=0; // Reply delay per level in seconds
ds_pkt.nav=0; // Time in seconds until next message to be sent
ds_pkt.mac_check_rate=100; // B-mac check rate in ms
ds_pkt.rssi_threshold=-35; // Reply RSSI threshold
ds_pkt.last_hop_mac=0;
ds_pkt.mac_filter_num=0; // Increase if MAC_FILTER is active
ds_pkt.aes_ctr[0]=0; // Encryption AES counter
ds_pkt.aes_ctr[1]=0;
ds_pkt.aes_ctr[2]=0;
ds_pkt.aes_ctr[3]=0;
} else
{
// These values setup the internal data structure and probably don't
// need to be changed
p2p_pkt.payload_len=0;
p2p_pkt.buf=tx_buf;
p2p_pkt.buf_len=P2P_PAYLOAD_START;
p2p_pkt.payload_start=P2P_PAYLOAD_START;
p2p_pkt.payload=&(tx_buf[P2P_PAYLOAD_START]);
// These are parameters that can be adjusted for different packets
//p2p_pkt.pkt_type=PING_PKT;
p2p_pkt.pkt_type=TRANSDUCER_PKT;
// p2p_pkt.ctrl_flags= MOBILE_MASK | /*LINK_ACK |*/ DEBUG_FLAG | ENCRYPT;
p2p_pkt.ctrl_flags= MOBILE_MASK | LINK_ACK | DEBUG_FLAG | ENCRYPT;
//p2p_pkt.ctrl_flags= MOBILE_MASK | DEBUG_FLAG | ENCRYPT;
p2p_pkt.seq_num=0; // Use the gateway's spiffy auto-cnt when set to 0
//p2p_pkt.seq_num=rand()%255; // Use the gateway's spiffy auto-cnt when set to 0
if(debug_txt_flag==1)
printf( "rand seq-num=%d\n",p2p_pkt.seq_num );
p2p_pkt.priority=0;
p2p_pkt.hop_cnt=0;
p2p_pkt.ttl=7;
p2p_pkt.ack_retry=10;
p2p_pkt.src_subnet_mac[0]=0;
p2p_pkt.src_subnet_mac[1]=0;
p2p_pkt.src_subnet_mac[2]=0;
p2p_pkt.src_mac=0;
p2p_pkt.last_hop_mac=0;
p2p_pkt.next_hop_mac=BROADCAST;
p2p_pkt.dst_subnet_mac[0] = 0;
p2p_pkt.dst_subnet_mac[1] = 0;
p2p_pkt.dst_subnet_mac[2] = 0;
p2p_pkt.dst_mac = node_mac_addr;
p2p_pkt.check_rate=100; // B-mac check rate in ms
}
// At the top level you have a SAMPL packet (ds_pkt)
// For transducers, this holds a single transducer pkt (tran_pkt)
// Each transducer packet contains multiple transducer messages (tran_msg)
// Transducers typically have helper functions used to pack the transducer messages.
// Setup Transducer Packet
tran_pkt.num_msgs=0;
tran_pkt.checksum=0;
tran_pkt.msgs_payload=buf;
// Build message to send to LCD
tran_msg.mac_addr = node_mac_addr;
tran_msg.type = TRAN_LCD_MESSAGE;
tran_msg.len = strlen(lcd_msg) + 1;
for(i = 0; i < tran_msg.len; i++)
mbuf[i] = (uint8_t)lcd_msg[i];
tran_msg.payload = mbuf;
// Add the transducer message to the transducer packet
transducer_msg_add( &tran_pkt, &tran_msg);
if(!p2p_mode)
{
// Add the packet to the payload
ds_pkt.payload_len = transducer_pkt_pack(&tran_pkt, ds_pkt.payload);
// This takes the structure and packs it into the raw
// array that is sent using SLIP
pack_downstream_packet( &ds_pkt);
// Add MAC filter entries below
// downstream_packet_add_mac_filter( &ds_pkt, 0x07 );
// downstream_packet_add_mac_filter( &ds_pkt, 3 );
// downstream_packet_add_mac_filter( &ds_pkt, 4 );
// downstream_packet_add_mac_filter( &ds_pkt, 5 );
// Print your packet on the screen
if(debug_txt_flag==1)
print_ds_packet(&ds_pkt );
if(error==0)
{
v=slipstream_send(ds_pkt.buf,ds_pkt.buf_len);
for(i=0; i<100; i++ )
{
v = slipstream_receive (rx_buf);
if(v==1 && rx_buf[0]=='A' ) { printf( "Serial Good\n" ); break;}
if(v==1 && rx_buf[0]=='N') {
printf( "Serial Error 1\n" );
}
usleep(1000);
}
if(i==100) printf( "Serial Error 2\n" );
}
//nav_time_secs=ds_pkt.nav;
nav_time_secs=5;
reply_time_secs=ds_pkt.delay_per_level * ds_pkt.hop_max;
}
else {
p2p_pkt.payload_len =
transducer_pkt_pack(&tran_pkt,p2p_pkt.payload);
// This takes the structure and packs it into the raw
// array that is sent using SLIP
pack_peer_2_peer_packet( &p2p_pkt);
if(error==0)
{
if(retry_flag)
v=slipstream_acked_send(p2p_pkt.buf,p2p_pkt.buf_len,3);
else
v=slipstream_send(p2p_pkt.buf,p2p_pkt.buf_len);
}
if(debug_txt_flag==1)
{
if (v == 0) printf( "Serial Error\n" );
else printf( "Sent request %d\n",p2p_pkt.seq_num);
}
nav_time_secs=5;
reply_time_secs=5;
}
if(debug_txt_flag==1)
{
if (v == 0) printf( "Error sending\n" );
else printf( "Sent request %d\n",cnt);
}
//LCD message sent
if(v > 0)
printf("[%i] Message \'%s\' sent to node 0x%x.\n", cnt, lcd_msg, node_mac_addr);
t=time(NULL);
reply_timeout=t+reply_time_secs+1;
nav_timeout=t+nav_time_secs;
while (nav_timeout > time (NULL)) {
v = slipstream_receive (rx_buf);
if (v > 0) {
if (check_for_ack(rx_buf,v, node_mac_addr, p2p_pkt.seq_num)==1 ) { printf( "ACK\n" ); return 1; }
}
usleep (1000);
}
cnt++;
if(cnt>2) break;
}
printf( "NCK\n" );
return 0;
}
int main (int argc, char *argv[])
{
FILE *fp;
uint8_t tx_buf[128];
uint8_t rx_buf[128];
int32_t v,cnt,i,len;
uint8_t nav_time_secs, reply_time_secs,checksum;
int32_t tmp;
time_t reply_timeout,nav_timeout,t;
uint8_t cmd,error;
char buf[1024];
time_t clockt;
uint32_t epocht;
SAMPL_GATEWAY_PKT_T gw_pkt;
debug_txt_flag=0;
if (argc < 3 || argc > 4) {
printf ("Usage: server port [-d]\n");
printf (" d Debug Output\n");
exit (1);
}
if(argc==4)
{
// Grab dash command line options
if(strstr(argv[3],"d")!=NULL )
{
debug_txt_flag=1;
}
}
v=slipstream_open(argv[1],atoi(argv[2]),NONBLOCKING);
nav_time_secs=25;
cnt = 0;
while (1) {
error=0;
cmd=0;
// Setup the packet to send out to the network
// These values setup the internal data structure and probably don't
// need to be changed
ds_pkt.payload_len=0;
ds_pkt.buf=tx_buf;
ds_pkt.buf_len=DS_PAYLOAD_START;
ds_pkt.payload_start=DS_PAYLOAD_START;
ds_pkt.payload=&(tx_buf[DS_PAYLOAD_START]);
// These are parameters that can be adjusted for different packets
ds_pkt.pkt_type=CONTROL_PKT;
ds_pkt.ctrl_flags= ENCRYPT | DS_MASK | LINK_ACK | DEBUG_FLAG;
ds_pkt.seq_num=0;
ds_pkt.priority=0;
ds_pkt.ack_retry=10;
ds_pkt.subnet_mac[0]=0;
ds_pkt.subnet_mac[1]=0;
ds_pkt.subnet_mac[2]=0;
ds_pkt.hop_cnt=0; // Starting depth, always keep at 0
ds_pkt.hop_max=5; // Max tree depth
ds_pkt.delay_per_level=1; // Reply delay per level in seconds
ds_pkt.nav=30; // Time in seconds until next message to be sent
ds_pkt.mac_check_rate=100; // B-mac check rate in ms
ds_pkt.rssi_threshold=-40; // Reply RSSI threshold
ds_pkt.last_hop_mac=0;
ds_pkt.mac_filter_num=0; // Increase if MAC_FILTER is active
ds_pkt.aes_ctr[0]=0; // Encryption AES counter
ds_pkt.aes_ctr[1]=0;
ds_pkt.aes_ctr[2]=0;
ds_pkt.aes_ctr[3]=0;
clockt = time(NULL);
epocht = clockt;
ds_pkt.epoch_time[0] = epocht & 0xff; // Epoch time
ds_pkt.epoch_time[1] = (epocht>>8) & 0xff;
ds_pkt.epoch_time[2] = (epocht>>16) & 0xff;
ds_pkt.epoch_time[3] = (epocht>>24) & 0xff;
ds_pkt.payload[0]=(-40);
ds_pkt.payload[1]=0x01;
ds_pkt.payload[2]=0x1f;
ds_pkt.payload[3]=0xff;
ds_pkt.payload[4]=0x1f;
ds_pkt.payload[5]=0xff;
checksum=0;
for(i=0; i<6; i++ )
checksum+=ds_pkt.payload[i];
ds_pkt.payload[6]=checksum;
ds_pkt.payload_len=7;
// This takes the structure and packs it into the raw
// array that is sent using SLIP
pack_downstream_packet( &ds_pkt);
// Add MAC filter entries below
// downstream_packet_add_mac_filter( &ds_pkt, 2 );
// downstream_packet_add_mac_filter( &ds_pkt, 3 );
// downstream_packet_add_mac_filter( &ds_pkt, 4 );
// downstream_packet_add_mac_filter( &ds_pkt, 5 );
// Print your packet on the screen
if(debug_txt_flag==1)
print_ds_packet(&ds_pkt );
cnt++;
if(error==0)
v=slipstream_send(ds_pkt.buf,ds_pkt.buf_len);
if(debug_txt_flag==1)
{
if (v == 0) printf( "Error sending\n" );
else printf( "Sent request %d\n",ds_pkt.seq_num);
}
nav_time_secs=ds_pkt.nav;
reply_time_secs=ds_pkt.delay_per_level * ds_pkt.hop_max;
t=time(NULL);
reply_timeout=t+reply_time_secs+1;
nav_timeout=t+nav_time_secs;
// Collect Reply packets
while(reply_timeout>time(NULL))
{
v=slipstream_receive( rx_buf);
if (v > 0) {
gw_pkt.buf=rx_buf;
gw_pkt.buf_len=v;
print_gw_packet_elements(&gw_pkt);
}
usleep(1000);
}
// What for NAV and service incoming messages
// This is the time window when the network is idle and can
// be used for asynchronous communications.
while(nav_timeout>time(NULL))
{
v=slipstream_receive( rx_buf);
if (v > 0) {
// Check for mobile/p2p packets
gw_pkt.buf=rx_buf;
gw_pkt.buf_len=v;
print_gw_packet_elements(&gw_pkt);
}
usleep(1000);
}
}
}
int main (int argc, char *argv[])
{
FILE *fp;
uint8_t tx_buf[128];
uint8_t rx_buf[128];
TRANSDUCER_PKT_T tran_cmd_pkt;
TRANSDUCER_MSG_T tran_msg_pkts[10];
int32_t v,cnt,i,len;
uint8_t nav_time_secs, reply_time_secs;
int32_t tmp;
time_t reply_timeout,nav_timeout,t;
uint8_t cmd,error;
char buf[1024];
uint8_t num_msgs;
SAMPL_GATEWAY_PKT_T gw_pkt;
debug_txt_flag=0;
if (argc < 5 ) {
printf ("Usage: server port num-msgs [mac-addr socket state] [-d]\n");
printf (" ex: ./jigo-ctrl localhost 5000 1 0x000000f0 1 on\n");
printf (" mac-addr MAC address of node to actuate\n");
printf (" socket 0 or 1\n");
printf (" state on or off\n");
printf (" d Debug Output\n");
exit (1);
}
for(i=0; i<argc; i++ )
{
// Grab dash command line options
if(strstr(argv[i],"-d")!=NULL )
{
debug_txt_flag=1;
}
}
sscanf( argv[3],"%d", &num_msgs );
if(num_msgs>9 ) { printf( "Sorry, too many messages...\n" ); return 0; }
if(debug_txt_flag==1)
printf( "Composing %d actuation msgs\n", num_msgs );
for(i=0; i<num_msgs; i++ )
{
sscanf( argv[(i*2)+4],"%x",&tmp );
subnet_3=(tmp&0xff000000) >> 24;
subnet_2=(tmp&0xff0000) >> 16;
subnet_1=(tmp&0xff00) >> 8;
tran_msg_pkts[i].mac_addr=(tmp & 0xff);
if(debug_txt_flag==1) printf( "MAC_ADDR: 0x%x ",tran_msg_pkts[i].mac_addr );
sscanf( argv[(i*2)+5],"%s",buf);
tran_msg_pkts[i].key=TRAN_LED_BLINK;
tran_msg_pkts[i].value=0;
if(strstr(buf,"red")!=NULL) tran_msg_pkts[i].value|=TRAN_RED_LED_MASK;
if(strstr(buf,"green")!=NULL) tran_msg_pkts[i].value|=TRAN_GREEN_LED_MASK;
if(strstr(buf,"blue")!=NULL) tran_msg_pkts[i].value|=TRAN_BLUE_LED_MASK;
if(strstr(buf,"orange")!=NULL) tran_msg_pkts[i].value|=TRAN_ORANGE_LED_MASK;
}
v=slipstream_open(argv[1],atoi(argv[2]),NONBLOCKING);
nav_time_secs=25;
cnt = 0;
while (1) {
error=0;
cmd=0;
// Setup the packet to send out to the network
// These values setup the internal data structure and probably don't
// need to be changed
ds_pkt.payload_len=0;
ds_pkt.buf=tx_buf;
ds_pkt.buf_len=DS_PAYLOAD_START;
ds_pkt.payload_start=DS_PAYLOAD_START;
ds_pkt.payload=&(tx_buf[DS_PAYLOAD_START]);
// These are parameters that can be adjusted for different packets
//ds_pkt.pkt_type=PING_PKT;
ds_pkt.pkt_type=TRANSDUCER_CMD_PKT;
ds_pkt.ctrl_flags= DS_MASK | ENCRYPT;
ds_pkt.seq_num=0; // Use the gateway's spiffy auto-cnt when set to 0
ds_pkt.priority=0;
ds_pkt.ack_retry=10;
ds_pkt.subnet_mac[0]=subnet_1;
ds_pkt.subnet_mac[1]=subnet_2;
ds_pkt.subnet_mac[2]=subnet_3;
ds_pkt.hop_cnt=0; // Starting depth, always keep at 0
ds_pkt.hop_max=5; // Max tree depth
ds_pkt.delay_per_level=0; // Reply delay per level in seconds
ds_pkt.nav=0; // Time in seconds until next message to be sent
ds_pkt.mac_check_rate=100; // B-mac check rate in ms
ds_pkt.rssi_threshold=-45; // Reply RSSI threshold
ds_pkt.last_hop_mac=0;
ds_pkt.mac_filter_num=0; // Increase if MAC_FILTER is active
ds_pkt.aes_ctr[0]=0; // Encryption AES counter
ds_pkt.aes_ctr[1]=0;
ds_pkt.aes_ctr[2]=0;
ds_pkt.aes_ctr[3]=0;
//tran_msg_pkts[0].mac_addr=0xf0;
//tran_msg_pkts[0].key=TRAN_POWER_CTRL_SOCK_0;
//tran_msg_pkts[0].value=SOCKET_OFF;
tran_cmd_pkt.num_msgs=num_msgs;
tran_cmd_pkt.msg=tran_msg_pkts;
ds_pkt.payload_len=transducer_cmd_pkt_add( &tran_cmd_pkt, ds_pkt.payload);
transducer_cmd_pkt_checksum( &tran_cmd_pkt, ds_pkt.payload);
// This takes the structure and packs it into the raw
// array that is sent using SLIP
pack_downstream_packet( &ds_pkt);
// Add MAC filter entries below
// downstream_packet_add_mac_filter( &ds_pkt, 0x07 );
// downstream_packet_add_mac_filter( &ds_pkt, 3 );
// downstream_packet_add_mac_filter( &ds_pkt, 4 );
// downstream_packet_add_mac_filter( &ds_pkt, 5 );
// Print your packet on the screen
if(debug_txt_flag==1)
print_ds_packet(&ds_pkt );
cnt++;
for(i=0; i<ds_pkt.buf_len; i++ )
{
printf( "%02x",ds_pkt.buf[i] );
}
printf( "\n" );
if(error==0)
v=slipstream_send(ds_pkt.buf,ds_pkt.buf_len);
if(debug_txt_flag==1)
{
if (v == 0) printf( "Error sending\n" );
else printf( "Sent request %d\n",ds_pkt.seq_num);
}
//nav_time_secs=ds_pkt.nav;
nav_time_secs=5;
reply_time_secs=ds_pkt.delay_per_level * ds_pkt.hop_max;
t=time(NULL);
reply_timeout=t+reply_time_secs+1;
nav_timeout=t+nav_time_secs;
// Collect Reply packets
while(reply_timeout>time(NULL))
{
v=slipstream_receive( rx_buf);
if (v > 0) {
gw_pkt.buf=rx_buf;
gw_pkt.buf_len=v;
print_gw_packet_elements(&gw_pkt);
}
usleep(1000);
}
// What for NAV and service incoming messages
// This is the time window when the network is idle and can
// be used for asynchronous communications.
while(nav_timeout>time(NULL))
{
v=slipstream_receive( rx_buf);
if (v > 0) {
// Check for mobile/p2p packets
gw_pkt.buf=rx_buf;
gw_pkt.buf_len=v;
print_gw_packet_elements(&gw_pkt);
}
usleep(1000);
}
// only run once
break;
}
}
int main (int argc, char *argv[])
{
FILE *fp;
uint8_t tx_buf[128];
uint8_t rx_buf[128];
int32_t v,cnt,i,len;
uint8_t nav_time_secs;
int32_t tmp;
time_t t;
uint8_t cmd,error;
char buf[1024];
debug_txt_flag=0;
xmpp_flag=0;
no_slip_flag=0;
print_input_flag=0;
if (argc < 3 || argc > 4) {
printf ("Usage: server port [-dx]\n");
printf (" d Debug Input Text\n");
printf (" x Use XMPP server\n");
printf (" n Don't send SLIP packets (but receive them)\n");
exit (1);
}
if(argc==4)
{
// Grab dash command line options
if(strstr(argv[3],"d")!=NULL )
{
debug_txt_flag=1;
}
if(strstr(argv[3],"x")!=NULL )
{
xmpp_flag=1;
}
if(strstr(argv[3],"n")!=NULL )
{
no_slip_flag=1;
}
}
fp=fopen( "ff_config.txt","r" );
if(fp==NULL) {
printf( "Could not open ff_config.txt!\n" );
printf( "This is required for sending control commands\n" );
exit(0);
}
v=slipstream_open(argv[1],atoi(argv[2]),NONBLOCKING);
nav_time_secs=25;
cnt = 0;
while (1) {
error=0;
cmd=0;
// Check if TX queue has
// Read Data packet from script file
while(cmd==0)
{
v=fscanf( fp, "%[^\n]\n", buf);
if(v==-1) rewind(fp);
if(buf[0]!='#' && v!=-1)
{
uint8_t offset;
offset=0;
i=0;
tmp=1;
while(tmp==1) {
tmp=sscanf( &buf[offset*HEX_STR_SIZE],"0x%x ",&tx_buf[i] );
// printf( "i=%d tmp=%d val=0x%x\n",i,tmp,tx_buf[i] );
if(tmp==1) {
offset++;
i++;
}
}
// Setup the packet to send out to the network which was read from the file
len=offset;
ds_pkt.buf_len=offset;
ds_pkt.buf=tx_buf;
unpack_downstream_packet( &ds_pkt, 0 );
// write to the structure and raw buffer
// We end up transmitting the raw buffer after adding thecorrect sequence number
tx_buf[SEQ_NUM]=cnt;
ds_pkt.seq_num=cnt;
if(debug_txt_flag==1)
print_ds_packet(&ds_pkt );
if(i<20 )
{
error=1;
printf( "Error parsing input file!\n" );
}
cnt++;
nav_time_secs=tx_buf[DS_NAV];
cmd=1;
}
}
// Send the packet
if(len>128) len=128;
if(!no_slip_flag && error==0)
v=slipstream_send(tx_buf,len);
if(debug_txt_flag==1)
{
if (v == 0) printf( "Error sending\n" );
else printf( "Sent request %d\n",tx_buf[SEQ_NUM]);
}
if(debug_txt_flag==1)
printf( "Waiting %d seconds\n",nav_time_secs );
t=time(NULL);
t+=nav_time_secs;
// Collect Reply packets for NAV seconds
while(t>time(NULL))
{
v=slipstream_receive( rx_buf);
if (v > 0) {
handle_incomming_pkt(rx_buf,v);
}
usleep(1000);
}
}
}
int main (int argc, char *argv[])
{
char buffer[128];
int v, cnt, i, size, socket, state;
uint32_t target_mac;
FF_POWER_PKT my_pwr_pkt;
FF_ENV_PKT my_env_pkt;
PKT_T my_pkt;
time_t ts;
if (argc < 3) {
printf ("Usage: server port [-v]\n");
exit (1);
}
state = 0;
verbose=0;
if(argc==4)
{
if(strcmp(argv[3],"-v")==0) { printf( "Verbose on" ); verbose=1; }
}
v = slipstream_open (argv[1], atoi (argv[2]), BLOCKING);
v = send_ping ();
cnt = 0;
while (1) {
v = slipstream_receive (buffer);
if (v > 0) {
v = buf_to_pkt (buffer, &my_pkt);
if (v == 1) {
// printf ("TYPE: %d\n", my_pkt.type);
// printf ("SRC MAC: %d\n", my_pkt.src_mac);
// printf ("DST MAC: %d\n", my_pkt.dst_mac);
// printf ("PAYLOAD LEN: %d\n", my_pkt.payload_len);
// printf ("PAYLOAD: [");
// for (i = 0; i < my_pkt.payload_len; i++)
// printf ("%d ", my_pkt.payload[i]);
// printf ("]\n");
if(my_pkt.type==APP)
{
ts=time(NULL);
switch(my_pkt.payload[1])
{
case 1:
power_unpack (my_pkt.payload, &my_pwr_pkt);
if(verbose)
printf( "(time,mac,total_secs,freq,v-rms,i-rms,t-pwr,energy,i-rms2,t-pwr2,energy2): %u,%x,%d,",ts,my_pkt.src_mac,my_pwr_pkt.total_secs );
else
printf( "P,%u,%x,%d,",ts,my_pkt.src_mac,my_pwr_pkt.total_secs );
printf( "%u,%u,%u,%u,%lu",my_pwr_pkt.freq, my_pwr_pkt.rms_voltage,my_pwr_pkt.rms_current, my_pwr_pkt.true_power,my_pwr_pkt.long_energy);
printf( ",%u,%u,%lu",my_pwr_pkt.rms_current1, my_pwr_pkt.true_power1,my_pwr_pkt.long_energy1);
printf( ",%u,%u",my_pwr_pkt.v_p2p_low, my_pwr_pkt.v_p2p_high);
printf( ",%u,%u",my_pwr_pkt.c_p2p_low, my_pwr_pkt.c_p2p_high);
printf( ",%u,%u",my_pwr_pkt.c_p2p_low2, my_pwr_pkt.c_p2p_high2);
printf( ",%u,%u,%u",my_pwr_pkt.v_center, my_pwr_pkt.c_center, my_pwr_pkt.c2_center);
// printf ("%d,%d)",
// ((float) my_pwr_pkt.true_power) / POWER_SCALER,
// my_pwr_pkt.true_power);
printf( "\n" );
break;
case 3:
env_unpack(my_pkt.payload, &my_env_pkt );
if(verbose)
printf( "(time,mac,bat,light,temp,acc_x,acc_y,acc_z,audio_p2p,digital-temp,humidity,pressure,motion,gpio_state): %u,%x,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u",ts,my_pkt.src_mac, my_env_pkt.bat, my_env_pkt.light, my_env_pkt.temp, my_env_pkt.acc_x, my_env_pkt.acc_y, my_env_pkt.acc_z, my_env_pkt.audio_p2p, my_env_pkt.digital_temp,my_env_pkt.humidity, my_env_pkt.pressure,my_env_pkt.motion,my_env_pkt.gpio_state );
else
printf( "S,%u,%x,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u",ts,my_pkt.src_mac, my_env_pkt.bat, my_env_pkt.light, my_env_pkt.temp, my_env_pkt.acc_x, my_env_pkt.acc_y, my_env_pkt.acc_z, my_env_pkt.audio_p2p,my_env_pkt.digital_temp,my_env_pkt.humidity, my_env_pkt.pressure, my_env_pkt.motion, my_env_pkt.gpio_state );
printf( "\n" );
break;
case 4:
printf("(time,mac,state): %u,%u,%u\n",ts,my_pkt.src_mac,my_pkt.payload[2] );
break;
default:
if(verbose)
printf( "unkown pkt type (%d): ",my_pkt.payload[1] );
else
printf( "U,%d,",my_pkt.payload[1] );
for(i=2; i<my_pkt.payload_len; i++ )
printf( ",%d",my_pkt.payload[i] );
printf( "\n" );
}
}
}
}
else
printf ("Error reading packet\n");
// Count to 5 and then send an actuate packet
/* cnt++;
if (cnt > 5) {
target_mac=0x04;
socket=0;
state=1;
printf ("Sending an actuate command [mac=0x%x socket %d, state %d]\n",target_mac,socket,state);
// Enable outlet 0 on node 0x01
outlet_actuate (target_mac, socket, state);
cnt = 0;
}*/
}
}
int main (int argc, char *argv[])
{
char buffer[128];
int v, cnt, i, size, socket, state;
uint32_t target_mac;
FF_POWER_PKT my_pwr_pkt;
FF_ENV_PKT my_env_pkt;
FF_3PHASE_PKT my_three_phase_pkt;
PKT_T my_pkt;
time_t ts;
uint32_t small_cnt, large_cnt;
if (argc < 3) {
printf ("Usage: server port [-v]\n");
exit (1);
}
state = 0;
verbose=0;
if(argc==4)
{
if(strcmp(argv[3],"-v")==0) { printf( "Verbose on" ); verbose=1; }
}
v = slipstream_open (argv[1], atoi (argv[2]), BLOCKING);
v = send_ping ();
cnt = 0;
while (1) {
v = slipstream_receive (buffer);
if (v > 0) {
v = buf_to_pkt (buffer, &my_pkt);
//printf( "pkt: %d\n",v );
if (v == 1) {
/*
* printf ("TYPE: %d\n", my_pkt.type);
printf ("RSSI: %u\n", my_pkt.rssi);
printf ("SRC MAC: %d\n", my_pkt.src_mac);
printf ("DST MAC: %d\n", my_pkt.dst_mac);
printf ("PAYLOAD LEN: %d\n", my_pkt.payload_len);
printf ("PAYLOAD: [");
for (i = 0; i < my_pkt.payload_len; i++)
printf ("%d ", my_pkt.payload[i]);
printf ("]\n");
*/
if(my_pkt.type==APP)
{
ts=time(NULL);
switch(my_pkt.payload[1])
{
case 1:
power_unpack (my_pkt.payload, &my_pwr_pkt);
if(verbose)
printf( "(time,mac,rssi,total_secs,freq,v-rms,i-rms,t-pwr,energy,i-rms2,t-pwr2,energy2): %u,%x,%u,%u,",ts,my_pkt.src_mac,my_pkt.rssi,my_pwr_pkt.total_secs );
else
printf( "P,%u,%x,%u,%u,",ts,my_pkt.src_mac,my_pkt.rssi,my_pwr_pkt.total_secs );
printf( "%u,%u,%u,%u,%lu",my_pwr_pkt.freq, my_pwr_pkt.rms_voltage,my_pwr_pkt.rms_current, my_pwr_pkt.true_power,my_pwr_pkt.long_energy);
printf( ",%u,%u,%lu",my_pwr_pkt.rms_current1, my_pwr_pkt.true_power1,my_pwr_pkt.long_energy1);
printf( ",%u,%u",my_pwr_pkt.v_p2p_low, my_pwr_pkt.v_p2p_high);
printf( ",%u,%u",my_pwr_pkt.c_p2p_low, my_pwr_pkt.c_p2p_high);
printf( ",%u,%u",my_pwr_pkt.c_p2p_low2, my_pwr_pkt.c_p2p_high2);
printf( ",%u,%u,%u,%u",my_pwr_pkt.v_center, my_pwr_pkt.c_center, my_pwr_pkt.c2_center, my_pwr_pkt.socket_state);
// printf ("%d,%d)",
// ((float) my_pwr_pkt.true_power) / POWER_SCALER,
// my_pwr_pkt.true_power);
printf( "\n" );
break;
case 3:
env_unpack(my_pkt.payload, &my_env_pkt );
if(verbose)
printf( "(time,mac,rssi,bat,light,temp,acc_x,acc_y,acc_z,audio_p2p,digital-temp,humidity,pressure,motion,gpio_state): %u,%x,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u",ts,my_pkt.src_mac, my_pkt.rssi,my_env_pkt.bat, my_env_pkt.light, my_env_pkt.temp, my_env_pkt.acc_x, my_env_pkt.acc_y, my_env_pkt.acc_z, my_env_pkt.audio_p2p, my_env_pkt.digital_temp,my_env_pkt.humidity, my_env_pkt.pressure,my_env_pkt.motion,my_env_pkt.gpio_state );
else
printf( "S,%u,%x,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u",ts,my_pkt.src_mac, my_pkt.rssi, my_env_pkt.bat, my_env_pkt.light, my_env_pkt.temp, my_env_pkt.acc_x, my_env_pkt.acc_y, my_env_pkt.acc_z, my_env_pkt.audio_p2p,my_env_pkt.digital_temp,my_env_pkt.humidity, my_env_pkt.pressure, my_env_pkt.motion, my_env_pkt.gpio_state );
printf( "\n" );
break;
case 4:
printf("(time,mac,rssi,state): %u,%x,%u,%u\n",ts,my_pkt.src_mac,my_pkt.rssi,my_pkt.payload[2] );
break;
case 5:
if(verbose)
printf("(time,mac,rssi,gain): %u,%x,%u,%u\n",ts,my_pkt.src_mac,my_pkt.rssi, my_pkt.payload[2] );
else
printf("B,%u,%u,%u,%u\n",ts,my_pkt.src_mac,my_pkt.rssi,my_pkt.payload[2] );
break;
case 6:
// Payload index 2 represents counts per minute
if(verbose)
printf("(time,mac,rssi,cpm): %u,%x,%u\n",ts,my_pkt.src_mac,my_pkt.rssi,my_pkt.payload[2] );
else
printf("R,%u,%x,%u,%u\n",ts,my_pkt.src_mac,my_pkt.rssi,my_pkt.payload[2] );
break;
case 7:
// Payload index 2,3,4,5 represent a little endian value for small particles counted
// Payload index 6,7,8,9 represent a little endian value for large particles counted
small_cnt=my_pkt.payload[2] | my_pkt.payload[3]<<8 | my_pkt.payload[4]<<16 | my_pkt.payload[5]<<24;
large_cnt=my_pkt.payload[6] | my_pkt.payload[7]<<8 | my_pkt.payload[8]<<16 | my_pkt.payload[9]<<24;
if(verbose)
printf("(time,mac,rssi,small_cnt,large_cnt): %u,%x,%u,%u,%u\n",ts,my_pkt.src_mac,my_pkt.rssi,small_cnt,large_cnt );
else
printf("A,%u,%x,%u,%u,%u\n",ts,my_pkt.src_mac,my_pkt.rssi,small_cnt,large_cnt);
break;
case 8:
three_phase_unpack (my_pkt.payload, &my_three_phase_pkt);
if(verbose)
printf( "3 Phase meter (time,mac,rssi,total_secs,period,awatthr,awatt,ava,avrms,airms,bwatt,bwatthr,bva,bvrms,birms,cwatt,cwatthr,cva,cvrms,cirms): %u,%x,%u,%u,",ts,my_pkt.src_mac,my_pkt.rssi,my_three_phase_pkt.total_secs );
else
printf( "M,%u,%x,%u,%u,",ts,my_pkt.src_mac,my_pkt.rssi,my_three_phase_pkt.total_secs );
printf( "%u,%d,%d,%d,%d,%d,",my_three_phase_pkt.period, my_three_phase_pkt.awatthr,my_three_phase_pkt.awatt,my_three_phase_pkt.ava,my_three_phase_pkt.avrms,my_three_phase_pkt.airms );
printf( "%d,%d,%d,%d,%d,",my_three_phase_pkt.bwatthr,my_three_phase_pkt.bwatt,my_three_phase_pkt.bva,my_three_phase_pkt.bvrms,my_three_phase_pkt.birms );
printf( "%d,%d,%d,%d,%d",my_three_phase_pkt.cwatthr,my_three_phase_pkt.cwatt,my_three_phase_pkt.cva,my_three_phase_pkt.cvrms,my_three_phase_pkt.cirms );
printf( "\n" );
break;
default:
if(verbose)
printf( "unkown pkt type (%d): ",my_pkt.payload[1] );
else
printf( "U,%d",my_pkt.payload[1] );
for(i=2; i<my_pkt.payload_len; i++ )
printf( ",%d",my_pkt.payload[i] );
printf( "\n" );
}
}
}
}
else
printf ("Error reading packet\n");
// Count to 5 and then send an actuate packet
/* cnt++;
if (cnt > 5) {
target_mac=0x04;
socket=0;
state=1;
printf ("Sending an actuate command [mac=0x%x socket %d, state %d]\n",target_mac,socket,state);
// Enable outlet 0 on node 0x01
outlet_actuate (target_mac, socket, state);
cnt = 0;
}*/
}
}
