NRF-Nano V3.0 Entwicklungsboard, CH340, ATMega328p mit NRF24L01, Typ C

Dieses Tutorial verwendet das Board NRF-Nano V3.0 als Entwicklungsboard selbst, programmiert über die Arduino IDE als Arduino Nano, ohne ein weiteres Arduino-Board. Das Board kombiniert einen ATmega328P mit einem Funkmodul nRF24L01+ für 2,4 GHz. Daher wird es für Fernbedienungen, Sensornetze und jedes Projekt verwendet, in dem zwei oder mehr Boards Daten drahtlos austauschen müssen.

Wir bauen einen Funktest mit zwei identischen Boards. An jedes Board wird ein Taster und eine LED angeschlossen. Jedes Board sendet den Zustand seines Tasters und schaltet die LED des anderen Boards ein. Die Stromversorgung und die Programmierung erfolgen über USB Type-C vom Computer.

So funktioniert es:

Das Board besteht aus zwei Teilen, die zusammenarbeiten. Der Mikrocontroller ATmega328P führt das Programm aus, und das Funkmodul nRF24L01+ sendet und empfängt Pakete im 2,4-GHz-Band. Beide kommunizieren über SPI, mit CE an D7, CSN an D8, MOSI an D11, MISO an D12 und SCK an D13. Aus diesem Grund können diese fünf Pins nicht für andere Zwecke verwendet werden.

Das Funkmodul arbeitet auf Kanälen mit 1 MHz Abstand, nummeriert von 0 bis 125. Die Frequenz eines Kanals wird wie folgt berechnet: Frequenz = 2400 MHz + Kanalnummer. Für den im Programm verwendeten Kanal 76 ergibt sich 2400 + 76 = 2476 MHz. Die beiden Boards müssen denselben Kanal und dieselbe Übertragungsrate verwenden.

Jedes Board hat eine Adresse mit 5 Bytes. Board A sendet an die Adresse von Board B und hört auf seine eigene Adresse. Board B macht es umgekehrt. Das Funkmodul verwendet eine automatische Paketbestätigung, daher liefert die Funktion write() nur dann true zurück, wenn das andere Board das Paket empfangen hat. Ein Paket kann höchstens 32 Bytes haben, und wir senden nur ein Byte mit dem Zustand des Tasters.

Der Taster wird mit INPUT_PULLUP gelesen. Der interne Widerstand verbindet den Pin mit 5 V, und beim Drücken verbindet der Taster ihn mit GND. Der Messwert ist daher LOW, wenn der Taster gedrückt ist. Die LED hat einen Vorwiderstand von 220 Ohm in Reihe. Der Strom durch die LED beträgt etwa (5 V - 2 V) / 220 Ohm = 14 mA und liegt damit unter der Grenze von 40 mA eines Pins.

Anschluss:

Versorgen Sie das Board über USB Type-C von einem USB-Anschluss des Computers mit 5 V. Die Logik des Boards arbeitet mit 5 V, und das Funkmodul wird intern mit 3,3 V vom Regler auf dem Board versorgt. Daher sind weder ein Pegelwandler noch eine separate Versorgung für das Funkmodul nötig. Bestücken Sie beide Boards mit denselben Bauteilen.

Taster, Einstellungen und Anzeigen:

Der Taster RESET hat keine Langdruckfunktion mit einer anderen Aufgabe. Drücken Sie ihn einmal, nachdem Sie die Schaltung verbunden haben, und Sie sehen auf dem seriellen Monitor die Startmeldung. Das bestätigt, dass das Programm neu gestartet wurde.

Die Test-LED an D13 braucht keine Einstellung. In diesem Tutorial steuern wir sie nicht über das Programm an, und sie kann leicht flackern, weil D13 den SPI-Takt des Funkmoduls führt. Das ist normal.

Der Taster an D2 und die LED an D3 sind die Bauteile, die Sie montiert haben. Der Start erfolgt mit losgelassenem Taster (Messwert HIGH) und ausgeschalteter LED. Beim Drücken des Tasters an einem Board muss die LED am anderen Board aufleuchten.

Board und Bibliotheken:

In der Arduino IDE wählen Sie Tools > Board > Arduino AVR Boards > Arduino Nano. Das Paket Arduino AVR Boards ist im Lieferumfang der Arduino IDE enthalten und muss nicht separat installiert werden. Unter Tools > Processor wählen Sie ATmega328P. Falls das Hochladen einen Fehler meldet, wählen Sie ATmega328P (Old Bootloader). Unter Tools > Port wählen Sie den neu erschienenen seriellen Port.

Installieren Sie über den Library Manager die Bibliothek RF24 von TMRh20, Version 1.4.0 oder neuer. Die Bibliothek SPI ist im Lieferumfang der Arduino IDE enthalten und muss nicht installiert werden.

Der Code:

Dasselbe Programm wird auf beide Boards geladen. Der einzige Unterschied ist der Wert NODE_ID am Anfang, der 0 für das erste Board und 1 für das zweite Board ist.

/*
  NRF-Nano V3.0 radio test: two boards, each sends its button state
  and lights the LED of the other board.
  Board in Arduino IDE: Arduino Nano (Tools > Board > Arduino AVR Boards > Arduino Nano)
  Processor: ATmega328P (if upload fails, use ATmega328P (Old Bootloader))
  Board package: Arduino AVR Boards (comes with Arduino IDE)
  Library to install from Library Manager: RF24 by TMRh20 (version 1.4.0 or newer)
  SPI library comes with Arduino IDE.
  Wiring on each board:
    D2  -> push button pin 1 (button pin 2 -> GND), INPUT_PULLUP
    D3  -> resistor 220 ohm -> LED anode (LED cathode -> GND)
  Built-in radio nRF24L01+: CE = D7, CSN = D8, MOSI = D11, MISO = D12, SCK = D13
  Upload this same sketch to both boards.
  Set NODE_ID to 0 for the first board and to 1 for the second board.
*/
#include <SPI.h>
#include <RF24.h>
// Identity of this board: 0 for the first board, 1 for the second board
#define NODE_ID 0
// Pin definitions
const uint8_t PIN_BUTTON = 2;   // Push button to GND, read with internal pull-up
const uint8_t PIN_LED = 3;      // LED through 220 ohm resistor
const uint8_t PIN_CE = 7;       // Radio CE pin on NRF-Nano V3.0
const uint8_t PIN_CSN = 8;      // Radio CSN pin on NRF-Nano V3.0
// Timing settings in milliseconds
const unsigned long SEND_INTERVAL_MS = 100;    // How often the button state is sent
const unsigned long LINK_TIMEOUT_MS = 1000;    // Link is lost after this time without packets
const unsigned long PRINT_INTERVAL_MS = 500;   // How often the status is printed
// Radio object
RF24 radio(PIN_CE, PIN_CSN);
// One address for each board (5 characters plus the end of string)
const byte addresses[][6] = {"NODE0", "NODE1"};
// State variables
uint8_t localState = 0;        // 1 when the local button is pressed
uint8_t remoteState = 0;       // 1 when the button of the other board is pressed
bool lastSendOk = false;       // Result of the last transmission
bool everReceived = false;     // True after the first packet is received
unsigned long lastSend = 0;
unsigned long lastReceive = 0;
unsigned long lastPrint = 0;
// Prints the current status on the serial monitor
void printStatus() {
  bool linkOk = everReceived && (millis() - lastReceive < LINK_TIMEOUT_MS);
  Serial.print(F("Local: "));
  Serial.print(localState ? F("PRESSED") : F("RELEASED"));
  Serial.print(F(" | Sent: "));
  Serial.print(lastSendOk ? F("OK") : F("FAILED"));
  Serial.print(F(" | Remote: "));
  Serial.print(remoteState ? F("PRESSED") : F("RELEASED"));
  Serial.print(F(" | Link: "));
  Serial.println(linkOk ? F("OK") : F("LOST"));
}
void setup() {
  // Start the serial monitor
  Serial.begin(9600);
  // Configure the button with pull-up and the LED as output
  pinMode(PIN_BUTTON, INPUT_PULLUP);
  pinMode(PIN_LED, OUTPUT);
  digitalWrite(PIN_LED, LOW);
  // Start the radio and stop if it does not answer
  if (!radio.begin()) {
    Serial.println(F("Radio not responding. Check CE and CSN pins."));
    while (true) {
      // Wait here forever
    }
  }
  // Radio settings, they must be the same on both boards
  radio.setPALevel(RF24_PA_LOW);   // Low power is enough for a bench test
  radio.setChannel(76);            // 2400 + 76 = 2476 MHz
  // This board writes to the other board and listens on its own address
  const uint8_t ownIndex = NODE_ID;
  const uint8_t peerIndex = 1 - NODE_ID;
  radio.openWritingPipe(addresses[peerIndex]);
  radio.openReadingPipe(1, addresses[ownIndex]);
  // Listen by default
  radio.startListening();
  Serial.print(F("Radio ready on channel 76, node "));
  Serial.println(NODE_ID);
}
void loop() {
  unsigned long now = millis();
  // Read the button and send its state at a fixed interval
  if (now - lastSend >= SEND_INTERVAL_MS) {
    lastSend = now;
    localState = (digitalRead(PIN_BUTTON) == LOW) ? 1 : 0;  // LOW means pressed
    radio.stopListening();                                   // Switch to transmit mode
    lastSendOk = radio.write(&localState, sizeof(localState));
    radio.startListening();                                  // Back to receive mode
  }
  // Read every packet that arrived
  while (radio.available()) {
    radio.read(&remoteState, sizeof(remoteState));
    lastReceive = millis();
    everReceived = true;
  }
  // Turn the LED on only while the link is alive and the remote button is pressed
  bool linkOk = everReceived && (millis() - lastReceive < LINK_TIMEOUT_MS);
  digitalWrite(PIN_LED, (linkOk && remoteState) ? HIGH : LOW);
  // Print the status from time to time
  if (now - lastPrint >= PRINT_INTERVAL_MS) {
    lastPrint = now;
    printStatus();
  }
}

So funktioniert der Code:

Am Anfang definieren wir NODE_ID, die Pins PIN_BUTTON (D2), PIN_LED (D3), PIN_CE (D7) und PIN_CSN (D8) sowie die Zeitintervalle SEND_INTERVAL_MS, LINK_TIMEOUT_MS und PRINT_INTERVAL_MS. Das Funkobjekt wird mit RF24 radio(PIN_CE, PIN_CSN) erzeugt, und das Feld addresses enthält die Adressen der beiden Boards.

In setup() starten wir die serielle Schnittstelle mit 9600 Baud, konfigurieren den Taster mit INPUT_PULLUP und die LED als Ausgang und starten dann das Funkmodul mit radio.begin(). Antwortet das Funkmodul nicht, zeigt das Programm eine Meldung an und hält an. Danach setzen wir den Kanal 76, die Sendeleistungsstufe RF24_PA_LOW, die Schreibadresse des anderen Boards mit openWritingPipe() und die eigene Leseadresse mit openReadingPipe(). Zum Schluss rufen wir startListening() auf, sodass das Board standardmäßig zuhört.

In loop() senden wir alle SEND_INTERVAL_MS den Zustand des Tasters. Zuerst lesen wir den Taster in die Variable localState, die 1 ist, wenn der Taster gedrückt ist. Wir beenden das Zuhören mit stopListening(), senden das Byte mit write(), speichern das Ergebnis in lastSendOk und nehmen das Zuhören wieder auf.

Solange radio.available() wahr ist, lesen wir das Paket in remoteState und speichern den Empfangszeitpunkt in lastReceive. Die LED an D3 folgt dem Zustand remoteState. Wenn wir länger als LINK_TIMEOUT_MS nichts mehr empfangen, erlischt die LED als Sicherheitsmaßnahme. Alle PRINT_INTERVAL_MS zeigt die Funktion printStatus() den Zustand des lokalen Tasters, das Ergebnis des Sendens, den Zustand des Tasters am anderen Board und den Zustand der Verbindung an.

Ergebnis:

Öffnen Sie Tools > Serial Monitor und stellen Sie die Geschwindigkeit auf 9600 Baud ein. Nach dem Start zeigen die beiden Boards alle eine halbe Sekunde ihren Zustand an. Wenn Sie den Taster an einem Board drücken, leuchtet die LED am anderen auf, und die Zeile im seriellen Monitor zeigt RELEASED oder PRESSED.

Radio ready on channel 76, node 0
Local: RELEASED | Sent: FAILED | Remote: RELEASED | Link: LOST
Local: RELEASED | Sent: OK | Remote: RELEASED | Link: OK
Local: RELEASED | Sent: OK | Remote: RELEASED | Link: OK
Local: PRESSED | Sent: OK | Remote: RELEASED | Link: OK
Local: PRESSED | Sent: OK | Remote: RELEASED | Link: OK
Local: RELEASED | Sent: OK | Remote: PRESSED | Link: OK
Local: RELEASED | Sent: OK | Remote: PRESSED | Link: OK
Local: RELEASED | Sent: OK | Remote: RELEASED | Link: OK

Häufige Probleme:

Das Board erscheint nicht als serieller Port. Die Ursache ist meist ein Kabel, das nur zum Laden geeignet ist, oder der Treiber CH340. Verwenden Sie ein Kabel USB-A auf USB Type-C mit Datenübertragung. Falls der Port trotzdem nicht erscheint, installieren Sie den Treiber aus dem Bereich Download, denn die neueste Version von 2023 kann mit dem Board inkompatibel sein.

Das Hochladen bricht mit dem Fehler avrdude not in sync ab. Das Board hat einen älteren Bootloader. Wählen Sie unter Tools > Processor die Variante ATmega328P (Old Bootloader) und laden Sie erneut hoch.

Im seriellen Monitor erscheint die Meldung, dass das Funkmodul nicht antwortet. Prüfen Sie, ob Sie RF24 radio(7, 8) verwenden, was für das V3.0 korrekt ist. Die älteren Boards RF-Nano V1 und V2 verwenden CE an D10 und CSN an D9. Versuchen Sie dafür RF24 radio(10, 9). Prüfen Sie außerdem, dass Sie nichts an D7, D8, D11, D12 oder D13 angeschlossen haben.

Der Verbindungsstatus steht dauerhaft auf LOST. Prüfen Sie, ob NODE_ID auf den beiden Boards unterschiedlich ist (0 und 1), ob beide den Kanal 76 verwenden und ob beide mit Strom versorgt werden. Bringen Sie die Boards auf einige Meter Abstand und entfernen Sie sie von Metallgegenständen.

Die LED ist dauerhaft aus oder dauerhaft an. Prüfen Sie die Polung der LED (Anode zum Widerstand) und ob der Taster diagonal montiert ist, mit einem Pin an D2 und dem anderen an GND. Mit INPUT_PULLUP muss der Taster nur dann LOW lesen, wenn er gedrückt ist.

Das Funkmodul stoppt oder setzt sich zufällig zurück. Das Funkmodul reagiert empfindlich auf eine instabile Stromversorgung. Verwenden Sie einen direkten USB-Anschluss des Computers oder ein gutes Netzteil, nicht einen schwach versorgten Hub.

Einschränkungen und Tipps:

Die Pins D7, D8, D11, D12 und D13 sind vom Funkmodul belegt. Für Sensoren bleiben daher D2 - D6, A0 - A7 (A6 und A7 sind nur analoge Eingänge) sowie die seriellen Pins D0 und D1 frei. Jeder I/O-Pin verträgt höchstens 40 mA, daher werden Relais und Motoren über Transistoren oder dedizierte Module angesteuert.

Ein Funkpaket hat höchstens 32 Bytes. Die Reichweite hängt von der Umgebung, von Hindernissen und von der eingestellten Leistung ab. Die Stufe RF24_PA_LOW reicht für Tests auf dem Tisch aus. Für größere Entfernungen können Sie die Stufe mit setPALevel() erhöhen, vorausgesetzt, die Stromversorgung ist stabil.

Ausgehend von diesem Aufbau können Sie eine Fernbedienung mit mehreren Tasten bauen, einen Temperatursensor, der Werte an ein zentrales Board sendet, oder ein Sternnetz, in dem ein Board auf mehreren Adressen von mehreren Sendern empfängt.