void tx_task () { // Get the signal for UART RX //uart_rx_signal=nrk_uart_rx_signal_get(); // Register your task to wakeup on RX Data //if(uart_rx_signal==NRK_ERROR) nrk_kprintf( PSTR("Get Signal ERROR!\r\n") ); //nrk_signal_register(uart_rx_signal); //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 // do not call bmac_init()... bmac_init (26); bmac_encryption_set_key(aes_key,16); bmac_encryption_enable(); bmac_rx_pkt_set_buffer (rx_buf, RF_MAX_PAYLOAD_SIZE); //nrk_kprintf (PSTR ("bmac_started()\r\n")); bmac_set_cca_thresh (-45); check_period.secs = 0; check_period.nano_secs = 100 * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_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); rx_signal = bmac_get_rx_pkt_signal (); nrk_signal_register (rx_signal); cnt = 0; while (1) { nrk_kprintf(PSTR("\r\n*************************************************************\r\n")); nrk_kprintf(PSTR(" PHOENIX WIRELESS UPDATE SYSTEM \r\n")); nrk_kprintf(PSTR("*************************************************************\r\n")); nrk_kprintf(PSTR("Press 'p' : To PING Nodes in Vicinity \r\n")); nrk_kprintf(PSTR("Press 'u' : To Begin Node Update \r\n")); nrk_kprintf(PSTR(" \r\n")); nrk_kprintf(PSTR("*************************************************************\r\n")); printf("Enter Choice: "); //sm=nrk_event_wait(SIG(uart_rx_signal)); //if(sm != SIG(uart_rx_signal)) //{ // nrk_kprintf( PSTR("UART signal error\r\n") ); // while(1); //} // Wait for UART signal while(1) { if(nrk_uart_data_ready(NRK_DEFAULT_UART)!=0) { // Read Character c=getchar(); printf( "%c\r\n",c); break; } timeout.secs = 0; timeout.nano_secs = 20 * NANOS_PER_MS; nrk_wait(timeout); } // Choose mode switch(c){ case 'p': programState = PING; break; case 'u': getDestMac(); phoenix_init(); programState = UPDATE; break; default: programState = NONE; nrk_kprintf(PSTR("Invalid Command! Please Try Again\r\n")); } // Reset c c = 0; nrk_wait_until_next_period(); // Execute protocol switch(programState) { case PING: pingMode(); break; case UPDATE: updateMode(); break; case NONE:;// Do nothing break; default: nrk_kprintf(PSTR("Invalid Program State\r\n")); break; } nrk_wait_until_next_period (); } }
void tx_task () { uint8_t j, i, error,unique; uint8_t samples; int8_t len; int8_t rssi, val; uint8_t *local_rx_buf; nrk_sig_t tx_done_signal; nrk_sig_t rx_signal; nrk_sig_mask_t ret; nrk_time_t check_period; nrk_time_t timeout, start, current; nrk_sig_mask_t my_sigs; 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 // do not call bmac_init()... bmac_init (26); bmac_rx_pkt_set_buffer (rx_buf, RF_MAX_PAYLOAD_SIZE); val=bmac_addr_decode_set_my_mac(((uint16_t)MY_SUBNET_MAC_0<<8)|MY_MAC); val=bmac_addr_decode_dest_mac(0xffff); // broadcast by default bmac_addr_decode_enable(); nrk_kprintf (PSTR ("bmac_started()\r\n")); bmac_set_cca_thresh (-45); check_period.secs = 0; check_period.nano_secs = 100 * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_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); rx_signal = bmac_get_rx_pkt_signal (); nrk_signal_register (rx_signal); cnt = 0; check_period.secs = 0; check_period.nano_secs = DEFAULT_CHECK_RATE * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_period); while (1) { my_nlist_elements=0; for(samples=0; samples<10; samples++ ) { nrk_led_set (GREEN_LED); check_period.secs = 0; check_period.nano_secs = DEFAULT_CHECK_RATE * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_period); build_ping_pkt( &p2p_pkt ); // Pack data structure values in buffer before transmit pack_peer_2_peer_packet(&p2p_pkt); // For blocking transmits, use the following function call. val = bmac_tx_pkt (p2p_pkt.buf, p2p_pkt.buf_len); check_period.secs = 0; check_period.nano_secs = p2p_pkt.check_rate * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_period); #ifdef TXT_DEBUG nrk_kprintf (PSTR ("\r\nSent Request:\r\n")); #endif nrk_led_clr (GREEN_LED); // Wait for packets or timeout nrk_time_get (&start); while (1) { timeout.secs = REPLY_WAIT_SECS; timeout.nano_secs = 0; // Wait until an RX packet is received //val = bmac_wait_until_rx_pkt (); nrk_set_next_wakeup (timeout); my_sigs = nrk_event_wait (SIG (rx_signal) | SIG (nrk_wakeup_signal)); if (my_sigs == 0) nrk_kprintf (PSTR ("Error calling nrk_event_wait()\r\n")); if (my_sigs & SIG (rx_signal)) { // Get the RX packet local_rx_buf = bmac_rx_pkt_get (&len, &rssi); // Check the packet type from raw buffer before unpacking if ((local_rx_buf[CTRL_FLAGS] & (DS_MASK | US_MASK)) == 0) { // Set the buffer p2p_pkt.buf=local_rx_buf; p2p_pkt.buf_len=len; p2p_pkt.rssi=rssi; unpack_peer_2_peer_packet(&p2p_pkt); #ifdef TXT_DEBUG // Check if newly received packet is for this node if (((p2p_pkt.dst_subnet_mac[2] == MY_SUBNET_MAC_2 && p2p_pkt.dst_subnet_mac[1] == MY_SUBNET_MAC_1 && p2p_pkt.dst_subnet_mac[0] == MY_SUBNET_MAC_0 && p2p_pkt.dst_mac == MY_MAC ) || p2p_pkt.dst_mac == BROADCAST) && p2p_pkt.pkt_type==PING_PKT) { // Packet arrived and is good to go printf( "src: %d ",p2p_pkt.src_mac); printf( "rssi: %d ",p2p_pkt.rssi); printf( "subnet: %d %d %d ",p2p_pkt.src_subnet_mac[0], p2p_pkt.src_subnet_mac[1], p2p_pkt.src_subnet_mac[2]); printf( "type: %d ",p2p_pkt.pkt_type); nrk_kprintf (PSTR ("payload: [")); for (i = 0; i < p2p_pkt.payload_len; i++) printf ("%d ", p2p_pkt.payload[i]); nrk_kprintf (PSTR ("]\r\n")); unique=1; // Check if the MAC is unique for(i=0; i<my_nlist_elements; i++ ) { if(my_nlist[i*NLIST_SIZE]==p2p_pkt.src_subnet_mac[2] && my_nlist[i*NLIST_SIZE+1]==p2p_pkt.src_subnet_mac[1] && my_nlist[i*NLIST_SIZE+2]==p2p_pkt.src_subnet_mac[0] && my_nlist[i*NLIST_SIZE+3]==p2p_pkt.src_mac) { unique=0; break; } } // If MAC is unique, add it if(unique) { my_nlist[my_nlist_elements*NLIST_SIZE]=p2p_pkt.src_subnet_mac[2]; my_nlist[my_nlist_elements*NLIST_SIZE+1]=p2p_pkt.src_subnet_mac[1]; my_nlist[my_nlist_elements*NLIST_SIZE+2]=p2p_pkt.src_subnet_mac[0]; my_nlist[my_nlist_elements*NLIST_SIZE+3]=p2p_pkt.src_mac; my_nlist[my_nlist_elements*NLIST_SIZE+4]=p2p_pkt.rssi; my_nlist_elements++; } } #endif } // Release the RX buffer so future packets can arrive bmac_rx_pkt_release (); } nrk_time_get (¤t); if (start.secs + REPLY_WAIT_SECS < current.secs) break; } cnt++; } check_period.secs = 0; check_period.nano_secs = DEFAULT_CHECK_RATE * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_period); nrk_kprintf (PSTR ("Done Waiting for response...\r\n")); nrk_kprintf (PSTR ("\r\n\r\nSurvey Says:\r\n")); nrk_kprintf( PSTR("LOC_DESC: \"location name\"\r\n" )); for(i=0; i<my_nlist_elements; i++ ) { nrk_kprintf( PSTR( "MAC: " )); if(my_nlist[i*NLIST_SIZE]<0x10) printf( "0%x", my_nlist[i*NLIST_SIZE] ); else printf( "%x", my_nlist[i*NLIST_SIZE] ); if(my_nlist[i*NLIST_SIZE]<0x10) printf( "0%x", my_nlist[i*NLIST_SIZE+1] ); else printf( "%x", my_nlist[i*NLIST_SIZE+1] ); if(my_nlist[i*NLIST_SIZE]<0x10) printf( "0%x", my_nlist[i*NLIST_SIZE+2] ); else printf( "%x", my_nlist[i*NLIST_SIZE+2] ); if(my_nlist[i*NLIST_SIZE]<0x10) printf( "0%x", my_nlist[i*NLIST_SIZE+3] ); else printf( "%x", my_nlist[i*NLIST_SIZE+3] ); printf( " RSSI: %d\r\n", (int8_t)my_nlist[i*NLIST_SIZE+4] ); } nrk_wait_until_next_period (); } }
void tx_task () { uint8_t j, i, cnt, error; int8_t len; int8_t rssi, val; uint8_t *local_rx_buf; nrk_sig_t tx_done_signal; nrk_sig_t rx_signal; nrk_sig_mask_t ret; nrk_time_t check_period; nrk_time_t timeout, start, current; nrk_sig_mask_t my_sigs; 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 // do not call bmac_init()... bmac_init (26); // Configure address for other packet handlers (my not be needed) my_mac= MY_MAC; my_subnet_mac[0]= MY_SUBNET_MAC_0; my_subnet_mac[1]= MY_SUBNET_MAC_1; my_subnet_mac[2]= MY_SUBNET_MAC_2; mac_address= (uint8_t)MY_SUBNET_MAC_2 << 24 | (uint8_t)MY_SUBNET_MAC_1 <<16 | (uint8_t)MY_SUBNET_MAC_0 << 8 | (uint8_t)MY_MAC; while (!bmac_started ()) nrk_wait_until_next_period (); bmac_rx_pkt_set_buffer (rx_buf, RF_MAX_PAYLOAD_SIZE); val = bmac_addr_decode_set_my_mac (((uint16_t) MY_SUBNET_MAC_0 << 8) | MY_MAC); val = bmac_addr_decode_dest_mac (0xffff); // broadcast by default bmac_addr_decode_enable (); nrk_kprintf (PSTR ("bmac_started()\r\n")); bmac_set_cca_thresh (-45); check_period.secs = 0; check_period.nano_secs = 100 * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_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); rx_signal = bmac_get_rx_pkt_signal (); nrk_signal_register (rx_signal); cnt = 0; while (1) { // Build a TX packet by hand... p2p_pkt.pkt_type = DATA_STORAGE_PKT; p2p_pkt.ctrl_flags = LINK_ACK | MOBILE_MASK; // | DEBUG_FLAG ; p2p_pkt.ack_retry = 0x0f; p2p_pkt.ttl = 1; p2p_pkt.src_subnet_mac[0] = MY_SUBNET_MAC_0; p2p_pkt.src_subnet_mac[1] = MY_SUBNET_MAC_1; p2p_pkt.src_subnet_mac[2] = MY_SUBNET_MAC_2; p2p_pkt.src_mac = MY_MAC; p2p_pkt.last_hop_mac = MY_MAC; // p2p_pkt.dst_subnet_mac[0] = BROADCAST; // p2p_pkt.dst_subnet_mac[1] = BROADCAST; // p2p_pkt.dst_subnet_mac[2] = BROADCAST; // p2p_pkt.dst_mac = BROADCAST; p2p_pkt.dst_subnet_mac[0] = BROADCAST; p2p_pkt.dst_subnet_mac[1] = BROADCAST; p2p_pkt.dst_subnet_mac[2] = BROADCAST; p2p_pkt.dst_mac = 0x1; p2p_pkt.buf = tx_buf; p2p_pkt.buf_len = P2P_PAYLOAD_START; p2p_pkt.seq_num = cnt; p2p_pkt.priority = 0; p2p_pkt.check_rate = 100; p2p_pkt.payload = &(tx_buf[P2P_PAYLOAD_START]); cnt++; #ifdef TEST_WRITE data_pkt.mode=EE_WRITE; data_pkt.addr=0x110; // Must be greater than 0x100 data_pkt.data_len=0x10; // point the eeprom data structure to our local data buffer data_pkt.eeprom_payload=eeprom_data; // copy over some data for(i=0; i<data_pkt.data_len; i++ ) data_pkt.eeprom_payload[i]=i; #endif #ifdef TEST_READ data_pkt.mode=EE_READ; data_pkt.addr=0x200; // Must be greater than 0x100 data_pkt.data_len=0x3d; #endif // add the eeprom pkt to the p2p pkt p2p_pkt.payload_len= eeprom_storage_pkt_pack(&data_pkt, p2p_pkt.payload); // Pack data structure values in buffer before transmit pack_peer_2_peer_packet (&p2p_pkt); nrk_led_set (BLUE_LED); check_period.secs = 0; check_period.nano_secs = 100 * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_period); nrk_kprintf( PSTR("sending: " )); for(i=0; i<p2p_pkt.buf_len; i++ ) printf( "%u ",p2p_pkt.buf[i] ); printf( "\r\n" ); // For blocking transmits, use the following function call. val = bmac_tx_pkt (p2p_pkt.buf, p2p_pkt.buf_len); check_period.secs = 0; check_period.nano_secs = FAST_CHECK_RATE * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_period); #ifdef TXT_DEBUG nrk_kprintf (PSTR ("\r\nSent Request:\r\n")); #endif nrk_led_clr (BLUE_LED); nrk_led_clr (GREEN_LED); // Wait for packets or timeout nrk_time_get (&start); while (1) { timeout.secs = REPLY_WAIT_SECS; timeout.nano_secs = 0; // Wait until an RX packet is received //val = bmac_wait_until_rx_pkt (); if(bmac_rx_pkt_ready()==0) { nrk_set_next_wakeup (timeout); my_sigs = nrk_event_wait (SIG (rx_signal) | SIG (nrk_wakeup_signal)); } if (my_sigs == 0) nrk_kprintf (PSTR ("Error calling nrk_event_wait()\r\n")); if (my_sigs & SIG (rx_signal)) { // Get the RX packet local_rx_buf = bmac_rx_pkt_get (&len, &rssi); // Check the packet type from raw buffer before unpacking if ((local_rx_buf[CTRL_FLAGS] & (DS_MASK | US_MASK)) == 0) { // Set the buffer p2p_pkt.buf = local_rx_buf; p2p_pkt.buf_len = len; p2p_pkt.rssi = rssi; unpack_peer_2_peer_packet (&p2p_pkt); #ifdef TXT_DEBUG if ((p2p_pkt.dst_subnet_mac[2] == MY_SUBNET_MAC_2 && p2p_pkt.dst_subnet_mac[1] == MY_SUBNET_MAC_1 && p2p_pkt.dst_subnet_mac[0] == MY_SUBNET_MAC_0 && p2p_pkt.dst_mac == MY_MAC ) || p2p_pkt.dst_mac == BROADCAST) { nrk_led_set (GREEN_LED); // Packet arrived and is good to go printf ("full mac: %d %d %d %d ", p2p_pkt.src_subnet_mac[0], p2p_pkt.src_subnet_mac[1], p2p_pkt.src_subnet_mac[2], p2p_pkt.src_mac); printf ("rssi: %d ", p2p_pkt.rssi); printf ("type: %d ", p2p_pkt.pkt_type); nrk_kprintf (PSTR ("payload: [")); for (i = 0; i < p2p_pkt.payload_len; i++) printf ("%d ", p2p_pkt.payload[i]); nrk_kprintf (PSTR ("]\r\n")); if(p2p_pkt.pkt_type== DATA_STORAGE_PKT ) { eeprom_storage_pkt_unpack(&data_pkt, p2p_pkt.payload ); nrk_kprintf( PSTR("\r\n Storage Packet " )); nrk_kprintf( PSTR("\r\n Mode: " )); switch(data_pkt.mode) { case EE_REPLY: nrk_kprintf( PSTR( "Reply")); break; case EE_ERROR: nrk_kprintf( PSTR( "Error" )); break; case EE_READ: nrk_kprintf( PSTR( "Read" )); break; case EE_WRITE: nrk_kprintf( PSTR( "Write" )); break; default: nrk_kprintf( PSTR( "unknown" )); } nrk_kprintf( PSTR("\r\n From: " )); printf( "%u",data_pkt.mac ); nrk_kprintf( PSTR("\r\n Addr: " )); printf( "%u",data_pkt.addr); nrk_kprintf( PSTR("\r\n Len: " )); printf( "%u",data_pkt.data_len); nrk_kprintf( PSTR("\r\n Data: " )); for(i=0; i<data_pkt.data_len; i++ ) printf( "%u ",data_pkt.eeprom_payload[i]); nrk_kprintf( PSTR("\r\n" )); } } #endif } } nrk_time_get (¤t); if (start.secs + REPLY_WAIT_SECS < current.secs) break; // Release the RX buffer so future packets can arrive bmac_rx_pkt_release (); } nrk_kprintf (PSTR ("Done Waiting for response...\r\n")); nrk_wait_until_next_period (); } }
void tx_task () { uint8_t i, unique; uint8_t samples ; uint8_t len; int8_t rssi, val; uint8_t *local_rx_buf; nrk_sig_t tx_done_signal; nrk_sig_t rx_signal; nrk_time_t check_period; nrk_time_t timeout, start, current; nrk_sig_mask_t my_sigs; 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 // do not call bmac_init()... bmac_init (26); bmac_rx_pkt_set_buffer (rx_buf, RF_MAX_PAYLOAD_SIZE); val = bmac_addr_decode_set_my_mac (((uint16_t) MY_SUBNET_MAC_0 << 8) | MY_MAC ); val = bmac_addr_decode_dest_mac (0xffff); // broadcast by default bmac_addr_decode_enable (); nrk_kprintf (PSTR ("bmac_started()\r\n")); bmac_set_cca_thresh (-45); check_period.secs = 0; check_period.nano_secs = 100 * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_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); rx_signal = bmac_get_rx_pkt_signal (); nrk_signal_register (rx_signal); cnt = 0; check_period.secs = 0; check_period.nano_secs = DEFAULT_CHECK_RATE * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_period); // Main loop that does: // 1) Sends out ping message // 2) Collects replies, build neighbor list and then times out // 3) Repeat 1 and 2 for 3 times // 4) Build Extended Neighborlist packet // 5) Send Neighbor list packet // 6) Wait until next period and repeat 1-6 while (1) { nrk_led_clr (ORANGE_LED); // Set our local neighbor list to be empty my_nlist_elements = 0; for (samples = 0; samples < 3; samples++) { nrk_led_set (GREEN_LED); check_period.secs = 0; check_period.nano_secs = DEFAULT_CHECK_RATE * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_period); // Construct a ping packet to send (this is being built into tx_buf) build_ping_pkt (&p2p_pkt); // Pack data structure values in buffer before transmit pack_peer_2_peer_packet (&p2p_pkt); // Send the Ping packet val = bmac_tx_pkt (p2p_pkt.buf, p2p_pkt.buf_len); // Set update rate based on p2p reply rate. // This is usually faster to limit congestion check_period.secs = 0; check_period.nano_secs = p2p_pkt.check_rate * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_period); #ifdef TXT_DEBUG nrk_kprintf (PSTR ("Pinging...\r\n")); #endif nrk_led_clr (GREEN_LED); // Grab start time for timeout nrk_time_get (&start); while (1) { // Set the amount of time to wait for timeout timeout.secs = REPLY_WAIT_SECS; timeout.nano_secs = 0; // Check if packet is already ready, or wait until one arrives // Also set timeout to break from function if no packets come my_sigs=0; if (bmac_rx_pkt_ready () == 0) { nrk_set_next_wakeup (timeout); my_sigs = nrk_event_wait (SIG (rx_signal) | SIG (nrk_wakeup_signal)); } if (my_sigs == 0) nrk_kprintf (PSTR ("Error calling nrk_event_wait()\r\n")); if (my_sigs & SIG (rx_signal)) { // Get the RX packet local_rx_buf = bmac_rx_pkt_get (&len, &rssi); // Check the packet type from raw buffer before unpacking if ((local_rx_buf[CTRL_FLAGS] & (DS_MASK | US_MASK)) == 0) { // Setup a p2p packet data structure with the newly received buffer p2p_pkt.buf = local_rx_buf; p2p_pkt.buf_len = len; p2p_pkt.rssi = rssi; // Unpack the data from the array into the p2p_pkt data struct unpack_peer_2_peer_packet (&p2p_pkt); // Check if newly received packet is for this node if (((p2p_pkt.dst_subnet_mac[2] == MY_SUBNET_MAC_2 && p2p_pkt.dst_subnet_mac[1] == MY_SUBNET_MAC_1 && p2p_pkt.dst_subnet_mac[0] == MY_SUBNET_MAC_0 && p2p_pkt.dst_mac == MY_MAC ) || p2p_pkt.dst_mac == BROADCAST) && (p2p_pkt.pkt_type == PING_PKT)) { // Packet arrived and is ping pkt! // Lets print some values out on the terminal printf ("full mac: %d %d %d %d ", p2p_pkt.src_subnet_mac[0], p2p_pkt.src_subnet_mac[1], p2p_pkt.src_subnet_mac[2], p2p_pkt.src_mac); printf ("rssi: %d ", p2p_pkt.rssi); printf ("type: %d ", p2p_pkt.pkt_type); nrk_kprintf (PSTR ("payload: [")); for (i = 0; i < p2p_pkt.payload_len; i++) printf ("%d ", p2p_pkt.payload[i]); nrk_kprintf (PSTR ("]\r\n")); unique = 1; // Check if the MAC of this ping is unique or if it already // exists in our neighbor list for (i = 0; i < my_nlist_elements; i++) { if (my_nlist[i * NLIST_SIZE] == p2p_pkt.src_subnet_mac[2] && my_nlist[i * NLIST_SIZE + 1] == p2p_pkt.src_subnet_mac[1] && my_nlist[i * NLIST_SIZE + 2] == p2p_pkt.src_subnet_mac[0] && my_nlist[i * NLIST_SIZE + 3] == p2p_pkt.src_mac) { unique = 0; break; } } // If MAC is unique, add it to our neighbor list if (unique) { my_nlist[my_nlist_elements * NLIST_SIZE] = p2p_pkt.src_subnet_mac[2]; my_nlist[my_nlist_elements * NLIST_SIZE + 1] = p2p_pkt.src_subnet_mac[1]; my_nlist[my_nlist_elements * NLIST_SIZE + 2] = p2p_pkt.src_subnet_mac[0]; my_nlist[my_nlist_elements * NLIST_SIZE + 3] = p2p_pkt.src_mac; my_nlist[my_nlist_elements * NLIST_SIZE + 4] = p2p_pkt.rssi; my_nlist_elements++; } } } } // Check if we are done waiting for pings nrk_time_get (¤t); if (start.secs + REPLY_WAIT_SECS < current.secs) break; // exit loops waiting for pings // Release the RX buffer so future packets can arrive bmac_rx_pkt_release (); // Go back to top loop to wait for more pings } cnt++; // Repeat ping 3 times } // Now we are ready to build extended neighborlist packet and send it to gateway check_period.secs = 0; check_period.nano_secs = DEFAULT_CHECK_RATE * NANOS_PER_MS; val = bmac_set_rx_check_rate (check_period); nrk_kprintf (PSTR ("Done Waiting for response...\r\n")); // If we have any neighbors, build the list if (my_nlist_elements > 0) { // Look in this function for format of extended neighborlist packet // This function also configures the parameters and destination address // of the p2p packet. The values are probably okay as defaults. build_extended_neighbor_list_pkt (&p2p_pkt, my_nlist, my_nlist_elements); // This function takes at p2p struct and packs it into an array for sending pack_peer_2_peer_packet (&p2p_pkt); nrk_led_set (BLUE_LED); // Send the list to the gateway. val = bmac_tx_pkt (p2p_pkt.buf, p2p_pkt.buf_len); printf ("size of pkt: %d\r\n", p2p_pkt.buf_len); nrk_kprintf (PSTR ("sent neighbor list packet\r\n")); nrk_led_clr (BLUE_LED); } else { nrk_led_set (RED_LED); nrk_spin_wait_us (1000); nrk_led_clr (RED_LED); } // Wait a long time until we send out the pings again // This is in a loop so that period can be small for // other uses. for (i = 0; i < 10; i++) nrk_wait_until_next_period (); // Might as well release packets that arrived during long // break since they are not replies to your ping. bmac_rx_pkt_release (); } }