Ein robustes Arduino Wireless Mesh Network mit NRF24L01 Modulen aufbauen

In diesem Tutorial lernen Sie, wie Sie ein Arduino Wireless Network aufbauen, das aus mehreren NRF24L01 Transceiver-Modulen besteht. Sie können das folgende Video ansehen oder die schriftliche Anleitung unten lesen.

Überblick

Als Beispiel habe ich ein Netzwerk aus 5 Knoten erstellt, von denen jeder mit jedem anderen Knoten im Netzwerk kommunizieren kann und gleichzeitig als Sender und Empfänger fungiert. Dieses Beispiel ist so aufgebaut, dass es zeigt, wie man ein viel größeres Netzwerk erstellt – genauer gesagt können insgesamt 3125 Module auf einem einzigen RF-Kanal miteinander kommunizieren. Sehen wir uns an, wie das funktioniert.

In meinen vorherigen Tutorials haben wir bereits gelernt, wie man eine drahtlose Kommunikation zwischen zwei Arduino-Boards mit NRF24L01-Modulen und der RF24-Bibliothek herstellt. Zusätzlich zu dieser Bibliothek werden wir nun die RF24Network-Bibliothek verwenden, die es auf einfache Weise ermöglicht, ein Arduino Wireless Network mit vielen Boards aufzubauen, die miteinander kommunizieren. Hier ist die Funktionsweise der Netzwerktopologie.

Kommunikation mehrerer NRF24L01 Module

Ein einzelnes NRF24L01 Modul kann aktiv bis zu 6 andere Module gleichzeitig abhören.

Diese Fähigkeit wird von der RF24Network-Bibliothek genutzt, um ein Netzwerk in einer Baumtopologie zu erzeugen, wobei ein Knoten die Basis ist und alle anderen Knoten Kinder entweder dieses Knotens oder eines anderen sind. Jeder Knoten kann bis zu 5 Kinder haben, und dies kann 5 Ebenen tief gehen, was bedeutet, dass wir ein Netzwerk von insgesamt 3125 Knoten erstellen können. Jeder Knoten muss mit einer 15-Bit-Adresse definiert werden, die die Position des Knotens im Baum genau beschreibt.

Wir können die Adressen der Knoten tatsächlich im Oktalformat definieren. Die Adresse des Masters oder der Basis ist 00, die Kinder der Basis haben die Adressen 01 bis 05, die Kinder des Knotens 01 haben die Adressen 011 bis 051 usw.

Beachten Sie, dass wenn Knoten 011 mit Knoten 02 sprechen möchte, die Kommunikation über Knoten 01 und den Basisknoten 00 laufen muss. Daher müssen diese beiden Knoten ständig aktiv sein, damit die Kommunikation erfolgreich ist.

Arduino Wireless Servo Motor Control using the RF24Network Library

Bevor wir das Hauptbeispiel dieses Tutorials erklären, machen wir zur besseren Verständnis der Bibliothek ein einfacheres Beispiel mit zwei Arduino-Boards, die miteinander kommunizieren. Hier ist der Schaltplan für dieses Beispiel.

Sie erhalten die für dieses Arduino Tutorial benötigten Komponenten über die Links unten:

• NRF24L01 Transceiver Modul
• Servo Motor
• Potentiometer
• Arduino Nano

Mit dem Potentiometer am ersten Arduino steuern wir den Servomotor am zweiten Arduino. Sehen wir uns nun die Quellcodes an.

Code auf der Potentiometer-Seite (Knoten 00)

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial == Example 01 - Servo Control / Node 00 - Potentiometer == by Dejan, www.HowToMechatronics.com Libraries: nRF24/RF24, https://github.com/nRF24/RF24 nRF24/RF24Network, https://github.com/nRF24/RF24Network */
#include <RF24.h>
#include <RF24Network.h>
#include <SPI.h>

RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 00; // Address of this node in Octal format
const uint16_t node01 = 01;

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node); //(channel, node address)
}

void loop() {
  network.update();
  unsigned long potValue = analogRead(A0); // Read the potentiometer value
  unsigned long angleValue = map(potValue, 0, 1023, 0, 180); // Convert to 0-180
  RF24NetworkHeader header(node01); // (Address where the data is going)
  bool ok = network.write(header, &angleValue, sizeof(angleValue)); // Send the data
}

Zuerst müssen wir beide Bibliotheken RF24 und RF24Network sowie die SPI-Bibliothek einbinden. Dann erstellen wir das RF24-Objekt und fügen es in das RF24Network-Objekt ein. Hier definieren wir die Adressen der Knoten im Oktalformat: 00 für diesen Knoten und 01 für den anderen Knoten auf der Servo-Seite.

Im Setup initialisieren wir das Netzwerk, indem wir den Kanal und die Adresse dieses Knotens festlegen.

Im Loop rufen wir ständig die update()-Funktion auf, über die alle Aktionen im Netzwerk ablaufen. Dann lesen wir den Potentiometer-Wert und wandeln ihn in einen Wert von 0 bis 180 um, der für die Servosteuerung geeignet ist. Anschließend erstellen wir einen Netzwerk-Header, in dem wir die Adresse des Zielknotens angeben. Am Ende senden wir die Daten mit der write()-Funktion an den anderen Knoten. Der erste Parameter enthält die Adressinformationen, der zweite zeigt auf die zu sendenden Daten, und der dritte ist die Datengröße.

Code auf der Servo-Seite (Knoten 01)

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial == Example 01 - Servo Control / Node 01 - Servo motor == */
#include <RF24.h>
#include <RF24Network.h>
#include <SPI.h>
#include <Servo.h>

RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 01; // Address of our node in Octal format
Servo myservo; // create servo object to control a servo

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node); //(channel, node address)
  myservo.attach(3); // (servo pin)
}

void loop() {
  network.update();
  while ( network.available() ) { // Is there any incoming data?
    RF24NetworkHeader header;
    unsigned long incomingData;
    network.read(header, &incomingData, sizeof(incomingData)); // Read the incoming data
    myservo.write(incomingData); // tell servo to go to a particular angle
  }
}

Auf der Servomotor-Seite definieren wir die Bibliotheken und Objekte同样. Die Adresse dieses Knotens im Oktalformat ist 01. Nach der Definition des Servomotors überprüfen wir im Loop mit der while()-Schleife und der available()-Funktion kontinuierlich, ob eingehende Daten vorhanden sind. Falls ja, erstellen wir einen Netzwerk-Header, über den die Daten akzeptiert werden, und eine Variable zum Speichern der Daten. Dann lesen wir die Daten mit der read()-Funktion und speichern sie in der incomingData-Variable. Am Ende verwenden wir diese Daten, um den Servomotor entsprechend dem Potentiometer des anderen Knotens zu bewegen.

Arduino Wireless Network mit mehreren NRF24L01 Modulen

Nachdem wir dieses Beispiel verstanden haben, können wir zum Hauptbeispiel dieses Tutorials übergehen und ein Wireless Network aus 5 Arduinos aufbauen, die miteinander kommunizieren. Hier ist ein Blockdiagramm des Beispiels.

Von der Basis aus steuern wir mit einem Potentiometer den Servomotor am Knoten 01, mit dem zweiten Potentiometer die LEDs am Knoten 022, mit dem Taster die LED am Knoten 012, und die LED an der Basis wird mit dem Potentiometer am Knoten 02 gesteuert. Außerdem steuern wir mit dem Infrarotsensor am Knoten 012 die LED am Knoten 01. Man sieht, dass dieses Beispiel zeigt, wie man gleichzeitig Daten senden und empfangen kann sowie wie man mit Knoten aus verschiedenen Zweigen kommuniziert. Sehen wir uns nun die Arduino-Codes an.

Related: DIY Arduino RC Transmitter

Basis 00 Quellcode

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial == Base/ Master Node 00== by Dejan, www.HowToMechatronics.com Libraries: nRF24/RF24, https://github.com/nRF24/RF24 nRF24/RF24Network, https://github.com/nRF24/RF24Network */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#define button 2
#define led 3
RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 00; // Address of this node in Octal format
const uint16_t node01 = 01; // Address of the other node in Octal format
const uint16_t node012 = 012;
const uint16_t node022 = 022;

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node); //(channel, node address)
  radio.setDataRate(RF24_2MBPS);
  pinMode(button, INPUT_PULLUP);
  pinMode(led, OUTPUT);
}

void loop() {
  network.update();
  //===== Receiving =====//
  while ( network.available() ) { // Is there any incoming data?
    RF24NetworkHeader header;
    unsigned long incomingData;
    network.read(header, &incomingData, sizeof(incomingData)); // Read the incoming data
    analogWrite(led, incomingData); // PWM output to LED 01 (dimming)
  }
  //===== Sending =====//
  // Servo control at Node 01
  unsigned long potValue = analogRead(A0);
  unsigned long angleValue = map(potValue, 0, 1023, 0, 180); // Suitable for servo control
  RF24NetworkHeader header2(node01); // (Address where the data is going)
  bool ok = network.write(header2, &angleValue, sizeof(angleValue)); // Send the data
  // LED Control at Node 012
  unsigned long buttonState = digitalRead(button);
  RF24NetworkHeader header4(node012); // (Address where the data is going)
  bool ok3 = network.write(header4, &buttonState, sizeof(buttonState)); // Send the data
  // LEDs control at Node 022
  unsigned long pot2Value = analogRead(A1);
  RF24NetworkHeader header3(node022); // (Address where the data is going)
  bool ok2 = network.write(header3, &pot2Value, sizeof(pot2Value)); // Send the data
}

An der Basis oder dem Master-Knoten definieren wir die Bibliotheken und Objekte wie zuvor erklärt und auch alle anderen Knoten, an die der Master Daten senden wird. Im Loop überprüfen wir ständig, ob eingehende Daten vorhanden sind. Falls ja, lesen wir die Daten, speichern sie in der incomingData-Variable und verwenden sie zur Steuerung der LED-Helligkeit. Diese Daten kommen tatsächlich vom Potentiometer vom Knoten 02. Schaut man sich dessen Code an, ist das Setup ziemlich ähnlich. Wichtig ist, die richtige Adresse anzugeben, an die wir Daten senden wollen. In diesem Fall ist das der Master 00. Nach dem Lesen des Potentiometer-Werts und der Umwandlung in einen geeigneten PWM-Wert von 0 bis 255 senden wir diese Daten an den Master. Hier wurde die millis()-Funktion verwendet, um die Daten in Intervallen von 10 Millisekunden zu senden.

Knoten 02 Quellcode

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial == Node 02 (Child of Master node 00) == */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 02; // Address of our node in Octal format
const uint16_t master00 = 00; // Address of the other node in Octal format
const unsigned long interval = 10; //ms // How often to send data to the other unit
unsigned long last_sent; // When did we last send?

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node); //(channel, node address)
  radio.setDataRate(RF24_2MBPS);
}

void loop() {
  network.update();
  //===== Sending =====//
  unsigned long now = millis();
  if (now - last_sent >= interval) { // If it's time to send a data, send it!
    last_sent = now;
    unsigned long potValue = analogRead(A0);
    unsigned long ledBrightness = map(potValue, 0, 1023, 0, 255);
    RF24NetworkHeader header(master00); // (Address where the data is going)
    bool ok = network.write(header, &ledBrightness, sizeof(ledBrightness)); // Send the data
  }
}

Als Nächstes senden wir vom Master die Potentiometer-Daten an Knoten 01 zur Steuerung des Servomotors.

Knoten 01 Quellcode

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial == Node 02 (Child of Master node 00) == */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#include <Servo.h>
#define led 2
RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 01; // Address of our node in Octal format
const uint16_t master00 = 00; // Address of the other node in Octal format
Servo myservo; // create servo object to control a servo

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node); //(channel, node address)
  radio.setDataRate(RF24_2MBPS);
  myservo.attach(3); // (servo pin)
  pinMode(led, OUTPUT);
}

void loop() {
  network.update();
  //===== Receiving =====//
  while ( network.available() ) { // Is there any incoming data?
    RF24NetworkHeader header;
    unsigned long incomingData;
    network.read(header, &incomingData, sizeof(incomingData)); // Read the incoming data
    if (header.from_node == 0) { // If data comes from Node 00 (Master)
      myservo.write(incomingData); // tell servo to go to a particular angle
    }
    if (header.from_node == 10) { // If data comes from Node 012 (octal 012 = decimal 10)
      digitalWrite(led, !incomingData); // Turn on or off the LED 02
    }
  }
}

Knoten 01 empfängt tatsächlich Daten von zwei verschiedenen Knoten: einer für die Servosteuerung und der andere für die LED-Steuerung, der vom Infrarotsensor vom Knoten 012 kommt.

In einem solchen Fall verwenden wir das Attribut header.from_node, um Informationen darüber zu erhalten, von welchem Knoten die Daten stammen. Falls die eingehenden Daten vom Master kommen, verwenden wir sie zur Steuerung des Servos; falls sie vom Knoten 012 kommen, verwenden wir sie zur Steuerung der LED.

Knoten 012 Quellcode

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial == Node 012 (child of Node 02)== */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#define led 2
#define IR 3
RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 012; // Address of our node in Octal format
const uint16_t node01 = 01; // Address of the other node in Octal format

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node); //(channel, node address)
  radio.setDataRate(RF24_2MBPS);
  pinMode(led, OUTPUT);
  pinMode(IR, INPUT);
}

void loop() {
  network.update();
  //===== Receiving =====//
  while ( network.available() ) { // Is there any incoming data?
    RF24NetworkHeader header;
    unsigned long buttonState;
    network.read(header, &buttonState, sizeof(buttonState)); // Read the incoming data
    digitalWrite(led, !buttonState); // Turn on or off the LED
  }
  //===== Sending =====//
  unsigned long irV = digitalRead(IR); // Read IR sensor
  RF24NetworkHeader header8(node01);
  bool ok = network.write(header8, &irV, sizeof(irV)); // Send the data
}

Am Knoten 012 haben wir sowohl Senden als auch Empfangen. Der Infrarotsensor steuert die zuvor erwähnte LED am Knoten 01 und die LED hier wird vom Taster am Master gesteuert.

Knoten 022 Quellcode

/* Arduino Wireless Network - Multiple NRF24L01 Tutorial == Node 022 (child of Node 02)== */
#include <RF24Network.h>
#include <RF24.h>
#include <SPI.h>
#define led1 2
#define led2 3
#define led3 4
#define led4 5
RF24 radio(10, 9); // nRF24L01 (CE,CSN)
RF24Network network(radio); // Include the radio in the network
const uint16_t this_node = 022; // Address of our node in Octal format
const uint16_t master00 = 00; // Address of the other node in Octal format

void setup() {
  SPI.begin();
  radio.begin();
  network.begin(90, this_node); //(channel, node address)
  radio.setDataRate(RF24_2MBPS);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}

void loop() {
  network.update();
  //===== Receiving =====//
  while ( network.available() ) { // Is there any incoming data?
    RF24NetworkHeader header;
    unsigned long potValue;
    network.read(header, &potValue, sizeof(potValue)); // Read the incoming data
    // Turn on the LEDs as depending on the incoming value from the potentiometer
    if (potValue > 240) { digitalWrite(led1, HIGH); } else { digitalWrite(led1, LOW); }
    if (potValue > 480) { digitalWrite(led2, HIGH); } else { digitalWrite(led2, LOW); }
    if (potValue > 720) { digitalWrite(led3, HIGH); } else { digitalWrite(led3, LOW); }
    if (potValue > 960) { digitalWrite(led4, HIGH); } else { digitalWrite(led4, LOW); }
  }
}

Schließlich werden die LEDs am Knoten 022 mit den Daten gesteuert, die vom anderen Potentiometer am Master kommen.

Zusammenfassend: Wenn alles richtig angeschlossen ist und alle Knoten ständig aktiv sind, reduziert sich unsere Aufgabe darauf, die Knoten präzise zu adressieren – die ganze schwere Arbeit im Hintergrund erledigt die unglaubliche RF24Network-Bibliothek.

Das war es für dieses Arduino-Projekt. Ich hoffe, es hat Ihnen gefallen und Sie haben etwas Neues gelernt. Stellen Sie gerne Fragen im Kommentarbereich unten.