Halo zusammen,
ich bin in letzter Zeit am experimentieren mit dem nRF24 Modul. Dabei arbeite ich mit der Bibliothek Optimized high speed nRF24L01+ driver class documentation: Optimized High Speed Driver for nRF24L01(+) 2.4GHz Wireless Transceiver. Mit den mitgelieferten Beispielen kam ich leider nicht weit. Alles richtig verkabelt und Sketch richtig hochgeladen. Dennoch kommt kein handshake...
/*
* See documentation at https://nRF24.github.io/RF24
* See License information at root directory of this library
* Author: Brendan Doherty (2bndy5)
*/
/**
* A simple example of sending data from 1 nRF24L01 transceiver to another.
*
* This example was written to be used on 2 devices acting as "nodes".
* Use the Serial Monitor to change each node's behavior.
*/
#include <SPI.h>
#include "printf.h"
#include "RF24.h"
// instantiate an object for the nRF24L01 transceiver
RF24 radio(7, 8); // using pin 7 for the CE pin, and pin 8 for the CSN pin
// Let these addresses be used for the pair
uint8_t address[][6] = {"1Node", "2Node"};
// It is very helpful to think of an address as a path instead of as
// an identifying device destination
// to use different addresses on a pair of radios, we need a variable to
// uniquely identify which address this radio will use to transmit
bool radioNumber = 1; // 0 uses address[0] to transmit, 1 uses address[1] to transmit
// Used to control whether this node is sending or receiving
bool role = false; // true = TX role, false = RX role
// For this example, we'll be using a payload containing
// a single float number that will be incremented
// on every successful transmission
float payload = 0.0;
void setup() {
Serial.begin(115200);
while (!Serial) {
// some boards need to wait to ensure access to serial over USB
}
// initialize the transceiver on the SPI bus
if (!radio.begin()) {
Serial.println(F("radio hardware is not responding!!"));
while (1) {} // hold in infinite loop
}
// print example's introductory prompt
Serial.println(F("RF24/examples/GettingStarted"));
// To set the radioNumber via the Serial monitor on startup
Serial.println(F("Which radio is this? Enter '0' or '1'. Defaults to '0'"));
while (!Serial.available()) {
// wait for user input
}
char input = Serial.parseInt();
radioNumber = input == 1;
Serial.print(F("radioNumber = "));
Serial.println((int)radioNumber);
// role variable is hardcoded to RX behavior, inform the user of this
Serial.println(F("*** PRESS 'T' to begin transmitting to the other node"));
// Set the PA Level low to try preventing power supply related problems
// because these examples are likely run with nodes in close proximity to
// each other.
radio.setPALevel(RF24_PA_LOW); // RF24_PA_MAX is default.
// save on transmission time by setting the radio to only transmit the
// number of bytes we need to transmit a float
radio.setPayloadSize(sizeof(payload)); // float datatype occupies 4 bytes
// set the TX address of the RX node into the TX pipe
radio.openWritingPipe(address[radioNumber]); // always uses pipe 0
// set the RX address of the TX node into a RX pipe
radio.openReadingPipe(1, address[!radioNumber]); // using pipe 1
// additional setup specific to the node's role
if (role) {
radio.stopListening(); // put radio in TX mode
} else {
radio.startListening(); // put radio in RX mode
}
// For debugging info
// printf_begin(); // needed only once for printing details
// radio.printDetails(); // (smaller) function that prints raw register values
// radio.printPrettyDetails(); // (larger) function that prints human readable data
} // setup
void loop() {
if (role) {
// This device is a TX node
unsigned long start_timer = micros(); // start the timer
bool report = radio.write(&payload, sizeof(float)); // transmit & save the report
unsigned long end_timer = micros(); // end the timer
if (report) {
Serial.print(F("Transmission successful! ")); // payload was delivered
Serial.print(F("Time to transmit = "));
Serial.print(end_timer - start_timer); // print the timer result
Serial.print(F(" us. Sent: "));
Serial.println(payload); // print payload sent
payload += 0.01; // increment float payload
} else {
Serial.println(F("Transmission failed or timed out")); // payload was not delivered
}
// to make this example readable in the serial monitor
delay(1000); // slow transmissions down by 1 second
} else {
// This device is a RX node
uint8_t pipe;
if (radio.available(&pipe)) { // is there a payload? get the pipe number that recieved it
uint8_t bytes = radio.getPayloadSize(); // get the size of the payload
radio.read(&payload, bytes); // fetch payload from FIFO
Serial.print(F("Received "));
Serial.print(bytes); // print the size of the payload
Serial.print(F(" bytes on pipe "));
Serial.print(pipe); // print the pipe number
Serial.print(F(": "));
Serial.println(payload); // print the payload's value
}
} // role
if (Serial.available()) {
// change the role via the serial monitor
char c = toupper(Serial.read());
if (c == 'T' && !role) {
// Become the TX node
role = true;
Serial.println(F("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK"));
radio.stopListening();
} else if (c == 'R' && role) {
// Become the RX node
role = false;
Serial.println(F("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK"));
radio.startListening();
}
}
} // loop
Nachdem ich mich durch einige Tutorials geschlagen habe, habe ich einen Sketch gefunden der funktionierte.
Transmitter
// NRF24L01 Module Tutorial - Code for Transmitter using Arduino
//Include needed Libraries at beginning
#include "RF24.h"
#include "SPI.h"
#define SwitchPin 8 // Arcade switch is connected to Pin 8 on NANO
int SentMessage[2]; // Used to store value before being sent through the NRF24L01
RF24 radio(9,10); // NRF24L01 used SPI pins + Pin 9 and 10 on the NANO
const uint64_t pipe = 0xE6E6E6E6E6E6; // Needs to be the same for communicating between 2 NRF24L01
const int max_payload_size = 32;
int ping_out[max_payload_size+1];
void setup(void){
Serial.begin(9600);
pinMode(SwitchPin, INPUT_PULLUP); // Define the arcade switch NANO pin as an Input using Internal Pullups
radio.begin(); // Start the NRF24L01
radio.setPALevel(RF24_PA_MIN); //RF24_PA_MAX
radio.setRetries(5,15);
radio.openWritingPipe(pipe); // Get NRF24L01 ready to transmit
}
void loop(void){
if (digitalRead(SwitchPin) == LOW) { // If Switch is Activated
ping_out[0] = 1;
radio.write(ping_out, max_payload_size); // Send value through NRF24L01
}
else {
ping_out[0] = 0;
radio.write(ping_out, max_payload_size); // Send value through NRF24L01
}
}
Receiver
// NRF24L01 Module Tutorial - Code for Receiver using Arduino
//Include needed Libraries at beginning
#include "RF24.h"
#include "SPI.h"
#define LED_PIN 8 // Digital In (DI) of RGB Stick connected to pin 8 of the UNO
int ReceivedMessage[2]; // Used to store value received by the NRF24L01
RF24 radio(9,10); // NRF24L01 used SPI pins + Pin 9 and 10 on the UNO
const uint64_t pipe = 0xE6E6E6E6E6E6; // Needs to be the same for communicating between 2 NRF24L01
const int max_payload_size = 32;
int ping_out[max_payload_size+1];
void setup(void){
Serial.begin(9600);
radio.begin(); // Start the NRF24L01
radio.setPALevel(RF24_PA_MIN); //RF24_PA_MAX
radio.setRetries(5,15);
radio.openReadingPipe(1,pipe); // Get NRF24L01 ready to receive
radio.startListening(); // Listen to see if information received
pinMode(LED_PIN, OUTPUT); // Set RGB Stick UNO pin to an OUTPUT
}
void loop(void){
while (radio.available()) {
radio.read(ping_out, max_payload_size); // Read information from the NRF24L01
if (ping_out[0] == 1) { // Indicates switch is pressed
digitalWrite(LED_PIN, true);
}
else {
digitalWrite(LED_PIN, false);
}
}
}
Jetzt will ich aber mit dem Acknowledgement arbeiten und komme mit dem funktionierenden Tutorial nicht sehr weit. Ich würde gerne die Beispielsketchs der Bibliothek zum laufen zu bringen um Zugang zu dem Acknowledge und anderen Funktionen zu bekommen.
Ich bedanke mich schon mal im Vorraus.
Gruß Johann