void Task1()
{
uint8_t * local_rx_buf;
uint8_t my_addr8;
uint8_t my_level;
int8_t rssi;
uint8_t length;
uint16_t slot;
uint8_t cnt = 0;
tdma_init(10);
while(!tdma_started())
nrk_wait_until_next_period();
//tdma_schedule_print();
//my_addr8 = tdma_mac_get();
my_addr8 = 1;
//my_level = tdma_tree_level_get();
my_level = 0;
nrk_kprintf(PSTR("Starting task!\r\n"));
while(1)
{
if (tdma_rx_pkt_check() != 0)
{
// I have a packet
local_rx_buf = tdma_rx_pkt_get(&length, &rssi, &slot);
printf("Got pkt len %d rssi %d slot %d\r\n", length, rssi, slot);
for (uint8_t i = TDMA_DATA_START; i < length; i++)
{
printf("%c", local_rx_buf[i]);
}
nrk_kprintf(PSTR("\r\n"));
tdma_rx_pkt_release();
}
/*
if (tdma_tx_pkt_check() == 0)
{
sprintf(&tx_buf[TDMA_DATA_START], "From %d lvl %d cnt %d\r\n",
my_addr8, my_level, cnt);
length = strlen(&tx_buf[TDMA_DATA_START] + TDMA_DATA_START);
tdma_tx_pkt(tx_buf, length);
cnt++;
}
tdma_wait_until_rx_or_tx();
*/
}
}
void tx_task ()
{
int8_t v,state,outlet_state,dst_mac, outlet;
uint8_t len, cnt;
nrk_sig_t uart_rx_signal;
char c;
printf ("Gateway Tx Task PID=%u\r\n", nrk_get_pid ());
while (!tdma_started ())
nrk_wait_until_next_period ();
uart_rx_signal=nrk_uart_rx_signal_get();
nrk_signal_register(uart_rx_signal);
cnt = 0;
state=0;
while (1) {
if(nrk_uart_data_ready(NRK_DEFAULT_UART))
{
c=getchar();
if(state==1) {
dst_mac=c;
state=2;
} else if(state==2) {
outlet=c;
state=3;
} else if(state==3)
{
outlet_state=c;
state=4;
}
if(c=='S') state=1;
if(c=='E') {
if(state==4)
{
printf( "TX: %d %d %d\r\n",dst_mac, outlet, outlet_state );
tx_buf[0]=dst_mac;
tx_buf[1]=outlet;
tx_buf[2]=outlet_state;
len=3;
// Only transmit data if you want to do so
// Messages from the host are always broadcasts
v = tdma_send (&tx_tdma_fd, &tx_buf, len, TDMA_BLOCKING);
if (v == NRK_OK) {
nrk_kprintf (PSTR ("Host Packet Sent\n"));
}
}
state=0;
}
} else nrk_event_wait(SIG(uart_rx_signal));
}
}
void tx_task()
{
int8_t v,fd;
uint8_t len,cnt,chan;
printf( "Tx Task PID=%u\r\n",nrk_get_pid());
while(!tdma_started()) nrk_wait_until_next_period();
v=tdma_tx_slot_add(mac_address);
cnt=0;
while(1) {
// Open ADC device as read
fd = nrk_open (FIREFLY_SENSOR_BASIC, READ);
nrk_wait_until_next_period(); // allow sensor to warm up
if (fd == NRK_ERROR)
nrk_kprintf (PSTR ("Failed to open sensor driver\r\n"));
v = nrk_set_status (fd, SENSOR_SELECT, BAT);
v = nrk_read (fd, &bat, 2);
v = nrk_set_status (fd, SENSOR_SELECT, LIGHT);
v = nrk_read (fd, &light, 2);
v = nrk_set_status (fd, SENSOR_SELECT, TEMP);
v = nrk_read (fd, &temp, 2);
v = nrk_set_status (fd, SENSOR_SELECT, ACC_X);
v = nrk_read (fd, &adxl_x, 2);
v = nrk_set_status (fd, SENSOR_SELECT, ACC_Y);
v = nrk_read (fd, &adxl_y, 2);
v = nrk_set_status (fd, SENSOR_SELECT, ACC_Z);
v = nrk_read (fd, &adxl_z, 2);
v = nrk_set_status (fd, SENSOR_SELECT, AUDIO_P2P);
v = nrk_read (fd, &mic, 2);
nrk_close(fd);
// Build a sensor packet
sprintf (tx_buf,
"S MAC: %u bat: %u light: %u temp: %u audio: %u adxl: %u %u %u\r\n",
(uint16_t) (mac_address & 0xffff), bat, light, temp, mic, adxl_x,
adxl_y, adxl_z);
len=strlen(tx_buf);
v=tdma_send(&tx_tdma_fd, &tx_buf, len, TDMA_BLOCKING );
if(v==NRK_OK)
{
printf ("%s", tx_buf);
}
}
}
void rx_task ()
{
nrk_time_t t;
uint16_t cnt;
int8_t v;
uint8_t len, i;
cnt = 0;
nrk_kprintf (PSTR ("Nano-RK Version "));
printf ("%d\r\n", NRK_VERSION);
printf ("RX Task PID=%u\r\n", nrk_get_pid ());
t.secs = 5;
t.nano_secs = 0;
// setup a software watch dog timer
//nrk_sw_wdt_init(0, &t, NULL);
// nrk_sw_wdt_start(0);
tdma_init (TDMA_HOST, 13, 0);
// Change these parameters at runtime...
tdma_set_slot_len_ms (10);
tdma_set_slots_per_cycle (32);
while (!tdma_started ())
nrk_wait_until_next_period ();
while (1) {
// Update watchdog timer
// nrk_sw_wdt_update(0);
v = tdma_recv (&rx_tdma_fd, &rx_buf, &len, TDMA_BLOCKING);
if (v == NRK_OK) {
// nrk_kprintf (PSTR ("Got pkt "));
// printf ("src: %u rssi: %d ", rx_tdma_fd.src, rx_tdma_fd.rssi);
// printf ("slot: %u ", rx_tdma_fd.slot);
// printf ("len: %u\r\nS ", len);
printf ("S " );
for (i = 0; i < len; i++)
printf ("%d ", rx_buf[i]);
printf ("\r\n");
}
// nrk_wait_until_next_period();
}
}
void tx_task ()
{
uint8_t j, i, val, cnt;
int8_t len;
int8_t v,fd;
uint8_t buf[2];
nrk_sig_t tx_done_signal;
nrk_sig_mask_t ret;
nrk_time_t r_period;
printf ("tx_task PID=%d\r\n", nrk_get_pid ());
// Wait until the tx_task starts up bmac
// This should be called by all tasks using bmac that
while (!tdma_started ())
nrk_wait_until_next_period ();
while (1) {
tx_pkt.payload[0] = 1; // ELEMENTS
tx_pkt.payload[1] = 5; // Key
tx_pkt.payload[2]=Gain;
tx_pkt.payload_len=3;
if(gpio_pin) nrk_led_set(BLUE_LED);
else nrk_led_clr(BLUE_LED);
tx_pkt.src_mac=mac_address;
tx_pkt.dst_mac=0;
tx_pkt.type=APP;
len=pkt_to_buf(&tx_pkt,&tx_buf );
if(len>0)
{
v = tdma_send (&tx_tdma_fd, &tx_buf, len, TDMA_BLOCKING);
if (v == NRK_OK) {
//nrk_kprintf (PSTR ("App Packet Sent\n"));
}
} else nrk_wait_until_next_period();
}
}
void rx_task ()
{
nrk_time_t t;
uint16_t cnt;
int8_t v;
uint8_t len, i;
uint8_t chan;
cnt = 0;
nrk_kprintf (PSTR ("Nano-RK Version "));
printf ("%d\r\n", NRK_VERSION);
nrk_kprintf( PSTR( "RX Task PID=" ));
printf ("%u\r\n", nrk_get_pid ());
t.secs = 5;
t.nano_secs = 0;
while (cal_done==0)
nrk_wait_until_next_period ();
chan = RADIO_CHANNEL;
if (SET_MAC == 0x00) {
v = read_eeprom_mac_address (&mac_address);
if (v == NRK_OK) {
v = read_eeprom_channel (&chan);
v = read_eeprom_aes_key(aes_key);
}
else {
while (1) {
nrk_kprintf (PSTR
("* ERROR reading MAC address, run eeprom-set utility\r\n"));
nrk_wait_until_next_period ();
}
}
}
else
mac_address = SET_MAC;
printf ("MAC ADDR: %x\r\n", mac_address & 0xffff);
printf ("chan = %d\r\n", chan);
len=0;
for(i=0; i<16; i++ ) {
len+=aes_key[i];
}
printf ("AES checksum = %d\r\n", len);
tdma_init (TDMA_CLIENT, chan, (mac_address));
tdma_aes_setkey(aes_key);
tdma_aes_enable();
while (!tdma_started ())
nrk_wait_until_next_period ();
v = tdma_tx_slot_add (mac_address&0xff);
if (v != NRK_OK)
nrk_kprintf (PSTR ("Could not add slot!\r\n"));
// setup a software watch dog timer
t.secs=30;
t.nano_secs=0;
nrk_sw_wdt_init(0, &t, NULL);
nrk_sw_wdt_start(0);
while (1) {
// Update watchdog timer
nrk_sw_wdt_update(0);
v = tdma_recv (&rx_tdma_fd, &rx_buf, &len, TDMA_BLOCKING);
if (v == NRK_OK) {
// printf ("src: %u\r\nrssi: %d\r\n", rx_tdma_fd.src, rx_tdma_fd.rssi);
// printf ("slot: %u\r\n", rx_tdma_fd.slot);
// printf ("cycle len: %u\r\n", rx_tdma_fd.cycle_size);
v=buf_to_pkt(&rx_buf, &rx_pkt);
if(v==NRK_OK)
{
if(((rx_pkt.dst_mac&0xff) == (mac_address&0xff)) || ((rx_pkt.dst_mac&0xff)==0xff))
{
if(rx_pkt.type==PING)
{
send_ack=1;
nrk_led_clr(0);
nrk_led_clr(1);
if(rx_pkt.payload[0]==PING_1)
{
nrk_led_set(0);
nrk_wait_until_next_period();
nrk_wait_until_next_period();
nrk_wait_until_next_period();
nrk_led_clr(0);
}
if(rx_pkt.payload[0]==PING_2)
{
nrk_led_set(1);
nrk_wait_until_next_period();
nrk_wait_until_next_period();
nrk_wait_until_next_period();
nrk_led_clr(1);
}
if(rx_pkt.payload[0]==PING_PERSIST)
{
nrk_led_set(0);
}
}
if(rx_pkt.type==APP)
{
// payload 1: Key
if(rx_pkt.payload[1]==2)
{
send_ack=1;
// payload 2: Outlet Number
// payload 3: On/Off
if(rx_pkt.payload[3]==0) {
power_socket_disable(rx_pkt.payload[2]);
plug_led_green_clr();
//printf( "Disable %d\r\n", rx_pkt.payload[2] );
}
if(rx_pkt.payload[3]==1) {
power_socket_enable(rx_pkt.payload[2]);
//printf( "Enable %d\r\n", rx_pkt.payload[2] );
plug_led_green_set();
}
}
// payload 1: Key
if(rx_pkt.payload[1]==3)
{
send_ack=1;
true_power_thresh=((uint32_t)rx_pkt.payload[3])<<16 | ((uint32_t)rx_pkt.payload[4])<<8 | (uint32_t)rx_pkt.payload[5];
set_power_thresh(true_power_thresh);
}
}
}
}
/* printf ("len: %u\r\npayload: ", len);
for (i = 0; i < len; i++)
printf ("%d ", rx_buf[i]);
printf ("\r\n");
if(rx_buf[0]==(mac_address&0xff))
{
if(rx_buf[2]==0) {
power_socket_disable(rx_buf[1]);
printf( "Disable %d\r\n", rx_buf[1] );
}
if(rx_buf[2]==1) {
power_socket_enable(rx_buf[1]);
printf( "Enable %d\r\n", rx_buf[1] );
}
}
*/
}
tdma_rx_pkt_release();
// nrk_wait_until_next_period();
}
}
void tx_task ()
{
uint8_t j, i, val, cnt;
int8_t len;
int8_t v,fd;
uint8_t buf[2];
nrk_sig_mask_t ret;
nrk_time_t t;
// Set Port D.0 as input
// On the FireFly nodes we use this for motion or syntonistor input
// It can be interrupt driven, but we don't do this with TDMA since updates are so fast anyway
// DDRD &= ~(0x1);
printf ("tx_task PID=%d\r\n", nrk_get_pid ());
// setup a software watch dog timer
t.secs=10;
t.nano_secs=0;
nrk_sw_wdt_init(0, &t, NULL);
nrk_sw_wdt_start(0);
while (!tdma_started ())
nrk_wait_until_next_period ();
// set port G as input for gpio
DDRG=0;
while (1) {
nrk_led_clr(RED_LED);
tx_pkt.payload[0] = 1; // ELEMENTS
tx_pkt.payload[1] = 3; // Key
fd=nrk_open(FIREFLY_3_SENSOR_BASIC,READ);
if(fd==NRK_ERROR) nrk_kprintf(PSTR("Failed to open sensor driver\r\n"));
val=nrk_set_status(fd,SENSOR_SELECT,MOTION);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[28]=buf[1];
tx_pkt.payload[29]=buf[0];
val=nrk_set_status(fd,SENSOR_SELECT,BAT);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[2]=buf[1];
tx_pkt.payload[3]=buf[0];
//printf( "Task bat=%d",buf);
// tx_pkt.payload[2]=0;
// tx_pkt.payload[3]=0;
val=nrk_set_status(fd,SENSOR_SELECT,LIGHT);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[4]=buf[1];
tx_pkt.payload[5]=buf[0];
//printf( " light=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,TEMP);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[6]=buf[1];
tx_pkt.payload[7]=buf[0];
//printf( " temp=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,ACC_X);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[8]=buf[1];
tx_pkt.payload[9]=buf[0];
//printf( " acc_x=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,ACC_Y);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[10]=buf[1];
tx_pkt.payload[11]=buf[0];
//printf( " acc_y=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,ACC_Z);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[12]=buf[1];
tx_pkt.payload[13]=buf[0];
//printf( " acc_z=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,HUMIDITY);
val=nrk_read(fd,&buf,4);
tx_pkt.payload[16]=buf[3];
tx_pkt.payload[17]=buf[2];
tx_pkt.payload[18]=buf[1];
tx_pkt.payload[19]=buf[0];
val=nrk_set_status(fd,SENSOR_SELECT,TEMP2);
val=nrk_read(fd,&buf,4);
tx_pkt.payload[20]=buf[3];
tx_pkt.payload[21]=buf[2];
tx_pkt.payload[22]=buf[1];
tx_pkt.payload[23]=buf[0];
val=nrk_set_status(fd,SENSOR_SELECT,PRESS);
val=nrk_read(fd,&buf,4);
tx_pkt.payload[24]=buf[3];
tx_pkt.payload[25]=buf[2];
tx_pkt.payload[26]=buf[1];
tx_pkt.payload[27]=buf[0];
val=nrk_set_status(fd,SENSOR_SELECT,AUDIO_P2P);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[14]=buf[1];
tx_pkt.payload[15]=buf[0];
// GPIO data
// gpio_pin = !!(PINE & 0x4);
gpio_pin = PING & 0x1;
tx_pkt.payload[30]=gpio_pin;
//printf( " audio=%d\r\n",buf);
nrk_close(fd);
tx_pkt.payload_len=31;
tx_pkt.src_mac=mac_address;
tx_pkt.dst_mac=0;
tx_pkt.type=APP;
len=pkt_to_buf(&tx_pkt,&tx_buf );
if(len>0)
{
v = tdma_send (&tx_tdma_fd, &tx_buf, len, TDMA_BLOCKING);
if (v == NRK_OK) {
}
} else {
nrk_kprintf(PSTR("Pkt tx error\r\n"));
nrk_wait_until_next_period();
}
nrk_sw_wdt_update(0);
}
}
void rx_task ()
{
nrk_time_t t;
uint16_t cnt;
int8_t v,fd;
uint8_t len, i;
uint8_t chan;
cnt = 0;
nrk_kprintf (PSTR ("Nano-RK Version "));
printf ("%d\r\n", NRK_VERSION);
printf ("RX Task PID=%u\r\n", nrk_get_pid ());
t.secs = 5;
t.nano_secs = 0;
chan = CHAN;
if (SET_MAC == 0x00) {
v = read_eeprom_mac_address (&mac_address);
if (v == NRK_OK) {
v = read_eeprom_channel (&chan);
}
else {
while (1) {
nrk_kprintf (PSTR
("* ERROR reading MAC address, run eeprom-set utility\r\n"));
nrk_wait_until_next_period ();
}
}
}
else
mac_address = SET_MAC;
printf ("MAC ADDR: %x\r\n", mac_address & 0xffff);
printf ("chan = %d\r\n", chan);
tdma_init (TDMA_CLIENT, chan, mac_address);
while (!tdma_started ())
nrk_wait_until_next_period ();
// Set TDMA slot to lower byte of MAC address
v = tdma_tx_slot_add (mac_address & 0xff);
if (v != NRK_OK)
nrk_kprintf (PSTR ("Could not add slot!\r\n"));
while (1) {
// Update watchdog timer
// nrk_sw_wdt_update(0);
v = tdma_recv (&rx_tdma_fd, &rx_buf, &len, TDMA_BLOCKING);
if (v == NRK_OK) {
// printf ("src: %u\r\nrssi: %d\r\n", rx_tdma_fd.src, rx_tdma_fd.rssi);
// printf ("slot: %u\r\n", rx_tdma_fd.slot);
// printf ("cycle len: %u\r\n", rx_tdma_fd.cycle_size);
v=buf_to_pkt(&rx_buf, &rx_pkt);
tdma_rx_pkt_release();
/*if((rx_pkt.dst_mac&0xff) == (mac_address&0xff))
{
printf ("len: %u\r\npayload: ", len);
for (i = 0; i < len; i++)
printf ("%d ", rx_buf[i]);
printf ("\r\n");
}*/
}
// nrk_wait_until_next_period();
}
}
void tx_task ()
{
uint8_t j, i, val, cnt;
int8_t len;
int8_t v,fd;
uint8_t buf[2];
nrk_sig_mask_t ret;
nrk_time_t t;
int8_t* success;
int16_t acbuf[3];
int gyrobuf[3];
int magbuf[3];
/* Setup application timer with:
* Prescaler = 5
* Compare Match = 2500
* Sys Clock = 1.0 MHz according to Mega128RFA1 manual pg149
* Prescaler 5 means divide sys clock by 1024
* 1000000 / 1024 = 976.5625 Hz clock
* 1 / 976.5625 = 1.024 ms per tick
* 1.024 ms * 1000 = ~1024 ms / per interrupt callback
*/
val=nrk_timer_int_configure(NRK_APP_TIMER_0, 5, 1000, &my_timer_callback );
if(val==NRK_OK) nrk_kprintf( PSTR("Callback timer setup\r\n"));
else nrk_kprintf( PSTR("Error setting up timer callback\r\n"));
// Zero the timer...
nrk_timer_int_reset(NRK_APP_TIMER_0);
// Start the timer...
nrk_timer_int_start(NRK_APP_TIMER_0);
// Set Port D.0 as input
// On the FireFly nodes we use this for motion or syntonistor input
// It can be interrupt driven, but we don't do this with TDMA since updates are so fast anyway
// DDRD &= ~(0x1);
//nrk_kprintf( PSTR("Booting Up ADXL345. . .\r\n") );
/**** Start Accelerometer and check connections
* Start up accelerometer
* Ensure ADXL is connected.
* Enable continous measurement
* INT_SCALER = 10000
* Set accelerometer range to maximum og 2G
* Set sample rate to 1.6Khz
****/
set_up_ADXL345();
/**** Start Gyro and check connections
* Start up gyro
* Zero calibrate gyro.
* INT_SCALER_GYRO = 100
* Leave gyro still for about 2 seconds to zero-calibrate
* sets gyro sample rate to 8Khz with a 256Hz BW(bandwidth) LP (low pass) filter
****/
set_up_ITG3200();
/**** Start magnetometer and check connections
* set scale to +/- 1.3 gauss
* set measurement mode to continous
* INT_SCALER_MAG = 1000
* sets sample rate to highest value of 75Hz
* sets averaging value to 8 samples per reading givein at 75 Hz
****/
success = set_up_HMC5883L();
if (*success) nrk_kprintf( PSTR("HMC5883L(Magnetometer) boot success. Scale +/- 1.3 Ga. . .\r\n"));
if ( *(success+1) ) nrk_kprintf( PSTR("HMC5883L measurement mode: continuous . .\r\n") );
//printf( "My node's address is %d\r\n",NODE_ADDR );
printf ("tx_task PID=%d\r\n", nrk_get_pid ());
// setup a software watch dog timer
t.secs=10;
t.nano_secs=0;
nrk_sw_wdt_init(0, &t, NULL);
nrk_sw_wdt_start(0);
while (!tdma_started ())
nrk_wait_until_next_period ();
while (1) {
//nrk_led_toggle(GREEN_LED);
tx_pkt.payload[0] = 1; // ELEMENTS
tx_pkt.payload[1] = 3; // Key
/* fd=nrk_open(FIREFLY_3_SENSOR_BASIC,READ);
if(fd==NRK_ERROR) nrk_kprintf(PSTR("Failed to open sensor driver\r\n"));
// val=nrk_set_status(fd,SENSOR_SELECT,BAT);
// val=nrk_read(fd,&buf,2);
// tx_pkt.payload[2]=buf[1];
// tx_pkt.payload[3]=buf[0];
//printf( "Task bat=%d",buf);
tx_pkt.payload[2]=0;
tx_pkt.payload[3]=0;
//val=nrk_set_status(fd,SENSOR_SELECT,LIGHT);
//val=nrk_read(fd,&buf,2);
tx_pkt.payload[4]=buf[1];
tx_pkt.payload[5]=buf[0];
//printf( " light=%d",buf);
//val=nrk_set_status(fd,SENSOR_SELECT,TEMP);
//val=nrk_read(fd,&buf,2);
tx_pkt.payload[6]=buf[1];
tx_pkt.payload[7]=buf[0];
//printf( " temp=%d",buf);
//val=nrk_set_status(fd,SENSOR_SELECT,ACC_X);
//val=nrk_read(fd,&buf,2);
tx_pkt.payload[8]=buf[1];
tx_pkt.payload[9]=buf[0];
//printf( " acc_x=%d",buf);
//val=nrk_set_status(fd,SENSOR_SELECT,ACC_Y);
//val=nrk_read(fd,&buf,2);
tx_pkt.payload[10]=buf[1];
tx_pkt.payload[11]=buf[0];
//printf( " acc_y=%d",buf);
//val=nrk_set_status(fd,SENSOR_SELECT,ACC_Z);
//val=nrk_read(fd,&buf,2);
tx_pkt.payload[12]=buf[1];
tx_pkt.payload[13]=buf[0];
//printf( " acc_z=%d",buf);
/*
val=nrk_set_status(fd,SENSOR_SELECT,HUMIDITY);
val=nrk_read(fd,&buf,4);
tx_pkt.payload[16]=buf[3];
tx_pkt.payload[17]=buf[2];
tx_pkt.payload[18]=buf[1];
tx_pkt.payload[19]=buf[0];
val=nrk_set_status(fd,SENSOR_SELECT,TEMP2);
val=nrk_read(fd,&buf,4);
tx_pkt.payload[20]=buf[3];
tx_pkt.payload[21]=buf[2];
tx_pkt.payload[22]=buf[1];
tx_pkt.payload[23]=buf[0];
val=nrk_set_status(fd,SENSOR_SELECT,PRESS);
val=nrk_read(fd,&buf,4);
tx_pkt.payload[24]=buf[3];
tx_pkt.payload[25]=buf[2];
tx_pkt.payload[26]=buf[1];
tx_pkt.payload[27]=buf[0];
//val=nrk_set_status(fd,SENSOR_SELECT,MOTION);
//val=nrk_read(fd,&buf,2);
tx_pkt.payload[28]=buf[1];
tx_pkt.payload[29]=buf[0];
//val=nrk_set_status(fd,SENSOR_SELECT,AUDIO_P2P);
//val=nrk_read(fd,&buf,2);
tx_pkt.payload[14]=buf[1];
tx_pkt.payload[15]=buf[0];
// GPIO data
//gpio_pin = !!(PINE & 0x4);
//tx_pkt.payload[30]=gpio_pin;
//printf( " audio=%d\r\n",buf);
nrk_close(fd);*/
tx_pkt.payload[30]=30;
tx_pkt.payload[29]=29;
tx_pkt.payload[28]=8;
tx_pkt.payload[27]=0;
tx_pkt.payload[26]=0;
tx_pkt.payload[25]=29;
tx_pkt.payload[24]=8;
tx_pkt.payload[23]=0;
tx_pkt.payload[22]=0;
tx_pkt.payload[21]=8;
tx_pkt.payload[20]=0;
tx_pkt.payload[19]=0;
tx_pkt.payload[18]=0;
tx_pkt.payload[17]=0;
tx_pkt.payload[16]=0;
tx_pkt.payload[15]=60;
tx_pkt.payload[14]=0;
tx_pkt.payload[13]=0;
tx_pkt.payload[12]=0;
tx_pkt.payload[11]=0;
tx_pkt.payload[10]=0;
tx_pkt.payload[9]=0;
tx_pkt.payload[8]=0;
tx_pkt.payload[7]=155;
tx_pkt.payload[6]=45;
tx_pkt.payload[5]=8;
tx_pkt.payload[4]=5;
tx_pkt.payload[3]=3;
tx_pkt.payload[2]=2;
tx_pkt.payload_len=31;
tx_pkt.src_mac=mac_address;
tx_pkt.dst_mac=0;
tx_pkt.type=APP;
len=pkt_to_buf(&tx_pkt,&tx_buf );
if(len>0){
v = tdma_send (&tx_tdma_fd, &tx_buf, len, TDMA_BLOCKING);
if (v == NRK_OK) {
}
}
else {
nrk_kprintf(PSTR("Pkt tx error\r\n"));
nrk_wait_until_next_period();
}
nrk_sw_wdt_update(0);
}
}
void tx_task ()
{
uint8_t j, i, val, cnt;
int8_t len;
int8_t v,fd;
uint8_t buf[2];
nrk_sig_t tx_done_signal;
nrk_sig_mask_t ret;
nrk_time_t r_period;
// Set Port D.0 as input
// On the FireFly nodes we use this for motion or syntonistor input
// It can be interrupt driven, but we don't do this with TDMA since updates are so fast anyway
DDRD &= ~(0x1);
printf ("tx_task PID=%d\r\n", nrk_get_pid ());
// Wait until the tx_task starts up bmac
// This should be called by all tasks using bmac that
while (!tdma_started ())
nrk_wait_until_next_period ();
while (1) {
fd=nrk_open(FIREFLY_SENSOR_BASIC,READ);
if(fd==NRK_ERROR) nrk_kprintf(PSTR("Failed to open sensor driver\r\n"));
tx_pkt.payload[0] = 1; // ELEMENTS
tx_pkt.payload[1] = 3; // Key
val=nrk_set_status(fd,SENSOR_SELECT,BAT);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[2]=buf[1];
tx_pkt.payload[3]=buf[0];
//printf( "Task bat=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,LIGHT);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[4]=buf[1];
tx_pkt.payload[5]=buf[0];
//printf( " light=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,TEMP);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[6]=buf[1];
tx_pkt.payload[7]=buf[0];
//printf( " temp=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,ACC_X);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[8]=buf[1];
tx_pkt.payload[9]=buf[0];
//printf( " acc_x=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,ACC_Y);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[10]=buf[1];
tx_pkt.payload[11]=buf[0];
//printf( " acc_y=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,ACC_Z);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[12]=buf[1];
tx_pkt.payload[13]=buf[0];
//printf( " acc_z=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,AUDIO_P2P);
nrk_spin_wait_us(60000);
val=nrk_read(fd,&buf,2);
tx_pkt.payload[14]=buf[1];
tx_pkt.payload[15]=buf[0];
// GPIO data
gpio_pin = (PIND & 0x1);
tx_pkt.payload[16]=gpio_pin;
//printf( " audio=%d\r\n",buf);
tx_pkt.payload_len=17;
nrk_close(fd);
tx_pkt.src_mac=mac_address;
tx_pkt.dst_mac=0;
tx_pkt.type=APP;
len=pkt_to_buf(&tx_pkt,&tx_buf );
if(len>0)
{
v = tdma_send (&tx_tdma_fd, &tx_buf, len, TDMA_BLOCKING);
if (v == NRK_OK) {
//nrk_kprintf (PSTR ("App Packet Sent\n"));
}
} else nrk_wait_until_next_period();
}
}
void tdma_nw_task ()
{
int8_t v, i;
uint16_t slot, tmp,sync;
nrk_sig_mask_t event;
do {
nrk_wait_until_next_period ();
} while (!tdma_started ());
_tdma_slot_time.nano_secs = TDMA_DEFAULT_SLOT_MS * NANOS_PER_MS;
_tdma_slot_time.secs = 0;
//register the signal after bmac_init has been called
v = nrk_signal_register (tdma_enable_signal);
if (v == NRK_ERROR)
nrk_kprintf (PSTR ("Failed to register signal\r\n"));
slot = 0;
//rf_set_rx (&tdma_rfRxInfo, tdma_chan);
while (1) {
if (tdma_mode == TDMA_HOST) {
sync_status=1; // HOST is always synced
// This is the downstream transmit slot
if (slot == 0) {
//rf_rx_off();
// If there is no pending packet, lets make an empty one
if (tx_data_ready == 0) {
tdma_rfTxInfo.pPayload = tdma_tx_buf;
// Setup the header data
tdma_rfTxInfo.pPayload[TDMA_DST_LOW] = 0xff; // dst
tdma_rfTxInfo.pPayload[TDMA_DST_HIGH] = 0xff;
tdma_rfTxInfo.pPayload[TDMA_SRC_LOW] = 0x00; // src
tdma_rfTxInfo.pPayload[TDMA_SRC_HIGH] = 0x00;
tdma_rfTxInfo.pPayload[TDMA_SEQ_NUM_LOW] = 0x00; // seq num
tdma_rfTxInfo.pPayload[TDMA_SEQ_NUM_HIGH] = 0x00;
tdma_rfTxInfo.length = TDMA_PCF_HEADER;
}
tdma_rfTxInfo.pPayload[TDMA_CYCLE_SIZE_LOW] = tdma_slots_per_cycle & 0xff; // cycle size
tdma_rfTxInfo.pPayload[TDMA_CYCLE_SIZE_HIGH] =
tdma_slots_per_cycle >> 8;
tdma_rfTxInfo.pPayload[TDMA_SLOT_LOW] = 0; // slot
tdma_rfTxInfo.pPayload[TDMA_SLOT_HIGH] = 0;
tdma_rfTxInfo.pPayload[TDMA_SLOT_SIZE] = tdma_slot_len_ms;
nrk_time_get (&_tdma_next_wakeup);
tdma_rfTxInfo.destAddr = 0xffff;
tdma_rfTxInfo.ackRequest = 0;
tdma_rfTxInfo.cca = 0;
_tdma_tx ();
rf_rx_on ();
}
else {
// Upstream data slot
v = _tdma_rx ();
if (v == 1)
tdma_last_tx_slot = slot;
}
slot++;
if (slot >= tdma_slots_per_cycle + 1)
slot = 0;
nrk_time_add (&_tdma_next_wakeup, _tdma_next_wakeup, _tdma_slot_time);
nrk_time_compact_nanos (&_tdma_next_wakeup);
nrk_wait_until (_tdma_next_wakeup);
}
void rx_task()
{
nrk_time_t t;
uint16_t cnt;
int8_t v;
uint8_t len,i,chan;
cnt=0;
nrk_kprintf( PSTR("Nano-RK Version ") );
printf( "%d\r\n",NRK_VERSION );
printf( "Gateway Task PID=%u\r\n",nrk_get_pid());
t.secs=10;
t.nano_secs=0;
// setup a software watch dog timer
nrk_sw_wdt_init(0, &t, NULL);
nrk_sw_wdt_start(0);
chan = 16;
if (SET_MAC == 0xffff) {
v = read_eeprom_mac_address (&mac_address);
if (v == NRK_OK) {
v = read_eeprom_channel (&chan);
}
else {
while (1) {
nrk_kprintf (PSTR
("* ERROR reading MAC address, run eeprom-set utility\r\n"));
nrk_led_toggle(RED_LED);
nrk_wait_until_next_period ();
}
}
}
else
mac_address = SET_MAC;
printf ("MAC ADDR: %x\r\n", mac_address & 0xffff);
printf ("chan = %d\r\n", chan);
tdma_init(TDMA_HOST, chan, mac_address);
// Change these parameters anytime you want...
tdma_set_slot_len_ms(10);
tdma_set_slots_per_cycle(12);
slip_init (stdin, stdout, 0, 0);
while(!tdma_started()) nrk_wait_until_next_period();
nrk_led_set(GREEN_LED);
while(1) {
v=tdma_recv(&rx_tdma_fd, &slip_tx_buf, &len, TDMA_BLOCKING );
nrk_led_set(ORANGE_LED);
if(v==NRK_OK)
{
//for(i=0; i<len; i++ ) printf( "%c", rx_buf[i]);
// Got a packet from the network so send it over SLIP
slip_tx ( slip_tx_buf, len );
}
else tdma_rx_pkt_release();
nrk_led_clr(ORANGE_LED);
nrk_sw_wdt_update(0);
}
}
void tx_task ()
{
uint8_t j, i, val, cnt;
int8_t len;
int8_t v,fd;
nrk_sig_mask_t ret;
nrk_time_t t;
// Set Port D.0 as input
// On the FireFly nodes we use this for motion or syntonistor input
// It can be interrupt driven, but we don't do this with TDMA since updates are so fast anyway
printf ("tx_task PID=%d\r\n", nrk_get_pid ());
// setup a software watch dog timer
t.secs=10;
t.nano_secs=0;
nrk_sw_wdt_init(0, &t, NULL);
nrk_sw_wdt_start(0);
while (!tdma_started ())
nrk_wait_until_next_period ();
// set port G as input for gpio
nrk_gpio_direction(NRK_PORTG_0,NRK_PIN_INPUT );
send_ack=0;
while (1) {
nrk_led_clr(RED_LED);
tx_pkt.payload[0] = 1; // ELEMENTS
tx_pkt.payload[1] = 4; // Key
tx_pkt.payload[2] = nrk_gpio_get(NRK_PORTG_0); // Key
tx_pkt.payload_len=3;
tx_pkt.src_mac=mac_address;
tx_pkt.dst_mac=0;
tx_pkt.type=APP;
if(send_ack==1)
{
tx_pkt.type=ACK;
tx_pkt.payload_len=0;
send_ack=0;
}
len=pkt_to_buf(&tx_pkt,&tx_buf );
if(len>0)
{
v = tdma_send (&tx_tdma_fd, &tx_buf, len, TDMA_BLOCKING);
if (v == NRK_OK) {
}
} else {
nrk_kprintf(PSTR("Pkt tx error\r\n"));
nrk_wait_until_next_period();
}
nrk_sw_wdt_update(0);
}
}
void rx_task ()
{
nrk_time_t t;
uint16_t cnt;
int8_t v;
uint8_t len, i;
uint8_t chan;
cnt = 0;
nrk_kprintf (PSTR ("Nano-RK Version "));
printf ("%d\r\n", NRK_VERSION);
printf ("RX Task PID=%u\r\n", nrk_get_pid ());
t.secs = 5;
t.nano_secs = 0;
chan = CHAN;
if (SET_MAC == 0x00) {
v = read_eeprom_mac_address (&mac_address);
if (v == NRK_OK) {
v = read_eeprom_channel (&chan);
v=read_eeprom_aes_key(aes_key);
}
else {
while (1) {
nrk_kprintf (PSTR
("* ERROR reading MAC address, run eeprom-set utility\r\n"));
nrk_wait_until_next_period ();
}
}
}
else
mac_address = SET_MAC;
printf ("MAC ADDR: %x\r\n", mac_address & 0xffff);
printf ("chan = %d\r\n", chan);
len=0;
for(i=0; i<16; i++ ) {
len+=aes_key[i];
}
printf ("AES checksum = %d\r\n", len);
tdma_init (TDMA_CLIENT, chan, mac_address);
tdma_aes_setkey(aes_key);
tdma_aes_enable();
while (!tdma_started ())
nrk_wait_until_next_period ();
// Mask off lower byte of MAC address for TDMA slot
// FIXME: This should eventually be lower 2 bytes for larger TDMA cycles
v = tdma_tx_slot_add (mac_address&0xFF);
if (v != NRK_OK)
nrk_kprintf (PSTR ("Could not add slot!\r\n"));
while (1) {
// Update watchdog timer
// nrk_sw_wdt_update(0);
v = tdma_recv (&rx_tdma_fd, &rx_buf, &len, TDMA_BLOCKING);
if (v == NRK_OK) {
// printf ("src: %u\r\nrssi: %d\r\n", rx_tdma_fd.src, rx_tdma_fd.rssi);
// printf ("slot: %u\r\n", rx_tdma_fd.slot);
// printf ("cycle len: %u\r\n", rx_tdma_fd.cycle_size);
v=buf_to_pkt(&rx_buf, &rx_pkt);
/*
printf ("raw len: %u\r\nraw buf: ", len);
for (i = 0; i < len; i++)
printf ("%d ", rx_buf[i]);
printf ("\r\n");
*/
if(rx_pkt.type==PING && (((rx_pkt.dst_mac&0xff) == (mac_address&0xff)) || ((rx_pkt.dst_mac&0xff)==0xff)))
{
send_ack=1;
nrk_led_clr(0);
nrk_led_clr(1);
if(rx_pkt.payload[0]==PING_1)
{
nrk_led_set(0);
nrk_wait_until_next_period();
nrk_wait_until_next_period();
nrk_wait_until_next_period();
nrk_led_clr(0);
}
if(rx_pkt.payload[0]==PING_2)
{
nrk_led_set(1);
nrk_wait_until_next_period();
nrk_wait_until_next_period();
nrk_wait_until_next_period();
nrk_led_clr(1);
}
if(rx_pkt.payload[0]==PING_PERSIST)
{
nrk_led_set(0);
}
}
if(rx_pkt.type==NW_CONFIG && (((rx_pkt.dst_mac&0xff) == (mac_address&0xff)) || (rx_pkt.dst_mac==0xff)))
{
/* printf ("payload len: %u\r\npayload: ", rx_pkt.payload_len);
for (i = 0; i < rx_pkt.payload_len; i++)
printf ("%d ", rx_pkt.payload[i]);
printf ("\r\n");
*/
// Sleep control packet
if(rx_pkt.payload[1]==NW_CONFIG_SLEEP)
{
// sleep mode off
if(rx_pkt.payload[2]==0 )
{
// Enter Deep Sleep
deep_sleep_button();
}
if(rx_pkt.payload[2]==2 )
{
// Enter snooze mode
tdma_disable();
nrk_wait_until_next_period();
tdma_snooze();
tdma_enable();
}
}
}
}
// nrk_wait_until_next_period();
}
}
