void Task4()
{
uint16_t cnt;
uint8_t v;
uint8_t row;
printf( "Task4 PID=%u\r\n",nrk_get_pid());
oled_on();
cnt=0;
row=0;
while(1) {
v=hrm_get_value();
sprintf(txt_str,"%d%d%d cnt=%d hrm=%d",nrk_gpio_get(NRK_MMC_9), nrk_gpio_get(NRK_MMC_10), nrk_gpio_get(NRK_MMC_11), cnt,v);
oled_write_str( 2, row, 0, 0xFFFF, txt_str );
/* oled_clear_screen();
nrk_wait_until_ticks(50);
sprintf(txt_str,"Neighbor List:");
oled_write_str( 2, 3, 0, 0xFFFF, txt_str );
nrk_wait_until_ticks(50);
sprintf(txt_str," 0x100002a -27 4");
oled_write_str( 2, 4, 0, 0xFFFF, txt_str );
nrk_wait_until_ticks(50);
sprintf(txt_str," 0x1000012: -30 2");
oled_write_str( 2, 5, 0, 0xFFFF, txt_str );
nrk_wait_until_ticks(50);
sprintf(txt_str," 0x100000a: -5 3");
oled_write_str( 2, 6, 0, 0xFFFF, txt_str );
nrk_wait_until_ticks(50);
sprintf(txt_str,"Round Trip Pkt: 93%%");
oled_write_str( 2, 9, 0, 0xFFFF, txt_str );
nrk_wait_until_ticks(50);
//putc0(0x70);
//putc0(0x01);
//nrk_wait_until_ticks(50);
oled_draw_square( 8, 83, 150, 92, 0x001F );
nrk_wait_until_ticks(50);
//putc0(0x70);
//putc0(0x00);
//nrk_wait_until_ticks(50);
oled_draw_square( 10, 85, 100, 90, 0x07e0 );
nrk_wait_until_ticks(50);
*/
cnt++;
row++;
if(row==15) {
oled_clear_screen();
row=0;
}
nrk_wait_until_next_period();
}
}
void Task1()
{
uint16_t cnt;
int8_t fd;
nrk_kprintf( PSTR("Nano-RK Version ") );
printf( "%d\r\n",NRK_VERSION );
//while(1) nrk_wait_until_next_period();
nrk_gpio_direction(NRK_MMC_9,NRK_PIN_INPUT);
nrk_gpio_direction(NRK_MMC_10,NRK_PIN_INPUT);
nrk_gpio_direction(NRK_MMC_11,NRK_PIN_INPUT);
bpm_index=0;
nrk_gpio_pullups(1);
nrk_ext_int_configure(NRK_PC_INT_5, NULL, &button_press_int);
nrk_ext_int_configure(NRK_PC_INT_6, NULL, &button_press_int);
nrk_ext_int_configure(NRK_PC_INT_7, NULL, &button_press_int);
nrk_ext_int_enable(NRK_PC_INT_5);
nrk_ext_int_enable(NRK_PC_INT_6);
nrk_ext_int_enable(NRK_PC_INT_7);
nrk_ext_int_configure(NRK_EXT_INT_0, NRK_RISING_EDGE, &heart_rate_int);
nrk_ext_int_enable(NRK_EXT_INT_0);
cnt=0;
printf( "My node's address is %u\r\n",NODE_ADDR );
fd=nrk_open(FIREFLY_SENSOR_BASIC,READ);
if(fd==NRK_ERROR) nrk_kprintf(PSTR("Failed to open sensor driver\r\n"));
printf( "Task1 PID=%u\r\n",nrk_get_pid());
while(1) {
//printf( "Task1 cnt=%u\r\n",cnt );
nrk_wait_until_next_period();
printf( "9=%d ",nrk_gpio_get(NRK_MMC_9));
printf( "10=%d ",nrk_gpio_get(NRK_MMC_10));
printf( "11=%d ",nrk_gpio_get(NRK_MMC_11));
printf( "%d %d\r\n",cnt,hrm_get_value() );
nrk_led_toggle(GREEN_LED);
// Uncomment this line to cause a stack overflow
cnt++;
}
}
// This is an interrupts routine that handles the button press.
// It has a 300ms debounce
void button_handler()
{
int8_t v;
// Make sure button is depressed for at least 50 us
nrk_spin_wait_us(50);
v=nrk_gpio_get(NRK_PORTD_0);
if(v!=0) return;
nrk_time_get(&button_cur_press);
nrk_time_sub(&button_tmp_press, button_cur_press, button_last_press );
if(button_tmp_press.secs>=1 || button_tmp_press.nano_secs>=(300*NANOS_PER_MS))
{
// Reboot the node...
socket_0_disable();
power_socket_disable(0);
nrk_int_disable();
while(1);
if(socket_0_active==1)
{
plug_led_green_clr();
power_socket_disable(0);
}
else
{
plug_led_green_set();
power_socket_enable(0);
}
button_last_press.secs=button_cur_press.secs;
button_last_press.nano_secs=button_cur_press.nano_secs;
}
}
void Task1()
{
uint16_t cnt;
int8_t fd,val,chan;
uint16_t sample;
printf( "Task1 PID=%d\r\n",nrk_get_pid());
nrk_gpio_direction(NRK_BUTTON, NRK_PIN_INPUT);
nrk_gpio_direction(NRK_DEBUG_0, NRK_PIN_OUTPUT);
nrk_led_set(RED_LED);
do{} while(nrk_gpio_get(NRK_BUTTON)==1);
nrk_led_clr(RED_LED);
nrk_led_set(GREEN_LED);
// Initialize values here
ADC_INIT ();
ADC_ENABLE ();
ADC_SET_CHANNEL (2);
while(1) {
ADC_SAMPLE_SINGLE();
ADC_GET_SAMPLE_10(sample);
// Send sync byte
putchar(0x55);
putchar(sample>>8);
putchar(sample&0xff);
}
}
void Task1()
{
nrk_time_t t;
uint16_t cnt;
uint8_t val;
cnt=0;
nrk_kprintf( PSTR("Nano-RK Version ") );
printf("b");
printf( "%d\r\n",NRK_VERSION );
printf( "My node's address is %u\r\n",NODE_ADDR );
printf( "Task1 PID=%u\r\n",nrk_get_pid());
t.secs=30;
t.nano_secs=0;
// setup a software watch dog timer
nrk_sw_wdt_init(0, &t, NULL);
nrk_sw_wdt_start(0);
nrk_gpio_direction(BUTTON, NRK_PIN_INPUT);
while(1) {
// Update watchdog timer
nrk_sw_wdt_update(0);
nrk_led_toggle(ORANGE_LED);
val=nrk_gpio_get(BUTTON);
// Button logic is inverter 0 means pressed, 1 not pressed
printf( "Task1 cnt=%u button state=%u\r\n",cnt,val );
nrk_wait_until_next_period();
// Uncomment this line to cause a stack overflow
// if(cnt>20) kill_stack(10);
// At time 50, the OS will halt and print statistics
// This requires the NRK_STATS_TRACKER #define in nrk_cfg.h
if(cnt==50) {
nrk_stats_display_all();
nrk_halt();
}
cnt++;
}
}
void Task1()
{
nrk_time_t t;
uint8_t val;
nrk_kprintf( PSTR("Nano-RK Version ") );
printf( "%d\r\n",NRK_VERSION );
nrk_gpio_direction(NRK_BUTTON, NRK_PIN_INPUT);
while(1) {
// Update watchdog timer
nrk_led_toggle(GREEN_LED);
val=nrk_gpio_get(NRK_BUTTON);
// Button logic is inverter 0 means pressed, 1 not pressed
if(val==0) nrk_led_set(BLUE_LED);
else nrk_led_clr(BLUE_LED);
printf( "button state=%u\r\n",val );
nrk_wait_until_next_period();
}
}
void deep_sleep_button()
{
int i,cnt;
nrk_int_disable();
nrk_eeprom_write_byte(EEPROM_SLEEP_STATE_ADDR,1);
nrk_led_set(0);
nrk_spin_wait_us(50000);
nrk_led_clr(0);
nrk_led_clr(1);
nrk_led_clr(2);
nrk_led_clr(3);
nrk_watchdog_disable();
nrk_int_disable();
_nrk_os_timer_stop();
nrk_gpio_direction(NRK_BUTTON, NRK_PIN_INPUT);
rf_power_down();
// Enable Pullup for button
//PORTD = 0xff;
nrk_gpio_set(NRK_BUTTON);
nrk_ext_int_configure( NRK_EXT_INT_1,NRK_LEVEL_TRIGGER, &wakeup_func);
EIFR=0xff;
nrk_ext_int_enable( NRK_EXT_INT_1);
nrk_int_enable();
DDRA=0x0;
DDRB=0x0;
DDRC=0x0;
ASSR=0;
TRXPR = 1 << SLPTR;
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
sleep_cpu();
// reboot
while(1) {
//printf( "awake!\r\n" );
nrk_led_clr(0);
nrk_led_clr(1);
nrk_led_set(1);
cnt=0;
for(i=0; i<100; i++ )
{
//if((PIND & 0x2)==0x2)cnt++;
if(nrk_gpio_get(NRK_BUTTON)==0)cnt++;
nrk_spin_wait_us(10000);
}
printf( "cnt=%d\n",cnt );
if(cnt>=50 ) {
// reboot
nrk_led_clr(1);
nrk_led_set(0);
nrk_eeprom_write_byte(EEPROM_SLEEP_STATE_ADDR,0);
nrk_spin_wait_us(50000);
nrk_spin_wait_us(50000);
nrk_watchdog_enable();
while(1);
}
nrk_led_clr(0);
nrk_led_clr(1);
TRXPR = 1 << SLPTR;
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
sleep_cpu();
}
}
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 ()
{
uint8_t i, len;
uint16_t j;
int8_t rssi, val;
int8_t data_ready, button_state;
uint8_t *local_rx_buf;
uint16_t seq_num;
uint16_t pkt_cnt;
nrk_time_t check_period;
printf ("rx_task PID=%d\r\n", nrk_get_pid ());
// init bmac on channel 25
bmac_init (15);
// Enable AES 128 bit encryption
// When encryption is active, messages from plaintext
// source will still be received.
//bmac_encryption_set_key(aes_key,16);
//bmac_encryption_enable();
// bmac_encryption_disable();
// By default the RX check rate is 100ms
// below shows how to change that
//check_period.secs=0;
//check_period.nano_secs=200*NANOS_PER_MS;
//val=bmac_set_rx_check_rate(check_period);
// The default Clear Channel Assement RSSI threshold is -45
// Setting this value higher means that you will only trigger
// receive with a very strong signal. Setting this lower means
// bmac will try to receive fainter packets. If the value is set
// too high or too low performance will suffer greatly.
bmac_set_cca_thresh(-50);
//if(val==NRK_ERROR) nrk_kprintf( PSTR("ERROR setting bmac rate\r\n" ));
// This sets the next RX buffer.
// This can be called at anytime before releaseing the packet
// if you wish to do a zero-copy buffer switch
bmac_rx_pkt_set_buffer (rx_buf, RF_MAX_PAYLOAD_SIZE);
index=0;
while (1) {
nrk_led_clr(GREEN_LED);
nrk_led_set(RED_LED);
do {
nrk_led_toggle(BLUE_LED);
printf( "\r\nTest Data\r\n" );
for(j=0; j<index; j++ )
{
printf( "run: %u pkts: %u rssi: %d\r\n",j, data[j],rssi_avg[j] );
}
for(j=0; j<100; j++ ) nrk_wait_until_next_period ();
}while( nrk_gpio_get(NRK_BUTTON)==1 );
nrk_led_clr(BLUE_LED);
nrk_led_clr(RED_LED);
for(j=0; j<100; j++ ) nrk_wait_until_next_period ();
nrk_led_set(GREEN_LED);
pkt_cnt=0;
while(1) {
// Wait until an RX packet is received
do {
data_ready=bmac_rx_pkt_ready();
button_state=nrk_gpio_get(NRK_BUTTON);
nrk_wait_until_next_period();
} while(data_ready==0 && button_state==1 );
if(button_state==0) break;
val = bmac_wait_until_rx_pkt ();
// Get the RX packet
nrk_led_set (ORANGE_LED);
local_rx_buf = bmac_rx_pkt_get (&len, &rssi);
//if( bmac_rx_pkt_is_encrypted()==1 ) nrk_kprintf( PSTR( "Packet Encrypted\r\n" ));
//printf ("Got RX packet len=%d RSSI=%d [", len, rssi);
rssi_acc+=rssi;
seq_num=local_rx_buf[1]<<8 | local_rx_buf[0];
printf ("cnt: %u seq num: %u\r\n",pkt_cnt, seq_num);
pkt_cnt++;
nrk_led_clr (ORANGE_LED);
// Release the RX buffer so future packets can arrive
bmac_rx_pkt_release ();
}
rssi_avg[index]=rssi_acc/pkt_cnt;
data[index]=pkt_cnt;
index++;
}
}
