Stappenpan: Programmeren van de Robot
Hier onder de stappen om de Robot te Programmeren.
Om de robots te programmeren heb je een ontwikkel omgeving nodig.
Hiervoor gebruiken we de Arduino ontwikkel omgeving.
Wat is Arduino ?
Arduino is een opensource elektronica platform. Dat wil zeggen dat iedereen kan bijdragen
aan de ontwikkeling van dit product. Door de enorme hoeveelheid gebruikers kan men wel zeggen dat dit de standaard is onder de makers !
Is men opzoek naar informatie of voorbeelden dan kan dat gemakkelijk gevonden worden op het internet.
De combinatie van hardware en software sluit goed op elkaar aan zodat men snel en gemakkelijk van start kan gaan.
De Arduino programmeer omgeving ondersteund natuurlijk alle Arduino-boards ( dit zijn print platen met een processor, aansluiting om hem te programmeren en diverse aansluitingen om elektronica aan te sturen )
Daarnaast zijn er “ontelbare” andere Processor-Boards welke geprogrammeerd kunnen worden met de Arduino omgeving. Voor dit project hebben we voor (goedkoop en uitgebreid) alternatief gekozen.
Het gebruikte bord voor dit project heeft naast diverse aansluitingen voor elektronica componenten ook nog Wifi op de print. Deze kunnen we later gaan gebruiken om op afstand de robot te besturen en of gegevens uit te lezen.
Om de beginnen met Arduino gaat men naar de volgende Webpagina:
Kijk hier eerst maar eens rustig rond hier staan bijvoorbeeld ook honderden voorbeeld projecten met uitleg op de [PROJECT HUB]
Om de software te installeren in stap 1 gaan we op de hoofdpagina naar het tabblad [SOFTWARE]
Stap 1
De Installatie van de ontwikkel omgeving.
Op de Arduino Software pagina kunnen we de programmatuur welke we nodig hebben gratis downloaden.
Wel kan je een donatie geven voor de ontwikkeling van toekomstige Arduino producten.
Download en installeer voor Uw systeem de software hier:
Als alles gelukt kan je het programma voor de eerste keer opstarten
Stap 2
In deze handleiding gaan we niet (in alle diepte uitleggen) hoe verder de software te gebruiken.
Maar we laten wel de stappen zien hoe de omgeving gereed te maken om onze hardware te gebruiken.
De meeste borden om te programmeren bezitten een USB aansluiting welke aan onze computer/laptop gekoppeld kan worden. Deze koppeling wordt vaak omgezet naar een seriële communicatie poort.
Vaak afgekort als COM-Poort, de computer heeft vaak meerdere poorten dus krijgen ze allen een volgnummer,
bijvoorbeeld COM3 , COM7 ect. Deze nummers hoeven niet netjes elkaar te volgen. Om de computer te laten praten met het processorbord moet er binnen Arduino een poort gekozen worden.
Deze kan men selecteren onder het menu [Hulpmiddelen] ->[Poort] -> ( hier staan dan de mogelijke poorten onder)
Als men het bord voor het eerst aansluit op de pc zullen er veelal eerst “drivers” voor deze poort geïnstalleerd te worden.
De controller chip welke op ons bord zit is veelal een CH340 chip. Als dit het geval is moet men de drivers zelf installeren.
Hoe herkent men de chip varianten, kijk naar de volgende afbeelding en ga op zoek naar de chip op je bord.
Is het een CP2102 (een vierkante chip) dan wordt deze automatisch door Windows herkend en hoef je niets te doen.
Is het een rechthoekige chip dan is het de CH340 en dient men handmatig de driver te installeren
Zoek op het internet naar de juiste drivers voor uw systeem met de zoekterm “CH340 Driver” eventueel met uw besturingssysteem er achter.
Als ze geïnstalleerd zijn zijn kan je het bord aansluiten op je pc ( let hierbij altijd op dat deze niet met de aansluit pinnen ergens kortsluiting kan maken )
Als de drivers goed geïnstalleerd zijn , komt er een extra COM-Poort bij binnen de Arduino omgeving ( eventueel opnieuw opstarten )
In dit geval is er COM62 bijgekomen dat is dus de communicatie poort van het processorbord.
Deze poort dient dus gekozen te worden om het bord straks van een programma te voorzien.
Stap 3
Installeren van het extra type processor board.
De programmeer omgeving van Arduino dient te weten welke hardware er aangesloten wordt om het
programma goed te laten werken. Elk bord heeft een specifiek aantal poorten en mogelijkheden.
De Arduino omgeving moet dus weten voor welk bord men gaat programmeren ( de taal veranderd niet wel de mogelijkheden ).
In ons geval maken we gebruik van een NodeMCU 1.0 (ESP-12E Module).
Om deze te kunnen installeren binnen de omgeving dienen we eerst een installatie pakket binnen te halen via de Arduino omgeving.
Ga naar het menu [Bestand] -> [Voorkeuren] -> Vul dan in bij Additionele Bordenbeheer URLs in:
http://arduino.esp8266.com/stable/package_esp8266com_index.json
en kies daarna voor [OK]
Nu kan het bord gevonden worden binnen bordenbeheer. Dus we gaan nu het juiste bord selecteren.
In het menu [Hulpmiddelen] ->[Board:] ->[Bordenbeheerder…]
Hier gaan we op zoek naar het juiste bord.
Bij “Filter je zoekresultaten…” vul je in : esp8266
Er komt nu een optie naar voren , men kan nu een versie selecteren en deze installeren !
Als deze geïnstalleerd is kunnen we dit scherm afsluiten en het bord daadwerkelijk selecteren onder borden beheer. Ga hiervoor opnieuw naar [Hulpmiddelen] -> [Board:] en kies het bord nodeMcu 1.0 (ESP-12E Module)
We zijn nu klaar om het bord te gaan programmeren !!
Stap 4
Het eerste Test programma.
Knip en plak onderstaande programma code naar de Arduino IDE. Het volgende programma kan testen of
je esp goed is aangesloten en dat we hem kunnen programmeren. Het volgende test programma laat het ledje op de
print knipperen 1 seconde aan , 2 seconden uit. ( Dit gaat eindeloos door )
Heb je het programma geplakt druk dan op [->] (de tweede ronde knop boven in het programma). Onder in de zwarte balk zal informatie naar voren komen over het compileren en transporteren van het programma naar de esp.
zodra er boven de zwarte balk Uploaden Voltooid komt te staan zal de ESP led gaan knipperen !!!
// Bij het setup gedeelte stellen we alle poorten in ,in dit geval een standaard poort void setup() { pinMode(LED_BUILTIN, OUTPUT); // Aangeven of we gaan lezen of schrijven // OUTPUT - De poort stuurt uit } // De volgende functie wordt eindeloos herhaald ( hoofd programma lus ) void loop() { digitalWrite(LED_BUILTIN, LOW); // Schakel de uitgang naar Low = 0 = laag // Lijkt het ledje uit te schakelen // Maar op het ESP bord gaat de led branden bij 0 delay(1000); // Wacht een seconde ( 1000 milliseconde ) digitalWrite(LED_BUILTIN, HIGH); // Schakel de uitgang naar High = 1 = hoog // In dit geval gaat dan de led uit delay(2000); // Wacht voor twee seconden en begin weer // opnieuw boven aan de loop }
Probeer eens wat te veranderen aan het programma, bij voorbeeld een uitbreiding dat er een sos signaal ontstaat 3x kort, 3x lang, 3x kort, knipperen en dan een wat langere pauze daar tussen.
Stap 5
Het testen van de motor stuur print of alles juist is aangesloten.
Het volgende programma gaat testen of de motoren juist zijn aangesloten, probeer ook eens wat te spelen met de code.
- Laat de robot achteruit rijden
- Laat de robot 5 seconde op volle snelheid vooruit rijden en dan stoppen.
- Laat de robot in een ruime cirkel rijden ( niet om zijn as laten draaien )
// Test Programma om de Aansluiting van de Motoren te testen // In het volgende blok kunnen we zien dat de numering van de inputs en outputs van het ESP-Bord // anders genummerd zijn dan op een standaard Arduino // gebruiken we de poortnummers vab arduino dan zien we de bijbehoordende D nummers van het ESP-Bord // Daar achter staan weer waarvoor wij de poorten gaan gebruiken // A = linkerkant van robot B = rechter kant //static const uint8_t D0 = 16; // Led Op de Print - Vrij als I/0 te gebruiken //static const uint8_t D1 = 5; // Motor Uitvoer Snelheid A //static const uint8_t D2 = 4; // Motor Uitvoer Snelheid B //static const uint8_t D3 = 0; // Motor Uitvoer Voor/Achter A+ //static const uint8_t D4 = 2; // Motor Uitvoer Voor/Achter B+ //static const uint8_t D5 = 14; // Ping Sensor 1 Trigger A //static const uint8_t D6 = 12; // Ping Sensor 1 Echo A //static const uint8_t D7 = 13; // Ping Sensor 2 Trigger B //static const uint8_t D8 = 15; // Ping Sensor 2 Echo B //static const uint8_t D9 = 3; // vrij te gebruiken //static const uint8_t D10 = 1; // vrij te gebruiken // handig is om namen te definieren voor de i/o poorten daar is de code overzichtelijker // in plaats van nummers namen gebruiken in de code #define MotorSnelheidL 5 // Output analoog waarde tussen 0-1023 #define MotorRichtingL 0 // Output digitaal 0 of 1 #define MotorSnelheidR 4 // Output analoog waarde tussen 0-1023 #define MotorRichtingR 2 // Output digitaal 0 of 1 #define TriggerPingL 14 // Output digitaal 0 of 1 #define EchoPingL 12 // Input digitaal 0 of 1 #define TriggerPingR 13 // Output digitaal 0 of 1 #define EchoPingR 15 // Input digitaal 0 of 1 void setup() { pinMode(MotorSnelheidL, OUTPUT); // de pinnen definieren als in of output pinMode(MotorSnelheidR, OUTPUT); pinMode(MotorRichtingL, OUTPUT); pinMode(MotorRichtingR, OUTPUT); pinMode(TriggerPingL, OUTPUT); pinMode(EchoPingL, INPUT); pinMode(TriggerPingR, OUTPUT); pinMode(EchoPingR, INPUT); digitalWrite(MotorRichtingL, HIGH); // Motor Richting instellen. digitalWrite(MotorRichtingR, HIGH); // Blijft ongewijzigd tijdens deze test. // Laten we HIGH als voor uit aansluiten // Gaat de robot achteruit tijdens de test beide polen // omkeren } // einde setup() void loop() { // De Robot zal als het goed is langzaam gaan rijden ( steeds sneller ) // Daarna langzaam afremmen // CONTROLE : De robot moet recht vooruit rijden, is dit niet het geval de // draden van de aansluiting van de betreffende motor omwisselen // Rechtsom - > Rechts omwisselen -> Motor aansluiting B + en min om-wisselen // Linksom - > Links omwisselen -> Motor aansluiting A + en min om-wisselen // Achteruit in plaats van vooruit beide omdraaien for (int i=0; i<=1023 ; i++) // Snelheid motor van laag naar hoog { analogWrite(MotorSnelheidL, i); analogWrite(MotorSnelheidR, i); delay (1); } for (int i=1023; i>=0 ; i-- ) // Snelheid motor van hoog naar laag { analogWrite(MotorSnelheidL, i); analogWrite(MotorSnelheidR, i); delay (1); } } // einde loop()
Stap 6
De Ping Sensoren testen
Om te controleren of de sensoren de afstand goed kunnen meten kan het volgende test programma gebruikt worden.
We gaan in dit programma ook gebruik maken van de seriële monitor, Met deze tool kan je binnen arduino gegevens tussen je processorbord en je pc uitwisselen. Bijvoorbeeld om te controleren of je programma goed loopt. Let hierbij op dat de uitwisseling snelheid van je bord en arduino ide gelijk zijn , in dit geval 9600. Bij dit test programma lezen we de linker en de rechter sensor uit en “printen” de waardes naar de seriële monitor.
Deze monitor kan dan dus de waardes op je pc/laptop tonen ter controle of alles naar wens werkt.
Hou een blad voor de sensor en bekijk hoe de waarden veranderen als je hem verder af houd of dichter bij brengt.
Vraag je zelf af, wat zijn nuttige waarden om te meten. En welke waarden ga ik niets mee doen.
* Zijn alle waarden ook bruikbaar ? ( zo niet welke niet )
* Zijn alle waarden juist ?
Als je de bovenstaande vragen beantwoord , zie je dat je niet altijd alle waarden die uit een sensor kan gebruiken.
En dat het verstandig is dat je een filter toepast, om deze waarden beter te gebruiken.
Voorbeelden hiervan zijn:
* bepaal het gebied waar in je meet b.v. tussen 3 en 30 cm ( alles daar buiten is bijna niet bruikbaar )
* bepaal het gemiddelde van een aantal metingen , zodat uitschieters er niet voor zorgen dat je robot agressief gaat reagreren op meetwaarden
// Programma om de Aansluiting van de Ping Sensoren te testen // In het volgende blok kunnen we zien dat de numering van de inputs en outputs van het ESP-Bord // anders genummerd zijn dan op een standaard Arduino // gebruiken we de poortnummers vab arduino dan zien we de bijbehoordende D nummers van het ESP-Bord // Daar achter staan weer waarvoor wij de poorten gaan gebruiken // A = linkerkant van robot B = rechter kant //static const uint8_t D0 = 16; // Led Op de Print - Vrij als I/0 te gebruiken //static const uint8_t D1 = 5; // Motor Uitvoer Snelheid A //static const uint8_t D2 = 4; // Motor Uitvoer Snelheid B //static const uint8_t D3 = 0; // Motor Uitvoer Voor/Achter A+ //static const uint8_t D4 = 2; // Motor Uitvoer Voor/Achter B+ //static const uint8_t D5 = 14; // Ping Sensor 1 Trigger A //static const uint8_t D6 = 12; // Ping Sensor 1 Echo A //static const uint8_t D7 = 13; // Ping Sensor 2 Trigger B //static const uint8_t D8 = 15; // Ping Sensor 2 Echo B //static const uint8_t D9 = 3; // vrij te gebruiken //static const uint8_t D10 = 1; // vrij te gebruiken // handig is om namen te definieren voor de i/o poorten daar is de code overzichtelijker // in plaats van nummers namen gebruiken in de code #define MotorSnelheidL 5 // Output analoog waarde tussen 0-1023 #define MotorRichtingL 0 // Output digitaal 0 of 1 #define MotorSnelheidR 4 // Output analoog waarde tussen 0-1023 #define MotorRichtingR 2 // Output digitaal 0 of 1 #define TriggerPingL 14 // Output digitaal 0 of 1 #define EchoPingL 12 // Input digitaal 0 of 1 #define TriggerPingR 13 // Output digitaal 0 of 1 #define EchoPingR 15 // Input digitaal 0 of 1 long TijdsDuurL; // variabelen met comma voor linker sensor long TijdsDuurR; // variabelen met comma voor rechter sensor int cmL; // variabele afstand zonder comma ( afgeronde waarde ) int cmR; // variabele afstand zonder comma ( afgeronde waarde ) void setup() { Serial.begin(9600); // snelheid van de communicatie pinMode(MotorSnelheidL, OUTPUT); // de pinnen definieren als in of output pinMode(MotorSnelheidR, OUTPUT); pinMode(MotorRichtingL, OUTPUT); pinMode(MotorRichtingR, OUTPUT); pinMode(TriggerPingL, OUTPUT); pinMode(EchoPingL, INPUT); pinMode(TriggerPingR, OUTPUT); pinMode(EchoPingR, INPUT); digitalWrite(MotorRichtingL, HIGH); // Motor Richting instellen. digitalWrite(MotorRichtingR, HIGH); // Blijft ongewijzigd tijdens deze test. // Laten we HIGH als voor uit aansluiten // Gaat de robot achteruit tijdens de test beide polen // omkeren analogWrite(MotorSnelheidL, 0); // Zet de motors still analogWrite(MotorSnelheidR, 0); // bij testen Ping sensor } // einde setup() void loop() { digitalWrite(TriggerPingL, LOW); // ook dit is om de sensor even'schoon'te maken, delayMicroseconds(2); // gedurende 2 microseconden. digitalWrite(TriggerPingL, HIGH); // Hier sturen we het ultrasoon signaal , delayMicroseconds(5); // gedurende 5 microseconden. digitalWrite(TriggerPingL, LOW); TijdsDuurL = pulseIn(EchoPingL, HIGH); // Meten hoelang het toontje onderweg is. cmL = (TijdsDuurL / 58); // en rekenen die tijdsduur om in cm. delay(10); digitalWrite(TriggerPingR, LOW); // ook dit is om de sensor even'schoon'te maken, delayMicroseconds(2); // gedurende 2 microseconden. digitalWrite(TriggerPingR, HIGH); // Hier sturen we het ultrasoon signaal , delayMicroseconds(5); // gedurende 5 microseconden. digitalWrite(TriggerPingR, LOW); TijdsDuurR = pulseIn(EchoPingR,HIGH);// Meten hoelang het toontje onderweg is. cmR = (TijdsDuurR / 58); // en rekenen die tijdsduur om in cm. delay(10); Serial.print(" Afstand sensor Links: "); // afdrukken naar de serieele poort Serial.print(cmL); // dit kan je uitlezen via de pc Serial.print(" cm"); // met bijvoorbeeld de serieele monitor van arduino Serial.print(" - Afstand sensor Rechts: "); // let op dat ook de monitor in de zelfde snelheid staat Serial.print(cmR); // in dit geval ook op 9600 Serial.println(" cm"); // println gaat naar de volgende regel ( delay(10); } // einde loop()