DIY Arduino RC-Empfänger für RC-Modelle und Arduino-Projekte

Beschreibung: Also müssen wir zuerst die SPI- und die RF24-Bibliothek einbinden, einige Pins, das Funkobjekt und die Datenstruktur definieren, in der wir die eingehenden Daten vom Sender speichern werden. Im Setup-Bereich müssen wir die Pin-Ausgänge definieren und die Funkkommunikation beginnen. Für weitere Details, wie das funktioniert und was jede dieser Zeilen tut, können Sie mein ausführliches NRF24L01-Tutorial lesen.

Im Schleifenabschnitt prüfen wir ständig, ob wir Daten empfangen, und wenn ja, lesen wir diese eingehenden Daten. Wenn wir einen kurzen Blick auf den Code des Senders werfen, können wir sehen, welche Art von Daten er an den Empfänger sendet. Es liest die Daten von all seinen Controllern, den Joysticks, den Potentiometern und den Tasten und sendet diese Daten als einzelnes Paket an den Empfänger.

Sobald wir diese Daten gelesen haben, können wir damit machen, was wir wollen. In diesem Fall verwenden wir den Wert der Y-Achse von Joystick 1 zur Steuerung des Gashebels und den Wert der X-Achse zur Steuerung der Lenkung. Ich habe diese Daten in separate Gas- und Lenkvariablen gesteckt. Die Werte, die wir von den Joysticks erhalten, reichen von 0 bis 255. Wenn wir also den Joystick nach unten bewegen, stellen wir die Steuerstifte des Fahrers entsprechend ein, damit sich das Auto rückwärts bewegt, und verwenden den Drosselwert zur Steuerung der Bewegungsgeschwindigkeit. Das gleiche Prinzip gilt für Vorwärts-, Links- und Rechtsfahren. Auch hier habe ich bereits ein detailliertes Tutorial zur Funktionsweise dieses Autos, damit Sie es zum besseren Verständnis überprüfen können. Am Ende des Codes können wir die benutzerdefinierte Funktion resetData() notieren, die alle Werte auf ihre anfänglichen Standardwerte zurücksetzt, sodass das Auto im Falle eines Verlusts der Funkkommunikation erkennen kann, dass es sich bewegt.

Beispiel 2 – Steuerung von Arduino RC-Empfänger-Servos und bürstenlosen Motoren

In Ordnung, jetzt können wir mit dem zweiten Beispiel fortfahren und Servos und bürstenlose Motoren mit diesem Arduino RC-Empfänger steuern.

Zur Steuerung bürstenloser Motoren benötigen wir einen ESC oder Electronic Speed ​​Controller. Der Arduino kommuniziert mit nur einem einzigen Pin mit dem ESC. Zur Steuerung des ESC sendet der Arduino ein bestimmtes PWM-Signal an den ESC und damit steuert der ESC die Motordrehzahl. Der ESC mit demselben Anschluss liefert 5 V über seine Batterie-Eliminator-Schaltungsfunktion, sodass wir unseren Empfänger auch damit versorgen können.

Siehe auch:Anleitung zur bürstenlosen Motorsteuerung von Arduino | ESC | BLDC

Was die Servomotoren betrifft, so haben sie die gleiche Art von Anschlüssen wie der ESC und wir können sie einfach an jeden der verfügbaren Kanäle anschließen.

Die für dieses Beispiel benötigten Komponenten erhalten Sie über die folgenden Links:

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

Die Eingangssignale zur Steuerung von Servos und bürstenlosen Motoren mit ESCs sind nahezu gleich. Sie verwenden ein spezifisches 50-Hz-PWM-Signal, das mit der Arduino Servo-Bibliothek einfach generiert werden kann.

Hinweis:  Wenn Sie MG996R-Servos mit diesem Setup verwenden, können sie ein Problem in der Schaltung verursachen und den Arduino Pro Mini verbrennen. Das könnte einen höheren Strom ziehen und Spannungsspitzen an der 5-V-Schiene verursachen. Der Arduino Pro Mini sollte bis zu 5,5 V am 5-V-Pin verarbeiten, aber wenn diese Spitzen auftreten, könnte das den Arduino verbrennen. Ich hatte dieses Problem beim Testen der Schaltung, und jemand im Kommentarbereich hat dasselbe gemeldet. Eine Lösung dafür könnte sein, größere Entkopplungskondensatoren an den Servos zu platzieren, aber ich bin mir nicht ganz sicher und habe es nicht getestet. Bitte beachten Sie dieses Problem.

Andererseits habe ich in dem Beispiel zwei andere MG996R-Servos verwendet, die den Arduino nicht verbrannt haben, denke ich, weil sie nicht so hohe Spitzen verursachten. Außerdem habe ich dieses Beispiel mit 4 kleineren S90-Servos verwendet und es gab keine Probleme.

Siehe auch:Funktionsweise des Servomotors & So steuern Sie Servos mit Arduino

/*
  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;  // create servo object to control the 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; //Create a variable with the above structure
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(); //  Set the module as receiver
  resetData();
  esc.attach(10);   // Arduino digital pin D10 - CH9 on PCB board
  servo1.attach(4); // D4 - CH1
  servo2.attach(5); // D5 - CH2
}
void loop() {

  // Check whether we keep receving data, or we have a connection between the two modules
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
    resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone jas a throttle up, if we lose connection it can keep flying away if we dont reset the function
  }

  // Check whether there is data to be received
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
    lastReceiveTime = millis(); // At this moment we have received the data
  }

  // Controlling servos
  servo1Value = map(data.j2PotX, 0, 255, 0, 180); // Map the receiving value form 0 to 255 to 0 to 180(degrees), values used for controlling servos
  servo2Value = map(data.j2PotY, 0, 255, 0, 180);
  servo1.write(servo1Value);
  servo2.write(servo2Value);

  // Controlling brushless motor with ESC
  escValue = map(data.j1PotY, 127, 255, 1000, 2000); // Map the receiving value form 127 to 255 to  1000 to 2000, values used for controlling ESCs
  esc.writeMicroseconds(escValue); // Send the PWM control singal to the ESC
  
}
void resetData() {
  // Reset the values when there is no radio connection - Set initial default values
  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;
} Codesprache:Arduino (arduino) 

Nachdem wir die Daten vom Sender erhalten haben, wandeln wir also die Werte von 0 bis 255 in Werte von 0 bis 180 um, um die Servos mit der Funktion write() zu steuern. Auf ähnliche Weise wandeln wir die Daten zur Steuerung des ESC in Werte von 1000 bis 2000 um. In diesem Beispiel steuern wir diesen ESC vom Mittelpunkt des Joysticks Nummer 1 in die obere Position, also wandeln wir die Werte aus der Mitte um , 127 bis 255 in Werte von 1000 bis 2000. Mit der Funktion WriteMicroseconds() der Servobibliothek senden wir das PWM-Signal an den ESC und können so die Geschwindigkeit des bürstenlosen Motors von minimal bis maximal steuern.

Siehe auch: Arduino RC-Flugzeug | 100 % DIY

Auf diese Weise können wir also RC-Flugzeuge, Autos, Boote usw. steuern, da sie normalerweise diese Art von Motoren, Servos und bürstenlosen Motoren verwenden.

Beispiel 3 – RC-Car-Modellsteuerung

Das ferngesteuerte Auto wurde mit einem eigenen Controller geliefert, der die Vorderräder steuern kann, um sich nach links und rechts zu bewegen, sowie das Auto vorwärts und rückwärts zu bewegen.

Da es sich jedoch um ein billiges RC-Auto handelt, sind die Bedienelemente digital oder entweder ein- oder ausgeschaltet, um die maximale Position links und rechts und die maximale Geschwindigkeit zu erreichen. Unabhängig davon habe ich das Auto zerlegt, um zu sehen, was drin ist und wie ich den Arduino RC-Empfänger zur Steuerung implementieren kann.

Als ich die elektronischen Komponenten aufdeckte, bemerkte ich, dass die beiden Motoren eigentlich einfache Gleichstrommotoren sind, die mit 5 V betrieben werden. Sogar der vordere Motor, der die begrenzten Bewegungen für die Lenkung steuert, ist ein einfacher Gleichstrommotor mit kontinuierlicher Rotation.

Anscheinend wissen wir also bereits, wie man Gleichstrommotoren steuert, also wird es ganz einfach sein, diese Platine durch unseren DIY-Arduino-Empfänger zu ersetzen. Zusätzlich zu unserem Empfänger benötigen wir nur einen Motortreiber, der zwei Motoren gleichzeitig antreiben kann. Es gibt viele Optionen für diesen Zweck, sogar die, die wir im ersten Beispiel verwendet haben, den L298N-Treiber.

Dieser ist jedoch zu groß für diese Anwendung, also habe ich mich für den Motortreiber MX1508 entschieden. Dies ist ein einfacher Dual-DC-Motortreiber mit H-Brücken- und PWM-Steuerung. Es hat 4 Steuereingangspins, 4 Pins für die Motoren und 2 Pins für die Stromversorgung.

Ich habe die Motoranschlüsse von der RC-Car-Platine abgelötet und an den Treiber gelötet. Auf der Rückseite habe ich die Powerpins angelötet und jetzt muss ich diesen Treiber noch mit dem Empfänger verbinden. Die Energie für dieses RC-Auto kommt von einem 4,8-V-Ni-Cd-Akku, der sich an der Unterseite des Autos befindet.

Also habe ich diese Pins mit Sprungdrähten mit dem VCC-Pin des Arduino verbunden und auch die 4 Steuereingangspins des Treibers mit 4 digitalen Kanälen verbunden. Wie gesagt, dieser Treiber unterstützt die PWM-Steuerung, also habe ich für den Motor B oder den hinteren Motor die PWM-Kanäle Nummer 2 und 3 verwendet.

Die für dieses Beispiel benötigten Komponenten erhalten Sie über die folgenden Links:

• MGRC RC-Auto …………………………………
• DC-Motortreiber MX1508 ………………
• Steckbrett und Schaltdrähte ………… 

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;

// 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; //Create a variable with the above structure

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(); //  Set the module as receiver
  resetData();
}
void loop() {
  // Check whether we keep receving data, or we have a connection between the two modules
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
    resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone jas a throttle up, if we lose connection it can keep flying away if we dont reset the function
  }
  // Check whether there is data to be received
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
    lastReceiveTime = millis(); // At this moment we have received the data
  }
  // Parse the data from the Joystic 1 to the steering and throttle variables
  steering = data.j2PotX;
  throttle = data.j1PotY;


// Throttle used for forward and backward control
  if (throttle < 110) {
    // Convert the declining throttle readings for going backward from 110 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedB = map(throttle, 110, 0, 0, 255);
    // Set Motor B backward
    analogWrite(in3, motorSpeedB);
    digitalWrite(in4, LOW);
  }
  else if (throttle > 140) {
    // Convert the increasing throttle readings for going forward from 140 to 255 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedB = map(throttle, 140, 255, 0, 255);
    // Set Motor B forward
    digitalWrite(in3, LOW);
    analogWrite(in4, motorSpeedB);
  }
  // If joystick stays in middle the motors are not moving
  else {
    digitalWrite(in3, HIGH);
    digitalWrite(in4, HIGH);
  }
  
// steering used for left and right control
  if (steering < 110) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
  }
  if (steering > 140) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
  }
  // If joystick stays in middle the motors are not moving
  else {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, HIGH);
  }
}
void resetData() {
  // Reset the values when there is no radio connection - Set initial default values
  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;
} Codesprache:Arduino (arduino) 

Wir verwenden die Daten, die von den Joysticks kommen, um das Gas und die Lenkung des RC-Autos zu steuern. Für die Rückwärtsbewegung verwenden wir die Funktion analogWrite(), um ein PWM-Signal am Input3-Pin an den Treiber zu senden, während wir den Input4-Pin LOW halten. Um vorwärts zu kommen, machen wir das umgekehrt. Bleibt der Joystick in der Mitte, geben wir dem Fahrer den Befehl, zu bremsen oder die Motoren zu stoppen. Das gleiche Prinzip wird für den Lenkmotor verwendet, obwohl wir hier die Funktion analogWrite() nicht verwenden müssen, da wir die Geschwindigkeit dieses Motors nicht steuern müssen.

Nachdem ich diese Skizze auf den Arduino hochgeladen hatte, musste ich das RC-Auto wieder zusammenbauen. Ich legte den kleinen Treiber in das Innengehäuse und befestigte die restlichen Teile mit den Schrauben. Ich habe den Empfänger wieder mit dem Fahrer verbunden und ihn unter das äußere Gehäuse des Autos gelegt, das genug Platz hatte, um in den Empfänger zu passen.

Also haben wir dieses RC-Auto nicht nur so modifiziert, dass es mit unserem DIY-RC-Sender gesteuert werden kann, sondern es auch verbessert, indem wir eine PWM-Steuerung hinzugefügt haben, sodass wir jetzt auch die Geschwindigkeit des Autos steuern können. Falls das RC-Modell, das Sie modifizieren möchten, Servos und bürstenlose Motoren anstelle von Gleichstrommotoren hat, können Sie der im zweiten Beispiel erläuterten Methode folgen.

Ich hoffe, Ihnen hat dieses Tutorial gefallen und Sie haben etwas Neues gelernt. Fühlen Sie sich frei, Fragen im Kommentarbereich unten zu stellen, und vergessen Sie nicht, meine Sammlung von Arduino-Projekten zu überprüfen.