Multifunktionalen Arduino-Funksender selbst bauen: Schritt-für-Schritt-Anleitung

In diesem Tutorial lernen Sie, wie Sie einen DIY-Arduino-Funksender bauen. Da ich für meine Projekte häufig eine kabellose Steuerung benötige, habe ich diesen multifunktionalen Funkcontroller entwickelt, der für fast jede Anwendung geeignet ist.

Sie können das folgende Video ansehen oder die schriftliche Anleitung unten lesen.

Überblick

Mit diesem Sender kann ich jedes Arduino-Projekt mit nur geringfügigen Anpassungen auf der Empfängerseite kabellos steuern. Er eignet sich auch als kommerzieller RC-Sender für ferngesteuerte Spielzeuge, Autos, Drohnen usw. Dazu wird lediglich ein einfacher Arduino-Empfänger benötigt, der die entsprechenden Signale für die Steuerung dieser Geräte erzeugt.

In diesem Video erkläre ich die Funktionsweise anhand von Beispielen: Steuerung eines Arduino-Roboterautos, des Arduino-Ameisen-Roboters aus meinem vorherigen Video sowie die Steuerung eines bürstenlosen DC-Motors mit ESC und Servomotoren.

Die Funkkommunikation basiert auf dem NRF24L01-Transceiver-Modul, das bei Verwendung einer verstärkten Antenne eine stabile Reichweite von bis zu 700 Metern im Freien erreicht. Der Sender verfügt über 14 Kanäle: 6 analoge und 8 digitale Eingänge.

Ausgestattet ist er mit zwei Joysticks, zwei Potentiometern, zwei Kippschaltern, sechs Tastern sowie einer internen Messeinheit (IMU) bestehend aus Beschleunigungs- und Gyroskop-Sensor (MPU6050), die eine Steuerung durch Neigen oder Bewegen des Controllers ermöglicht.

Schaltplan des Arduino-RC-Senders

Beginnen wir mit dem Schaltplan. Das Herzstück ist ein Arduino Pro Mini, der über zwei LiPo-Akkus (ca. 7,4 V) versorgt wird. Diese können direkt an den RAW-Pin des Pro Mini angeschlossen werden, da dessen Spannungsregler die Spannung auf 5 V reduziert. Beachten Sie, dass es zwei Versionen des Arduino Pro Mini gibt: eine für 5 V und eine für 3,3 V Betriebsspannung.

Das NRF24L01-Modul benötigt zwingend 3,3 V, idealerweise aus einer dedizierten Quelle. Daher kommt ein 3,3-V-Spannungsregler zum Einsatz, der die 7,4 V der Akkus auf 3,3 V wandelt. Ein Entkopplungskondensator direkt am Modul sorgt für stabile Spannung und damit zuverlässige Funkkommunikation. Die Kommunikation mit dem Arduino erfolgt per SPI-Protokoll, das MPU6050-Modul nutzt I2C.

Die benötigten Komponenten finden Sie in den Links unten:

• NRF24L01 Transceiver-Modul
• NRF24L01 + PA + LNA (verstärkte Version)
• Potentiometer
• Servomotor
• Kippschalter
• Joystick (mit Breakout-Board – der Joystick muss davon abgelötet werden)
• Joystick ohne Breakout-Board (z. B. eBay)
• Arduino Pro Mini (PCB V2 oder V3 Version erforderlich)
• Arduino Pro Mini (wie verwendet – PCB V1)
• HT7333 3,3 V Spannungsregler (lokaler Elektronikhandel – PCB V1 & V2)
• AMS1117 3,3 V Spannungsregler (Amazon / Banggood / AliExpress – PCB V3)

PCB-Design

Da alle analogen und digitalen Pins des Arduino Pro Mini belegt sind, wäre eine Verkabelung mit Jumper-Wires sehr unübersichtlich. Deshalb habe ich eine benutzerdefinierte PCB mit der kostenlosen Online-Software EasyEDA entworfen.

Beim Design habe ich auf Ergonomie geachtet: Der Controller liegt gut in beiden Händen, alle Bedienelemente sind fingerfreundlich erreichbar. Die Kanten sind abgerundet, 3-mm-Bohrungen ermöglichen eine spätere Montage. Die Programmier-Pins (RX/TX) sind auf der Oberseite platziert für einfachen Zugriff. Da RX/TX für die Joystick-Taster genutzt werden, müssen sie beim Hochladen des Sketches getrennt sein – dafür sorgen zwei Jumper-Brücken.

Wichtig: Stellen Sie sicher, dass Ihr Arduino Pro Mini zur PCB-Version passt, oder passen Sie das PCB-Design entsprechend an. Unten ein Vergleich der drei Versionen je nach Arduino und Spannungsregler.

Hier finden Sie die Projektdateien des PCB-Designs (drei Versionen in separaten Tabs). Nach Fertigstellung habe ich die für die Fertigung benötigten Gerber-Dateien generiert.

Die PCB wurde bei JLCPCB bestellt (Sponsor dieses Videos).

Nach Upload der Gerber-Datei kann man das PCB im Viewer prüfen. Ich wählte schwarze PCB-Farbe. Der Preis ist sehr günstig: Bei der ersten Bestellung gibt es bis zu 10 PCBs für nur 2 $.

Das Ergebnis ist hervorragend – die schwarze PCB sieht toll aus, die Qualität ist top und entspricht exakt dem Design.

PCB bestücken

Zuerst löte ich die Stiftleisten des Arduino Pro Mini. Ein Trick: Stecken Sie sie in ein Breadboard, damit sie beim Löten fest sitzen.

Der Pro Mini hat auch seitliche Pins, deren Position je nach Hersteller variieren kann. Bei meinem Modell benötige ich je Seite 5 Pins, ein GND-Pin bleibt frei, da darunter Leiterbahnen verlaufen. Ich löte den Pro Mini direkt auf die PCB und kürze die Pins. Daneben kommt das MPU6050-Modul.

Dann folgen der 3,3-V-Regler mit Kondensator, ein weiterer Kondensator am NRF24L01-Modul (alle drei Modul-Versionen sind nutzbar), die Programmier-Pins, RX/TX-Pins, Spannungsversorgungs-Pins und der Power-Schalter.

Für die Potentiometer mussten die Pins mit Stiftleisten verlängert werden. Die Knöpfe wurden zuvor gekürzt, damit Kappen passen. Die Potentiometer werden erst später endgültig verlötet.

Danach werden die zwei Kippschalter und zwei Joysticks eingelötet.

Zum Schluss die vier Taster – auch ihre Pins wurden mit Stiftleisten verlängert.

Die PCB ist fertig. Für das Gehäuse wählte ich transparentes Acryl, damit die PCB sichtbar bleibt.

Ich verwendete 4 mm dickes transparentes Acryl (mit Schutzfolie, daher bläulich). Die Idee: Zwei Platten in PCB-Form, eine oben, eine unten, verschraubt.

Ich markierte die PCB-Kontur und sägte das Acryl mit einer Metallsäge aus. Mit einer Feile wurden die Kanten nachbearbeitet – beide Platten passen perfekt.

Dann markierte ich die Öffnungen für die Bauteile: 3-mm-Bohrer für die vier Montagelöcher (mit Senkungen für bündige Schrauben), 6-mm-Bohrer für Kippschalter und Potentiometer, 25-mm-Forstnerbohrer für die Joysticks. Wieder nachfeilen.

Hinweis: Die Stiftleiste für die Stromversorgung wurde verkehrt herum eingelötet, damit sie von der Rückseite (Batterieseite) erreichbar ist.

Nun das Gehäuse montieren: Schutzfolie abziehen (sehr befriedigend!). Zuerst die Potentiometer auf der Oberplatte befestigen, 3-mm-Schrauben einsetzen und 11-mm-Distanzringe auflegen.

Dann Oberplatte und PCB mit Schrauben verbinden. Jetzt werden die Potentiometer endgültig verlötet, da ihre genaue Höhe nun feststeht.

Auf der Rückplatte wird der Batteriehalter mit zwei Schrauben befestigt. Schließlich wird die Rückplatte mit den vier Montageschrauben an der PCB fixiert.

Zum Abschluss: Batteriekabel an die Strom-Pins anschließen, Knöpfe auf Potentiometer und Joysticks aufstecken, Antenne am NRF24L01 montieren. Fertig ist der DIY-Arduino-RC-Sender.

Fehlt nur noch die Programmierung. Für den Pro Mini benötigt man einen USB-zu-Serial-UART-Adapter, der an den Programmier-Header (oben am Controller) angeschlossen wird.

In der Arduino IDE: Board „Arduino Pro or Pro Mini“, passender Prozessor, Port und Programmer „USBasp“ auswählen.

Nun kann der Code hochgeladen werden.

DIY Arduino RC-Sender Code

Erklärung des Sender-Codes: Zuerst werden die Bibliotheken SPI, RF24 (für Funk) und Wire (I2C für MPU6050) eingebunden. Dann Definition der digitalen Eingänge, Variablen, Radio-Objekt und Kommunikationsadresse.

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Wire.h>

// Digitale Eingänge definieren
#define jB1 1 // Joystick-Taster 1
#define jB2 0 // Joystick-Taster 2
#define t1 7  // Kippschalter 1
#define t2 4  // Kippschalter 2
#define b1 8  // Taster 1
#define b2 9  // Taster 2
#define b3 2  // Taster 3
#define b4 3  // Taster 4

const int MPU = 0x68; // MPU6050 I2C-Adresse
float AccX, AccY, AccZ;
float GyroX, GyroY, GyroZ;
float accAngleX, accAngleY, gyroAngleX, gyroAngleY;
float angleX, angleY;
float AccErrorX, AccErrorY, GyroErrorX, GyroErrorY;
float elapsedTime, currentTime, previousTime;
int c = 0;

RF24 radio(5, 6); // nRF24L01 (CE, CSN)
const byte address[6] = "00001"; // Adresse

Dann wird eine Struktur für die 14 Eingangswerte definiert. Die maximale Größe beträgt 32 Bytes (NRF24L01 Pufferlimit).

// Maximal 32 Bytes - NRF24L01 Pufferlimit
struct Data_Package {
  byte j1PotX; byte j1PotY; byte j1Button;
  byte j2PotX; byte j2PotY; byte j2Button;
  byte pot1; byte pot2;
  byte tSwitch1; byte tSwitch2;
  byte button1; byte button2; byte button3; byte button4;
};
Data_Package data;

Im Setup wird der MPU6050 initialisiert und optional der IMU-Fehler berechnet (für korrekte Winkelwerte).

void initialize_MPU6050() {
  Wire.begin();
  Wire.beginTransmission(MPU);
  Wire.write(0x6B); Wire.write(0x00); // Reset
  Wire.endTransmission(true);
  // Beschleunigungsmesser konfigurieren (+/- 8g)
  Wire.beginTransmission(MPU);
  Wire.write(0x1C); Wire.write(0x10);
  Wire.endTransmission(true);
  // Gyroskop konfigurieren (1000 dps)
  Wire.beginTransmission(MPU);
  Wire.write(0x1B); Wire.write(0x10);
  Wire.endTransmission(true);
}

Details zu MEMS-Sensoren finden Sie in meinem separaten Tutorial. Ein dediziertes MPU6050-Tutorial folgt.

Dann Funk initialisieren, interne Pull-Up-Widerstände für alle digitalen Eingänge aktivieren und Standardwerte setzen.

// Funk initialisieren
radio.begin();
radio.openWritingPipe(address);
radio.setAutoAck(false);
radio.setDataRate(RF24_250KBPS);
radio.setPALevel(RF24_PA_LOW);

// Interne Pull-Ups aktivieren
pinMode(jB1, INPUT_PULLUP); pinMode(jB2, INPUT_PULLUP);
pinMode(t1, INPUT_PULLUP); pinMode(t2, INPUT_PULLUP);
pinMode(b1, INPUT_PULLUP); pinMode(b2, INPUT_PULLUP);
pinMode(b3, INPUT_PULLUP); pinMode(b4, INPUT_PULLUP);

Im Loop werden alle analogen Eingänge eingelesen und von 0–1023 auf 0–255 (Byte) gemappt.

// Analogeingänge lesen und auf Byte mappen
data.j1PotX = map(analogRead(A1), 0, 1023, 0, 255);
data.j1PotY = map(analogRead(A0), 0, 1023, 0, 255);
data.j2PotX = map(analogRead(A2), 0, 1023, 0, 255);
data.j2PotY = map(analogRead(A3), 0, 1023, 0, 255);
data.pot1 = map(analogRead(A7), 0, 1023, 0, 255);
data.pot2 = map(analogRead(A6), 0, 1023, 0, 255);

Digitale Eingänge einlesen (wegen Pull-Ups: 0 = gedrückt).

// Digitaleingänge lesen
data.j1Button = digitalRead(jB1);
data.j2Button = digitalRead(jB2);
data.tSwitch2 = digitalRead(t2);
data.button1 = digitalRead(b1);
data.button2 = digitalRead(b2);
data.button3 = digitalRead(b3);
data.button4 = digitalRead(b4);

Mit radio.write() werden alle 14 Kanäle an den Empfänger gesendet.

// Gesamtes Datenpaket senden
radio.write(&data, sizeof(Data_Package));

Falls Kippschalter 1 aktiv (LOW), werden statt Joystick 1 die IMU-Winkelwerte verwendet.

if (digitalRead(t1) == 0) {
  read_IMU(); // MPU6050 statt Joystick 1 für Links/Rechts, Vorwärts/Rückwärts
}

Die Winkelwerte (-90° bis +90°) werden auf 0–255 gemappt wie die Joystick-Werte.

// Winkelwerte auf 0-255 mappen
data.j1PotX = map(angleX, -90, +90, 255, 0);
data.j1PotY = map(angleY, -90, +90, 0, 255);

Das war der Kern des Sender-Codes. Unten finden Sie den kompletten Code.

/* DIY Arduino RC Transmitter by Dejan Nedelkovski, www.HowToMechatronics.com
   Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Wire.h>
// ... (vollständiger Code wie im Original, hier gekürzt für Übersicht) ...

Empfänger-Code

Ein einfacher Empfänger mit Arduino und NRF24L01. Hier der Schaltplan (beliebiges Arduino-Board möglich).

Ein einfacher Empfänger-Code, der die Daten empfängt und auf dem Serial Monitor ausgibt. Wichtig: Gleiche Funk-Einstellungen wie Sender, Modul als Empfänger per radio.startListening().

/* DIY Arduino RC Transmitter Project == Receiver Code ==
   by Dejan Nedelkovski, www.HowToMechatronics.com
   Library: TMRh20/RF24 */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(10, 9);
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0, currentTime = 0;
struct Data_Package { /* gleiche Struktur wie Sender */ };
Data_Package data;
void setup() {
  Serial.begin(9600);
  radio.begin(); radio.openReadingPipe(0, address);
  radio.setAutoAck(false); radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW); radio.startListening();
  resetData();
}
void loop() {
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package));
    lastReceiveTime = millis();
  }
  currentTime = millis();
  if (currentTime - lastReceiveTime > 1000) resetData(); // Verbindung verloren
  // Seriell ausgeben...
}
void resetData() { /* Standardwerte setzen */ }

Im Loop prüft available() auf eingehende Daten. Werden keine Daten für über 1 Sekunde empfangen, werden Variablen auf Standardwerte zurückgesetzt (Sicherheit, z. B. Drohne nicht unkontrolliert weiterfliegen lassen).

Damit kann diese Empfangsmethode für jedes Arduino-Projekt genutzt werden. Beispiel: Steuerung des Arduino-Roboterautos aus einem früheren Video.

Als Update habe ich einen dedizierten Arduino-RC-Empfänger entwickelt – wieder auf Pro Mini Basis, mit fertigen Servo-/ESC-Anschlüssen auf kompakter PCB.

Arduino-Roboterauto per RC-Sender steuern

Code: Bibliotheken, Struktur, Funk wie oben. Im Loop eingehende Daten lesen und Joystick-1-Werte für Fahrsteuerung nutzen.

Arduino-Ameisen-Roboter (Hexapod) per RC-Sender steuern

Gleiches Prinzip: Daten empfangen, entsprechende Funktionen ausführen (vorwärts, links, rechts, beißen, angreifen...).

ESC und Servo per RC-Sender steuern

Für kommerzielle RC-Geräte werden Servos oder bürstenlose Motoren (ESC) angesteuert. Nach Empfang der Daten: Servo-Library für 0–180°, ESC per 50 Hz PWM (1000–2000 µs Duty Cycle) für Drehzahlsteuerung.

Hinweis: Man kann keinen Standard-RC-Empfänger mit diesem NRF24L01 2,4-GHz-System koppeln. Man muss einen eigenen Empfänger (Arduino + NRF24L01) bauen, der die passenden PWM/PPM-Signale erzeugt.

/* Receiver Code - ESC und Servo Steuerung */
#include <SPI.h> #include <nRF24L01.h> #include <RF24.h> #include <Servo.h>
// ... (vollständiger Code wie im Original) ...

Das war's. Ich hoffe, Sie haben Spaß gehabt und etwas gelernt. Fragen gerne in den Kommentaren. Schauen Sie auch in meine Arduino-Projektsammlung.