181 lines
4.0 KiB
Plaintext
181 lines
4.0 KiB
Plaintext
/*
|
|
Copyright (C) 2011 James Coliz, Jr. <maniacbug@ymail.com>
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
version 2 as published by the Free Software Foundation.
|
|
*/
|
|
|
|
/**
|
|
* Example RF Radio Ping Pair
|
|
*
|
|
* This is an example of how to use the RF24 class. Write this sketch to two different nodes,
|
|
* connect the role_pin to ground on one. The ping node sends the current time to the pong node,
|
|
* which responds by sending the value back. The ping node can then see how long the whole cycle
|
|
* took.
|
|
*/
|
|
|
|
#include <SPI.h>
|
|
#include "nRF24L01.h"
|
|
#include "RF24.h"
|
|
#include "printf.h"
|
|
|
|
//
|
|
// Hardware configuration
|
|
//
|
|
|
|
// Set up nRF24L01 radio on SPI bus plus pins 8 & 9
|
|
|
|
RF24 radio(8,9);
|
|
|
|
// sets the role of this unit in hardware. Connect to GND to be the 'pong' receiver
|
|
// Leave open to be the 'ping' transmitter
|
|
const short role_pin = 7;
|
|
|
|
//
|
|
// Topology
|
|
//
|
|
|
|
// Radio pipe address for the 2 nodes to communicate.
|
|
const uint64_t pipe = 0xE8E8F0F0E1LL;
|
|
|
|
//
|
|
// Role management
|
|
//
|
|
// Set up role. This sketch uses the same software for all the nodes
|
|
// in this system. Doing so greatly simplifies testing. The hardware itself specifies
|
|
// which node it is.
|
|
//
|
|
// This is done through the role_pin
|
|
//
|
|
|
|
// The various roles supported by this sketch
|
|
typedef enum { role_ping_out = 1, role_pong_back } role_e;
|
|
|
|
// The debug-friendly names of those roles
|
|
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};
|
|
|
|
// The role of the current running sketch
|
|
role_e role;
|
|
|
|
void setup(void)
|
|
{
|
|
//
|
|
// Role
|
|
//
|
|
|
|
// set up the role pin
|
|
pinMode(role_pin, INPUT);
|
|
digitalWrite(role_pin,HIGH);
|
|
delay(20); // Just to get a solid reading on the role pin
|
|
|
|
// read the address pin, establish our role
|
|
if ( digitalRead(role_pin) )
|
|
role = role_ping_out;
|
|
else
|
|
role = role_pong_back;
|
|
|
|
//
|
|
// Print preamble
|
|
//
|
|
|
|
Serial.begin(9600);
|
|
printf_begin();
|
|
printf("\n\rRF24/examples/pingpair_pl/\n\r");
|
|
printf("ROLE: %s\n\r",role_friendly_name[role]);
|
|
|
|
//
|
|
// Setup and configure rf radio
|
|
//
|
|
|
|
radio.begin();
|
|
|
|
// We will be using the Ack Payload feature, so please enable it
|
|
radio.enableAckPayload();
|
|
|
|
//
|
|
// Open pipes to other nodes for communication
|
|
//
|
|
|
|
// This simple sketch opens a single pipes for these two nodes to communicate
|
|
// back and forth. One listens on it, the other talks to it.
|
|
|
|
if ( role == role_ping_out )
|
|
{
|
|
radio.openWritingPipe(pipe);
|
|
}
|
|
else
|
|
{
|
|
radio.openReadingPipe(1,pipe);
|
|
}
|
|
|
|
//
|
|
// Start listening
|
|
//
|
|
|
|
if ( role == role_pong_back )
|
|
radio.startListening();
|
|
|
|
//
|
|
// Dump the configuration of the rf unit for debugging
|
|
//
|
|
|
|
radio.printDetails();
|
|
}
|
|
|
|
void loop(void)
|
|
{
|
|
static uint32_t id = 0;
|
|
|
|
//
|
|
// Ping out role. Repeatedly send the current time
|
|
//
|
|
|
|
if (role == role_ping_out)
|
|
{
|
|
// Take the time, and send it. This will block until complete
|
|
unsigned long time = millis();
|
|
printf("Now sending %lu...",time);
|
|
radio.write( &time, sizeof(unsigned long) );
|
|
|
|
if ( radio.isAckPayloadAvailable() )
|
|
{
|
|
radio.read(&id,sizeof(id));
|
|
printf("Ack: [%lu] ",id);
|
|
}
|
|
printf("OK\n\r");
|
|
|
|
// Try again soon
|
|
delay(2000);
|
|
}
|
|
|
|
//
|
|
// Pong back role. Receive each packet, dump it out, add ack payload for next time
|
|
//
|
|
|
|
if ( role == role_pong_back )
|
|
{
|
|
// if there is data ready
|
|
if ( radio.available() )
|
|
{
|
|
// Dump the payloads until we've gotten everything
|
|
static unsigned long got_time;
|
|
boolean done = false;
|
|
while (!done)
|
|
{
|
|
// Fetch the payload, and see if this was the last one.
|
|
done = radio.read( &got_time, sizeof(unsigned long) );
|
|
|
|
// Spew it
|
|
printf("Got payload %lu\n",got_time);
|
|
}
|
|
|
|
// Add an ack packet for the next time around. This is a simple
|
|
// packet counter
|
|
radio.writeAckPayload( 1, &id, sizeof(id) );
|
|
++id;
|
|
}
|
|
}
|
|
}
|
|
// vim:ai:cin:sts=2 sw=2 ft=cpp
|