Created
April 17, 2016 03:52
-
-
Save ethanjli/c7732784afe1b08db92882808e4be6f8 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
Copyright (C) 2011 J. Coliz <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 for Getting Started with nRF24L01+ radios. | |
* | |
* This is an example of how to use the RF24 class. Write this sketch to two | |
* different nodes. Put one of the nodes into 'transmit' mode by connecting | |
* with the serial monitor and sending a 'T'. 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 9 & 10 | |
RF24 radio(9,10); | |
// | |
// Topology | |
// | |
// Radio pipe addresses for the 2 nodes to communicate. | |
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL }; | |
const uint8_t PAYLOAD_SIZE = 2; | |
// | |
// Role management | |
// | |
// Set up role. This sketch uses the same software for all the nodes | |
// in this system. Doing so greatly simplifies testing. | |
// | |
// 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 = role_ping_out; | |
void setup(void) | |
{ | |
// | |
// Print preamble | |
// | |
Serial.begin(115200); | |
printf_begin(); | |
printf("\n\rRF24/examples/GettingStarted/\n\r"); | |
printf("ROLE: %s\n\r",role_friendly_name[role]); | |
printf("*** PRESS 'T' to begin transmitting to the other node\n\r"); | |
// | |
// Setup and configure rf radio | |
// | |
radio.begin(); | |
radio.setDataRate(RF24_1MBPS); | |
radio.setPALevel(RF24_PA_MAX); | |
// optionally, increase the delay between retries & # of retries | |
radio.setRetries(15,15); | |
// optionally, reduce the payload size. seems to | |
// improve reliability | |
radio.setPayloadSize(PAYLOAD_SIZE); | |
// | |
// Open pipes to other nodes for communication | |
// | |
// This simple sketch opens two pipes for these two nodes to communicate | |
// back and forth. | |
// Open 'our' pipe for writing | |
// Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading) | |
if ( role == role_ping_out ) | |
{ | |
radio.openWritingPipe(pipes[0]); | |
radio.openReadingPipe(1,pipes[1]); | |
} | |
else | |
{ | |
radio.openWritingPipe(pipes[1]); | |
radio.openReadingPipe(1,pipes[0]); | |
} | |
// | |
// Start listening | |
// | |
radio.startListening(); | |
// | |
// Dump the configuration of the rf unit for debugging | |
// | |
radio.printDetails(); | |
// Initialize pins | |
pinMode(6, INPUT_PULLUP); | |
pinMode(A4, INPUT_PULLUP); | |
pinMode(A5, INPUT); | |
pinMode(8, OUTPUT); | |
pinMode(5, OUTPUT); | |
pinMode(7, OUTPUT); | |
} | |
unsigned int getState() { | |
bool photoresistor = analogRead(A5) < 400; | |
bool tilt_switch = digitalRead(6); | |
bool manual_switch = digitalRead(A4); | |
unsigned int state = tilt_switch + (photoresistor << 1) + (manual_switch << 2); | |
return state; | |
} | |
void updateState(unsigned int state) { | |
bool tilt_switch = state & 1; | |
digitalWrite(5, tilt_switch); | |
state = state >> 1; | |
bool photoresistor = state & 1; | |
digitalWrite(8, photoresistor); | |
state = state >> 1; | |
bool manual_switch = state & 1; | |
if (manual_switch) { | |
tone(7, 440); | |
} else { | |
noTone(7); | |
} | |
} | |
void loop(void) | |
{ | |
// | |
// Ping out role. Repeatedly send the current time | |
// | |
if (role == role_ping_out) | |
{ | |
// First, stop listening so we can talk. | |
radio.stopListening(); | |
// Take the time, and send it. This will block until complete | |
unsigned int state = getState(); | |
printf("Now sending %u...",state); | |
bool ok = radio.write( &state, sizeof(unsigned int) ); | |
if (ok) | |
printf("ok..."); | |
else | |
printf("failed.\n\r"); | |
// Now, continue listening | |
radio.startListening(); | |
// Wait here until we get a response, or timeout (250ms) | |
unsigned long started_waiting_at = millis(); | |
bool timeout = false; | |
while ( ! radio.available() && ! timeout ) | |
if (millis() - started_waiting_at > 1500 ) | |
timeout = true; | |
// Describe the results | |
if ( timeout ) | |
{ | |
printf("Failed, response timed out.\n\r"); | |
} | |
else | |
{ | |
// Grab the response, compare, and send to debugging spew | |
unsigned int got_state; | |
radio.read( &got_state, sizeof(unsigned int) ); | |
updateState(got_state); | |
// Spew it | |
printf("Got response %u\n\r",got_state); | |
} | |
// Try again 0.5s later | |
delay(1000); | |
} | |
// | |
// Pong back role. Receive each packet, dump it out, and send it back | |
// | |
if ( role == role_pong_back ) | |
{ | |
// if there is data ready | |
if ( radio.available() ) | |
{ | |
// Dump the payloads until we've gotten everything | |
unsigned int got_state; | |
bool done = false; | |
while (!done) | |
{ | |
// Fetch the payload, and see if this was the last one. | |
done = radio.read( &got_state, sizeof(unsigned int) ); | |
updateState(got_state); | |
// Spew it | |
printf("Got payload %u...",got_state); | |
// Delay just a little bit to let the other unit | |
// make the transition to receiver | |
delay(20); | |
} | |
// First, stop listening so we can talk | |
radio.stopListening(); | |
// Send the final one back. | |
got_state = getState(); | |
radio.write( &got_state, sizeof(unsigned int) ); | |
printf("Sent response.\n\r"); | |
// Now, resume listening so we catch the next packets. | |
radio.startListening(); | |
} | |
} | |
// | |
// Change roles | |
// | |
if ( Serial.available() ) | |
{ | |
char c = toupper(Serial.read()); | |
if ( c == 'T' && role == role_pong_back ) | |
{ | |
printf("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK\n\r"); | |
// Become the primary transmitter (ping out) | |
role = role_ping_out; | |
radio.openWritingPipe(pipes[0]); | |
radio.openReadingPipe(1,pipes[1]); | |
} | |
else if ( c == 'R' && role == role_ping_out ) | |
{ | |
printf("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK\n\r"); | |
// Become the primary receiver (pong back) | |
role = role_pong_back; | |
radio.openWritingPipe(pipes[1]); | |
radio.openReadingPipe(1,pipes[0]); | |
} | |
} | |
} | |
// vim:cin:ai:sts=2 sw=2 ft=cpp |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment