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 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 inter_tx_task () {
uint8_t i;
nrk_sig_t tx_done_signal;
while (!bmac_started ())
nrk_wait_until_next_period ();
tx_done_signal = bmac_get_tx_done_signal ();
nrk_signal_register (tx_done_signal);
bmac_addr_decode_enable();
bmac_addr_decode_set_my_mac(MyOwnAddress);
while (1) {
if(ipQue>0) {
if(itxPtr>queMax-1) {
itxPtr=0;
}
bmac_addr_decode_enable();
bmac_addr_decode_set_my_mac(MyOwnAddress);
nrk_led_set(BLUE_LED);
bmac_auto_ack_disable();
for(i=0; i<ipLen[itxPtr]; i++) {
itx_buf[i]=ipDat[itxPtr][i];
}
if(ipDes[itxPtr]==0xFF) {
bmac_addr_decode_dest_mac(0xFFFF);
}
else {
bmac_addr_decode_dest_mac(ipDes[itxPtr]);
}
bmac_tx_pkt((char*)itx_buf,ipLen[itxPtr]);
ipQue--;
itxPtr++;
nrk_led_clr(BLUE_LED);
}
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 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++;
}
}
// net_tx_task - send network messages
void tx_net_task() {
volatile uint8_t counter = 0;
volatile uint8_t tx_data_flag;
// print task pid
printf("tx_net PID: %d.\r\n", nrk_get_pid());
// Wait until bmac has started. This should be called by all tasks
// using bmac that do not call bmac_init().
while(!bmac_started ()) {
nrk_wait_until_next_period ();
}
// loop forever
while(1) {
// increment counter and set flags
counter++;
tx_data_flag = counter % NODE_TX_DATA_FLAG;
// if data shoudl be transmitted, then call the tx_data() helper
if (TRANSMIT == tx_data_flag) {
tx_data();
counter = 0;
} else {
tx_cmds();
}
// nrk_kprintf(PSTR("OUT\r\n"));
nrk_wait_until_next_period();
}
nrk_kprintf(PSTR("Fallthrough: tx_net_task\r\n"));
}
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 tx_task ()
{
int r;
uint8_t length, val;
nrk_sig_t tx_done_signal;
nrk_sig_mask_t ret;
nrk_time_t r_period;
while (!bmac_started ())
nrk_wait_until_next_period ();
tx_done_signal = bmac_get_tx_done_signal ();
nrk_signal_register (tx_done_signal);
while(1) {
nrk_wait_until_next_period();
if(functionRecieved) {
tx_buf[0] = MY_ID;
tx_buf[1] = 100;
length = 2;
val=bmac_tx_pkt(tx_buf, length);
r = copied_function();
printf("Value returned from copied function is %d\n",r);
}
}
}
void TaskGPS ()
{
uint8_t i,n,checksum,index=0;
char c;
uint8_t line_cnt=0;
printf( "Task2 PID=%d\r\n",nrk_get_pid());
while(1) {
if(nrk_uart_data_ready_gps(1)) {
c = getc_gps();
gps_print_buf[index++]=c;
if(c=='\n') {
gps_print_buf[index]='\0';
while(uart_tx_busy==1) nrk_wait_until_next_period();
uart_tx_busy=1;
printf("%s\n", gps_print_buf);
uart_tx_busy=0;
index=0;
}
if(index>=GPS_PRINT_BUF_LEN)
index=0;
}
else{
nrk_wait_until_next_period();
}
}
}
void tx_task()
{
uint8_t cnt = 0;
uint8_t val;
int8_t v;
// printf( "tx_task: PID=%d\r\n",nrk_get_pid());
bmac_init(25);
while(!bmac_started()) nrk_wait_until_next_period();
while(1)
{
if (cnt > 25) {
nrk_led_set(BLUE_LED);
nrk_terminate_task();
}
nrk_led_set(RED_LED);
sprintf( tx_buf, "%d", cnt );
val = bmac_tx_pkt(tx_buf, strlen(tx_buf));
nrk_led_clr(RED_LED);
// nrk_kprintf( PSTR("TX task sent data!\r\n") );
nrk_wait_until_next_period();
v = nrk_sem_pend(lock);
if ( startCnt )
cnt++;
v = nrk_sem_post(lock);
}
}
//------------------------------------------------------------------------------
// 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 Task2()
{
int16_t cnt;
int8_t val;
uint32_t sector = 0;
nrk_sem_t *radio_sem;
while(1) nrk_wait_until_next_period();
radio_sem= rf_get_sem();
if(radio_sem==NULL) nrk_kprintf( PSTR("radio sem failed!\r\n" ));
printf( "Task2 PID=%u\r\n",nrk_get_pid());
cnt=0;
val=mmc_init();
if(val!=0 ) {
printf( "val=%d\r\n",val );
nrk_kprintf( PSTR("card init failed\r\n") );
while(1);
}
while(1) {
nrk_sem_pend (radio_sem);
printf("\nsector %lu\n\r",sector); // show sector number
val=mmc_readsector(sector,sectorbuffer); // read a data sector
printf( "readsector returned %d\n",val );
for(cnt=0; cnt<32; cnt++ )
printf( "%d ",sectorbuffer[cnt] );
printf( "\n\r" );
val=sectorbuffer[0];
val++;
for(cnt=0; cnt<512; cnt++ )
{
sectorbuffer[cnt]=val;
}
nrk_kprintf( PSTR("Writting\r\n") );
val=mmc_writesector(sector,sectorbuffer); // read a data sector
printf( "writesector returned %d\n",val );
printf( "After write:\r\n" );
val=mmc_readsector(sector,sectorbuffer); // read a data sector
nrk_sem_post(radio_sem);
printf( "readsector returned %d\n",val );
if(val==0)
{
for(cnt=0; cnt<32; cnt++ )
printf( "%d ",sectorbuffer[cnt] );
nrk_kprintf( PSTR("\n\r") );
}
sector++;
// nrk_led_toggle(RED_LED);
// printf( "Task2 signed cnt=%d\r\n",cnt );
nrk_wait_until_next_period();
cnt--;
}
}
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 ack_tx_task()
{
int i=0;
uint8_t val;
nrk_sig_t tx_done_signal;
while (!bmac_started ())
nrk_wait_until_next_period ();
//tx_done_signal = bmac_get_tx_done_signal ();
nrk_signal_register (tx_done_signal);
//printf("Ack task\n");
while(1)
{
for(i=1;i<=MAX_MOLES;i++)
{
if(i==MY_ID)
{
continue;
}
//send Ack
if(sendAckFlag[i])
{
sendAckFlag[i]=0;
switch(receiverNextPacket[i])
{
case SEND_ACK:
val=bmac_tx_pkt(&(ack_buf[i][0]),5);
printf("Sent Ack\n");
receiverNextPacket[i] = STOP;
break;
default:
break;
}
}
}
nrk_wait_until_next_period();
}
}
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);
}
}
}
}
void retrans_task() {
if(log_g) printf ("log:retrans_task PID=%d\r\n", nrk_get_pid ());
uint8_t cnt = 0;
uint8_t connection_l;
uint8_t data_cnt;
uint8_t prev_data_seq = 0;
// while (!bmac_started ())
nrk_wait_until_next_period ();
while(1) {
nrk_sem_pend(conn_sem);
connection_l = connection_g;
nrk_sem_post(conn_sem);
if(pending_retransmit_g == 1) {
if(log_g) printf("log:Re-transmitting packet\r\n");
bmac_tx_pkt(uart_rx_buf, strlen(uart_rx_buf));
retransmit_count_g++;
if(retransmit_count_g==5)
terminate_connection();
} else {
// this checks if there is a connection and one is receivng data then
// if the sender shuts down then the connection is terminated after a while
if(connection_l == 1 && data_index_g < 0) {
if(recv_data_seq_g == prev_data_seq)
data_cnt++;
if(recv_data_seq_g > prev_data_seq)
{
data_cnt = 0;
prev_data_seq = recv_data_seq_g;
}
if(data_cnt > 5) {
if(log_g)nrk_kprintf(PSTR("log:Recv cn term\n"));
terminate_connection();
data_cnt = 0;
}
}
cnt++;
//if(log_g) printf("log:ver activ con:%d cnt:%d\n",connection_l,cnt);
if(cnt>0 && connection_l == 0) {
cnt = 0;
vertsk_active_g = 1;
}
}
nrk_wait_until_next_period();
}
}
void Task3()
{
uint8_t i, len,cnt;
int8_t rssi, val;
uint8_t *local_rx_buf;
nrk_sig_mask_t ret;
nrk_time_t check_period;
printf( "Task3 PID=%u\r\n",nrk_get_pid());
// init bmac on channel 25
bmac_init (25);
bmac_rx_pkt_set_buffer (rx_buf, RF_MAX_PAYLOAD_SIZE);
while (!bmac_started ())
nrk_wait_until_next_period ();
/* while (1) {
// Wait until an RX packet is received
nrk_kprintf( PSTR( "Waiting for packet\r\n" ));
val = bmac_wait_until_rx_pkt ();
// Get the RX packet
nrk_led_set (ORANGE_LED);
local_rx_buf = bmac_rx_pkt_get (&len, &rssi);
printf ("Got RX packet len=%d RSSI=%d [", len, rssi);
for (i = 0; i < len; i++)
printf ("%c", rx_buf[i]);
printf ("]\r\n");
nrk_led_clr (ORANGE_LED);
// Release the RX buffer so future packets can arrive
bmac_rx_pkt_release ();
}
*/
while (1) {
// Build a TX packet
sprintf (tx_buf, "This is a test %d", cnt);
cnt++;
nrk_led_set (RED_LED);
// For blocking transmits, use the following function call.
// For this there is no need to register
val=bmac_tx_pkt(tx_buf, strlen(tx_buf)+1);
// Task gets control again after TX complete
nrk_kprintf (PSTR ("Tx task sent data!\r\n"));
nrk_led_clr (RED_LED);
nrk_wait_until_next_period ();
}
}
void tx_task ()
{
uint8_t j, i, val, len, cnt;
volatile uint8_t start;
uint16_t ticks,ticks_min,ticks_max;
uint16_t iterations;
uint16_t nrk_max_sleep_wakeup_time;
nrk_sig_t tx_done_signal;
nrk_sig_mask_t ret;
iterations=0;
ticks_min=-1;
ticks_max=0;
tx_data_ok=0;
// Wait until the tx_task starts up bmac
// This should be called by all tasks using bmac that
// do not call bmac_init()...
while (!bmac_started ())
nrk_wait_until_next_period ();
// Get and register the tx_done_signal if you want to
// do non-blocking transmits
tx_done_signal = bmac_get_tx_done_signal ();
nrk_signal_register (tx_done_signal);
cnt = 0;
while (1) {
// Build a TX packet
sprintf (tx_buf, "This is a test %d", cnt);
cnt++;
// For blocking transmits, use the following function call.
// For this there is no need to register
// val=bmac_tx_packet(tx_buf, strlen(tx_buf));
// This function shows how to transmit packets in a
// non-blocking manner
val = bmac_tx_pkt_nonblocking(tx_buf, strlen (tx_buf));
// This functions waits on the tx_done_signal
ret = nrk_event_wait (SIG(tx_done_signal));
// Just check to be sure signal is okay
if(ret & SIG(tx_done_signal) == 0 )
nrk_kprintf (PSTR ("TX done signal error\r\n"));
else tx_data_ok=1;
// Task gets control again after TX complete
//nrk_kprintf (PSTR ("Tx task sent data!\r\n"));
nrk_wait_until_next_period ();
}
}
void Task2 ()
{
uint8_t cnt;
printf ("Task2 PID=%d\r\n", nrk_get_pid ());
cnt = 0;
while (1) {
nrk_led_set (BLUE_LED);
printf ("Task2 cnt=%d\r\n", cnt);
nrk_wait_until_next_period ();
nrk_led_clr (BLUE_LED);
nrk_wait_until_next_period ();
cnt++;
}
}
void rx_task ()
{
uint8_t i, len, rssi;
int8_t val;
//char *local_rx_buf;
nrk_time_t check_period;
printf ("rx_task PID=%d\r\n", nrk_get_pid ());
// init bmac on channel 24
bmac_init (24);
// Enable AES 128 bit encryption
// When encryption is active, messages from plaintext
// source will still be received.
// Commented out by MB
//bmac_encryption_set_key(aes_key,16);
//bmac_encryption_enable();
// bmac_encryption_disable();
// By default the RX check rate is 200ms
// 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.
// 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(DEFAULT_BMAC_CCA);
// 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);
while (1) {
// Wait until an RX packet is received
//val = bmac_wait_until_rx_pkt ();
//printf("Hi..\n");
// Get the RX packet
nrk_led_set (ORANGE_LED);
length1=len;
nrk_led_clr (ORANGE_LED);
// Release the RX buffer so future packets can arrive
bmac_rx_pkt_release ();
// this is necessary
nrk_wait_until_next_period ();
}
}
void Task2()
{
uint8_t cnt;
printf( "Task2 PID=%d\r\n",nrk_get_pid());
cnt=0;
while(1) {
nrk_led_set(BLUE_LED);
printf( "Task2 cnt=%d\r\n",cnt );
cnt++;
//if(cnt>=10) while(1); // This will test the reservation
//if(cnt>=10) kill_stack(100);
nrk_wait_until_next_period();
nrk_led_clr(BLUE_LED);
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++;
}
}
//Reads the autogain
void synt_task()
{
int16_t cnt,RdVal;
int8_t v,ClkCnt;//Keeps track of the clock pulses every period
uint8_t RdBit;
cnt=0;
while(1)
{
RdVal = 0;
//Generate 8 clock pulses. Read data before L>H
//LSB received first. MSB rcvd last
for(ClkCnt=0;ClkCnt<8;ClkCnt++)
{
PORTD &= ~_BV(PORTD3);
nrk_wait_ticks(1);
RdBit = (PIND & 0x04)>>2;
RdVal |= (RdBit<<ClkCnt);
PORTD |= _BV(PORTD3);
nrk_wait_ticks(1);
}
Gain = RdVal;
//printf("Gain = %d\r\n",Gain);
nrk_wait_until_next_period();
cnt--;
}
}
void Task4()
{
int8_t v;
uint8_t cnt;
nrk_sig_mask_t my_sigs;
cnt =0;
printf("Node's addre is %d\r\n",NODE_ADDR);
printf("Task4 PID=%d\r\n",nrk_get_pid());
while(1)
{
// nrk_led_toggle(ORANGE_LED);
V_5Sec_U8R++;
if(V_5Sec_U8R==5)
{
V_5Sec_U8R=0;
// v = nrk_event_signal(signal_one);
// if(v==NRK_ERROR)
// nrk_kprintf( PSTR("T1 nrk_event_signal failed\r\n"));
cnt++;
}
else
{
}
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();
}
}
/* prints out data received from the adxl345 */
void Task_Accelorometer()
{
while(1){
messageBuf[0] = (ADXL345_ADDRESS) | (FALSE<<TWI_READ_BIT);
messageBuf[1] = ADXL345_REGISTER_XLSB;
TWI_Start_Transceiver_With_Data(messageBuf, 2);
/* Read 7 bytes from the data registers, starting with the LSB of X */
messageBuf[0] = (ADXL345_ADDRESS) | (TRUE<<TWI_READ_BIT);
/* set the rest of the messagebuf to 0, probably not necessary */
messageBuf[1] = 0;
messageBuf[2] = 0;
messageBuf[3] = 0;
messageBuf[4] = 0;
messageBuf[5] = 0;
messageBuf[6] = 0;
TWI_Start_Transceiver_With_Data(messageBuf, 7);
/* if successful, print data received */
/* data comes in like so: x1, x0, y1, y0, z1, z0, sign extended format */
/* the 0th byte of every axis represents its sign */
if (TWI_Get_Data_From_Transceiver(messageBuf, 7)){
printf("ADXL: x0:%x x1:%x y0:%x y1:%x z0:%x z1:%x \r\n",messageBuf[2],messageBuf[1],messageBuf[4],messageBuf[3],messageBuf[6],messageBuf[5]);
}
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 rx_task() {
uint8_t i, len, rssi, *local_rx_buf;
bmac_set_cca_thresh(DEFAULT_BMAC_CCA);
bmac_rx_pkt_set_buffer ((char*)rx_buf, RF_MAX_PAYLOAD_SIZE);
while (1) {
if(cache[0]==MyOwnAddress) {
nrk_led_set(RED_LED);
}
else {
nrk_led_clr(RED_LED);
}
bmac_wait_until_rx_pkt();
nrk_led_set(ORANGE_LED);
(char*)local_rx_buf = bmac_rx_pkt_get (&len, &rssi);
for(i=0; i<len; i++) {
putchar(local_rx_buf[i]);
}
RxPacketProcess(local_rx_buf,len);
nrk_led_clr (ORANGE_LED);
bmac_rx_pkt_release();
nrk_wait_until_next_period ();
}
}
nrk_status_t nrk_terminate_task(nrk_task_type * Task)
{
nrk_queue *curNode;
//PAJA: CRITICAL SECTIONS!!!!!!!
nrk_int_disable();
//////// nrk_rem_from_readyQ(nrk_cur_task_TCB->task_ID);
nrk_rem_from_readyQ(Task->task_ID);
nrk_cur_task_TCB->task_state = FINISHED;
//(Task->taskTCB)->task_state = FINISHED;
(Task->taskTCB)->event_suspend = 0; //fix srinivas
tasksNumber--;
curNode = _free_node; //free node can not be NULL
while (curNode->Next!=NULL) curNode = curNode->Next;
if (_free_node->Next!=NULL)
(curNode->Prev)->Next = NULL;
else
_free_node = NULL;
//free(curNode); paja: mui importante!!!!!!!!!
nrk_int_enable();
// HAHA, there is NO next period...
nrk_wait_until_next_period ();
return NRK_OK;
}
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();
}
}
