Arduino Wireless Network mit mehreren NRF24L01-Modulen

In diesem Tutorial lernen wir, wie man ein drahtloses Arduino-Netzwerk aufbaut, das aus mehreren NR24L01-Transceiver-Modulen besteht. Sie können sich das folgende Video ansehen oder das schriftliche Tutorial unten lesen.

Übersicht

Als Beispiel habe ich ein Netzwerk aus 5 Knoten erstellt und jeder von ihnen kann mit jedem Knoten im Netzwerk kommunizieren und gleichzeitig sowohl als Sender als auch als Empfänger arbeiten. Dieses Beispiel ist tatsächlich so aufgebaut, dass es erklärt, wie man ein viel größeres Netzwerk erstellt, oder um genau zu sein, wir können insgesamt 3125 Module haben, die auf einem einzigen HF-Kanal miteinander kommunizieren. Schauen wir uns also an, wie es funktioniert.

In meinen vorherigen Tutorials haben wir bereits gelernt, wie man mit den NRF24L01-Modulen und der RF24-Bibliothek eine drahtlose Kommunikation zwischen zwei Arduino-Boards herstellt. Jetzt werden wir zusätzlich zu dieser Bibliothek die Bibliothek RF24Network verwenden, die es auf einfache Weise ermöglicht, ein drahtloses Arduino-Netzwerk mit vielen miteinander kommunizierenden Platinen aufzubauen. So funktioniert die Netzwerktopologie.

Kommunikation mehrerer NRF24L01-Module

Ein einzelnes NRF24L01-Modul kann bis zu 6 andere Module gleichzeitig aktiv überwachen.

Diese Fähigkeit wird von der RF24Network-Bibliothek genutzt, um ein Netzwerk zu generieren, das in einer Baumtopologie angeordnet ist, 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 genau die Position des Knotens innerhalb des Baums beschreibt.

Wir können die Adressen der Knoten tatsächlich im Oktalformat definieren. Die Adresse des Masters oder der Basis lautet also 00, die untergeordneten Adressen der Basis sind 01 bis 05, die untergeordneten Adressen der 01-Knoten sind 011 bis 051 und so weiter.

Beachten Sie, dass, wenn der Knoten 011 mit dem Knoten 02 sprechen möchte, die Kommunikation über den Knoten 01 und den Basisknoten 00 gehen muss, sodass diese beiden Knoten die ganze Zeit aktiv sein müssen, damit die Kommunikation erfolgreich ist.

Drahtlose Arduino-Servomotorsteuerung mit der RF24Network-Bibliothek

Bevor wir das Hauptbeispiel dieses Tutorials erläutern, wollen wir zum besseren Verständnis der Funktionsweise der Bibliothek ein einfacheres Beispiel für zwei Arduino-Boards erstellen, die miteinander kommunizieren. Hier ist der Schaltplan für dieses Beispiel.

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

NRF24L01 Transceiver-Modul………..
Servomotor ……………………………………
Potentiometer ………………………………..
Arduino Nano ………………………………..

Mit dem Potentiometer am ersten Arduino steuern wir also den Servomotor am zweiten Arduino. Werfen wir jetzt einen Blick auf die Quellcodes.

Hier ist der Code auf der Potentiometerseite:

/*
  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 ( 04,031, etc)
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 the value to 0-180
  RF24NetworkHeader header(node01);     // (Address where the data is going)
  bool ok = network.write(header, &angleValue, sizeof(angleValue)); // Send the data
}

Codesprache:Arduino (arduino)

Zuerst müssen wir die beiden Bibliotheken RF24 und RF24Network sowie die SPI-Bibliothek einbinden. Dann müssen wir das RF24-Objekt erstellen und es in das RF24Network-Objekt einbinden. Hier müssen wir die Adressen der Knoten im Oktalformat definieren, oder 00 für diesen Knoten und 01 für den anderen Knoten auf der Servoseite.

Im Setup-Abschnitt müssen wir das Netzwerk initialisieren, indem wir den Kanal und die Adresse dieses Knotens einstellen.

Im Schleifenabschnitt müssen wir ständig die Funktion update() aufrufen, über die alle Aktionen im Netzwerk ausgeführt werden. Dann lesen wir den Wert des Potentiometers ab und wandeln ihn in einen für die Servosteuerung geeigneten Wert von 0 bis 180 um. Dann erstellen wir einen Netzwerk-Header, in dem wir die Adresse des Knotens zuweisen, an den die Daten gehen. Am Ende senden wir die Daten mit der Funktion write() an den anderen Knoten. Hier enthält also der erste Parameter die Adressinformationen, der zweite Parameter gibt an, welche Daten gesendet werden, und der dritte Parameter ist die Größe der Daten.

Hier ist der Code auf der Servoseite:

/*
  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 ( 04,031, etc)

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
  }
} Codesprache:Arduino (arduino)

Auf der anderen Seite müssen wir beim Servomotor die Bibliotheken und die Objekte auf die gleiche Weise wie zuvor beschrieben definieren. Hier ist die Adresse dieses Knotens im Oktalformat 01. Nachdem wir den Servomotor definiert haben, prüfen wir im Schleifenabschnitt mit der while()-Schleife und der available()-Funktion ständig, ob Daten eingehen. Wenn wahr, erstellen wir einen Netzwerk-Header, über den die Daten akzeptiert werden, und auch eine Variable, in der die Daten gespeichert werden. Dann lesen wir mit der Funktion read () die Daten und speichern sie in der Variable "incomingData". Am Ende verwenden wir diese Daten, um den Servomotor entsprechend dem Potentiometer vom anderen Knoten zu bewegen.

Arduino Wireless Network mit mehreren NRF24L01-Modulen

Nachdem wir dieses Beispiel verstanden haben, können wir mit dem Hauptbeispiel dieses Tutorials fortfahren und ein drahtloses Netzwerk 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 steuern wir die LEDs am Knoten 022, mit der Taste steuern wir die LED am Knoten 012 und die LED hier bei Die Basis wird mit dem Potentiometer am Knoten 02 gesteuert. Mit dem Infrarotsensor am Knoten 012 steuern wir auch die LED am Knoten 01. Wir können also feststellen, dass dieses Beispiel erklärt, wie Daten gleichzeitig gesendet und empfangen werden. sowie wie man mit Nodes aus verschiedenen Branches kommuniziert. Werfen wir jetzt einen Blick auf die Arduino-Codes.

Verwandt: DIY Arduino RC Transmitter

Base-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 ( 04,031, etc)
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
} Codesprache:Arduino (arduino)

An der Basis oder dem Master-Knoten müssen wir also die Bibliotheken und die Objekte wie zuvor erklärt definieren und auch alle anderen Knoten definieren, an die der Master Daten senden wird. Im Schleifenabschnitt prüfen wir zunächst ständig, ob Daten ankommen. Wenn ja, lesen wir die Daten, speichern sie in der Variable "incomingData" und verwenden sie, um die LED-Helligkeit zu steuern. Diese Daten stammen tatsächlich vom Potentiometer von Knoten 02. Wenn wir uns seinen Code ansehen, können wir feststellen, dass das Setup ziemlich gleich ist. Wichtig ist, die richtige Adresse zuzuordnen, wohin wir Daten senden wollen. In diesem Fall ist das der Master 00. Nachdem wir also den Potentiometerwert gelesen und in einen geeigneten PWM-Wert von 0 bis 255 umgewandelt haben, senden wir diese Daten an den Master. Wir können hier feststellen, dass ich die Funktion millis() verwendet habe, um die Daten in Intervallen von 10 Millisekunden zu senden.

Quellcode von Knoten 02

/*
  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 ( 04,031, etc)
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
  }
} Codesprache:Arduino (arduino)

Als nächstes senden wir vom Master die Potentiometerdaten an den Knoten 01 zur Steuerung des Servomotors.

Quellcode von Knoten 01

/*
  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 ( 04,031, etc)
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 02
      myservo.write(incomingData);  // tell servo to go to a particular angle
    }
    if (header.from_node == 10) {    // If data comes from Node 012
      digitalWrite(led, !incomingData);  // Turn on or off the LED 02
    }
  }
} Codesprache:Arduino (arduino)

Der Knoten 01 empfängt tatsächlich Daten von zwei verschiedenen Knoten, einen für die Servosteuerung und den anderen für die LED-Steuerung, die vom Infrarotsensor von Knoten 012 kommt.

Quellcode von Knoten 012

/*
  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 ( 04,031, etc)
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
} Codesprache:Arduino (arduino)

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

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 von der Taste am Master gesteuert.

Quellcode von Knoten 022

/*
  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 ( 04,031, etc)
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);
    }
  }
} Codesprache:Arduino (arduino)

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

Zusammenfassend lässt sich sagen, dass, wenn alles richtig verbunden ist und alle Knoten die ganze Zeit aktiv sind, unsere Aufgabe darauf hinausläuft, die Knoten genau zu adressieren, und die ganze schwere Arbeit dahinter wird von der unglaublichen RF24Network-Bibliothek ausgeführt. P>

Das wäre alles, ich hoffe, Sie haben dieses Arduino-Projekt genossen und etwas Neues gelernt. Fühlen Sie sich frei, Fragen im Kommentarbereich unten zu stellen.

DIY Arduino Roboterarm mit Smartphone-Steuerung Arduino Projekt für drahtlose Wetterstation