Master/Slave Netzwerk mit nRF24L01 und Arduino/ESP8266

In diesem Beitrag möchte ich euch meine Netzwerkbibliothek (SBNetwork) vorstellen, mit der es super einfach ist, Arduinos, ESP8266 (WeMos, nodeMCU, …) oder andere kleine Mikrocontroller über den nRF24L01 Transmitetr miteinander zu verbinden. Wer mein Tutorial „Arduino und nRF24L01“ gelesen hat, hat vielleicht bemerkt, dass die Verdrahtung zwar recht einfach ist, man sich programmiertechnisch allerdings um so ziemlich alles selbst kümmern muss. Wer dann zusätzlich noch etwas unerfahren im Programmieren ist oder schlicht keine Lust hat, sich damit herumzuschlagen, dem wird dieser Beitrag hier vielleicht gefallen.

Was soll SBNetwork können?

Nun ja, diese Frage sollten wir zuerst beantworten, bevor hier noch falsche Hoffnungen aufkommen. Ich habe mich jetzt schon mehre Jahre mit dem nRF24L01 beschäftigt und bin immer wieder auf die typischen Bibliotheken gestoßen, die beispielsweise TCP/IP Fähigkeit , Mesh-Netzwerke, Sensoren-Netzwerke oder Audiostreaming mit dem nRF24L01 implementieren. Ohne Frage, diese Bibliotheken sind super und ihre Erfinder/Programmierer mindestens genau so. Nur haben sie allesamt für mich ein paar entschiedene Nachteile. Mal sind sie schwierig/aufwendig zu konfigurieren und mal verbrauchen die Bibliothen schon so viel Speicher sodass nur noch wenig übrig bleibt, um die eigentlichen Funktionen wie Sensoren auslesen oder Aktoren Steuern, zu implementieren.

Nicht zuletzt wollte ich mich aber auch einfach mal selber mit der Materie intensiver beschäftigen. Sein eigenes kleines Kommunikationsprotokoll zu schreiben macht schon irgendiwe Spaß ;-). Aber gut, meine Ziele waren zunächst folgende:

  • Einfaches Master/Slave Netzwerk ohne Mesh und Routing Funktionen. Alle Slave-Geräte müssen in Reichweite des Master-Gerätes sein. Das sorgt vor allem für den geringen Konfigurationsaufwand. Außerdem habe ich den nRF jetzt schon länger getestet und er funktioniert tadellos vom 3 Stock bis in den Keller, ohne Probleme.
  • Keine x-te Implementierung eines TCP/IP Protokolls oder Mesh-Netzwerkes. Ich möchte einfach nicht, dass jeder Sensor oder Aktor ein Teil meines LAN/WLAN ist und eine IP Adresse erhält. Ok, zugegeben das entspricht nicht unbedingt dem IoT Gedanken, aber gut, jedem seines.
  • Automatische Suche nach und Verbinden mit einem Master-Gerät. Das sorgt erneut für einen geringen Konfigurationsaufwand. Es sollen außerdem nich einfach irgendwelche neuen Geräte ins Netzwerk reinfunken oder beitreten können.
  • Die Slave-Geräte sollen so stromsparend wie möglich betrieben werden können. Dazu zählt natürlich der bekannte Sleep-Modus. Wenn ein Slave also mal ein paar Minuten nichts von sich gibt, ist das auch OK.
  • Grundlage für eine weitere Bibliothek, die eine SmartHome ähnliche Umgebung implementieren kann. Dazu aber später mehr, in einem anderen Beitrag.

Was kann SBNetwork?

Im Grunde alles das, was ich oben als Ziele beschrieben habe.

Einfache Konfiguration

Um ein Gerät für das Netzwerk vorzubereiten, muss man ihm nur eine eindeutige Adresse (MAC Adresse) geben und ihm sagen, ob es ein Master oder Slave Gerät sein soll. Das war es eigentlich auch schon.

Automarisches Suchen und Verbinden

Schaltet man ein Slave-Gerät das erste mal ein, sucht es automatisch nach einem in der Nähe befindlichen Master. Hat es einen gefunden, paart es sich  automatisch mit dem Master, sofern er das zulässt. Von diesem Zeitpunkt an, ist das Slave-Gerät dann mit dem Master gepaart und verbindet sich immer automatisch zu ihm, auch wenn es aus und wieder eingeschaltet wird.

Einfaches Übertragen von Daten und Nachrichten

Das Senden von Daten und Nachrichten ist auch recht einfach (siehe Beispiele). Vor allem muss man sich keine Gedanken über die Länge einer Nachricht machen. Bekantermaßen kann der nRF24L01 nur 40 Byte pro Übertragung senden. Das kann schon mal knapp werden, vor allem bei Texten. Man muss sich mit der Bibliothek nicht darum kümmern, es können bis zu 200Byte pro Datenpaket übertragen werden. Das Auseinanderpflücken, Stückweise Übertragen und Wiederzusammensetzten übernimmt meine Bibliothek.

Was muss man selber noch tun?

Wie man die Bibliothek nutzt und welche Daten man übertragen möchte, muss natürlich jeder für sich entscheiden. Und somit muss man sich auch selber darum kümmern, wie man die Informationen ( z.B. Sensorwerte) verpackt und wieder ausliest. Die Bibliothek stellt zunächst erstmal nur eine Vereinfachung der Kommunikation zwischen zwei Geräten dar.

Tutorial SBNetwork – Ein kleines Beispiel

Also legen wir direkt los und bauen unser erstes kleines Beispiel.

Bibliothek installieren

Zunächst benötigt man die Quelldateien. Diese habe ich auf github veröffentlicht unter: https://github.com/Schullebernd/SBNetwork. Am besten man lädt sich das ganze ZIP Archiv herunter und entpackt es in den libraries Ordner der Arduino Umgebung ab (Bei Windows ist das in der Regel C:\Users\Benutzername\Documents\Arduino\libraries\).

Wir benötigen aber noch eine weitere Bibliothek, nämlich dieselbe, die auch in meinem ersten Tutorial zum Einsatz kam. Diese kann man allerdings auch über die Bibliotheksverwaltung einbinden „Sketch > Bibliothek einbinden > Bibliotheken verwalten„. Dort einfach den Suchbegriff nrf24 eingeben und die Bibliothek RF24 von TMRh20 herunterladen. Derselbe Entwickler hat im übrigen auch viele andere Bibliotheken für den nRF24L01 geschrieben, wie die besagte TCP/IP Library oder die Mesh Library, die echt sehenswert sind. Auch habe ich mich durch seinen Code sehr inspirieren lassen – Somit geht ein kleiner Dank  an TRMh20.

Geräte Vorbereiten

Für unser Beispiel benötigen wir zwei nRF24L01, einen WeMos D1 mini und einen Arduino  (Uno / Pro Mini / Nano …). Anstelle des WeMos D1 Mini ginge natürlich auch eine NodeMCU oder ein reiner ESP8266 oder aber auch eine zweiter Arduino. D.h. ESP8266 ist nicht pflicht, nützt einem später aber eher weniger, es seie denn, man möchte nur ein Display oder ähnliches betreiben.

Jetzt die nRF mit dem Wemos bzw. dem Arduino verdrahten. Eine Anleitung, wie das geht, ist hier auch noch einmal zu finden. In den Beisoiel-Sketches sind ebenfalls emtsprechende Übersichten enthalten, wie der Wemos bzw. der Arduino mit dem nRF24L01 verdrahtet werden muss. Hier noch einmal die Übersicht:

Anschlussbild nRF24L01 an ArduinoNano mit Elko

 

Anschlussbild nRF24L01 an Wemos D1 mini mit Elko
Anschlussbild nRF24L01 an Wemos D1 mini mit Elko

Am besten man verbindet gleich beide Microcontroller mit dem USB.

Beispiel-Sketches öffnen und ausführen

Als nächstes starten wir die Ardino IDE und schauen im Menü unter Datei > Beispiele > SBNetwork nach. Dort müssten zwei Beispiele zu sehen sein. GettingStartedMaster und GettingStartetClient.

Das Master-Gerät

Öffnen wir zunächst den Sketch GettingStartetMaster. Das ist der Sketch unseres Master Gerätes. Man könnte auch Basisstation sagen. Das Beispiel ist so vorbereitet, dass ein WeMos D1 Mini bzw. ein ESP8266-Board verwendet wird. Im Kommentar oben steht aber auch die Info, was zu ändern ist, wenn man einen Arduino einsetzen möchte.

/*
* Author - Marcel Schulz (alias Schullebernd)
* *************************************************************
* See further library details on https://github.com/Schullebernd/SBNetwork
* *************************************************************
* This Getting started is prepared for using it with a Wemos D1 mini as a master device.
* If you want to use an Arduino, then change the line 38 "SBNetwork networkDevice(false, D2, D8);" to the correct pinout for an Arduino "SBNetwork networkDevice(false, 6, 7);".
* **************************************************************
* Step 1 - Prepare your device
* Connect a nRF24L01 transmitter to a Wemos D1 mini or an Arduino Device
* WEMOS > RF24      ARDUINO > RF24      --------------------------------------
* ------------      --------------     |   GND #  # VCC          TOP VIEW     |
*   3V3 > VCC          VCC  > VCC      |    CE #  # CSN          of nRF24L01  |
*   GND > GND          GND  > GND      |   SCK #  # MOSI                      |
*    D2 > CE             6  > CE       |  MISO #  # IRQ                       |
*    D8 > CSN            7  > CSN      |                                      |
*    D7 > MOSI          11  > MOSI      --------------------------------------
*    D6 > MISO          12  > MISO
*    D5 > SCK           13  > SCK
*
* Step 2 - Build the sketch for the master device
* Connect the Wemos via USB to the PC, select the right board and COM interface in the tools menu and run the project.
* After building and loading up to the Wemos, the serial monitor should show some log data.
* 
* Step 3 - Now open the example sketch GettingStartedClient to build a client device
*/

#include <SBNetwork_config.h>
#include <SBNetwork.h>

// Type in here the mac address of the device.
// This must be unique within your complete network otherwise the network will not work.
SBMacAddress deviceMac(0x01, 0x02, 0x03, 0x04, 0x05);
//SBMacAddress deviceMac(0x05, 0x04, 0x03, 0x02, 0x01);

// Create a new network device with Wemos D1 mini and set the _ce and _cs pin.
// The first argument defines the type of the device. false=master and true=client device
SBNetwork networkDevice(false, D2, D8);
//SBNetwork networkDevice(true, 6, 7);

void setup() {
	// Init serial connection
	Serial.begin(19200);

	// Initialize the network device
	networkDevice.initialize(deviceMac);

  // Enables the master to automatically add new clients
  networkDevice.enableAutomaticClientAdding(true);

	Serial.println(F("*** PRESS 'N' to reset the device"));
}

void loop() {

	// This routine is for resetting the device
	// All flash data will be deleted
	if (Serial.available())
	{
		char c = toupper(Serial.read());
		if (c == 'N') {
			networkDevice.resetData();
		}
    if (c == 'E') {
      // Only master should handle the switch of adding new clients
      if (!networkDevice.RunAsClient) {
        Serial.println("*****");
        if (networkDevice.isAutomaticClientAddingEnabled()) {
          Serial.println("Deactivating AutomaticClientAdding");
        }
        else {
          Serial.println("Activating AutomaticClientAdding");
        }
        Serial.println("*****");
        networkDevice.enableAutomaticClientAdding(!networkDevice.isAutomaticClientAddingEnabled());        
      }
    }
	}

	// Call this in the loop() function to maintain the network device
	networkDevice.update();

	// Check, if there are messages available
	uint8_t messageSize = networkDevice.available();
	if (messageSize > 0) {
		Serial.print(F("Received Content: "));
		Serial.println((char*)networkDevice.getMessage());
	}

	// If the master has received a message, it will sent a message to the sender
	if (networkDevice.available()) {
		char* message = "Hello client, yes I can hear you well!";
		networkDevice.sendToDevice(networkDevice.MasterStorage.Slaves[0], message, strlen(message) + 1);
	}
} // Loop

Hier ein paar Erläuterungen zum Code.

In Zeile 33 legen wir eine MAC-Adresse an. Sie besteht aus 5 Bytes und ist somit 40bit lang. Für jedes neue Geräte, dass ihr eurem Netzwerk hinzufügt, muss eine neue MAC vergeben werden. Wenn zwei Geräte dieselbe MAC haben sollten, passiert es, dass beide Geräte dieselbe Nachicht empfangen und sich gegenseitig mitunter stören oder gar nicht mehr funktionieren.

In Zeile 38 wird ein Netzwerkgerät angelegt. Als Parameter werden die beiden CE und CS Pins übergeben, die den Microcontroller mit dem nRF24L01 Transmitter verbinden und ein false, was den Netzwerkgeräte mitteilt, dass es ein Master-Gerät sein soll.

In Zeile 46 wird das Netzwerkgerät und der RF24 Transmitter initialisiert. Diese Funktion sollte immer in der setup() Funktion aufgerufen werden. Bei einem Slave-Device finden hier auch die erste Initialisierung, die Suche nach einem Master und das Pairing statt.

In Zeile 62 wird das Netzwerkgeräte komplett zurückgesetzt und alle Einstellungen wie das Pairing werden gelöscht. Danach ist das Gerät in dem Zustand, als würde man es zum ersten Mal einschalten. Es ist allersdings ein Neustart nötig, damit der Reset wirkt.

In Zeile 84 wird das Netzwerkgeräte aktualisiert. Diese Funktion muss zwingend innerhalb der loop() Funktion augerufen werden. In der Funktion werden alle empfangenen Nachrichten verarbeitet und ggf. für den Anwender aufbereitet.

Zeile 84 prüft, ob eine empfangene Nachricht vorliegt. Die Funktion available() liefert dann die Anzahl der Bytes zurück, die empfangen wurden.

In 87 wird die empfangene Nachricht abgerufen. Je nachdem, was sich in dem Empfangspaket befindet, können die Daten ausgelesen und verarbeitet werden. Hier im GettingStarted Sketch übertragen wir nur Strings, daher wird der Inhalt der Nachricht gleich auf die serielle Ausgabe geleitet.

Zu guter letzt, senden wir in Zeile 93 eine Antwort zum Slave, nachdem er uns eine Nachricht gesendet hat.

Ok, damit hätten wir das Beispiel für ein Mastergerät fertig. Jetzt einfach den Sketch ausführen und (am besten vorher noch) den seriellen Monitor öffnen und schauen, welche Ausgaben erscheinen. Diese sollten in der Regel so ausschauen:

SBNetwork Version 1.0.2
====================

Try to read device config from internal flash...Failed
Creating new device config and stroing it to internal flash...
Done
Device MAC = 0x1 0x2 0x3 0x4 0x5
Master MAC = 0x0 0x0 0x0 0x0 0x0
NetKey = 0
Creating new Master Storage
Masterstorage Slot 0 0x0 0x0 0x0 0x0 0x0
Masterstorage Slot 1 0x0 0x0 0x0 0x0 0x0
Masterstorage Slot 2 0x0 0x0 0x0 0x0 0x0
Masterstorage Slot 3 0x0 0x0 0x0 0x0 0x0
Masterstorage Slot 4 0x0 0x0 0x0 0x0 0x0
Masterstorage Slot 5 0x0 0x0 0x0 0x0 0x0
Masterstorage Slot 6 0x0 0x0 0x0 0x0 0x0
Masterstorage Slot 7 0x0 0x0 0x0 0x0 0x0
Masterstorage Slot 8 0x0 0x0 0x0 0x0 0x0
Masterstorage Slot 9 0x0 0x0 0x0 0x0 0x0
Initializing NRF24L01 transmitter...Done
*** PRESS 'N' to reset the device

Voila, damit läuft der Master schon mal.

Das erste Slave-Gerät

Kommen wir zum Slave. Dafür öffnen wir nun, am besten in einem zweiten Arduino Fenster den Sketch GettingStartedClient.

Vom Code her wird hier vieles gemacht, wie beim Master. Es wird eine eindeutige MAC Adresse vergeben (Zeile 33), ein Netzwerk-Gerät angelegt (Zeile 38 – diesmal mit einem true als Parameter, das dem Gerät sagt, es ist ein Slave-Gerät). In setup() wird das Gerät initialisiert und in der loop() wird alle 4 Sekunden eine Nachricht an den Master verschickt.

Zu beachten ist hier, dass das Warten auf die 4 Sekunden nicht über ein klassisches delay(4000); gelöst wird, sondern bei jeden loop() Durchlauf die interne Uhr befragt wird. Würden wir den Arduino nämlich mit delay(4000); warten lassen, würde er keinen weiteren Code abarbeiten und somit auch nicht die update() funktion aufrufen. Aber in der update() funktion wird ja geprüft, ob es neue Nachrichten gibt. Also muss diese ständig aufgerufen werden.

Ok, soviel zur Theorie, kommen wir zur Praxis uns starten den Sketch. Der erste Start sollte im seriellen Monitor die folgende Ausgabe erzeugen.

*** PRESS 'N' to reset the device
SBNetwork Version 1.0.2
====================

Try to read device config from internal flash...Failed
Creating new device config and stroing it to internal flash...
Done
Device MAC = 0x5 0x4 0x3 0x2 0x1
Master MAC = 0x0 0x0 0x0 0x0 0x0
NetKey = 0
Initializing NRF24L01 transmitter...Done
Try to connect to master...Warning - Not paired to a master
Sending broadcast transmission to find a master...Done
Got answer from a master. Master-MAC is 0x1 0x2 0x3 0x4 0x5
Try to pair with master...Suceeded
Try to ping to master...Done - Master available
Received Content: Hello client, yes I can hear you well!
Received Content: Hello client, yes I can hear you well!
Received Content: Hello client, yes I can hear you well!

Wenn das erscheint, dann ist alle richtig gelaufen und es funktioniert. Damit haben wir das erste Master/Slave Paar, das miteinander kommuniziert.

Geschafft – nRF24L01 was will man mehr?

Und es war vollbracht. Super. Jetzt kann man seinen Ideen freien Lauf lassen und was auch immer programmieren. Chatprogramm, Sensoren-Werte lesen oder andere Dinge. Ich für meinen Teil habe sogleich damit begonnen, eine SmartHome Bibliothek zu entwickeln, die ich euch in einem weiteren Beitrag vorstellen werde. Die Bibliothek wird es noch mehr vereinfachen, Sensoren-Daten zu übertragen oder Aktoren zu steuern.

Wie gesagt, muss man sich jetzt zunächst selber darum kümmern, wie man Daten in eine Nachricht verpackt und wieder ausließt. Ich habe dazu mal ein kleines Beispiel erstellt, siehe UniversalSensorMaster und BME_280Client. Mit beiden Beispielen kann man die Werte eines BME280 (Temperatur, Luftfeuchte und Luftdruck) messen und an einen Master übertragen. Schaut sie euch einfach mal an.

Und wie immer gilt, Kritik, Lob, Verbesserungen und Fragen einfach per Kommentar oder Mail an mich.

Viel Spass beim Kommunizieren…

Bernd

 

17 Gedanken zu „Master/Slave Netzwerk mit nRF24L01 und Arduino/ESP8266“

  1. Hallo Bernd,

    beim Testen der Bibliothek habe ich das Problem, daß sich Master und Client zwar finden („Device available“), es werden aber keine Daten ausgetauscht.
    Auch „manuelles“ senden von Daten funktioniert nicht, in beide Richtungen.
    An was könnte das liegen?
    Vielen Dank.

    Grüße
    Klaus

  2. Hallo Marcel (Bernd)
    Deine Netzwerkidee konnte ich ganz einfach umsetzen und für mich erweitern. Super Arbeit!
    Ich nutze sie für mobile Belegtmelder auf meiner MoBa = ausprobieren, bevor Kabel gezogen werden.
    Aus Platzgründen und wegen des geringen Stromverbrauchs würde ich gern ATTINY 84 einsetzen.
    Der große G erzählt, dass hier spezielle Bibliotheken notwendig sind. Siehst du einen praktikablen Weg für diese Hardwarekombination?
    Danke und Grüße
    Josef

  3. Hallo Bernd
    Tolle Bibliothek, werde ich bei meinem in Planung befindlichen Projekt auch gern einsetzen. Ich hatte selbst schon an was ähnlichem gebastelt, aber sehr statisch, d,h. bei neuem Client musste auch im Master was geändert werden. Da gefällt mir deine dynamische Version mit neuen Verbindungen besser.
    Aber: was mir aufgefallen ist beim Durchlesen des Codes: Du speicherst die Konfiguration im EEPROM immer ab Adresse 0; da liegt aber evtl schon eine andere Konfiguration. Wäre schön, wenn du in der nächsten Version was einbaust, ab wo die SBNetwork Konfiguration gespeichert wird.
    Gruß
    Hubi

  4. Hallo Bernd,
    nun bin auch ich auf Deiner Seite gelandet und habe mit 2 Arduinos und den RF24L01 die Verbindung geschafft.
    Gibt es, passend zu Deinem Sketch GettingStartedClient, auch ein Gegenstück für die Raspberry Pi in Python?

  5. Hi,

    super Arbeit. Funktioniert alles out of the box bei einem Nano als Client und einem ESP8266 als Master.
    Jetzt versuch ich gerade den Master auf einem ESP32 ans laufen zu bringen. Irgendwie klappte es hier nicht. Er gibt mir auf dem Master keine MAC Adresse an. Ist hier der Zugriff auf den Speicher anders?

    Gruß Christoph

  6. Ich weiß nicht, ob ich so einfach Hilfe erhalten kann, habe mit Funk noch nichts weiter gemacht, nur die Beispiele versucht.
    Als eigenes Projekt habe ich eine Gartenlampensteuerung mit GPS und Schalten 0,5h vor oder nach Sonnengang für mich erfolgreich gebaut. Aber mit Funk wollte ich weiter machen,
    im Haus steuern.

    Arduino und nRF24L01 habe ich erfolgreich aufgebaut mit
    UNO R3 und Nano.
    Beim Versuch Master/Slave Netzwerk mit gleichem Aufbau und Korrektur 6,7 statt D2,D8, erhalte ich beim Kompilieren bereits eine Fehlermeldung, hier die Antwort:

    Arduino: 1.8.10 (Linux), Board: „Arduino Nano, ATmega328P“

    /home/lomue/Programme/arduino-1.8.10/arduino-builder -dump-prefs -logger=machine -hardware /home/lomue/Programme/arduino-1.8.10/hardware -tools /home/lomue/Programme/arduino-1.8.10/tools-builder -tools /home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -built-in-libraries /home/lomue/Programme/arduino-1.8.10/libraries -libraries /home/lomue/Arduino/libraries -fqbn=arduino:avr:nano:cpu=atmega328 -vid-pid=0403_6001 -ide-version=10810 -build-path /tmp/arduino_build_845365 -warnings=none -build-cache /tmp/arduino_cache_228560 -prefs=build.warn_data_percentage=75 -prefs=runtime.tools.avrdude.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -prefs=runtime.tools.avrdude-6.3.0-arduino17.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -prefs=runtime.tools.avr-gcc.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -prefs=runtime.tools.avr-gcc-7.3.0-atmel3.6.1-arduino5.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -prefs=runtime.tools.arduinoOTA.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -prefs=runtime.tools.arduinoOTA-1.3.0.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -verbose /home/lomue/Arduino/Projekte/MasterSlaveNetzwerk_M/MasterSlaveNetzwerk_M.ino
    /home/lomue/Programme/arduino-1.8.10/arduino-builder -compile -logger=machine -hardware /home/lomue/Programme/arduino-1.8.10/hardware -tools /home/lomue/Programme/arduino-1.8.10/tools-builder -tools /home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -built-in-libraries /home/lomue/Programme/arduino-1.8.10/libraries -libraries /home/lomue/Arduino/libraries -fqbn=arduino:avr:nano:cpu=atmega328 -vid-pid=0403_6001 -ide-version=10810 -build-path /tmp/arduino_build_845365 -warnings=none -build-cache /tmp/arduino_cache_228560 -prefs=build.warn_data_percentage=75 -prefs=runtime.tools.avrdude.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -prefs=runtime.tools.avrdude-6.3.0-arduino17.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -prefs=runtime.tools.avr-gcc.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -prefs=runtime.tools.avr-gcc-7.3.0-atmel3.6.1-arduino5.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -prefs=runtime.tools.arduinoOTA.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -prefs=runtime.tools.arduinoOTA-1.3.0.path=/home/lomue/Programme/arduino-1.8.10/hardware/tools/avr -verbose /home/lomue/Arduino/Projekte/MasterSlaveNetzwerk_M/MasterSlaveNetzwerk_M.ino
    Using board ’nano‘ from platform in folder: /home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr
    Using core ‚arduino‘ from platform in folder: /home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr
    Detecting libraries used…
    /home/lomue/Programme/arduino-1.8.10/hardware/tools/avr/bin/avr-g++ -c -g -Os -w -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -flto -w -x c++ -E -CC -mmcu=atmega328p -DF_CPU=16000000L -DARDUINO=10810 -DARDUINO_AVR_NANO -DARDUINO_ARCH_AVR -I/home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/cores/arduino -I/home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/variants/eightanaloginputs /tmp/arduino_build_845365/sketch/MasterSlaveNetzwerk_M.ino.cpp -o /dev/null
    Alternatives for SBNetwork_config.h: [SBNetwork-master@1.1.0]
    ResolveLibrary(SBNetwork_config.h)
    -> candidates: [SBNetwork-master@1.1.0]
    /home/lomue/Programme/arduino-1.8.10/hardware/tools/avr/bin/avr-g++ -c -g -Os -w -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -flto -w -x c++ -E -CC -mmcu=atmega328p -DF_CPU=16000000L -DARDUINO=10810 -DARDUINO_AVR_NANO -DARDUINO_ARCH_AVR -I/home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/cores/arduino -I/home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/variants/eightanaloginputs -I/home/lomue/Arduino/libraries/SBNetwork-master/src /tmp/arduino_build_845365/sketch/MasterSlaveNetzwerk_M.ino.cpp -o /dev/null
    Alternatives for RF24_config.h: [RF24-master@1.3.3]
    ResolveLibrary(RF24_config.h)
    -> candidates: [RF24-master@1.3.3]
    /home/lomue/Programme/arduino-1.8.10/hardware/tools/avr/bin/avr-g++ -c -g -Os -w -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -flto -w -x c++ -E -CC -mmcu=atmega328p -DF_CPU=16000000L -DARDUINO=10810 -DARDUINO_AVR_NANO -DARDUINO_ARCH_AVR -I/home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/cores/arduino -I/home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/variants/eightanaloginputs -I/home/lomue/Arduino/libraries/SBNetwork-master/src -I/home/lomue/Arduino/libraries/RF24-master /tmp/arduino_build_845365/sketch/MasterSlaveNetzwerk_M.ino.cpp -o /dev/null
    Alternatives for SPI.h: [SPI@1.0]
    ResolveLibrary(SPI.h)
    -> candidates: [SPI@1.0]
    /home/lomue/Programme/arduino-1.8.10/hardware/tools/avr/bin/avr-g++ -c -g -Os -w -std=gnu++11 -fpermissive -fno-exceptions -ffunction-sections -fdata-sections -fno-threadsafe-statics -Wno-error=narrowing -flto -w -x c++ -E -CC -mmcu=atmega328p -DF_CPU=16000000L -DARDUINO=10810 -DARDUINO_AVR_NANO -DARDUINO_ARCH_AVR -I/home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/cores/arduino -I/home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/variants/eightanaloginputs -I/home/lomue/Arduino/libraries/SBNetwork-master/src -I/home/lomue/Arduino/libraries/RF24-master -I/home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/libraries/SPI/src /tmp/arduino_build_845365/sketch/MasterSlaveNetzwerk_M.ino.cpp -o /dev/null
    Alternatives for arduino.h: []
    ResolveLibrary(arduino.h)
    -> candidates: []
    Mehrere Bibliotheken wurden für „SBNetwork_config.h“ gefunden
    Benutzt: /home/lomue/Arduino/libraries/SBNetwork-master
    Mehrere Bibliotheken wurden für „RF24_config.h“ gefunden
    Benutzt: /home/lomue/Arduino/libraries/RF24-master
    Mehrere Bibliotheken wurden für „SPI.h“ gefunden
    In file included from /home/lomue/Arduino/libraries/SBNetwork-master/src/SBDevice.h:5:0,
    Benutzt: /home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/libraries/SPI
    from /home/lomue/Arduino/libraries/SBNetwork-master/src/SBNetwork.h:11,
    from /home/lomue/Arduino/Projekte/MasterSlaveNetzwerk_M/MasterSlaveNetzwerk_M.ino:29:
    /home/lomue/Arduino/libraries/SBNetwork-master/src/SBTypes.h:5:10: fatal error: arduino.h: No such file or directory
    #include
    ^~~~~~~~~~~
    compilation terminated.
    Bibliothek SBNetwork-master in Version 1.1.0 im Ordner: /home/lomue/Arduino/libraries/SBNetwork-master wird verwendet
    Bibliothek RF24-master in Version 1.3.3 im Ordner: /home/lomue/Arduino/libraries/RF24-master wird verwendet
    Bibliothek SPI in Version 1.0 im Ordner: /home/lomue/Programme/arduino-1.8.10/hardware/arduino/avr/libraries/SPI wird verwendet
    exit status 1
    Fehler beim Kompilieren für das Board Arduino Nano.

  7. Hallo!
    Ich habe vor ein Netzwerk zwischen einigen Geräten aufzubauen, wobei eine Zentralle Befehle an mehrere Clients verteilt. Geplant habe ich das mit Wemos D1 mini’s sowohl bei der Zentralle (die einige Aufgaben hat und daher Rechenleistung und Speicher benötigt) als auch bei den Clients (die einfache Funktionen haben, wie ON/OFF, PWM). Alles ohne Anbindung ans Internet. Wenn ich über NRF2401 lese, scheint mir das die optimale (weil einfachere) Lösung für die Clients zu sein, z.B. NRF2401 und Arduino Pro mini oder sogar ATTiny. In den Tutorials finde ich aber immer Kommunikation zwischen 2 NRF, als ob Wemos D1 mini nicht selbst über WLAN kommunizieren könnte. Kann man keine Kommunikation Wemos D1 mini NRF2401 aufbauen und braucht sogar Wemos einen NRF um mit anderen NRF zu kommunizieren?

    Harald

    1. Die nrf24 nutzen zwar dieselbe Frequenz wie WLan die „Funktechnik“ ist jedoch eine andere und nicht mit der von Wlan zu kombinieren.

  8. Hallo Bernd,

    ist es mir irgendwie möglich die empfangene Nachricht in einer if-Abfrage zu verwenden?
    Hab schon das ein oder andere versucht aber komme zu keinem Ergebnis. z.B. die Message vom Master an den Slave war 1.
    aber der Slave geht nicht in das untenstehende netzwerk rein.
    if((char*)networkDevice.getMessage() == „1“) {
    char* message = „ich habe eine 1 bekommen“;
    networkDevice.sendToDevice(networkDevice.NetworkDevice.MasterMAC, message, strlen(message) + 1);
    }
    wäre nett wenn du mir helfen könntest.

    Gruß Julian

  9. Hallo Bernd,
    erstmal vielen Dank für die Mühe, genau sowas hab ich schon lange gesucht,… einfach und auch für nichtprogrammierer zu verstehen!
    In deinem Beispiel sketch zum BME client hast du wait auf 20 Sekunden. Hat das einen bestimmten Grund?

    Ein kleiner Tip oder eher eine Bitte:
    bitte mach die Lib über die Bibliotheksverwaltung zugänglich. Oder hat das auch einen Grund, zwecks Server oder Kosten usw.? Würde mich interessieren.

    Grüße, Thomas

    1. Hallo Thomas,
      die 20 Sekunden habe ich nur gewählt, damit nicht permanent Daten gesendet werde, aber beim Testen nicht so lange warten muss.
      Den Wert kann man beliebig ändern. Ich empfehle im Live-Betrieb so alle 120 Sekunden einen Wert zu übermitteln.
      Gruß Bernd

  10. Moin,

    das sind zwei ganz großartige Projekte mit dem nRF … was ich im Moment versuch zu finden, ist eine Übersicht der Funktionen des nRF`s . Bspw. kann mein Sim-Modul nebenher den Batteriestatus auslesen. Gibt es weiterführende Links ?

    Ich möchte ein kleines batteriebetriebenes nRF-Netzwerk aufbauen und würde mir wünschen, wenn täglich einmal jeder Slave seinen Status abgibt.

    Danke schn jetzt für eine Antwort

    1. Hallo Hagen,
      in der Bibliothek von TMRh20 gibt es sehr schöne Beispiele auch zum nrf24 selbst. Deine Anforderung lässt sich aber sehr leicht umsetzen. Ich habe etwas ähnliches für meine Wetterstation gemacht.
      Schau dir dafür mal die Lowpower lib an. Mit der kannst du den Arduinio ( in meinem Fall ein Arduino Mini) in den Tiefschlaf versetzen. Zusammen mit den Low Power Modus vom nrf24 und dem Herauslöten der LED vom Mini kam ich letztendlich auf knappe 70yA Stomaufnahme. Ein Betrieb mit einer LiIon Zelle (18650) oder zwei AA Baterien ist somit sehr gut möglich und lief bei mir auch recht lange stabil, sogar bei kalten Außentemperaturen. Dabei habe ich allerdings alle 5min Werte übertragen.

      Gruß Bernd

  11. Hallo. Ich würde gern einen wemos als Master nutzen. An diesem ist auf dem i2c bus bereits ein Helligkeitssensor angebunden. Der SDA des Bus läuft auf PIN D2. Kann man in deiner lib den von dir genutzten PIN 2 auch auf die 3 oder 4 legen?

  12. Hallo Torsten,
    danke für deinen Kommentar und dein Lob. Freut mich, wenn ich der Community auch was nützliches zurückgeben kann.

    Der nrf24l01 hat zwar 6 Pipes, diese benötigt man aber (meines Erachtens) so gut wie nicht. Eine Pipe reicht völlig aus. Die Adresse, die du der Pipe vergibst ist eine Art MAC Adresse, also eine physische Adresse. Alle Datenpakete, die an die physische Adresse gesendet werden, werden erstmal grundsätzlich empfangen und dem Microcontroller zur Weiterverarbeitung gereicht.
    Wenn du jetzt 12+ Sensoren hast, dann brauchst du nur eine Möglichkeit, zu unterscheiden, von wem ein Datenpaket empfangen wurde. Um das zu erreichen, wird einfach immer die Absenderadresse mit übermittelt.
    Der Master empfängt und sendet nur auf einer Pipe, weiß aber immer, von wem er ein Datenpaket empfangen hat und kann auch entsprechend an die korrekte Adresse antworten.
    Gruß Bernd – Mein Spitzname 😉

  13. Hallo Bernd?
    Ich bin etwas verwirrt da Du Dich Anfangs als Marcel Schulz vorstellst oder ich habe mich verlesen.
    Wie auch immer, Dein Werdegang und Dein offenes Dokumentieren und Programmieren von dem dann auch andere Interessierte parizipieren können ehrt Dich sehr !!! Meine Hochachtung und vielen Dank dafür!
    Das hilft wirklich, wenn Wissen so prima vermittelt wird.

    Und nun zu meiner Fragestellung:
    Ich habe die HW zusammen und möchte mein SmartHome mit Arduinos & Raspi als HyperMaster, verbunden via RS485 weiter ausbauen. Das Einbinden der Funkverbindungen ist notwendig, da ich beim Häusle-Bau die Sensor-Verkabelung zu den Fenstern teils verschwitzt habe…
    D.h. fensterseitig Arduino Mini Pro´s, die offen/zu und Ubatt senden sollen, batterieversorgt. Also mit Sleepmodus.
    Als Funk-Master soll ein weiterer Arduino z.B. ein Nano oder Mega 2560 dienen, der dann routet.
    Ich muss allerdings ca. 12 Fenster-Sensoren verwalten.
    Die max. 6 Pipes pro Channel stellen für mich daher ein Verständnisproblem dar. Ich benötige ja keine parallel Sendeverarbeitung, da meist nur ein einziger Sender was zu melden hat. Also alle Sender im gleichen Pipe oder je 2 ein Pipe teilen lassen ??? Wie mache ich das am Besten???

    Ich danke Die für Deine Zeit !!!!
    Gruß
    Torsten

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert