RC auto bouwen voor Arduino: Autonoom Voertuig - Deel 2

Inzicht in de mobiliteit van de toekomst met robotauto's, deel 2

Welkom bij het tweede deel van onze nieuwe blogserie over robotauto's. In het eerste deel hebben we de basisbeginselen van het basisvoertuig leren kennen. Deze keer willen we de mogelijkheden van afstandsbediening bespreken, een codesysteem ontwikkelen waarmee we de snelheidsstappen van de robotauto kunnen bepalen en tot slot een eenvoudige afstandsbediening realiseren met een infrarood afstandsbediening.

Waarom heb ik snelheidsstappen nodig voor een RC auto voor Arduino microcontrollers?

1. Voor het regelen van de motorsnelheden vanaf een ander apparaat is er in principe de mogelijkheid om continu waarden te bepalen en door te geven met een potentiometer (poti), of om de waarde van de snelheidstrap te verhogen of te verlagen door op een knop te drukken. De volgende afbeeldingen tonen enkele geselecteerde voorbeelden, in de eerste afbeelding joystickbediening:

In de tweede afbeelding zien we onder andere infrarood afstandsbedieningen, een smartphone app met Bluetooth ontvanger en het LCD1602 toetsenbordschild, dat bediend kan worden met een 433 MHz transceiver:

Om een uniform schema te krijgen, is het zinvol om de map() functie te gebruiken om de analoge waarden van de pot te reduceren tot waarden die via radio kunnen worden verzonden. De analoog-digitaal omzetter levert 10-bits getallen, dat wil zeggen waarden tussen 0 en 1023. De middelste stand van de mini-joysticks is ongeveer 511. Door de waarde door 100 te delen, kan één joystick twee waarden (x- en y-richting) bepalen die tussen 0 en 10 liggen of, bij gebruik van de map()-functie, tussen 1 en 9. Dit is voldoende voor het invoeren van de snelheid en de snelheid. Dit is voldoende voor het invoeren van de snelheid en voor het nemen van bochten. Ongeacht of we 11 of 9 waarden bepalen, betekent stilstand waarde 5 in de y-richting en voor rechtuit rijden ook waarde 5.

Kijkend naar de controller met de twee joysticks (onderdeel van de 4DOF Mini robotarm kit met joysticks en servoaandrijving), gezien de verscheidenheid aan verschillende systemen, kies ik voor een code tussen 1111 en 9999 die eenvoudig is over te brengen. Het eerste cijfer kan worden gebruikt voor de y-richting van de linker joystick, het tweede cijfer voor de x-richting van de linker joystick, het derde en vierde cijfer voor een optionele tweede joystick of bepaalde toetsen. In het eerste voorbeeld met de IR afstandsbediening hebben we alleen de eerste twee cijfers van de viercijferige code nodig.

De snelheidsregeling van de RC Car voor Arduino

De snelheidsregeling van de motoren gebeurt met pulsbreedtemodulatie (PWM). De waarde voor de zogenaamde duty cycle is een 8-bits getal, dat wil zeggen een waarde tussen 0 en 255 (=2 tot de macht 8 -1). Als je met een regelbare voeding spanningen tussen 0 en 6 V op de motor zet, zul je merken dat er tot ongeveer 1,5 V niets merkbaar is. Daarna begint de motor te zoemen, maar beweegt niet. Als je tegelijkertijd de stroom meet, zie je een relatief hoge waarde. De energie wordt omgezet in warmte en brommen - niet echt goed. Vanaf 2,4 - 3 volt begint de motor te draaien, de stroomsterkte daalt een beetje als de motor onbelast is. Daarna neemt de snelheid toe, afhankelijk van de toegepaste spanning. Als je de spanning omlaag regelt, zal de motor tot onder 2 volt draaien, maar als hij tot stilstand komt, bijvoorbeeld door verhoogde wrijvingsweerstand of een obstakel, zal hij niet opnieuw starten. Conclusie: Waarden onder ongeveer 2,4 volt moeten worden vermeden, de ingang moet gelijk worden gezet aan 0 (nul) om onnodige slijtage en stroomverbruik te voorkomen. Behalve voor stilstand (code=5) hebben we een Duty Cycle nodig tussen ongeveer 40% en 100% met een voedingsspanning van 6V voor de motoren.

De voeding voor de RC Car voor Arduino

We hebben in het eerste deel al verschillende mogelijkheden voor de voeding besproken. Vier AA-batterijen van elk 1,5V geven 6V, de maximale spanning van de kleine gele motortjes. Vier AA-batterijen van elk 1,2 V zijn niet genoeg voor de voeding. Je hebt dan een batterijhouder nodig voor 6 batterijen en dat geeft 7,2 volt. En twee lithium-ion batterijen (nominale spanning 3,7 V) leveren meer dan 8 volt als ze volledig zijn opgeladen. Het is dus logisch om in het programma een factor in te stellen die de spanning van het hoogste aandrijfniveau beperkt tot 6V.

De RC auto besturen voor Arduino

Als de rij-instructies worden gegeven met knoppen, mogelijk zelfs in een smartphone app, wordt de juiste waarde verhoogd of verlaagd voor de uitgangswaarde 55xx (stilstand) zonder het maximum te overschrijden.

De code correct uitlezen

De toewijzing van het eerste cijfer van de code aan de vereiste waarden van de bewegingstrappen gebeurt via de index van een lijst met de respectieve numerieke waarden.

Conclusie: Met een code van vier cijfers kunnen we de snelheid en het bochtenwerk regelen met de eerste twee cijfers, de achterste twee cijfers worden gebruikt voor andere functies (die in eerste instantie niet nodig zijn). Dus, bijvoorbeeld, code95xx voor snelste rechtuit, 55xx voor stilstand, 77xx voor vooruit rijden naar rechts. 

Nu willen we onze eerste Smart Robot Car bouwen met de kit, een ATmega328 microcontroller (UNO R3 ontwerp), een MotorShield V2 en IR zender en ontvanger.

Het MotorShield V2 kan maximaal vier motoren aansturen, met behulp van de zogenaamde I2C bus met de aansluitingen SDA (=Serial Data) op de analoge ingang A4 en SCL (=Serial Clock) op A5 voor het aansluiten van de stuurlijnen. Adafruit heeft hiervoor ook een geschikte programmabibliotheek ontwikkeld en beschikbaar gesteld. Let op: De bibliotheken voor Motor Shields V1 en V2 zijn niet compatibel.

Afbeelding Motor Shield V2 met modificatie:
Gesoldeerde busconnectoren (vrouwelijke connectoren) voor het aansluiten van extra apparatuur

Het maakt niet uit welk Motor Shield je wilt gebruiken - V1 of V2 -,  het is zinvol om extra busconnectoren te solderen voor beide Motor Shields om later Bluetooth of 433 MHz zenders/ontvangers of sensoren aan te sluiten. Meer hierover in de volgende blogposts. De IR-ontvanger heeft alleen voeding nodig van pin 3 en 4 en pin 2 voor de IR-ontvanger. De soldeerbout kan dan nog koud blijven.

Voor de besturing gebruiken we eerst de kleine infrarood afstandsbediening van Funduino en een IR ontvanger. Hoewel de "naakte" IR-sensor voldoende is, raad ik het kleine breakout bord aan, omdat hier een LED flikkert wanneer IR-signalen worden ontvangen; een waardevol hulpmiddel bij het zoeken naar een storing.

De schets is samengesteld uit twee beproefde onderdelen: Armin Joachimsmeyer's voorbeeldschets, die hij toevoegde aan zijn geweldige IRremote programmabibliotheek, en een Robot Car schets van de auteur op basis van Adafruit's programmabibliotheek.

De programmacode voor de RC Car voor Arduino

/* Voorbeeldcode voor robotauto met motorschild V2 en IR-ontvanger, vanaf 20220515
* gebaseerd op Adafruit Motor shield V2 bibliotheek, copyright Adafruit Industries LLC, 2009
* en SimpleReceiver.cpp, onderdeel van Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote
* MIT-licentie Copyright (c) 2020-2022 Armin Joachimsmeyer
* aangepast voor Funduino
* Motor Shield V2 gebruikt I2C met SDA=A4 en SCL=A5
* IR-ontvanger gebruikt pin 2
************************************************************************************
* Hierbij wordt gratis toestemming verleend aan iedereen die een kopie verkrijgt van
* van deze software en bijbehorende documentatiebestanden (de "Software"), om te handelen
* in de Software zonder beperking, inclusief zonder beperking de rechten
* de Software te gebruiken, te kopiëren, te wijzigen, samen te voegen, te publiceren, te distribueren, in sublicentie te geven en/of te verkopen, en kopieën van de Software toe te staan
* kopieën van de Software, en om personen aan wie de Software is geleverd toe te staan
* om dit te doen, onder de volgende voorwaarden:
*
* De bovenstaande copyrightmelding en deze toestemmingsmelding moeten worden opgenomen in alle
* kopieën of substantiële delen van de Software.
*
* DE SOFTWARE WORDT GELEVERD "ZOALS DEZE IS", ZONDER ENIGE VORM VAN GARANTIE, EXPLICIET OF IMPLICIET,
* INCLUSIEF MAAR NIET BEPERKT TOT DE GARANTIES VAN VERKOOPBAARHEID, GESCHIKTHEID VOOR EEN
* BEPAALD DOEL EN NIET-INBREUK. IN GEEN GEVAL ZULLEN DE AUTEURS OF
* HOUDERS AANSPRAKELIJK ZIJN VOOR ENIGE CLAIM, SCHADE OF ANDERE AANSPRAKELIJKHEID, HETZIJ IN EEN ACTIE VAN
* CONTRACT, ONRECHTMATIGE DAAD OF ANDERSZINS, VOORTVLOEIEND UIT, UIT OF IN VERBAND MET DE SOFTWARE
* OF HET GEBRUIK VAN OF ANDERE OMGANG MET DE SOFTWARE.
*************************************************************************************/
#include <Adafruit_MotorShield.h>
// Maak het motorschildobject aan met het standaard I2C-adres 0x60
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
// Selecteer welke 'poort' M1, M2, M3 of M4. 
Adafruit_DCMotor *motor1 = AFMS.getMotor(2);
Adafruit_DCMotor *motor2 = AFMS.getMotor(3);
// definieer protocol voor afstandsbediening, voor meer zie voorbeeldcode SimpleReceiver.cpp
#define DECODE_NEC // Inclusief Apple en Onkyo, ook voor kleine Funduino afstandsbediening
//#define INFO // Om waardevolle informatie te zien van universele decoder voor pulsbreedte- of pulsafstandprotocollen
#define IR_RECEIVE_PIN 2 // in plaats van #include "PinDefinitionsAndMore.h"
#include <Arduino.h>
#include <IRremote.hpp>
// IR ontvanger signaal aangesloten op pin2, VCC op pin3, GND op pin4
int IR_GND = 4;
int IR_VCC = 3;
int x = 0;
int y = 0;
int links = 0;
int rechts = 0;
int code = 5555;
int speedL = 0;
float factor = 1.8; // Correctie voor speedLevel 255/100 * 6V/VBatt
id setup() {
Serial.begin(9600);
Serial.println("Motortest!");
Serial.println("Motorshield v2 - DC Motortest!");
als (!AFMS.begin()) {         // create with the default frequency 1.6KHz
Serial.println("Could not find Motor Shield. Check wiring.");
while (1);
}
Serial.println("Motor Shield gevonden.");
// Gewoon om te weten welk programma draait op mijn Arduino
Serial.println(F("START " __FILE__ " from " __DATE__ "\rUsing library version " VERSION_IRREMOTE));
// De ontvanger starten
IrReceiver.begin(IR_RECEIVE_PIN); //, ENABLE_LED_FEEDBACK);
Serial.print(F("Klaar om IR-signalen van protocollen te ontvangen: "));
printActiveIRProtocols(&Serial);
Serial.print(F("op pin "));
Serial.println(IR_RECEIVE_PIN);
// initialiseer digitale pinnen als uitgang voor voeding
pinMode(IR_GND,OUTPUT);
pinMode(IR_VCC,OUTPUT);
digitalWrite(IR_GND,LOW);
digitalWrite(IR_VCC,HIGH);
} // einde setup
void loop() {
if (IrReceiver.decode()) {
// Druk een korte samenvatting van ontvangen gegevens af
IrReceiver.printIRResultShort(&Serial);
als (IrReceiver.decodedIRData.protocol == UNKNOWN) {
// We have an unknown protocol here, print more info
IrReceiver.printIRResultRawFormatted(&Serial, true);
}
Serial.println();
/*
* belangrijk!!! Schakel het ontvangen van de volgende waarde in,
* omdat het ontvangen is gestopt na het einde van het huidige ontvangen gegevenspakket.
*/
delay(100); // Debounce, geen snel opnieuw proberen 
IrReceiver.resume(); // Ontvangst van de  volgende waardeinschakelen
/*
* Controleer ten slotte de ontvangen gegevens en voer acties uit volgens het ontvangen commando
*/
als (IrReceiver.decodedIRData.command == 0x46)  {
if (code<9000)   code = code + 1000;
Serial.print("Code = ");
Serial.println(code);
}
anders als (IrReceiver.decodedIRData.command == 0x15) {
if (code>2000)   code = code - 1000;
Serial.print("Code = ");
Serial.println(code);
}
anders als (IrReceiver.decodedIRData.command == 0x43)  {
if ((code-1000*int(code/1000))<900)  code = code + 100;
Serial.print("Code = ");
Serial.println(code);
}
anders als (IrReceiver.decodedIRData.command == 0x44)  {
if (code-1000*int(code/1000) > 200)   code = code - 100;
Serial.print("Code = ");
Serial.println(code);
}
anders als (IrReceiver.decodedIRData.command == 0x40)  {
code = 5555;
Serial.print("Code = ");
Serial.println(code);
}
anders {
Serial.print("invalid code");
}
motor();
}
} // einde lus
void motor(){
int speedLevel[9]={-100,-80,-60,-40,0,40,60,80,100};
y = int(code / 1000);
x = int((code - 1000*y) / 100);
speedL = speedLevel[y-1];
Serial.print("code = ");
Serial.print(code);
Serial.print(" y =");
Serial.print(y);
Serial.print(" x =");
Serial.print(x);
Serial.print(" speedL =");
Serial.println(speedL);
//Correctie van de snelheidsstappen voor bochten
als (x==1){
right = speedL+16;
left = speedL-16;
}
anders als (x==2){
right = speedL+13;
left = speedL-13;
}
anders als (x==3) {
right = speedL+10;
left = speedL-10;
}
anders als (x==4) {
right = speedL+7;
left = speedL-7;
}
anders als (x==6) {
right = speedL -7;
left = speedL+7;
}
anders als (x==7) {
right = speedL-10;
left = speedL+10;
}
anders als (x==8) {
right = speedL-13;
left = speedL+13;
}
anders als (x==9) {
right = speedL-16;
left = speedL+16;
}
anders {
right = speedL;
left = speedL;
}
//Invoer van de rijstappen voor "links" en "rechts
Serial.print("links = ");
Serial.print(left);
Serial.print(" rechts = ");
Serial.println(rechts);
als (links < 40 & links > -40) {
motor1->run(RELEASE);
}
als (rechts < 40 & rechts > -40) {
motor2->run(RELEASE);
}
als (links>=40) {
if (left>100) left=100;
motor1->run(FORWARD);
motor1->setSpeed(left * factor);
}
als (rechts>=40) {
if (right>100) right=100;
motor2->run(FORWARD);
motor2->setSpeed(right * factor);
}
als (links<= -40) {
if (left<-100) left=-100;
motor1->run(BACKWARD);
motor1->setSpeed(-left * factor);
}
als (rechts<= -40) {
if (right<-100) right=-100;
motor2->run(BACKWARD);
motor2->setSpeed(-right * factor);
}
} // einde motor

Uitleg van de programmacode voor de RC Car

Na het opnemen van de bibliotheken voor het Motor Shield V2 en IRremote, worden twee motoren geïnitialiseerd met het nummer op het aansluitblok van de controller en worden enkele globale variabelen gedeclareerd (datatype) en geïnitialiseerd (beginwaarde).

In de functie setup( ) worden de seriële interface en de IR-ontvanger geïnitialiseerd en worden de pinnen voor de voeding van de IR-ontvanger ingesteld als uitgangen met de status HIGH of LOW.

In de loop() functie wordt eerst het signaal van de IR afstandsbediening ontvangen, daarna wordt de code voor de motorbesturing gewijzigd afhankelijk van de ingedrukte toets. De cursortoetsen omhoog en omlaag veranderen het eerste cijfer, links en rechts het tweede cijfer van de code in het waardebereik van 1 tot 9. De toets X leidt tot stilstand met code 5555. Het derde en vierde cijfer van de code zijn momenteel nog niet significant. Aan het einde wordt de zelfgedefinieerde functie motor() aangeroepen zonder argumenten, omdat we de variabelen globaal hadden gedefinieerd, d.w.z. geldig in alle functies.

In de zelfgedefinieerde functie motor(), die we ook in andere configuraties met andere afstandsbedieningen zullen gebruiken, worden de snelheidsstappen voor de linker- en rechtermotor bepaald vanuit de code. De procentuele waarde van het snelheidsniveau wordt uiteindelijk omgezet in de PWM-waarde voor setSpeed met behulp van de factor die aan het begin is gedefinieerd.

De robotauto is nu klaar voor gebruik. Hij werkt prima zolang je de optische verbinding tussen de afstandsbediening en de IR-ontvanger in stand kunt houden. Tijdens het rijden op de weg heb ik echter ervaren dat sterk zonlicht de ontvangst belemmert. Daarom stap ik over op radioafstandsbediening. Tot snel.