Einen zuverlässigen Arduino RC-Empfänger für Modelle & Projekte bauen

In diesem Tutorial lernen Sie, wie man einen Arduino-basierten RC-Empfänger baut. Seit ich meinen DIY Arduino RC-Sender in einem früheren Video vorgestellt habe, erhielt ich viele Anfragen, einen dedizierten Empfänger dafür zu entwickeln – hier ist er.

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

Diese beiden Geräte können nun problemlos miteinander kommunizieren und wir können sie verwenden, um viele Dinge drahtlos zu steuern. Ich erkläre die Funktionsweise anhand einiger Beispiele. Im ersten Beispiel nutzen wir diesen Arduino RC-Empfänger, um ein einfaches Auto mit zwei DC-Motoren zu steuern. Im zweiten Beispiel zeige ich, wie man bürstenlose Motoren und Servos steuert – gängige Komponenten in vielen kommerziellen RC-Flugzeugen, Booten, Autos usw. Wenn wir wissen, wie man sie steuert, können wir viele RC-Modelle problemlos mit unserem selbstgebauten Arduino-Sender modifizieren und steuern.

Einen zuverlässigen Arduino RC-Empfänger für Modelle & Projekte bauen

Als drittes Beispiel zeige ich, wie ich dieses Arduino-basierte RC-System modifiziert und verwendet habe, um ein kommerzielles RC-Auto zu steuern.

Schaltplan des Arduino RC-Empfängers

Beginnen wir mit dem Schaltplan dieses Systems. Die Funkkommunikation basiert auf den NRF24L01-Transceiver-Modulen.

Der Sender überträgt kontinuierlich Daten von seinen Bedienelementen – Joysticks, Buttons, Potentiometer und Kippschalter – und wir empfangen diese Daten mit dem Empfänger. Weitere Details zur Funktionsweise dieses Arduino-Senders finden Sie in meinem anderen ausführlichen Tutorial dazu.

Man kann auch festhalten, dass dieser RC-Empfänger nicht zwingend nur mit diesem speziellen Sender funktioniert. Er kann mit jedem anderen ähnlichen Setup arbeiten, das aus einem Arduino-Board und einem NRF24L01-Modul besteht.

Dennoch ist das Gehirn dieses RC-Empfängers ein Arduino Pro Mini Board. Zur Stromversorgung können wir entweder den VCC-Pin verwenden, an den wir 5V anschließen, oder den RAW-Pin, der 6 bis 12V akzeptiert. Beachten Sie, dass es zwei Versionen des Arduino Pro Mini gibt: die hier verwendete 5V-Version und eine 3,3V-Version. Der NRF24L01-Modul arbeitet jedoch mit 3,3V, daher benötigen wir einen Spannungsregler. Diesmal verwende ich den AMS1117-Spannungsregler, der aus Eingangsspannungen von 5V bis 12V eine stabile 3,3V-Ausgangsspannung liefert.

Die benötigten Komponenten für diesen Arduino RC-Empfänger erhalten Sie über die folgenden Links:

NRF24L01 Transceiver Modul
NRF24L01 + PA + LNA
AMS1117 3,3V Spannungsregler
Pin Header Male + Female Amazon / Banggood / AliExpress
Arduino Pro Mini
Arduino Pro Mini wie der hier verwendete

Für die Kommunikation mit dem Arduino nutzt das NRF24L01-Modul das SPI-Protokoll plus zwei zusätzliche digitale Pins. Damit verbleiben 9 digitale Pins als Ausgabe-Kanäle, wovon zwei die RX- und TX-Pins sind. Wichtig: Diese Pins müssen während des Hochladens eines Sketches vom Arduino getrennt sein, daher habe ich sie über separate Pin-Header verbindbar/trennbar gemacht. Tatsächlich können wir auch die analogen Eingänge als digitale Ausgänge nutzen, sodass trotz der geringen Größe des Boards viele Ausgänge/Kanäle zur Verfügung stehen.

PCB-Design

Um die Schaltung kompakt zu halten, habe ich ein eigenes PCB mit der kostenlosen Online-Design-Software EasyEDA erstellt. Dabei habe ich die 8 Kanäle direkt neben einer 5V- und einer Ground-Schiene angeordnet, sodass Servos und ESCs direkt angeschlossen werden können. Kanal 9 befindet sich an separater Position, nahe dem VCC-Pin des Arduino, damit wir beispielsweise einen ESC mit dessen Battery Eliminator Circuit (BEC) nutzen können, der 5V liefert. Natürlich könnten auch andere Kanäle dafür verwendet werden, da der VCC-Pin mit der 5V-Schiene verbunden ist.

Bei den Kanälen 7 und 8 sieht man, wie sie durch Pin-Header unterbrochen sind. Wenn man sie nutzen möchte, verbindet man einfach die beiden Pins. Der Programmier-Header sitzt oben rechts und der 100µF-Kondensator dient sowohl dem Spannungsregler als auch dem NRF24L01-Modul. Unten links auf dem PCB befinden sich die analogen Pins.

Ein weiterer Hinweis: Manche Arduino Pro Mini Boards haben eine andere Pin-Belegung, daher habe ich eine zweite PCB-Version hinzugefügt, damit Sie die passende für Ihr Board wählen können.

Hier ist der Link zu den Projektdateien dieses PCBs. Nach Fertigstellung des Designs habe ich die für die Fertigung nötigen Gerber-Dateien generiert.

Gerber-Dateien:

Anschließend habe ich das PCB bei JLCPCB bestellt, die auch Sponsor dieses Videos sind.

Dort kann man die Gerber-Datei einfach per Drag & Drop hochladen und im Gerber-Viewer prüfen. Wenn alles stimmt, wählt man die gewünschten PCB-Eigenschaften und bestellt zu einem vernünftigen Preis. Bei der ersten Bestellung bei JLCPCB erhält man bis zu 5 PCBs für nur 2$.

PCB-Bestückung

Nach einigen Tagen sind die PCBs angekommen. Die Qualität ist hervorragend und alles entspricht exakt dem Design.

Nun geht es an die Bestückung. Zuerst löten wir die Pin-Header des Arduino-Boards. Eine praktische Methode: Die Pin-Header in ein Steckbrett stecken, damit das Board beim Löten fest sitzt. Wie erwähnt, kann die Pin-Belegung je nach Board leicht variieren – darauf beim Löten achten.

Einige Ground-Pins müssen frei bleiben, da darunter Leiterbahnen auf dem PCB verlaufen. Nach dem Einlöten des Arduino-Boards habe ich die überstehenden Pins abgeschnitten.

Als Nächstes werden alle weiteren Pin-Header platziert. Ob male oder female, bleibt Ihnen überlassen. Für die digitalen Kanäle empfiehlt es sich jedoch, male Header zu verwenden, da Servos und ESCs female Stecker haben – so lassen sie sich direkt verbinden.

Der Spannungsregler ist ein SMD-Bauteil; ich habe ihn mit etwas Blue-Tack fixiert, während ich ihn verlötete. Zuletzt werden die beiden Kondensatoren eingelötet und das NRF24L01-Modul auf die passenden Pin-Header gesteckt.

Je nach Anwendung und benötigter Reichweite kann man entweder das Standardmodul mit Onboard-Antenne oder die Variante mit externer Antenne verwenden, die im Freien bis zu 700 Meter Reichweite erreicht. Damit ist unser Arduino RC-Empfänger fertig und einsatzbereit.

Zum Programmieren des Empfängers – also zum Verbinden des Arduino Pro Mini mit dem Computer – verwendet man einen USB-zu-Serial-UART-Adapter, der an den Programmier-Header angeschlossen wird.

Im Arduino IDE Menü "Werkzeuge" wählt man: Board "Arduino Pro or Pro Mini", den passenden Prozessor (5V/16MHz), den richtigen Port und als Programmer "USBasp".

Damit können Sketches auf den Arduino hochgeladen werden.

Beispiel 1 – Arduino RC-Auto

Kommen wir zum ersten Beispiel.

Es handelt sich um ein einfaches Auto mit zwei 12V DC-Motoren, dessen Bau ich in früheren Videos bereits gezeigt habe.

Siehe auch: L298N Motortreiber & Arduino Interface, Funktionsweise, Codes, Schaltpläne

Diesmal steuern wir es mit unserem neuen Arduino RC-Empfänger. Für die Motoransteuerung nutzen wir den L298N-Treiber, die Stromversorgung erfolgt über 3 Li-Ion-Akkus (ca. 12V).

Benötigte Komponenten für dieses Beispiel:

L298N Treiber
12V High Torque DC Motor
DC Motor mit Kunststoff-Rad
Steckbrett und Jumper-Kabel

Die Verbindungen sind simpel: Die 12V von den Akkus gehen an den 12V-Pin unseres Empfängers, die sechs Steuerpins des Treibers an 6 Kanäle. Wichtig: Um die Motordrehzahl per PWM zu regeln, müssen die Enable-A- und Enable-B-Pins des Treibers ein PWM-Signal erhalten. Auf unserem Empfänger können die Kanäle 2, 3, 6 und 9 PWM ausgeben – ich habe die Enable-Pins an Kanal 2 und 6 angeschlossen.

Sehen wir uns nun den Arduino-Code an.

/* Arduino RC Receiver - Car Example by Dejan, www.HowToMechatronics.com Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

#define enA 9 // Arduino Pin D9 - CH6 auf PCB - PWM Output
#define in1 8 // D8 - CH5
#define in2 7 // D7 - CH4
#define in3 6 // D6 - CH3
#define in4 4 // D4 - CH1
#define enB 5 // D5 - CH2 - PWM Output

RF24 radio(3, 2); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;

// Max size of this struct is 32 bytes
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; // Variable mit obiger Struktur
int steering, throttle;
int motorSpeedA = 0;
int motorSpeedB = 0;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  // Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.startListening(); // Modul als Empfänger setzen
  resetData();
}

void loop() {
  // Prüfen, ob wir noch Daten empfangen / Verbindung besteht
  currentTime = millis();
  if (currentTime - lastReceiveTime > 1000) {
    // Wenn seit mehr als 1 Sekunde keine Daten empfangen -> Verbindung verloren
    resetData(); // Daten zurücksetzen, verhindert unerwünschtes Verhalten (z.B. Drohne fliegt weiter bei Gas)
  }

  // Prüfen, ob Daten empfangen wurden
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Gesamtes Datenpaket lesen und in 'data' speichern
    lastReceiveTime = millis(); // Zeitpunkt des letzten Empfangs speichern
  }

  // Daten vom Joystick 1 in throttle und steering Variablen parsen
  throttle = data.j1PotY;
  steering = data.j1PotX;

  // Throttle für Vorwärts/Rückwärts
  // Joystick Werte: 0 bis 255; unten = 0; Mitte = 127; oben = 255
  if (throttle < 110) {
    // Motor A rückwärts
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Motor B rückwärts
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Abfallende Throttle-Werte (110 bis 0) auf 0-255 PWM mappen für steigende Geschwindigkeit
    motorSpeedA = map(throttle, 110, 0, 0, 255);
    motorSpeedB = map(throttle, 110, 0, 0, 255);
  } else if (throttle > 140) {
    // Motor A vorwärts
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    // Motor B vorwärts
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    // Steigende Throttle-Werte (140 bis 255) auf 0-255 PWM mappen
    motorSpeedA = map(throttle, 140, 255, 0, 255);
    motorSpeedB = map(throttle, 140, 255, 0, 255);
  }
  // Joystick in Mitte -> Motoren stoppen
  else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }

  // Steering für Links/Rechts
  if (steering < 110) {
    // Abfallende Lenkwerte (110 bis 0) auf steigende 0-255 mappen
    int xMapped = map(steering, 110, 0, 0, 255);
    // Links: linken Motor langsamer, rechten schneller
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Bereich auf 0-255 begrenzen
    if (motorSpeedA < 0) motorSpeedA = 0;
    if (motorSpeedB > 255) motorSpeedB = 255;
  }
  if (steering > 140) {
    // Steigende Lenkwerte (140 bis 255) auf 0-255 mappen
    int xMapped = map(steering, 140, 255, 0, 255);
    // Rechts: rechten Motor langsamer, linken schneller
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    if (motorSpeedA > 255) motorSpeedA = 255;
    if (motorSpeedB < 0) motorSpeedB = 0;
  }

  // Brummen bei niedrigen Geschwindigkeiten verhindern (an eigene Motoren anpassen. Meine Motoren starteten erst ab PWM 70)
  if (motorSpeedA < 70) motorSpeedA = 0;
  if (motorSpeedB < 70) motorSpeedB = 0;

  analogWrite(enA, motorSpeedA); // PWM an Motor A
  analogWrite(enB, motorSpeedB); // PWM an Motor B
}

void resetData() {
  // Werte bei Funkverlust auf Standardwerte zurücksetzen
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}Code language: Arduino (arduino)

Erklärung: Zunächst werden die SPI- und RF24-Bibliothek eingebunden, Pins definiert, das Radio-Objekt und die Datenstruktur für die eingehenden Senderdaten angelegt. Im setup() werden die Pin-Modi gesetzt und die Funkkommunikation initialisiert. Details dazu finden Sie in meinem ausführlichen NRF24L01-Tutorial.

Im loop() prüfen wir kontinuierlich, ob Daten empfangen werden, und lesen diese ein. Ein Blick in den Sender-Code zeigt, welche Daten gesendet werden: Alle Bedienelemente (Joysticks, Potentiometer, Buttons) werden als einzelnes Paket übertragen.

Nach dem Einlesen können wir die Daten beliebig verwenden. Hier nutzen wir die Y-Achse von Joystick 1 für Gas (Throttle) und die X-Achse für Lenkung (Steering). Die Joystick-Werte reichen von 0 bis 255. Wird der Joystick nach unten gedrückt, setzen wir die Treiber-Pins für Rückwärtsfahrt und nutzen den Throttle-Wert für die Geschwindigkeit. Das gleiche Prinzip gilt für Vorwärts, Links und Rechts. Am Ende des Codes sorgt die Funktion resetData() dafür, dass bei Funkverlust alle Werte auf Standardwerte zurückgesetzt werden – das Auto stoppt dann sicher.

Beispiel 2 – Arduino RC-Empfänger: Servos und bürstenlose Motoren steuern

Weiter geht es mit dem zweiten Beispiel: Steuern von Servos und bürstenlosen Motoren mit diesem Arduino RC-Empfänger.

Für bürstenlose Motoren benötigt man einen ESC (Electronic Speed Controller). Der Arduino kommuniziert über einen einzigen Pin per PWM-Signal mit dem ESC, der damit die Motordrehzahl regelt. Der ESC liefert über seinen Battery Eliminator Circuit (BEC) auch 5V, womit wir unseren Empfänger mitversorgen können.

Siehe auch: Arduino Brushless Motor Control Tutorial | ESC | BLDC

Servomotoren haben denselben Anschluss wie ESCs und können einfach an beliebige freie Kanäle gesteckt werden.

Benötigte Komponenten:

Bürstenloser Motor
ESC 30A
Li-Po Akku
MG996R Servomotor

Die Steuersignale für Servos und ESCs sind fast identisch: Beide nutzen ein 50Hz PWM-Signal, das sich einfach mit der Arduino Servo-Bibliothek erzeugen lässt.

Hinweis: Bei Verwendung von MG996R-Servos mit diesem Aufbau kann es zu Problemen kommen, die den Arduino Pro Mini zerstören. Diese Servos können höhere Ströme ziehen und Spannungsspitzen an der 5V-Schiene erzeugen. Der Arduino Pro Mini verträgt am 5V-Pin bis zu 5,5V, aber solche Spitzen können ihn dennoch beschädigen. Ich hatte dieses Problem beim Testen, und auch ein Kommentator berichtete davon. Eine mögliche Lösung wären größere Entkopplungskondensatoren an den Servos, aber ich habe das nicht getestet. Seien Sie sich dieses Risikos bewusst.

In meinem Beispiel verwendete ich zwei andere MG996R-Servos, die den Arduino nicht beschädigten – vermutlich verursachten sie keine so starken Spitzen. Auch mit vier kleineren S90-Servos gab es keine Probleme.

Siehe auch: Wie Servomotoren funktionieren & Wie man Servos mit Arduino steuert

/* DIY RC Receiver - Servos and Brushless motors control by Dejan, www.HowToMechatronics.com Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Servo.h>

RF24 radio(3, 2); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;

Servo esc;      // Servo-Objekt für ESC
Servo servo1;
Servo servo2;

int escValue, servo1Value, servo2Value;

// Max size of this struct is 32 bytes - NRF24L01 buffer limit
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;

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(); // Als Empfänger setzen
  resetData();

  esc.attach(10);   // Arduino Pin D10 - CH9 auf PCB
  servo1.attach(4); // D4 - CH1
  servo2.attach(5); // D5 - CH2
}

void loop() {
  // Verbindungsprüfung
  currentTime = millis();
  if (currentTime - lastReceiveTime > 1000) {
    resetData();
  }

  // Daten empfangen
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package));
    lastReceiveTime = millis();
  }

  // Servos steuern
  servo1Value = map(data.j2PotX, 0, 255, 0, 180); // 0-255 auf 0-180° mappen
  servo2Value = map(data.j2PotY, 0, 255, 0, 180);
  servo1.write(servo1Value);
  servo2.write(servo2Value);

  // Bürstenloser Motor mit ESC steuern
  escValue = map(data.j1PotY, 127, 255, 1000, 2000); // Mitte (127) bis oben (255) auf 1000-2000µs mappen
  esc.writeMicroseconds(escValue); // PWM-Signal an ESC senden
}

void resetData() {
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}Code language: Arduino (arduino)

Nach dem Empfang der Senderdaten wandeln wir die 0-255 Werte per map() in 0-180° für die Servos um (mittels write()). Für den ESC mappen wir analog von 127-255 auf 1000-2000µs und senden das Signal per writeMicroseconds(). Damit lässt sich der bürstenlose Motor von Minimal- bis Maximaldrehzahl regeln.

Siehe auch: Arduino RC Airplane | 100% DIY

So lassen sich RC-Flugzeuge, Autos, Boote usw. steuern, da diese typischerweise Servos und bürstenlose Motoren verwenden.

Beispiel 3 – Steuerung eines RC-Auto-Modells

Das RC-Auto wurde mit einer eigenen Fernbedienung geliefert, die die Vorderräder digital (nur an/aus, volle Lenkung) und Vorwärts/Rückwärts mit maximaler Geschwindigkeit steuerte.

Da es ein günstiges Auto ist, habe ich es zerlegt, um zu sehen, wie ich unseren Arduino RC-Empfänger einbauen kann.

Im Inneren fand ich zwei einfache 5V DC-Motoren – sogar der Lenkmotor ist ein einfacher DC-Motor mit Dauerlauf. Da wir bereits wissen, wie man DC-Motoren steuert, ist der Austausch der Original-Platine gegen unseren DIY-Empfänger einfach. Zusätzlich benötigen wir nur einen Motortreiber für zwei Motoren, z.B. den L298N aus Beispiel 1.

Der L298N ist jedoch zu groß, daher wählte ich den MX1508 Dual-DC-Motortreiber mit H-Brücke und PWM-Steuerung: 4 Steuereingänge, 4 Motorausgänge, 2 Stromversorgungspins.

Ich lötete die Motoranschlüsse von der Originalplatine ab und an den Treiber an. Auf der Rückseite die Stromversorgungspins. Nun muss der Treiber nur noch mit dem Empfänger verbunden werden. Die Stromversorgung des Autos kommt von einem 4,8V Ni-Cd-Akku im Boden.

Per Jumper-Kabel verband ich diese Pins mit dem VCC-Pin des Arduino und die 4 Steuereingänge des Treibers mit 4 digitalen Kanälen. Da der Treiber PWM unterstützt, nutzte ich für Motor B (Hinterrad) die PWM-Kanäle 2 und 3.

Benötigte Komponenten:

MGRC RC Car
MX1508 DC Motor Driver
Steckbrett und Jumper-Kabel

Der Code für dieses RC-Auto ist dem ersten Beispiel sehr ähnlich.

/* Arduino RC Receiver - RC Model control by Dejan , www.HowToMechatronics.com Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

#define in3 5 // D5 - CH2 - PWM Output
#define in4 6 // D6 - CH3 - PWM Output
#define in1 7 // D7 - CH4
#define in2 8 // D8 - CH5

RF24 radio(3, 2); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;

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;
int steering, throttle;
int motorSpeedA = 0;
int motorSpeedB = 0;

void setup() {
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  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() {
  currentTime = millis();
  if (currentTime - lastReceiveTime > 1000) {
    resetData();
  }

  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package));
    lastReceiveTime = millis();
  }

  // Joystick 2 X-Achse = Lenkung, Joystick 1 Y-Achse = Gas
  steering = data.j2PotX;
  throttle = data.j1PotY;

  // Gas: Vorwärts/Rückwärts
  if (throttle < 110) {
    motorSpeedB = map(throttle, 110, 0, 0, 255);
    // Motor B rückwärts: PWM an in3, in4 LOW
    analogWrite(in3, motorSpeedB);
    digitalWrite(in4, LOW);
  } else if (throttle > 140) {
    motorSpeedB = map(throttle, 140, 255, 0, 255);
    // Motor B vorwärts: in3 LOW, PWM an in4
    digitalWrite(in3, LOW);
    analogWrite(in4, motorSpeedB);
  } else {
    // Mitte: Bremsen/Stop (beide HIGH bei diesem Treiber)
    digitalWrite(in3, HIGH);
    digitalWrite(in4, HIGH);
  }

  // Lenkung: Links/Rechts (kein PWM nötig, nur Richtung)
  if (steering < 110) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
  }
  if (steering > 140) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
  } else {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, HIGH);
  }
}

void resetData() {
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}Code language: Arduino (arduino)

Wir nutzen die Joystick-Daten für Gas und Lenkung. Rückwärts: analogWrite() an Input3, Input4 LOW. Vorwärts: umgekehrt. In Mittelstellung bremsen wir (beide HIGH). Beim Lenkmotor verzichten wir auf PWM, da keine Geschwindigkeitsregelung nötig ist.

Nach dem Hochladen des Sketches baute ich das Auto wieder zusammen. Den kleinen Treiber platzierte ich im Innenraum, befestigte alles mit Schrauben, verband Empfänger und Treiber und platzierte den Empfänger unter der äußeren Karosserie, die genug Platz bot.

Damit haben wir nicht nur das RC-Auto auf unseren DIY-Sender umgerüstet, sondern es auch verbessert: Jetzt lässt sich die Geschwindigkeit stufenlos per PWM regeln. Falls das zu modifizierende RC-Modell Servos und bürstenlose Motoren statt DC-Motoren hat, folgen Sie der Methode aus Beispiel 2.

Ich hoffe, Ihnen hat dieses Tutorial gefallen und Sie haben etwas Neues gelernt. Fragen gerne in den Kommentaren und schauen Sie sich meine Arduino-Projektsammlung an.