home Productietechnologie Fabricage-apparatuur
Industriële fabricage
Industrieel internet der dingen | Industriële materialen | Onderhoud en reparatie van apparatuur | Industriële programmering |
home  MfgRobots >> Industriële fabricage >  >> Manufacturing Technology >> Productieproces

Arduino draadloos netwerk met meerdere NRF24L01-modules

In deze tutorial leren we hoe we een draadloos Arduino-netwerk kunnen bouwen, samengesteld uit meerdere NR24L01-transceivermodules. Je kunt de volgende video bekijken of de schriftelijke tutorial hieronder lezen.

Overzicht

Als voorbeeld heb ik een netwerk gemaakt van 5 knooppunten en elk van hen kan communiceren met elk knooppunt in het netwerk en tegelijkertijd kunnen ze zowel als zenders als als ontvangers werken. Dit voorbeeld is zo opgezet dat het uitlegt hoe je een veel groter netwerk kunt maken, of om precies te zijn, we kunnen in totaal 3125 modules met elkaar laten communiceren op een enkel RF-kanaal. Dus laten we eens kijken hoe het werkt.

In mijn vorige tutorials hebben we al geleerd hoe je een draadloze communicatie kunt maken tussen twee Arduino-boards met behulp van de NRF24L01-modules en de RF24-bibliotheek. Nu zullen we naast deze bibliotheek de RF24Network-bibliotheek gebruiken, waarmee we op een gemakkelijke manier een draadloos Arduino-netwerk kunnen bouwen waarbij veel boards met elkaar communiceren. Zo werkt de netwerktopologie.

Communicatie met meerdere NRF24L01-modules

Een enkele NRF24L01-module kan actief naar maximaal 6 andere modules tegelijk luisteren.

Deze mogelijkheid wordt gebruikt door de RF24Network-bibliotheek om een ​​netwerk te genereren dat is gerangschikt in een boomtopologie, waarbij één knooppunt de basis is en alle andere knooppunten kinderen zijn van dat knooppunt of van een ander. Elk knooppunt kan maximaal 5 onderliggende knooppunten hebben, en dit kan 5 niveaus diep gaan, wat betekent dat we een netwerk van in totaal 3125 knooppunten kunnen creëren. Elk knooppunt moet worden gedefinieerd met een 15-bits adres, dat nauwkeurig de positie van het knooppunt in de boom beschrijft.

We kunnen de adressen van de knooppunten feitelijk in octaal formaat definiëren. Het adres van de master of de basis is dus 00, de onderliggende adressen van de basis zijn 01 tot 05, de adressen van de 01 knooppunten zijn 011 tot 051 enzovoort.

Merk op dat als knooppunt 011 met knooppunt 02 wil praten, de communicatie via knooppunt 01 en het basisknooppunt 00 moet gaan, dus deze twee knooppunten moeten de hele tijd actief zijn om de communicatie succesvol te laten zijn.

Arduino Wireless Servo Motor Control met behulp van de RF24Network Library

Voordat we het belangrijkste voorbeeld van deze tutorial uitleggen, laten we, om beter te begrijpen hoe de bibliotheek werkt, een eenvoudiger voorbeeld maken van twee Arduino-boards die met elkaar communiceren. Hier is het schakelschema voor dit voorbeeld.

U kunt de benodigde componenten voor deze Arduino-zelfstudie verkrijgen via de onderstaande links:

  • NRF24L01 Zendontvangermodule…………..
  • Servomotor …………………………………
  • Potentiometer ……………………………..
  • Arduino Nano ……………………………….. 

Dus met behulp van de potentiometer op de eerste Arduino zullen we de servomotor op de tweede Arduino besturen. Laten we nu eens naar de broncodes kijken.

Hier is de code aan de kant van de potentiometer:

/*
  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
}Code language: Arduino (arduino)

Eerst moeten we beide bibliotheken RF24 en RF24Network opnemen, evenals de SPI-bibliotheek. Vervolgens moeten we het RF24-object maken en opnemen in het RF24Network-object. Hier moeten we de adressen van de knooppunten in octaal formaat definiëren, of 00 voor dit knooppunt en 01 voor het andere knooppunt aan de servozijde.

In de setup-sectie moeten we het netwerk initialiseren door het kanaal en het adres van dit knooppunt in te stellen.

In de loop-sectie moeten we constant de update()-functie aanroepen waardoor alle actie in het netwerk plaatsvindt. Vervolgens lezen we de waarde van de potentiometer en zetten deze om in een waarde van 0 tot 180 die geschikt is voor de servobesturing. Vervolgens maken we een netwerkheader waarin we het adres toewijzen van het knooppunt waar de gegevens naartoe gaan. Aan het einde, met behulp van de functie write() sturen we de gegevens naar het andere knooppunt. Dus hier bevat de eerste parameter de adresseninformatie, de tweede parameter geeft aan welke gegevens worden verzonden en de derde parameter is de grootte van de gegevens.

Hier is de code aan de servozijde:

/*
  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
  }
}Code language: Arduino (arduino)

Aan de andere kant, bij de servomotor, moeten we de bibliotheken en de objecten op dezelfde manier definiëren als eerder uitgelegd. Hier is het adres van dit knooppunt in octaal formaat 01. Na het definiëren van de servomotor, in de lussectie, met behulp van de while()-lus en de available()-functie, controleren we constant of er binnenkomende gegevens zijn. Als dit waar is, maken we een netwerkheader waarmee de gegevens worden geaccepteerd en ook een variabele waar de gegevens worden opgeslagen. Vervolgens gebruiken we de functie read() om de gegevens te lezen en op te slaan in de variabele inkomendeData. Aan het einde gebruiken we deze gegevens om de servomotor te verplaatsen volgens de potentiometer van het andere knooppunt.

Arduino draadloos netwerk met meerdere NRF24L01-modules

Nadat we dit voorbeeld hebben begrepen, kunnen we verder gaan met het hoofdvoorbeeld van deze tutorial en een draadloos netwerk bouwen van 5 Arduino's die met elkaar communiceren. Hier is een blokschema van het voorbeeld.

Dus vanaf de basis zullen we met behulp van een potentiometer de servomotor op knooppunt 01 besturen, met de tweede potentiometer zullen we de LED's op knooppunt 022 besturen, met behulp van de knop zullen we de LED op knooppunt 012 besturen, en de LED hier op de basis zal worden bestuurd met behulp van de potentiometer op knooppunt 02. Ook met behulp van de infraroodsensor op knooppunt 012 zullen we de LED op knooppunt 01 bedienen. Dus we kunnen opmerken dat dit voorbeeld uitlegt hoe u tegelijkertijd gegevens kunt verzenden en ontvangen, evenals hoe te communiceren met knooppunten uit verschillende branches. Laten we nu eens kijken naar de Arduino-codes.

Gerelateerd: DIY Arduino RC-zender

Base 00 broncode

/*
  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
}Code language: Arduino (arduino)

Dus aan de basis of het masterknooppunt moeten we de bibliotheken en de objecten definiëren zoals eerder uitgelegd, en ook alle andere knooppunten definiëren waarnaar de master gegevens zal verzenden. In de loop-sectie beginnen we met het constant controleren of er binnenkomende gegevens zijn. Als dat zo is, lezen we de gegevens, slaan deze op in de variabele inkomendeData en gebruiken deze om de LED-helderheid te regelen. Deze gegevens komen eigenlijk van de potentiometer van knooppunt 02. Als we naar de code kijken, kunnen we zien dat de setup vrijwel hetzelfde is. Het belangrijkste is om het juiste adres toe te wijzen waar we gegevens naartoe willen sturen. In dit geval is dat de master 00. Dus na het lezen van de potentiometerwaarde en het converteren naar een geschikte PWM-waarde van 0 tot 255, sturen we deze gegevens naar de master. We kunnen hier opmerken dat ik de millis()-functie heb gebruikt om de gegevens met intervallen van 10 milliseconden te verzenden.

Node 02 broncode

/*
  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
  }
}Code language: Arduino (arduino)

Vervolgens sturen we van de master de potentiometergegevens naar het knooppunt 01 voor het besturen van de servomotor.

Node 01 broncode

/*
  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
    }
  }
}Code language: Arduino (arduino)

Het knooppunt 01 ontvangt feitelijk gegevens van twee verschillende knooppunten, een voor de servobesturing en de andere voor de LED-besturing die afkomstig is van de infraroodsensor van het knooppunt 012.

Node 012-broncode

/*
  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
}Code language: Arduino (arduino)

In een dergelijk geval gebruiken we het header.from_node attribuut om informatie te krijgen van welk knooppunt de gegevens komen. In het geval dat de inkomende gegevens van de master zijn, gebruiken we deze om de servo te besturen, en in het geval dat de inkomende gegevens van het knooppunt 012 komen, gebruiken we deze om de LED te besturen.

Op het knooppunt 012 hebben we zowel zenden als ontvangen. De infraroodsensor bestuurt de eerder genoemde LED op knooppunt 01 en de LED hier wordt bediend vanaf de knop op de master.

Node 022 broncode

/*
  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);
    }
  }
}Code language: Arduino (arduino)

Ten slotte worden de LED's op knooppunt 022 aangestuurd met behulp van de gegevens die afkomstig zijn van de andere potentiometer op de master.

Kortom, als alles goed is aangesloten en alle knooppunten altijd actief zijn, komt onze taak erop neer dat we de knooppunten precies aanspreken en al het zware werk dat erachter zit wordt uitgevoerd door de ongelooflijke RF24Network-bibliotheek.

Dus dat zou alles zijn, ik hoop dat je genoten hebt van dit Arduino-project en iets nieuws hebt geleerd. Stel gerust een vraag in de opmerkingen hieronder.


Productieproces

  • Productieproces
  • 3d printen
  • Automatisering Besturingssysteem
  • Industriële technologie
    1. Een draadloos sensornetwerk in uw huis bouwen
    2. AI-cijferherkenning met PiCamera
    3. Draadloze magnetische gegevensoverdracht
    4. CO2-monitoring met K30-sensor
    5. Doofblinde communicatie met 1Sheeld/Arduino
    6. Bedien muntvangers met Arduino
    7. Arduino met Bluetooth om een ​​LED te bedienen!
    8. Capacitieve vingerafdruksensor met een Arduino of ESP8266
    9. USB-BLE draadloze MIDI-adapters
    10. Spelen met Nextion Display
    11. Nunchuk-gestuurde robotarm (met Arduino)