DIY Arduino RC-ontvanger voor RC-modellen en Arduino-projecten

In deze tutorial zullen we leren hoe je een op Arduino gebaseerde RC-ontvanger kunt maken. Sinds ik mijn DIY Arduino RC-zender in een van mijn vorige video's heb gebouwd, kreeg ik veel verzoeken van jullie om er een speciale ontvanger voor te maken, dus hier is hij dan.

Je kunt de volgende video bekijken of de schriftelijke tutorial hieronder lezen.

Nu kunnen deze twee apparaten gemakkelijk communiceren en kunnen we ze gebruiken om veel dingen draadloos te besturen. Ik zal aan de hand van enkele voorbeelden uitleggen hoe alles werkt. In het eerste voorbeeld zullen we deze Arduino RC-ontvanger gebruiken om een ​​eenvoudige auto te besturen die bestaat uit twee DC-motoren. In het tweede voorbeeld zal ik je laten zien hoe je borstelloze motoren en servo's bestuurt, die veel voorkomende componenten zijn die te vinden zijn in veel commerciële RC-vliegtuigen, boten, auto's, enzovoort. Als we weten hoe we ze moeten besturen, kunnen we veel RC-modellen gemakkelijk aanpassen en besturen met onze eigen op maat gemaakte Arduino-zender.

Als derde voorbeeld zal ik je laten zien hoe ik dit op Arduino gebaseerde RC-systeem heb aangepast en gebruikt om een ​​commerciële RC-auto te besturen.

Arduino RC-ontvanger schakelschema

Laten we om te beginnen eens kijken naar het schakelschema van dit systeem. De radiocommunicatie is gebaseerd op de NRF24L01 transceivermodules.

De zender zendt constant data uit van zijn controllers, de joysticks, de knoppen, de potentiometers en de tuimelschakelaars, en deze data ontvangen wij met de ontvanger. Voor meer informatie over hoe deze Arduino-zender werkt, kun je mijn andere gedetailleerde tutorial ervoor bekijken.

We kunnen hier ook opmerken dat deze RC-ontvanger niet noodzakelijkerwijs werkt met alleen deze specifieke zender die ik heb gebouwd. Het kan werken met elke andere vergelijkbare opstelling die bestaat uit een Arduino-bord en een NRF24L01-module.

Desalniettemin is het brein van deze RC-ontvanger een Arduino Pro Mini-bord. Voor de voeding kunnen we ofwel de VCC-pin gebruiken waarop we 5V kunnen aansluiten, of de RAW-pin waarop we kunnen aansluiten van 6 tot 12V. Merk op dat er twee versies van de Arduino Pro Mini zijn, zoals degene die ik hier gebruik die werkt op 5V en de andere op 3,3V. Aan de andere kant werkt de NRF24L01-module op 3,3V, dus daarom hebben we een spanningsregelaar nodig. Deze keer gebruik ik de AMS1117-spanningsregelaar, die 3,3V levert via ingangen die kunnen variëren van 5V tot 12V.

U kunt de benodigde componenten voor deze Arduino RC-ontvanger krijgen via de onderstaande links:

• NRF24L01 Zendontvangermodule…….…………
• NRF24L01 + PA + LNA …………………..…….
• AMS1117 3.3V Spanningsregelaar ………..
• Pin Headers Man + Vrouw ……………….. Amazon / Banggood / AliExpress
• Arduino Pro Mini………………..……..…………..
• Arduino Pro Mini zoals degene die ik gebruikte...

Voor communicatie met de Arduino gebruikt de NRF24L01-module het SPI-protocol, plus twee extra digitale pinnen. Dat betekent dat we nog 9 digitale pinnen overhouden die als uitgangskanalen kunnen worden gebruikt, waarvan twee de RX- en de TX-pinnen. Het is vermeldenswaard dat deze pinnen van alles moeten worden losgekoppeld terwijl we een schets naar het Arduino-bord uploaden, dus daarom heb ik het mogelijk gemaakt om te worden aangesloten of losgekoppeld via afzonderlijke pin-headers. Eigenlijk kunnen we de analoge ingangen ook als digitale uitgangen gebruiken, dus hoewel dit Arduino-bord vrij klein is, hebben we genoeg uitgangen of kanalen beschikbaar.

PCB-ontwerp

Desalniettemin, om dit circuit compact te houden, heb ik een aangepaste PCB gemaakt met behulp van de gratis EasyEDA-software voor online circuitontwerp. Hier heb ik de 8 kanalen direct naast een 5V en een Ground rail gerangschikt, zodat we er direct servo's en ECS's op kunnen aansluiten. Het kanaalnummer 9 bevindt zich op een aparte positie, in de buurt van de VCC-pin van de Arduino, dus we kunnen bijvoorbeeld een ESC gebruiken om de Arduino van stroom te voorzien met zijn Battery Eliminator Circuit-functie die 5V levert. Natuurlijk kunnen we daarvoor andere kanalen gebruiken, omdat de VCC-pin ook op die 5V-rail is aangesloten.

Wat betreft de kanalen nummer 7 en 8, we kunnen hier zien hoe er wordt onderbroken met deze pin-headers. Als we ze willen gebruiken, hoeven we alleen de twee pinnen met elkaar te verbinden. De programmeerkop bevindt zich in de rechterbovenhoek en de 100uF-condensator dient voor zowel de spanningsregelaar als de NRF24L01-module. In de linkerbenedenhoek van de print heb ik de analoge pinnen geplaatst.

Hier kunnen we nog een ding opmerken, en dat is dat sommige Arduino Pro Mini-kaarten een andere pin-indeling kunnen hebben, dus daarom heb ik nog een versie van de PCB toegevoegd, zodat je degene kunt kiezen die overeenkomt met je Arduino Pro Mini-kaart.

Hier is een link naar de projectbestanden van deze PCB. Dus toen ik klaar was met het ontwerp, genereerde ik het Gerber-bestand dat nodig was voor het maken van de PCB.

Gerber-bestanden:

Toen bestelde ik de PCB bij JLCPCB, die ook de sponsor van deze video zijn.

Hier kunnen we eenvoudig het Gerber-bestand slepen en neerzetten en eenmaal geüpload, kunnen we onze PCB bekijken in de Gerber-viewer. Als alles in orde is, kunnen we doorgaan en de eigenschappen selecteren die we voor onze PCB willen. En dat was het, nu kunnen we onze PCB gewoon voor een redelijke prijs bestellen. Houd er rekening mee dat als het uw eerste bestelling bij JLCPCB is, u tot 5 PCB's kunt krijgen voor slechts $ 2.

PCB-assemblage

Na enkele dagen zijn de PCB's gearriveerd. De kwaliteit van de PCB's is geweldig en alles is precies hetzelfde als in het ontwerp.

Nu kunnen we verder gaan en de printplaat monteren. Eerst moeten we de pin-headers van het Arduino-bord solderen. Een handige manier om dat te doen is om met een breadboard de pin-headers erin te steken, zodat het bord tijdens het solderen stevig op zijn plaats blijft zitten. Zoals ik al eerder zei, kunnen de pinnen, afhankelijk van je board, een beetje variëren, dus houd daar rekening mee bij het solderen ervan.

Er zijn ook enkele grondpennen die we vrij moeten laten omdat er enkele sporen op de PCB eronder lopen. Nadat ik het Arduino-bord had gesoldeerd, knipte ik de overtollige lengte van de pinnen.

Vervolgens plaatste ik alle andere pin-headers op hun plaats. We hebben zowel mannelijke als vrouwelijke pin-headers nodig, of het is eigenlijk aan jou welke pin-headers je wilt gebruiken. Het is echter een goed idee om mannelijke pin-headers te gebruiken voor de digitale kanalen, aangezien de servomotoren en de ESC-aansluitingen vrouwelijk zijn, zodat we ze gemakkelijk kunnen aansluiten.

De spanningsregelaar is een component voor opbouwmontage, dus ik heb wat Blue-Tack-lijm gebruikt om hem tijdens het solderen op zijn plaats te houden. Als we ten slotte de twee condensatoren op hun plaats hebben gesoldeerd, kunnen we de NRF24L01-module op de juiste pin-headers bevestigen.

Afhankelijk van de toepassing, of het bereik dat we nodig hebben, kunnen we ofwel de normale module met de ingebouwde antenne gebruiken, of degene waaraan we een grotere antenne kunnen bevestigen en draadloze communicatie tot 700 meter in open ruimte kunnen bereiken . Dus dat is het, onze Arduino RC-ontvanger is nu klaar en we kunnen hem gebruiken voor alles wat we willen.

Voor het programmeren van de ontvanger, of het aansluiten van de Arduino Pro Mini op de computer, kunnen we een USB naar seriële UART-interface gebruiken die kan worden aangesloten op de programmeerkop.

In het menu Arduino IDE-tools moeten we het Arduino Pro- of Pro Mini-bord selecteren, de juiste versie van de processor selecteren, de poort selecteren en de programmeermethode "USBasp" selecteren.

En dus kunnen we nu codes uploaden naar de Arduino.

Voorbeeld 1 – Arduino RC-auto

Oké, nu kunnen we verder gaan en het eerste voorbeeld bekijken.

Het is een eenvoudige auto die bestaat uit twee 12V DC-motoren en in een aantal van mijn vorige video's heb ik je al laten zien hoe het werkt en hoe je het moet bouwen.

Zie ook:L298N Motor Driver – Arduino-interface, hoe het werkt, codes, schema's

Deze keer zullen we onze nieuwe Arduino RC-ontvanger gebruiken om hem te besturen. Voor het aandrijven van de DC-motoren gebruiken we de L298N-motordriver en voor de voeding gebruiken we 3 Li-ion-batterijen die ongeveer 12V leveren.

U kunt de benodigde componenten voor dit voorbeeld verkrijgen via de onderstaande links:

• L298N-stuurprogramma …………………………….. 
• 12V DC-motor met hoog koppel ………….. 
• DC-motor met kunststof bandenwiel …….
• Broodplank en springdraden ………… 

De aansluitingen zijn dus heel eenvoudig, de 12V die van de batterijen komt, gaat naar de 12V-pin op onze ontvanger en de zes stuurpinnen van de driver gaan naar de 6 kanalen. We moeten hier opmerken dat om de snelheid van de motoren te kunnen regelen, we een PWM-signaal moeten leveren aan de Enable A- en Enable B-pinnen van de driver. In onze ontvanger kunnen de kanalen nummer 2, 3, 6 en 9 PWM-signalen uitvoeren, dus daar heb ik de Enable-pinnen van de driver aangesloten op de kanalen nummer 2 en 6 in dit geval.

Laten we nu eens kijken naar de Arduino-code.

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

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(); //  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 throttle and steering variables
  throttle = data.j1PotY;
  steering = data.j1PotX;  
  
  // Throttle used for forward and backward control
  // Joystick values: 0 to 255; down = 0; middle = 127; up = 255
  if (throttle < 110) {
    // Set Motor A backward
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Set Motor B backward
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // 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
    motorSpeedA = map(throttle, 110, 0, 0, 255);
    motorSpeedB = map(throttle, 110, 0, 0, 255);
  }
  else if (throttle > 140) {
    // Set Motor A forward
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    // Set Motor B forward
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    // 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
    motorSpeedA = map(throttle, 140, 255, 0, 255);
    motorSpeedB = map(throttle, 140, 255, 0, 255);
  }
  // If joystick stays in middle the motors are not moving
  else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // Steering used for left and right control
  if (steering < 110) {
    // Convert the declining steering readings from 140 to 255 into increasing 0 to 255 value
    int xMapped = map(steering, 110, 0, 0, 255);
    // Move to left - decrease left motor speed, increase right motor speed
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA < 0) {
      motorSpeedA = 0;
    }
    if (motorSpeedB > 255) {
      motorSpeedB = 255;
    }
  }
  if (steering > 140) {
    // Convert the increasing steering readings from 110 to 0 into 0 to 255 value
    int xMapped = map(steering, 140, 255, 0, 255);
    // Move right - decrease right motor speed, increase left motor speed
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA > 255) {
      motorSpeedA = 255;
    }
    if (motorSpeedB < 0) {
      motorSpeedB = 0;
    }
  }
  // Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
  if (motorSpeedA < 70) {
    motorSpeedA = 0;
  }
  if (motorSpeedB < 70) {
    motorSpeedB = 0;
  }
  analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
  analogWrite(enB, motorSpeedB); // Send PWM signal to motor B
}
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;
}Code language: Arduino (arduino)

Beschrijving: Dus eerst moeten we de SPI en de RF24-bibliotheek opnemen, enkele pinnen, het radio-object en de gegevensstructuur definiëren waar we de binnenkomende gegevens van de zender zullen opslaan. In het setup-gedeelte moeten we de pin-uitgangen definiëren en de radiocommunicatie starten. Voor meer informatie over hoe dit werkt en wat deze regels doen, kun je mijn gedetailleerde NRF24L01-zelfstudie bekijken.

In de loop-sectie controleren we constant of we gegevens ontvangen en als we dat doen, lezen we die inkomende gegevens. Als we snel naar de zendercode kijken, kunnen we zien wat voor soort gegevens deze naar de ontvanger stuurt. Het leest de gegevens van al zijn controllers, de joysticks, de potentiometers en de knoppen, en stuurt die gegevens als één pakket naar de ontvanger.

Dus als we die gegevens eenmaal hebben gelezen, kunnen we ermee doen wat we willen. In dit geval gebruiken we de Joystick 1 Y-aswaarde voor het regelen van het gaspedaal en de X-aswaarde voor het regelen van de besturing. Ik heb deze gegevens in afzonderlijke gas- en stuurvariabelen gezet. De waarden die we van de joysticks krijgen, lopen van 0 tot 255. Dus als we de joystick naar beneden bewegen, zullen we de stuurpennen van de bestuurder zo instellen dat de auto achteruit rijdt, en de gasklep gebruiken om de bewegingssnelheid te regelen. Hetzelfde principe geldt voor vooruit, links en rechts rijden. Nogmaals, ik heb al een gedetailleerde tutorial over hoe deze auto werkt, zodat je dat kunt bekijken voor een beter begrip. Onderaan de code kunnen we de aangepaste functie resetData() zien, die alle waarden terugzet naar hun oorspronkelijke standaardwaarden, dus in het geval dat de radiocommunicatie wegvalt, zal de auto in beweging komen.

Voorbeeld 2 - Arduino RC-ontvangerservo's en borstelloze motorbesturing

Oké, nu kunnen we verder gaan met het tweede voorbeeld, servo's en borstelloze motoren besturen met behulp van deze Arduino RC-ontvanger.

Voor het aansturen van borstelloze motoren hebben we een ESC of Electronic Speed ​​Controller nodig. De Arduino communiceert met de ESC met slechts een enkele pin. Voor het aansturen van de ESC stuurt de Arduino een specifiek PWM-signaal naar de ESC en daarmee regelt de ESC de motorsnelheid. De ESC met dezelfde aansluiting levert 5V via de Battery Eliminator Circuit-functie, dus we kunnen onze ontvanger er ook mee voeden.

Zie ook:Arduino Brushless Motor Control Tutorial | ESC | BLDC

De servomotoren hebben hetzelfde type aansluitingen als de ESC en we kunnen ze eenvoudig aansluiten op elk van de beschikbare kanalen.

U kunt de benodigde componenten voor dit voorbeeld verkrijgen via de onderstaande links:

• Borstelloze motor ……………………..
• ESC 30A ……………………………………
• Li-Po-batterij …………………..……
• MG996R servomotor ………………

De ingangssignalen voor het besturen van zowel servo's als borstelloze motoren met behulp van ESC's zijn bijna hetzelfde. Ze gebruiken een specifiek 50Hz PWM-signaal dat eenvoudig kan worden gegenereerd met behulp van de Arduino Servo-bibliotheek.

Opmerking:  Bij gebruik van MG996R-servo's met deze opstelling, kunnen ze een probleem in het circuit veroorzaken en de Arduino Pro Mini verbranden. Het kan een hogere stroom trekken en spanningspieken op de 5V-rail veroorzaken. De Arduino Pro Mini zou tot 5,5 V moeten verwerken op de 5V-pin, maar wanneer die pieken optreden, kan de Arduino verbranden. Ik had dit probleem bij het testen van het circuit, en iemand in de commentarensectie meldde ook hetzelfde. Een oplossing hiervoor zou kunnen zijn om grotere ontkoppelcondensatoren bij de servo's te plaatsen, maar ik weet het niet zeker en heb het niet getest. Houd dus rekening met dit probleem.

Aan de andere kant gebruikte ik in het voorbeeld twee andere MG996R-servo's die de Arduino niet verbrandden, denk ik omdat ze niet zulke hoge pieken veroorzaakten. Ik heb dit voorbeeld ook gebruikt met 4 kleinere S90-servo's en dat gaf geen enkel probleem.

Zie ook: Hoe de servomotor werkt & Servo's besturen met 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;
}Code language: Arduino (arduino)

Dus, na ontvangst van de gegevens van de zender, converteren we de waarden van 0 tot 255 naar waarden van 0 tot 180 voor het besturen van de servo's met behulp van de functie write(). Op dezelfde manier converteren we de gegevens voor het regelen van de ESC naar waarden van 1000 tot 2000. In dit voorbeeld regelen we deze ESC vanaf het middelpunt van de joystick nummer 1, naar de bovenste positie, dus daarom converteren we de waarden van het midden , 127 tot 255 in waarden van 1000 tot 2000. Met behulp van de functie Servo Library writeMicroseconds() sturen we het PWM-signaal naar de ESC en zo kunnen we de snelheid van de borstelloze motor van minimum tot maximum regelen.

Zie ook:Arduino RC-vliegtuig | 100% doe-het-zelf

Dit is dus hoe we RC-vliegtuigen, auto's, boten enzovoort kunnen besturen, omdat ze meestal dit type motoren, servo's en borstelloze motoren gebruiken.

Voorbeeld 3 – RC-automodelbesturing

De RC-auto werd geleverd met een eigen controller die de voorwielen kan besturen om naar links en rechts te bewegen, en om de auto vooruit en achteruit te bewegen.

Omdat het echter een goedkope RC-auto is, zijn de bedieningselementen digitaal, of aan of uit, voor maximale positie links en rechts en maximale snelheid. Desondanks heb ik de auto gedemonteerd om te zien wat erin zit en hoe ik de Arduino RC-ontvanger kan implementeren om hem te besturen.

Toen ik eenmaal de elektronische componenten had ontdekt, merkte ik dat de twee motoren eigenlijk eenvoudige gelijkstroommotoren zijn die op 5V werken. Zelfs de voorste motor die de beperkte bewegingen voor de besturing regelt, is een eenvoudige continu draaiende gelijkstroommotor.

Dus blijkbaar weten we al hoe we DC-motoren moeten besturen, dus het vervangen van deze printplaat door onze DIY Arduino-ontvanger zal vrij eenvoudig zijn. Naast onze ontvanger hebben we alleen een motordriver nodig die twee motoren tegelijk kan aandrijven. Daarvoor zijn er tal van opties, zelfs degene die we in het eerste voorbeeld gebruikten, de L298N-driver.

Die is echter te groot voor deze toepassing, dus koos ik voor de MX1508 motordriver. Dit is een eenvoudige dubbele DC-motordriver met H-bridge en PWM-besturing. Het heeft 4 pinnen voor besturingsingangen, 4 pinnen voor de motoren en 2 pinnen voor voeding.

Ik heb de motoraansluitingen van de RC-autoprintplaat gedesoldeerd en aan de driver gesoldeerd. Aan de achterkant heb ik de powerpins gesoldeerd en wat nu overblijft is om deze driver met de ontvanger te verbinden. De stroom voor deze RC-auto komt van een 4.8V Ni-Cd-batterij aan de onderkant van de auto.

Dus met behulp van springkabels verbond ik deze pinnen met de VCC-pin van de Arduino en verbond ik ook de 4 besturingsingangspinnen van de driver met 4 digitale kanalen. Zoals ik al zei, ondersteunt deze driver PWM-besturing, dus voor de motor B of de achterste motor heb ik de PWM-kanalen nummer 2 en 3 gebruikt.

U kunt de benodigde componenten voor dit voorbeeld verkrijgen via de onderstaande links:

• MGRC RC-auto ………………………………
• MX1508 DC-motorbesturing ……………
• Broodplank en springdraden ………… 

De code voor deze RC-auto lijkt erg op het eerste voorbeeld.

/*
   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;
}Code language: Arduino (arduino)

We gebruiken de gegevens die van de joysticks komen om het gas en de besturing van de RC-auto te regelen. Om achteruit te gaan, gebruiken we de functie analogWrite() om het PWM-signaal naar de driver op de Input3-pin te sturen, terwijl we de input4-pin LOW houden. Om vooruit te komen, doen we dat andersom. Als de joystick in het midden blijft, geven we de chauffeur het commando om te remmen of de motoren te stoppen. Hetzelfde principe wordt gebruikt voor de stuurmotor, maar hier hoeven we de functie analogWrite() niet te gebruiken omdat we de snelheid van deze motor niet hoeven te regelen.

Nadat ik deze schets naar de Arduino had geüpload, moest ik de RC-auto weer in elkaar zetten. Ik plaatste de kleine driver in de binnenbehuizing en zette de rest van de onderdelen vast met de schroeven. Ik verbond de ontvanger opnieuw met de bestuurder en plaatste hem onder de buitenbehuizing van de auto die genoeg plaats had om in de ontvanger te passen.

Dus we hebben deze RC-auto niet alleen aangepast om te worden bestuurd met onze DIY RC-zender, maar ook verbeterd door PWM-besturing toe te voegen, zodat we nu ook de snelheid van de auto kunnen regelen. Als het RC-model dat u wilt wijzigen servo's en borstelloze motoren heeft in plaats van DC-motoren, kunt u de methode volgen die in het tweede voorbeeld wordt uitgelegd.

Ik hoop dat je deze tutorial leuk vond en iets nieuws hebt geleerd. Stel gerust een vraag in de opmerkingen hieronder en vergeet niet mijn verzameling Arduino-projecten te bekijken.