I am a beginner in arduino programming. I am trying to work with NRF24L01. In an example code I found the given instruction. Someone please tell me what it is for. Pardon if it is a silly question.
printf_P(PSTR("---------------------------------\n\r"));
I'm Including the example code as well
#include <avr/pgmspace.h>
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#include "printf.h"
/***********************************************************************
************* Set the Node Address *************************************
/***********************************************************************/
// These are the Octal addresses that will be assigned
const uint16_t node_address_set[10] = { 00, 02, 05, 012, 015, 022, 025, 032, 035, 045 };
// 0 = Master
// 1-2 (02,05) = Children of Master(00)
// 3,5 (012,022) = Children of (02)
// 4,6 (015,025) = Children of (05)
// 7 (032) = Child of (02)
// 8,9 (035,045) = Children of (05)
uint8_t NODE_ADDRESS = 0; // Use numbers 0 through to select an address from the array
//
//
RF24 radio(7,8); // CE & CS pins to use (Using 7,8 on Uno,Nano)
RF24Network network(radio);
uint16_t this_node; // Our node address
const unsigned long interval = 1000; // ms // Delay manager to send pings regularly.
unsigned long last_time_sent;
const short max_active_nodes = 10; // Array of nodes we are aware of
uint16_t active_nodes[max_active_nodes];
short num_active_nodes = 0;
short next_ping_node_index = 0;
bool send_T(uint16_t to); // Prototypes for functions to send & handle messages
bool send_N(uint16_t to);
void handle_T(RF24NetworkHeader& header);
void handle_N(RF24NetworkHeader& header);
void add_node(uint16_t node);
void setup(){
Serial.begin(115200);
printf_begin();
printf_P(PSTR("\n\rRF24Network/examples/meshping/\n\r"));
this_node = node_address_set[NODE_ADDRESS]; // Which node are we?
SPI.begin(); // Bring up the RF network
radio.begin();
radio.setPALevel(RF24_PA_HIGH);
network.begin(/channel/ 100, /node address/ this_node );
}
void loop(){
network.update(); // Pump the network regularly
while ( network.available() ) { // Is there anything ready for us?
RF24NetworkHeader header; // If so, take a look at it
network.peek(header);
switch (header.type){ // Dispatch the message to the correct handler.
case 'T': handle_T(header); break;
case 'N': handle_N(header); break;
default: printf_P(PSTR("*** WARNING *** Unknown message type %c\n\r"),header.type);
network.read(header,0,0);
break;
};
}
unsigned long now = millis(); // Send a ping to the next node every 'interval' ms
if ( now - last_time_sent >= interval ){
last_time_sent = now;
uint16_t to = 00; // Who should we send to? By default, send to base
if ( num_active_nodes ){ // Or if we have active nodes,
to = active_nodes[next_ping_node_index++]; // Send to the next active node
if ( next_ping_node_index > num_active_nodes ){ // Have we rolled over?
next_ping_node_index = 0; // Next time start at the beginning
to = 00; // This time, send to node 00.
}
}
bool ok;
if ( this_node > 00 || to == 00 ){ // Normal nodes send a 'T' ping
ok = send_T(to);
}else{ // Base node sends the current active nodes out
ok = send_N(to);
}
if (ok){ // Notify us of the result
printf_P(PSTR("%lu: APP Send ok\n\r"),millis());
}else{
printf_P(PSTR("%lu: APP Send failed\n\r"),millis());
last_time_sent -= 100; // Try sending at a different time next time
}
}
// delay(50); // Delay to allow completion of any serial printing
// if(!network.available()){
// network.sleepNode(2,0); // Sleep this node for 2 seconds or a payload is received (interrupt 0 triggered), whichever comes first
// }
}
/**
- Send a 'T' message, the current time
*/
bool send_T(uint16_t to)
{
RF24NetworkHeader header(/to node/ to, /type/ 'T' /Time/);
// The 'T' message that we send is just a ulong, containing the time
unsigned long message = millis();
printf_P(PSTR("---------------------------------\n\r"));
printf_P(PSTR("%lu: APP Sending %lu to 0%o...\n\r"),millis(),message,to);
return network.write(header,&message,sizeof(unsigned long));
}
/**
- Send an 'N' message, the active node list
*/
bool send_N(uint16_t to)
{
RF24NetworkHeader header(/to node/ to, /type/ 'N' /Time/);
printf_P(PSTR("---------------------------------\n\r"));
printf_P(PSTR("%lu: APP Sending active nodes to 0%o...\n\r"),millis(),to);
return network.write(header,active_nodes,sizeof(active_nodes));
}
/**
- Handle a 'T' message
- Add the node to the list of active nodes
*/
void handle_T(RF24NetworkHeader& header){
unsigned long message; // The 'T' message is just a ulong, containing the time
network.read(header,&message,sizeof(unsigned long));
printf_P(PSTR("%lu: APP Received %lu from 0%o\n\r"),millis(),message,header.from_node);
if ( header.from_node != this_node || header.from_node > 00 ) // If this message is from ourselves or the base, don't bother adding it to the active nodes.
add_node(header.from_node);
}
/**
- Handle an 'N' message, the active node list
*/
void handle_N(RF24NetworkHeader& header)
{
static uint16_t incoming_nodes[max_active_nodes];
network.read(header,&incoming_nodes,sizeof(incoming_nodes));
printf_P(PSTR("%lu: APP Received nodes from 0%o\n\r"),millis(),header.from_node);
int i = 0;
while ( i < max_active_nodes && incoming_nodes > 00 )
-
add_node(incoming_nodes[i++]);*
}
/**
* Add a particular node to the current list of active nodes
*/
void add_node(uint16_t node){ -
short i = num_active_nodes; // Do we already know about this node?*
-
while (i--) {*
if ( active_nodes == node )
* break;*
* }*
* if ( i == -1 && num_active_nodes < max_active_nodes ){ // If not, add it to the table*
* active_nodes[num_active_nodes++] = node;
printf_P(PSTR("%lu: APP Added 0%o to list of active nodes.\n\r"),millis(),node);
_ }_
_}*_