Hi Flavio - it is not exactly clear to me what you really want to achieve.
Anyway, here's an example which should work and/or should get you going.
Note that it is based on the old Mirf-library which was using a special Spi-library. The latest version of the Mirf-lib you can download now from the Arduino playground does use the SPI-lib of the Arduino 22 - but I have not tested that one against the code below.
Now to the example: it's basically a very trivial implementation of transmitting information from one Arduino moving around the environment (the "sensor") to a stationary base station. For simplicity, I opted for the following approach:
- The data is transmitted from the sensor in the form of simple ASCII strings.
- Each character of the ASCII is transmitted indiviually (very inefficient, but really simple).
- The base station just pipes the received data via the serial port to the PC.
- The PC is running software (for example based on Processing) which reads, error-checks and displays the received data.
Thus, it is a kind of a very simple "wireless serial link" between a sensor (transmitting only) and a base station (receiving only).
Here's the code for the base station. The code simply pushes every character value it receives from the nRF24L01 to the serial port. It's up to the PC-program to error-check and analyze what is received.
#include <Spi.h>
#include <mirf.h>
void setup()
{
Serial.begin(57600);
Mirf.init();
// name the receiving channel - must match tranmitter setting!
Mirf.setRADDR((byte *)"TX_01");
// just a single byte is transmitted
Mirf.payload = 1;
// we use channel 90 as it is outside of WLAN bands
// or channels used by wireless surveillance cameras
Mirf.channel = 90;
// now config the device....
Mirf.config();
// Set 1MHz data rate - this increases the range slightly
Mirf.configRegister(RF_SETUP,0x06);
}
void loop()
{
byte c;
// is there any data pending?
if( Mirf.dataReady() )
{
// well, get it
Mirf.getData(&c);
// ... and write it out to the PC
Serial.print(c);
}
}
The sensor now runs the following matching piece of code:
#include <Spi.h>
#include <mirf.h>
// converts a float into a char
// and sends it via nRF24L01
void transmit( float v)
{
byte c;
char buf[10];
dtostrf(v,9,3,buf);
for( int i=0 ; i<8 ; i++ )
{
c = buf[i];
Mirf.send(&c);
while( Mirf.isSending() ) ;
}
}
// sends a string via the nRF24L01
void transmit(const char *string)
{
byte c;
for( int i=0 ; string[i]!=0x00 ; i++ )
{
c = string[i];
Mirf.send(&c);
while( Mirf.isSending() ) ;
}
}
// send a CR/LF sequence via the nRF24L01
void transmitlf(void)
{
byte c;
c = '\r';
Mirf.send(&c);
while( Mirf.isSending() ) ;
c = '\n';
Mirf.send(&c);
while( Mirf.isSending() ) ;
}
void setup()
{
// init the transceiver
Mirf.init();
// we transmit only a single byte each time
Mirf.payload = 1;
// selecting a channel which is not too noisy
Mirf.channel = 90;
Mirf.config();
// Set 1MHz data rate
Mirf.configRegister(RF_SETUP,0x06);
// Set address - this one must match the
// address the receiver is using!
Mirf.setTADDR((byte *)"TX_01");
}
void loop()
{
float v01,v02;
// read in some values
v01 = analogRead(0);
v02 = analogRead(1);
// transmit a fixed token
transmit(" : ");
// transmit the first value
transmit(v01);
// transmit a separator
transmit(" : ");
// transmit a second token
transmit(v02);
// transmit a CR/LF for the PC
// software to sync to
transmitlf();
// ... just take your time
delay(100);
}
That's basically it.
The PC software monitors the serial port of the Arduino which is acting as a base station and waits for a CR/LF-sequence to arrive in the data stream in order to start processing.
Once a full string is received, a simple error-checking strategy is employed in the PC software. The first thing to check is whether the two ":" transmitted from the sensor are present.
Furthermore, as the float values are converted by the sensor into strings with a fixed length, the total length of the transmitted string stays constant. However, some bytes might not be received by the base station.
So if you display only data which does have the two ":" transmitted and does have the correct message length, the link becomes quite stable.
As mentioned, this code does not really use any of the advanced features of the nRF24L01, but it should get you started with communications between two Arduinos.
You might want to go further by trying to implement:
- Transmitting directly binary data in larger data chunks. The nRF24L01 can transmit up to 32byte in one piece.
- Fine-tuning the Shockburst mode and other transmission parameters for your needs.
- Implementing a two-communication link.
- Utilzing/taking care of the FIFO in the nRF24L01.
As the nRF24L01 does feature error-checking in Shockburst mode, such an improved implementation will release the burden of error-checking from the analyzing software running on the PC. The above described method is simple and fast (or quick and dirty, depending on the way you look at it ).