Arduino und nRF24L01

Eigentlich sollte mein erster Artikel hier im Blog die Vorstellung meiner selbstgeschrieben Bibliothek zum Bau eines kleinen Sensoren-Netzwerkes auf Basis der nRF24L01 Funktransmitter und dem Arduino werden. Dabei wollte ich die Grundlagen zum Anschließen der Hardware einfach nur etwas tiefer erläutern. Draus geworden ist jetzt allerdings eine komplette kleine Einführung zum Thema Arduino und nRF24L01. Meinen eigentlichen Artikel über das Sensoren-Netzwerk, werde ich aber in einem gesonderten Post nachreichen. Jetzt aber erstmal viel Spass beim Kennenlernen der nRF24L01-Welt.

Mein kleiner Liebling

Zum Einsatz kommen die beliebten nRF24L01 Chips, die auf 2,4 GHz senden und empfangen. Die kleinen Racker bieten sehr viele integrierte Funktionen sodass man sich als Entwickler wenig Gedanken über die Basiskommunikation machen muss. Das heist, die Themen Adressierung, Senden und Empfangen sind bereits im Chip integriert und man steuert diese nur über den SPI Bus an.

Aber zunächst einige Fakten zu den Funkchips. Wie schon gesagt, senden diese auf 2,4 GHz. Man kann bis zu 128 Kanäle wählen, um etwaige Funkkollisionen mit anderen Netzen zu vermeiden. Miteinander kommunizierende Chips müssen natürlich auf dem selben Kanal funken. Jedem Chip kann eine 40 Bit Adresse zugewiesen werden. Beim Absetzen eines Funkpaketes sorgen die Chips untereinander alleine dafür, dass die Übertragung erfolgreich ist. D.h. sie senden ein Funkpaket so oft neu, bis die Gegenstelle den erfolgreichen Empfang mit einem Acknowlegde bestätigt. Natürlich lassen sich diese ganzen Helferfunktionen auch deaktivieren sodass der Chip sozusagen direkt gesteuert werden kann. Das werden wir allerdings nicht tun und konzentrieren uns auf das Wesentliche.

Erhältlich sind die Chips in zwei Versionen. Einmal die ‘normalen’ nRF24L01 mit integrierter Antenne und die etwas größeren Varianten mit einer SMA Antenne für eine bessere Sende- und Empfangsleistung. Welche unterschiedlichen Reichweiten zwischen beiden Versionen erzielt werden, kann ich im Augenblick noch nicht sagen. Ich weiß jedoch, dass die günstige Version mit integrierter Antenne eine für mich völlig ausreichende Reichweite bietet. Völlig ausreichend heißt bei mir das erfolgreiche Funken innerhalb eines Hauses über 4 Etagen (vom Keller bis in den 3. Stock). Gehe ich mit einem Chip aber in den Garten und lasse den anderen im 3. Stock stehen, sieht es leider etwas schlechter aus und die Kommunikation funktioniert nur noch sporadisch bis gar nicht mehr. Deshalb habe ich mir zusätzlich noch die SMA Version bestellt Und werde diese bald testen.

Voraussetzungen und Teileliste

Was brauchen wir, um unser Kommunikationsprojekt zu bauen. Zunächst einmal setze ich voraus, dass du bereits etwas Erfahrung mit dem Arduino hast. Du solltest bereits erfolgreich deine ersten kleinen Projekte, wie die blinkende Lampe oder das Einlesen eines Schalters erstellt haben und etwas gefestigt mit dem Umgang der Programmiersprache für den Arduino nämlich C/C++ sein. Sollte das nicht der Fall sein, empfehle ich dir die Anfänger-Tutorials auf http://arduino.cc.

Die benötigte Hardware setzt sich aus folgenden Komponenten zusammen:

• Arduino UNO R3 oder alternativ ein Arduino Mega 2560. Letzterer wird vor allem später interessant, wenn wir weitere Funktionen wie Sensoren bauen wollen. Der UNO hat dann schlichtweg zu wenig Speicher und produziert Fehler.
• Einen zweiten Arduino als Kommunikationspartner. Ich empfehle hier einen Arduino Nano oder Micro. Ein Nano hat eine integrierte USB Schnittstelle, sodass die Tests hier etwas angenehmer sind. Ein Micro hingegen wird für den produktiven Einsatz interessant, vor allem wenn wenig Platz vorhanden ist oder er mit Batterie betrieben werden soll.
• Für den Anfang noch nicht wichtig, aber später ein Muss, das Ethernetshield für den Arduino UNO/Mega. Dieses wird dann benötigt, wenn wir unser Funknetz an das LAN anbinden wollen.
• Nicht zuletzt brauchen wir zwei nRF24L01 Funktransmitter. Diese gibt es günstig bei Amazon oder Ebay. Ich empfehle gleich drei oder fünf zu bestellen. Es kann schon mal sein, dass man einen mit einer falschen Spannung versorgt und sich dieser dann ins Jenseits verabschiedet und da ist es immer gut, noch einen auf Reserve zu haben, um nervige Unterbrechungen zu vermeiden.
• Wichtig sind auch zwei 10 yF Elektrolytkondensatoren kurz Elkos. Diese benötigen wir als Spannungsstabilitatoren für die Funktransmitter. Ein Fehlen der Elkos hat bei mir jedenfalls zu enormen Kommunikationsproblemen geführt.
• Außerdem solltest du eine Standardausrüstung zum Basteln mit dem Arduino haben. Dazu zählen Steckbrett,  Female-Female und Male-Female Steckberbindungen.

Bastelstunde

Jetzt geht es ans Eingemachte. Wir bauen uns zunächst den Master zusammen. Hierfür verbinden wir den Arduino UNO mit dem nRF24L01 Chip. Achte bitte unbedingt darauf, dass du den VCC Pin am Chip mit dem 3,3 V Pin vom Arduino verbindest. Eine 5 V Spannung kann den Transmitter zerstören und du brauchst direkt einen Neuen. Solltest du sehr günstige nRF Chips gekauft haben, haben diese oft keine Pin-Beschriftung. Nutze einfach die unten stehende Pin-Übersicht.

Verbinde bitte auch den Elko mit dem VCC und GND Pin des Transmitters. Ich habe das immer so gemacht, dass ich die Pins vom Elko mit in die Buchse zwischen Transmitterpin und Steckverbinder geklemmt habe. Hier muss du auch auf die Polung achten. Der längere Draht am Elko ist meist der Plus-Pol und muss an VCC des Transmitters.

Das war es auch schon mit dem Master. Kommen wir zum ersten Slave. Hierfür nehme ich der Einfacheit halber einen Arduino Nano. Dieser hat bereits eine 3,3 V Stromversorgung für den nRF Chip integriert. Wenn du einen Micro benutzen möchtest solltest du parallel einen 3,3 V Spannungsregler, z.B. einen LD1117V33, verwenden oder gleich die 3,3 V Variante des Micro kaufen.

Um den Funktransmitter am Nano anzuschließen, empfiehlt es sich, den Nano auf ein Steckbrett zu stecken und die Pins mit Female-Male Kabel zu verbinden. Denke auch hier wieder an den 10 yF Elko zwischen VCC und GND Pin, um Empfangsprobleme zu vermeiden. Unten findest du erneut eine Grafik mit der Übersicht der Pin-Verbindungen.

Umgebung einrichten

Nadem wir nun unsere Hardware vorbereitet haben, kommen wir zur Programmierung unserer Arduinos. Hierfür müssen wir glücklicherweise nicht von Grund auf neu anfangen. Es gibt nämlich schon einige Profies, die sich die Arbeit gemacht haben und eine Bibliothek für die Ansteuerung des nRF24L01 erstellt haben und dann noch freundlicherweise der Menschheit zur Verfügung stellen. Hier wurde ich zu Beginn etwas verwirrt. Es gibt nämlich viele solcher Biliotheken, im Programmieren-Volksmund auf Library genannt. Und wenn man nach diesen sucht und sie ausprobieren möchte, kommt es oft vor, dass ein Beispielprogramm nicht richtig funktioniert, einfach weil man das Beispielprogramm einer anderen Library benutzt hat. Das übersieht man beim ersten Hinsehen gerne mal. Und die große Anzahl an Forks (Abwandlungen) macht die Welt zusätzlich um einiges mehr unübersichtlicher.

Für unser erstes Beispiel nehmen wir die Bibliothek RF24 vom Entwickler TMRh20. Dieser hat die für mich beste Library geschrieben. Sie ist ein Fork der Basisbibliothek von maniacbug mit einigen Verbesserungen versehen. Sie wird auch noch aktiv gepflegt und wird ebenfalls in vielen weiteren Projekten desselben Entwicklers verwendet. Wen es interessiert: Audiostreaming oder IP-Basierte Netzwerke sind nur zwei Beispiele. Allerdings nutze ich nur die Basis-Library und habe alles andere selbst programmiert. Denn die weiterführenden Libraries vom Entwickler ermöglichen es zwar routingfähige Netze aufzubauen. Jedoch muss der Ersteller die Adressen der Netze fest einprogrammieren, was mir persönlich nicht gefällt. Und Routing bzw. IP basierte Netze benötige ich auch nicht, da ich a) nicht für jedes Gerät eine IP-Adresse in meinem Netzwerk haben möchte und b) meine Netzwerke räumlich so begrenzt sind, dass die Verbindung von einem Slave zum Master faktisch immer gegeben ist.

Um zu starten, gehe einfach auf https://github.com/TMRh20/RF24 und lade dir die aktuelle Version der Library herunter. Rechts auf der Seite, neben der Dateiliste, kannst du das komplette Projekt als ZIP Datei herunterladen.

Gehe nun in den Ordner für Libraries deiner Arduino Entwicklungsumgebung. Dieser befindet sich unter \Meine Dokumente\Arduino\libraries und lege dort einen neuen Ordner z.B. RF24 an. Entpacke nun die ZIP Datei in den neuen Ordner. Die RF24.h und alle anderen Dateien sollten nun direkt im Ordner RF24 liegen.

Das erste Beispielprogramm

Jetzt ist es Zeit, die Arduino Entwicklungsumgebung zu starten. Wenn du die Bibliothek richtig installiert hast, sollte im Menü Datei > Sketchbook > Libraries das Menü RF24 auftauchen, in dem wiederum viele Beispiele zu sehen sind.

Klicke auf den Eintrag GettingStarted. Die Umgebung lädt das erste Beispielprojekt aus der Library. Was jetzt folgt, sind ein paar Erläuterungen zum Quellcode.

Der Sketch ist so ausgelegt, dass er auf beiden Arduinos installiert wird. Man muss dem Programm nur sagen, welcher der beiden Arduinos der erste und welcher der zweite ist. Und das passiert auch gleich in Zeile 13.

/*
* Getting Started example sketch for nRF24L01+ radios
* This is a very basic example of how to send data from one node to another
* Updated: Dec 2014 by TMRh20
*/

#include <SPI.h>
#include "RF24.h"

/****************** User Config ***************************/
/***      Set this radio as radio number 0 or 1         ***/
bool radioNumber = 0;

/* Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 */
RF24 radio(7,8);
/**********************************************************/

Wenn du radioNumber auf 0 setzt und das Programm dann auf den Arduino UNO schreibst, musst du den Wert auf 1 ändern bevor du das Programm auf den Arduino Nano schreibst. Merke dir also am besten. Der UNO bekommt immer die 0. Der Nano bekommt immer die 1.

In Zeile 16 des Codes wird das Objekt für den nRF Chip erstellt. Dabei werden auch die Parameter übergeben, an welchen Pins wir CE und CSN angeschlossen haben. Hier müssen wir anstatt 7,8 die Werte 6,7 eintragen. Der fertige Code für unseren Arduino UNO sieht dann wie folgt aus:

/*
* Getting Started example sketch for nRF24L01+ radios
* This is a very basic example of how to send data from one node to another
* Updated: Dec 2014 by TMRh20
*/

#include <SPI.h>
#include "RF24.h"

/****************** User Config ***************************/
/***      Set this radio as radio number 0 or 1         ***/
bool radioNumber = 0;

/* Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 */
RF24 radio(6,7);
/**********************************************************/

Den Rest des Quellcodes können wir unverändert lassen. Verbinde jetzt den Arduino UNO per USB mit dem PC und wähle im Menü Werkzeuge > Platine > Arduino UNO aus. Setzte außerdem noch den korrekten Port unter Werkzeuge > Port > COM X (Arduino UNO) [Das X steht für deinen Port]. Jetzt kompiliere und lade den Sketch hoch. Öffne nun den Seriellen Monitor unter Werkzeuge > Serieller Monitor und stelle dort die richtige Baudrate ein. In unseren Fall ist das 115200. Wenn du das gemacht hast, sollte der Serielle Monitor etwas so aussehen:

Im Terminal steht, dass wir T eingeben sollen, um die Übertragung zu starten. Gesagt, getan. Gebe oben ein T ein und drücke Enter. Der UNO beginnt nun zu senden und wir erhalten lauter Meldungen über fehlgeschlagene Übetragungen.

Der UNO bekommt keine Antwort, was ja klar ist, denn wir haben den Kommunikationspartner, der die Nachrichten empfangen und Antwort geben soll, noch nicht eingerichtet. Aber das tun wir jetzt. Zuvor gebe im Terminal aber noch ein R ein und drücke Enter. Das versetzt den UNO wieder in den Empfangs-Modus.

Schließe nun das Terminal und verbinde den Arduino Nano per USB mit deinem PC. Im Quellcode änderst du noch die Zeile 13 und setzt radioNumber = 1. Damit ist unser Quellcode bereit für den Nano. Ändere noch unter Werkzeuge > Platine den Wetrt auf Arduino Nano und passe den COM Port ebenfalls an. Compiliere und lade den Sketch jetzt auf den Arduino Nano und öffner erneut das Terminal. Wieder sagt uns das Terminal, dass wir T eingeben sollen, um die Übertragung zu starten. Also gib T ein und bestätige mit Enter. Der Nano fängt nun an zu senden. Wenn du alles richtig gemacht hast, sollte er nun eine Antwort erhalten und das Terminal in etwas so ausschauen:

Bei mir schlägt das Senden ab und zu trotzdem Fehl. Ich habe herausgefunden, dass dies wahrscheinlich ein kleines Timing-Problem ist. Daher habe ich nach der Zeile 111 ( radio.stopListening(); ) noch ein delay(50); eingebaut. Das sorgt dafür, dass der Empänger der Nachricht kurz wartet, bevor er seine Antwort zurück an den Sender schickt. Ich glaube nämlich, dass der Empfänger manchmal schneller antwortet als der Sender in den Empfangsmodus gehen kann. Bei mir sorgt das delay jedenfalls für eine deutlich stabilere Kommunikation.

Voila! Damit haben wir unseren ersten großen Milenstein geschafft. Unsere Arduinos reden miteinander und das per Funk. Na das ist doch schon mal was, oder?

Ich hoffe der erste Teil hat dir soweit gefallen. Im nächsten Teil möchte ich gerne meine selbstgeschriebene Library vorstellen und zeigen, wie man mit ihr diverse Sensoren bauen kann. Die Werte der Sensoren werden auf dem Master abgespeichert und können dann per LAN angefragt werden.

Solltest du Fragen oder Anregungen haben, kannst du gerne Kommentare hinterlassen.

Bernd