Bouw een Multifunctionele Arduino RC Zender: Stap-voor-Stap DIY Handleiding

Overzicht

In deze tutorial leer je hoe je een DIY Arduino RC-zender bouwt. Omdat ik vaak draadloze controle nodig heb voor mijn projecten, heb ik deze multifunctionele radiocontroller ontworpen die voor bijna alles gebruikt kan worden.

Je kunt de onderstaande video bekijken of de geschreven handleiding volgen.

Hoe het werkt

Met deze zender kun je elk Arduino-project draadloos bedienen met slechts kleine aanpassingen aan de ontvanger. De zender kan ook dienen als commerciële RC-zender voor het besturen van RC-speelgoed, auto's, drones, enz. Hiervoor is een eenvoudige Arduino-ontvanger nodig die de juiste signalen genereert voor het besturen van die apparaten.

Ik leg de werking uit aan de hand van voorbeelden: het besturen van een Arduino robotauto, de Arduino Mier-robot uit een eerdere video, en het besturen van een brushless DC-motor met een ESC en servomotoren.

De radiocommunicatie is gebaseerd op de NRF24L01-transceivermodule. Met een versterkte antenne bereik je een stabiele bereik van tot 700 meter in open ruimte. De controller beschikt over 14 kanalen: 6 analoge ingangen en 8 digitale ingangen.

Er zitten twee joysticks, twee potentiometers, twee schakelaars, zes knoppen en een ingebouwde meetunit (accelerometer en gyroscoop) in. De IMU kan ook gebruikt worden voor besturing door de controller te bewegen of te kantelen.

Schakelschema Arduino RC-zender

De kern is een Arduino Pro Mini, gevoed door 2 LiPo-accu's (ca. 7,4 V). Deze worden aangesloten op de RAW-pin, die via de onboard regelaar 5 V levert. Let op: er zijn 5 V en 3,3 V versies van de Pro Mini.

De NRF24L01 heeft strikt 3,3 V nodig, bij voorkeur van een eigen bron. Daarom wordt een 3,3 V-spanningsregelaar (HT7333 of AMS1117) gebruikt, met een decouplingcondensator vlakbij de module voor stabiele communicatie. De NRF24L01 communiceert via SPI, de MPU6050 via I2C.

Benodigde componenten

• NRF24L01 Transceivermodule
• NRF24L01 + PA + LNA (versterkte versie)
• Potentiometer
• Servomotor
• Schakelaar (toggle switch)
• Joystick (met breakout-board – joystick moet afgesoldeerd worden)
• Joystick zonder breakout-board
• Arduino Pro Mini (PCB V2 of V3)
• Arduino Pro Mini (PCB V1)
• HT7333 3,3 V regelaar (lokale winkel – PCB V1 & V2)
• AMS1117 3,3 V regelaar (PCB V3)

PCB-ontwerp

Alle analoge en digitale pinnen van de Pro Mini worden gebruikt. Om een draadjeswarr te voorkomen, heb ik een custom PCB ontworpen in EasyEDA. Het ontwerp houdt rekening met ergonomie: de PCB past comfortabel in twee handen, alle bedieningselementen liggen binnen bereik van de vingers. De ronden zijn afgerond, en er zijn 3 mm montagegaten. De programmeerpinnen (RX/TX) liggen bovenaan voor gemakkelijke toegang. Let op: RX/TX moeten losgekoppeld zijn tijdens het uploaden van de sketch; daarom zijn ze onderbroken met jumper-pinnen.

Belangrijk: Kies de juiste Arduino Pro Mini versie die bij de PCB past, of pas het ontwerp aan. Hier is een vergelijking van de drie versies.

De Gerber-bestanden zijn beschikbaar via de projectlink. Ik heb de PCB's besteld bij JLCPCB (sponsor), in zwart. De kwaliteit is uitstekend.

PCB assembleren

Eerst de pinheaders van de Pro Mini solderen (handig op een breadboard vastzetten). De zijpinnen kunnen per fabrikant verschillen; mijn model heeft 5 pinnen per zijde (één GND overgeslagen voor PCB-sporen). De Pro Mini wordt direct op de PCB gesoldeerd, pinnen afgeknipt. Vervolgens de MPU6050, de 3,3 V regelaar met condensator, en een condensator bij de NRF24L01 (elke versie werkt).

Daarna programmeerpinnen, RX/TX, voedingspinnen en stroomschakelaar. Potentiometers krijgen verlengde pinnen via pinheaders (knoppen waren korter geknipt voor knopen). Twee schakelaars en twee joysticks worden gesoldeerd.

De vier drukknoppen krijgen ook verlengde pinnen. De PCB is nu klaar.

Behuizing maken

Ik koos voor transparant acrylaat (4 mm) om de PCB zichtbaar te houden. Twee platen in de vorm van de PCB, bevestigd met bouten.

Na zagen en vijlen passen de platen perfect. Gaten voor montage (3 mm met inzakking), openingen voor schakelaars/potentiometers (6 mm), joysticks (25 mm Forstner).

Let op: de voedingspinheader is omgekeerd gesoldeerd voor bereikbaarheid vanaf de batterijzijde.

Beschermfolie afhalen (zeer bevredigend). Potentiometers op bovenplaat monteren, 3 mm bouten en 11 mm afstandsringen plaatsen. Bovenplaat en PCB samenvoegen en bouten vastdraaien. Nu de potentiometers solderen (hoogte was nu vast).

Achterplaat: batterijhouder bevestigen (2 bouten). Achterplaat op de PCB schroeven (4 montagebouten).

Batterij aansluiten, knopen op potentiometers, joystickknopen, antenne op NRF24L01. Klaar!

Programmeren

Voor programmeren van de Pro Mini heb je een USB-naar-seriële UART-interface nodig, aangesloten op de programmeerheader bovenaan. In de Arduino IDE: Board "Arduino Pro or Pro Mini", juiste processor, poort, programmeermethode "USBasp".

Arduino Code voor RC-zender

De code werkt als volgt: bibliotheken voor SPI, RF24 (NRF24L01) en Wire (I2C voor MPU6050). Digitale ingangen definiëren, variabelen, radio-object en communicatie-adres.

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

// Digitale ingangen
#define jB1 1 // Joystick knop 1
#define jB2 0 // Joystick knop 2
#define t1 7  // Schakelaar 1
#define t2 4  // Schakelaar 2
#define b1 8  // Knop 1
#define b2 9  // Knop 2
#define b3 2  // Knop 3
#define b4 3  // Knop 4

const int MPU = 0x68; // MPU6050 I2C adres
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"; // Adres

Een structuur voor de 14 invoerwaarden (max 32 bytes, limiet NRF24L01 buffer):

// Max grootte struct is 32 bytes - NRF24L01 buffer limiet
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;

In setup(): MPU6050 initialiseren, eventueel IMU-fouten berekenen, radio initialiseren, interne pull-up resistors activeren voor digitale ingangen, standaardwaarden instellen.

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

void setup() {
  Serial.begin(9600);
  initialize_MPU6050();
  // calculate_IMU_error(); // optioneel

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

  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);

  // Standaardwaarden (joystick midden = 127)
  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;
}

In loop(): alle analoge ingangen lezen, mappen 0-1023 naar 0-255 (byte). Digitale ingangen lezen (pull-up: 0 = ingedrukt). Data verzenden via radio.write(). Als schakelaar 1 aanstaat (LOW), IMU-data gebruiken in plaats van joystick 1.

void loop() {
  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);

  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);

  if (digitalRead(t1) == 0) {
    read_IMU();
  }

  radio.write(&data, sizeof(Data_Package));
}

IMU-uitlezing: complementair filter combineert accelerometer en gyro data tot hoeken (-90 tot +90 graden), gemapt naar 0-255.

void read_IMU() {
  // Accelerometer uitlezen
  Wire.beginTransmission(MPU);
  Wire.write(0x3B);
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 6, true);
  AccX = (Wire.read() << 8 | Wire.read()) / 4096.0;
  AccY = (Wire.read() << 8 | Wire.read()) / 4096.0;
  AccZ = (Wire.read() << 8 | Wire.read()) / 4096.0;

  accAngleX = atan(AccY / sqrt(pow(AccX,2) + pow(AccZ,2))) * 180 / PI + 1.15;
  accAngleY = atan(-AccX / sqrt(pow(AccY,2) + pow(AccZ,2))) * 180 / PI - 0.52;

  // Gyro uitlezen
  previousTime = currentTime;
  currentTime = millis();
  elapsedTime = (currentTime - previousTime) / 1000.0;

  Wire.beginTransmission(MPU);
  Wire.write(0x43);
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 4, true);
  GyroX = (Wire.read() << 8 | Wire.read()) / 32.8 + 1.85;
  GyroY = (Wire.read() << 8 | Wire.read()) / 32.8 - 0.15;

  gyroAngleX = GyroX * elapsedTime;
  gyroAngleY = GyroY * elapsedTime;

  // Complementair filter
  angleX = 0.98 * (angleX + gyroAngleX) + 0.02 * accAngleX;
  angleY = 0.98 * (angleY + gyroAngleY) + 0.02 * accAngleY;

  // Mappen naar joystick bereik
  data.j1PotX = map(angleX, -90, 90, 255, 0);
  data.j1PotY = map(angleY, -90, 90, 0, 255);
}

De complete code (inclusief calculate_IMU_error()) staat aan het einde van de originele tutorial.

Ontvangercode

Eenvoudig ontvangerschema met Arduino en NRF24L01. De ontvanger gebruikt dezelfde structuur en radio-instellingen, maar met radio.startListening(). In de loop: data ontvangen, op seriële monitor printen, en na >1 seconde geen data: waarden resetten (veiligheid).

/* Ontvangercode */
#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 { /* zelfde struct */ };
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();

  Serial.print("j1PotX: "); Serial.print(data.j1PotX);
  Serial.print("; j1PotY: "); Serial.print(data.j1PotY);
  Serial.print("; button1: "); Serial.print(data.button1);
  Serial.print("; j2PotX: "); Serial.println(data.j2PotX);
}

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;
}

Toepassingen

Arduino Robotauto draadloos besturen

De ontvangercode leest de joystickwaarden en stuurt de motoren aan.

Arduino Mier-robot (Hexapod) besturen

Deze robot uit een eerdere video wordt nu draadloos bestuurd: vooruit, achteruit, links, rechts, bijten, aanvallen.

ESC en Servo besturen (commerciële RC)

Na ontvangst: servos via Servo-bibliotheek (0-180°), brushless motor via ESC met 50 Hz PWM (1000-2000 µs). Let op: standaard RC-ontvangers werken niet met NRF24L01; je bouwt een eigen ontvanger die PWM/PPM genereert.

/* ESC en Servo ontvanger */
#include <SPI.h> #include <nRF24L01.h> #include <RF24.h> #include <Servo.h>
RF24 radio(10, 9); const byte address[6] = "00001";
// ... zelfde struct en setup ...
Servo esc, servo1, servo2;
void setup() { /* ... */ esc.attach(9); servo1.attach(3); servo2.attach(4); }
void loop() {
  // verbinding check, data ontvangen
  servo1Value = map(data.j2PotX, 0, 255, 0, 180);
  servo2Value = map(data.j2PotY, 0, 255, 0, 180);
  servo1.write(servo1Value); servo2.write(servo2Value);
  escValue = map(data.pot1, 0, 255, 1000, 2000);
  esc.writeMicroseconds(escValue);
}

Dat was het! Veel plezier met bouwen. Vragen? Laat een reactie achter.