void Task1() {
uint16_t cnt;
int8_t v;
cnt = 0;
while (1) {
nrk_led_toggle(ORANGE_LED);
// printf("Task1 cnt=%d\r\n", cnt);
// nrk_kprintf(PSTR("Task1 accessing semaphore\r\n"));
// printf("T1_next_period = %u \n", nrk_cur_task_TCB->next_period);
v = nrk_sem_pend(sem1);
if (v == NRK_ERROR)
nrk_kprintf(PSTR("T1 error pend\r\n"));
// nrk_kprintf(PSTR("Task1 holding semaphore\r\n"));
// printf("In T1 sys_ceiling = %u \n", system_ceiling);
printf("In T1 Q --- ");
nrk_print_readyQ();
printf("\n");
// to something within the critical section
nrk_wait_until_next_period();
v = nrk_sem_post(sem1);
if (v == NRK_ERROR)
nrk_kprintf(PSTR("T1 error post\r\n"));
// nrk_kprintf(PSTR("Task1 released semaphore\r\n"));
nrk_wait_until_next_period();
if (cnt == 3)
break;
cnt++;
}
nrk_stats_display_all();
}
void Task1()
{
uint16_t cnt;
int8_t v;
printf( "My node's address is %d\r\n",NODE_ADDR );
printf( "Task1 PID=%d\r\n",nrk_get_pid());
cnt=0;
while(1) {
nrk_led_toggle(ORANGE_LED);
printf( "Task1 cnt=%d\r\n",cnt );
nrk_kprintf( PSTR("Task1 accessing semaphore\r\n"));
v = nrk_sem_pend(my_semaphore);
if(v==NRK_ERROR) nrk_kprintf( PSTR("T1 error pend\r\n"));
nrk_kprintf( PSTR("Task1 holding semaphore\r\n"));
// wait some time inside semaphore to show the effect
nrk_wait_until_next_period();
v = nrk_sem_post(my_semaphore);
if(v==NRK_ERROR) nrk_kprintf( PSTR("T1 error post\r\n"));
nrk_kprintf( PSTR("Task1 released semaphore\r\n"));
nrk_wait_until_next_period();
cnt++;
}
}
void tx_task()
{
int8_t v,i;
uint8_t len,cnt;
printf( "Gateway Tx Task PID=%u\r\n",nrk_get_pid());
cnt=0;
while(1) {
// This is simply a place holder in case you want to add Host -> Client Communication
v = slip_rx ( slip_rx_buf, TDMA_MAX_PKT_SIZE);
if (v > 0) {
nrk_kprintf (PSTR ("Sending data: "));
for (i = 0; i < v; i++)
printf ("%d ", slip_rx_buf[i]);
printf ("\r\n");
v=tdma_send(&tx_tdma_fd, &slip_rx_buf, v, TDMA_BLOCKING );
}
nrk_led_toggle(BLUE_LED);
}
}
void rx_task ()
{
uint8_t i,len;
int8_t rssi, v;
nrk_status_t ret;
uint8_t *local_rx_buf;
// printf( "rx_task: PID=%d\r\n",nrk_get_pid());
bmac_rx_pkt_set_buffer(rx_buf,RF_MAX_PAYLOAD_SIZE);
while(!bmac_started()) nrk_wait_until_next_period();
while(1)
{
if( bmac_rx_pkt_ready()==0)
bmac_wait_until_rx_pkt();
v = nrk_sem_pend(lock);
if( startCnt == 0 )
startCnt = 1;
v = nrk_sem_post(lock);
nrk_led_toggle(GREEN_LED);
local_rx_buf = bmac_rx_pkt_get(&len,&rssi);
printf( "rx_task: rssi=%d data=", rssi);
for( i=0; i<len; i++ ) {
printf( "%c", local_rx_buf[i]);
}
nrk_kprintf( PSTR("\r\n") );
bmac_rx_pkt_release();
}
}
void discover_task()
{
uint8_t len;
uint8_t connection_l;
while (!bmac_started ())
nrk_wait_until_next_period ();
if(log_g) printf("log:discover_task PID=%d\r\n",nrk_get_pid());
while(1) {
nrk_sem_pend(conn_sem);
connection_l = connection_g;
nrk_sem_post(conn_sem);
if(connection_l == 0 && vertsk_active_g == 0 && version_g[MAC_ADDR] > 0) {
nrk_led_toggle(BLUE_LED);
if(log_g) printf("log:Sending discover pkt\r\n");
nrk_sem_pend(tx_sem);
sprintf(tx_buf,"0:%d:S:%d",MAC_ADDR,version_g[MAC_ADDR]);
bmac_tx_pkt(tx_buf, strlen(tx_buf));
nrk_sem_post(tx_sem);
memset(tx_buf,0,strlen(tx_buf));
}
nrk_wait_until_next_period ();
}
}
//------------------------------------------------------------------------------
// void TaskRcv (void)
//
// DESCRIPTION:
// Task that periodically checks to receive a packet
//------------------------------------------------------------------------------
void TaskRcv()
{
uint8_t len;
int8_t rssi;
uint8_t *local_rx_buf;
// widom init must be in a task
wd_init (WD_CHANNEL);
// This sets the next RX buffer.
// This can be called at anytime before releasing the packet
// if you wish to do a zero-copy buffer switch
wd_rx_pkt_set_buffer (rx_buf, RF_MAX_PAYLOAD_SIZE);
while(1) {
nrk_led_toggle(GREEN_LED);
if (wd_wait_until_rx_packet() == NRK_OK) {
// Get the RX packet
local_rx_buf = wd_rx_pkt_get (&len, &rssi);
printf ("Rx Packet len=%u, prio=%u\r\n", len, local_rx_buf[1]);
//
// do something with packet here ...
//
//for (i = 0; i < len; i++)
// printf ("%c", rx_buf[i]);
//printf ("]\r\n");
wd_rx_pkt_release();
}
nrk_wait_until_next_period();
}
}
// creates Task4 and uses semaphore1
void Task4()
{
uint8_t counter;
uint8_t waitCount=3;
printf( "Task4 PID=%d\r\n",nrk_get_pid());
counter=0;
while(1)
{
nrk_led_toggle(GREEN_LED);
printf( "Task4 counter=%d\r\n",counter );
if(0==waitCount)
{
nrk_kprintf( PSTR("Task4 accessing semaphore1\r\n"));
nrk_sem_pend(semaphore1);
nrk_kprintf( PSTR("Task4 holding semaphore1\r\n"));
}
waitCount++;
if(3==waitCount)
{
nrk_sem_post(semaphore1);
nrk_kprintf( PSTR("Task4 released semaphore1\r\n"));
waitCount=0;
}
nrk_wait_until_next_period();
counter++;
}
}
void Task3 ()
{
int8_t v;
int8_t i;
printf ("Task3 PID=%d\r\n", nrk_get_pid ());
while (slip_started () != 1)
nrk_wait_until_next_period ();
while (1) {
nrk_led_toggle (GREEN_LED);
printf ("Task3\r\n");
v = slip_rx (slip_rx_buf, MAX_SLIP_BUF);
if (v > 0) {
nrk_kprintf (PSTR ("Task3 got data: "));
for (i = 0; i < v; i++)
printf ("%c", slip_rx_buf[i]);
printf ("\r\n");
}
else
nrk_kprintf (PSTR ("Task3 data failed\r\n"));
nrk_wait_until_next_period ();
}
}
void Task3 ()
{
int8_t v;
int8_t i;
printf ("Task3 PID=%d\r\n", nrk_get_pid ());
slip_init (stdin, stdout, 0, 0);
while (slip_started () != 1)
nrk_wait_until_next_period ();
while (1) {
nrk_led_toggle (RED_LED);
v = slip_rx (slip_rx_buf, MAX_SLIP_BUF);
printf ("%d\r\n", slip_rx_buf[0]);
/* if (v > 0) {
nrk_kprintf (PSTR ("Task3 got data "));
printf( "%d bytes: ",v );
for (i = 0; i < v; i++)
printf ("%d ", slip_rx_buf[i]);
printf ("\r\n");
}
else
nrk_kprintf (PSTR ("Task3 data failed\r\n"));
*/
//nrk_wait_until_next_period ();
}
}
void Task2() {
uint8_t cnt;
int8_t v;
cnt = 0;
while (1) {
nrk_led_toggle(BLUE_LED);
// printf("Task2 cnt=%d\r\n", cnt);
// nrk_kprintf(PSTR("Task2 accessing semaphore\r\n"));
// printf("T2_next_period = %u \n", nrk_cur_task_TCB->next_period);
v = nrk_sem_pend(sem1);
if (v == NRK_ERROR)
nrk_kprintf(PSTR("T2 error pend\r\n"));
// nrk_kprintf(PSTR("Task2 holding semaphore\r\n"));
// printf("In T2 sys_ceiling = %u \n", system_ceiling);
printf("In T2 Q --- ");
nrk_print_readyQ();
printf("\n");
// to something within the critical section
nrk_wait_until_next_period();
v = nrk_sem_post(sem1);
if (v == NRK_ERROR)
nrk_kprintf(PSTR("T2 error post\r\n"));
// nrk_kprintf(PSTR("Task2 released semaphore\r\n"));
nrk_wait_until_next_period();
cnt++;
}
}
//------------------------------------------------------------------------------
// void TaskSnd (void)
//
// DESCRIPTION:
// Task that periodically sends a packet
//------------------------------------------------------------------------------
void TaskSnd()
{
uint8_t ret;
// Wait until the rx_task starts up the protocol
while (!wd_started ())
nrk_wait_until_next_period ();
while(1) {
nrk_led_toggle(BLUE_LED);
// put just two bytes of payload in the packet...
tx_buf[0]=0xCB;
tx_buf[1]=MSG_PRIO; // put MSG_PRIO in the payload also
// For blocking transmits, just use the following function call.
// wd_tx_packet(tx_buf, 2, MSG_PRIO);
// This function transmits packets in a non-blocking manner
ret = wd_tx_packet_enqueue (tx_buf, 2, MSG_PRIO);
nrk_kprintf (PSTR ("Tx packet enqueued\r\n"));
// This function waits on the tx_done_signal
//ret = wd_wait_until_tx_packet();
// Just check to be sure signal is okay
if(ret != NRK_OK )
nrk_kprintf (PSTR ("TX done error!\r\n"));
nrk_wait_until_next_period();
}
}
void my_timer_callback()
{
nrk_led_toggle(ORANGE_LED);
nrk_gpio_toggle(NRK_DEBUG_0);
// Normally you should not call long functions like printf
// inside a interrupt callback
nrk_kprintf( PSTR("*** Timer interrupt!\r\n"));
}
void rx_task ()
{
uint8_t rssi,len,*local_rx_buf,mole, from, received_round;;
int i,r;
bmac_set_cca_thresh(DEFAULT_BMAC_CCA);
bmac_rx_pkt_set_buffer (rx_buf,102);
//cleaning up the target sector in the flash
iap.erase(TARGET_SECTOR,TARGET_SECTOR);
while(!bmac_started());
printf("Receiver node Bmac initialised\n");
while(1) {
nrk_wait_until_next_period();
if( !bmac_rx_pkt_ready())
continue;
printf("received packet\n\r");
nrk_led_toggle(ORANGE_LED);
local_rx_buf = (uint8_t *)bmac_rx_pkt_get (&len, &rssi);
for(i=0;i<2;i++)
printf("%d", local_rx_buf[i]);
printf("\r\n");
for(i = 2; i < len; i++)
printf("0x%X ", local_rx_buf[i]);
// getting function code
for(i = 0; i < 200; i++){
code[i] = local_rx_buf[i+2];
}
//getting function size
functionSize=local_rx_buf[1];
iap.prepare(TARGET_SECTOR, TARGET_SECTOR);
//alloting space and writing the cvode in the flash
if(functionSize % 256 ==0)
r = iap.write( code, sector_start_adress[TARGET_SECTOR], 256);
else
r = iap.write( code, sector_start_adress[TARGET_SECTOR], 256);
printf("size: %d\n", functionSize + functionSize % 256);
printf( "copied: SRAM(0x%08X)->Flash(0x%08X) for %d bytes. (result=0x%08X)\r\n", code, sector_start_adress[ TARGET_SECTOR ], 1024, r );
startAddress+=functionSize;//starting Address for next functtion to be added
functionRecieved = 0;
bmac_rx_pkt_release ();
copied_function=(function) (0xE000 | 1);
//calling the copi8ed function
functionRecieved=1;
}
// pointing the function pointer to the copied code in the flash
}
//------------------------------------------------------------------------------
// void main (void)
//
// DESCRIPTION:
// Startup routine and main loop
//------------------------------------------------------------------------------
int main (void)
{
uint8_t i,length;
uint32_t cnt;
nrk_setup_ports();
nrk_setup_uart (UART_BAUDRATE_115K2);
printf( "Basic TX...\r\n" );
nrk_led_set(0);
nrk_led_set(1);
nrk_led_clr(2);
nrk_led_clr(3);
/*
while(1) {
for(i=0; i<40; i++ )
halWait(10000);
nrk_led_toggle(1);
}
*/
rfRxInfo.pPayload = rx_buf;
rfRxInfo.max_length = RF_MAX_PAYLOAD_SIZE;
nrk_int_enable();
rf_init (&rfRxInfo, 26, 0x2420, 0x1214);
cnt=0;
while(1){
DPDS1 |= 0x3;
DDRG |= 0x1;
PORTG |= 0x1;
DDRE|=0xE0;
PORTE|=0xE0;
rfTxInfo.pPayload=tx_buf;
sprintf( tx_buf, "%lu", cnt);
rfTxInfo.length= strlen(tx_buf) + 1;
rfTxInfo.destAddr = 0x1215;
rfTxInfo.cca = 0;
rfTxInfo.ackRequest = 0;
printf( "Sending\r\n" );
// nrk_gpio_set(NRK_DEBUG_0);
if(rf_tx_packet(&rfTxInfo) != 1)
printf("--- RF_TX ERROR ---\r\n");
// nrk_gpio_clr(NRK_DEBUG_0);
cnt++;
for(i=0; i<10; i++ )
halWait(10000);
nrk_led_toggle(RED_LED);
}
}
void Task1()
{
nrk_time_t t;
uint16_t cnt;
cnt=0;
nrk_kprintf( PSTR("Nano-RK Version ") );
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());
while(1) {
nrk_led_toggle(ORANGE_LED);
//nrk_gpio_toggle(NRK_DEBUG_0);
printf( "Task1 cnt=%u\r\n",cnt );
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();
// This will induce a kernel panic on purpose
nrk_halt();
}
// This is an example of how to access the task execution data
if( cnt==10 ) {
nrk_stats_get(nrk_get_pid(), &my_stats);
nrk_kprintf( PSTR( "\r\n Total CPU: "));
t=_nrk_ticks_to_time(my_stats.total_ticks);
printf( "%lu secs %lu ms", t.secs, t.nano_secs/NANOS_PER_MS );
nrk_kprintf( PSTR( "\r\n Time [Min,Last,Max]: "));
t=_nrk_ticks_to_time(my_stats.min_exec_ticks);
printf( "%lu secs %lu ms, ", t.secs, t.nano_secs/NANOS_PER_MS );
t=_nrk_ticks_to_time(my_stats.last_exec_ticks);
printf( "%lu secs %lu ms, ", t.secs, t.nano_secs/NANOS_PER_MS );
t=_nrk_ticks_to_time(my_stats.max_exec_ticks);
printf( "%lu secs %lu ms", t.secs, t.nano_secs/NANOS_PER_MS );
nrk_kprintf( PSTR( "\r\n Swap-ins: "));
printf( "%lu",my_stats.swapped_in );
nrk_kprintf( PSTR( "\r\n Preemptions: "));
printf( "%lu",my_stats.preempted);
nrk_kprintf( PSTR( "\r\n Kernel Violations: "));
printf( "%u",my_stats.violations);
nrk_kprintf( PSTR( "\r\n Overflow Error Status: "));
printf( "%u",my_stats.overflow);
nrk_kprintf( PSTR("\r\n") );
}
cnt++;
}
}
void EncryptionTask()
{
uint8_t i, data[32], len;
while(1) {
nrk_led_toggle(ORANGE_LED);
/* 16-byte AES key */
uint8_t key[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
/* 32-byte string is used as example plaintext data */
sprintf(data, "This string is used as an input");
len = 32;
/* Set AES encryption key
** (must be 16 bytes) */
aes_setkey(key);
printf("key hex (16B): ");
for(i=0; i<16; i++)
printf("%x ", key[i]);
printf("\r\n");
printf("plaintext (%dB): \"%s\"\r\n", len, data);
printf("plaintext hex: ");
for(i=0; i<len; i++)
printf("%x ", data[i]);
printf("\r\n");
/* Encrypt data (len must be
** a multiple of 16 bytes) */
aes_encrypt(data, len);
printf("\t\t\t\t...encrypt...\r\n");
printf("cyphertext hex: ");
for(i=0; i<len; i++)
printf("%x ", data[i]);
printf("\r\n");
/* Decrypt data (len must be
** a multiple of 16 bytes) */
aes_decrypt(data, len);
printf("\t\t\t\t...decrypt...\r\n");
printf("plaintext hex: ");
for(i=0; i<len; i++)
printf("%x ", data[i]);
printf("\r\n\r\n\r\n");
nrk_wait_until_next_period();
}
}
void tx_task()
{
uint8_t cnt;
printf( "tx_task PID=%d\r\n",nrk_get_pid());
cnt=0;
while(1) {
nrk_led_toggle(BLUE_LED);
// printf( "Task2 cnt=%d\r\n",cnt );
nrk_wait_until_next_period();
cnt++;
}
}
void Task3()
{
uint16_t cnt;
//printf( "Task3 PID=%u\r\n",nrk_get_pid());
cnt=0;
while(1) {
nrk_led_toggle(GREEN_LED);
//printf( "Task3 cnt=%u\r\n",cnt );
nrk_wait_until_next_period();
cnt++;
}
}
void Task3() {
uint16_t cnt;
printf("Task3 PID=%u\r\n", nrk_get_pid());
cnt = 0;
while (1) {
nrk_led_toggle(BLUE_LED);
nrk_gpio_toggle(NRK_DEBUG_2);
printf("Task3 cnt=%u\r\n", cnt);
nrk_wait_until_next_period();
cnt++;
}
}
void Task4()
{
uint16_t cnt;
printf( "Task4 PID=%u\r\n",nrk_get_pid());
cnt=0;
while(1) {
nrk_led_toggle(RED_LED);
printf( "Task4 cnt=%u\r\n",cnt );
nrk_wait_until_next_period();
cnt++;
}
}
void Task4() {
uint8_t cnt;
cnt = 0;
while (1) {
nrk_led_toggle(GREEN_LED);
printf("In T4 sys_ceiling = %u \n", system_ceiling);
printf("In T4 Q --- ");
nrk_print_readyQ();
printf("\n");
nrk_wait_until_next_period();
cnt++;
}
}
void Task2() {
int16_t cnt;
printf("Task2 PID=%u\r\n", nrk_get_pid());
cnt = 0;
while (1) {
nrk_led_toggle(GREEN_LED);
nrk_gpio_toggle(NRK_DEBUG_1);
printf("Running: Task2 , signed cnt=%d\r\n", cnt);
nrk_wait_until_next_period();
//nrk_stats_display_pid(nrk_get_pid());
cnt--;
}
}
void Task2()
{
int16_t cnt;
//printf( "Task2 PID=%u\r\n",nrk_get_pid());
cnt=0;
while(1) {
nrk_led_toggle(BLUE_LED);
//printf( "Task2 signed cnt=%d\r\n",cnt );
//nrk_stats_display_pid(nrk_get_pid());
nrk_wait_until_next_period();
cnt--;
}
}
void Task3 ()
{
int8_t v;
uint8_t pckts=0;
printf ("radio stuff Task3 PID=%d\r\n", nrk_get_pid ());
while (slip_started () != 1)
nrk_wait_until_next_period ();
while (1) {
v = slip_rx (slip_rx_buf, MAX_SLIP_BUF);
printf("nanork@ bytesread %d\n",v);
//for (i=0;i<v;i++) printf("<%d>",slip_rx_buf[i]);
//printf("\n");
if (v > HDR_SIZE) {
ack_buf[0] = 'Z';
ack_buf[1] = slip_rx_buf[1];
ack_buf[2] = slip_rx_buf[2];
while(uart_tx_busy==1) nrk_wait_until_next_period();
uart_tx_busy=1;
slip_tx (ack_buf, 3);
uart_tx_busy=0;
rfTxInfo.pPayload = slip_rx_buf;
rfTxInfo.length= v;
rfTxInfo.destAddr = 0xFFFF;
rfTxInfo.cca = 0;
rfTxInfo.ackRequest = 0;
nrk_led_toggle (RED_LED);
pckts++;
PORTG=0x1;
if(rf_tx_packet(&rfTxInfo) != 1) {
printf("--- RF_TX ERROR ---\r\n");
nrk_spin_wait_us(10000);
}
}
}
}
// creates Task2
void Task2()
{
int16_t counter;
printf( "Task2 PID=%u\r\n",nrk_get_pid());
counter=0;
while(1)
{
nrk_led_toggle(BLUE_LED);
printf( "Task2 signed counter=%d\r\n",counter );
nrk_stats_display_pid(nrk_get_pid());
nrk_wait_until_next_period();
counter--;
}
}
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++;
}
}
int main() {
uint8_t led = 0;
nrk_setup_ports();
nrk_led_clr(ORANGE_LED);
nrk_led_clr(BLUE_LED);
nrk_led_clr(GREEN_LED);
nrk_led_clr(RED_LED);
while (1) {
nrk_led_toggle(ORANGE_LED);
nrk_spin_wait_us(PERIOD);
}
return 0;
}
void Task1()
{
uint16_t cnt;
int8_t i,fd,val;
uint16_t buf;
printf( "My node's address is %d\r\n",NODE_ADDR );
printf( "Task1 PID=%d\r\n",nrk_get_pid());
cnt=0;
while(1) {
// Open ADC device as read
fd=nrk_open(FIREFLY_SENSOR_BASIC,READ);
if(fd==NRK_ERROR) nrk_kprintf(PSTR("Failed to open sensor driver\r\n"));
nrk_led_toggle(BLUE_LED);
// Example of setting a sensor
val=nrk_set_status(fd,SENSOR_SELECT,BAT);
// Read battery first while other sensors warm up
val=nrk_read(fd,&buf,2);
printf( "Task bat=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,LIGHT);
val=nrk_read(fd,&buf,2);
printf( " light=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,TEMP);
val=nrk_read(fd,&buf,2);
printf( " temp=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,ACC_X);
val=nrk_read(fd,&buf,2);
printf( " acc_x=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,ACC_Y);
val=nrk_read(fd,&buf,2);
printf( " acc_y=%d",buf);
val=nrk_set_status(fd,SENSOR_SELECT,ACC_Z);
val=nrk_read(fd,&buf,2);
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);
printf( " audio=%d\r\n",buf);
nrk_close(fd);
nrk_wait_until_next_period();
cnt++;
}
}
void Task3() {
uint8_t cnt;
cnt = 0;
while (1) {
nrk_led_toggle(GREEN_LED);
// nrk_sem_pend(sem1);
// printf("In T3 sys_ceiling = %u \n", system_ceiling);
printf("In T3 Q --- ");
nrk_print_readyQ();
printf("\n");
nrk_wait_until_next_period();
// nrk_sem_post(sem1);
nrk_wait_until_next_period();
cnt++;
}
}
void Task1()
{
nrk_time_t t;
uint16_t cnt;
cnt=0;
nrk_kprintf( PSTR("Nano-RK Version ") );
printf( "%d\r\n",NRK_VERSION );
setup_uart1(UART_BAUDRATE_19K2);
DDRE=0x2;
printf( "My node's address is %u\r\n",NODE_ADDR );
printf( "Task1 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);
putc1('~'); putc1('A'); putc1(' '); putc1('8');
nrk_wait_until_next_period();
putc1('~'); putc1('A'); putc1(' '); putc1('8');
while(1) {
// Update watchdog timer
nrk_sw_wdt_update(0);
nrk_led_toggle(ORANGE_LED);
nrk_gpio_toggle(NRK_DEBUG_0);
printf( "Task1 cnt=%u\r\n",cnt );
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++;
}
}
