CARduino

Carduino Voorbladafbeelding

Inleiding

Anno 2013 is het bijna al de gewoonste zaak van de wereld geworden, robots die zelfstandig hun weg kunnen vinden in omgevingen waar menig mens noch dier een touw aan vast zou kunnen knopen. Denk bijvoorbeeld aan de Curiosity die op de onherbergzame vlaktes van de planeet Mars zich geheel zelfstandig van a naar b weet te verplaatsen. Dat zo'n marsrover voortkomt uit jaren vol zware beproevingen voor de knapste koppen van NASA zal niemand verbazen gezien het schijnbare gemak waarmee de rover geheel zelfstandig de moeilijkste handelingen verricht. Maar wat minder voor de hand ligt is dat als je alle toeters en bellen van zo'n rover afhaalt je eigenlijk een redelijk simpel concept overhoudt.

MarsroverPijlCarDuino concept

Op het internet zijn er al meerdere voorbeelden te vinden van mensen die zelf met geïmproviseerde onderdelen kleine 'rovers' hebben gemaakt, en zo zijn ook wij door het rechter plaatje op het idee gekomen om zelf een robot te bouwen.

Maar een robot bouw je niet zomaar, zeker niet als je zelf een computerchip moet maken. Al vrij snel kwamen we er achter dat dergelijke computerchips gewoon te koop zijn op het internet. Zo kwamen wij op het spoor van de Arduino microcontroller. Arduino’s gelden als goed instappunt voor robotica, en je kan Arduino-projecten, door de vele mogelijkheden van de chip, zo moeilijk maken als je zelf wil.

Uiteindelijk zijn we aan ons project begonnen met als doel een Arduino computerchip zo te programmeren dat deze zelfstandig een klein autootje kan besturen. Het is de bedoeling dat deze robot zelfstandig de obstakels die hij onderweg tegenkomt weet te omzeilen met behulp van een sensor waarmee hij deze obstakels moet detecteren.


Theoretische achtergrond

De code waarin je gaat schrijven als je Arduino gaat programmeren is een variatie van de bestaande codetalen C en C++. Om onze uiteindelijke code te kunnen begrijpen is hier een uitleg van de belangrijkste begrippen. Aan de hand van deze begrippen en de aantekeningen aan de zijkant van de code zou een leek in programmeren onze redenatie in de code moeten volgen. Eerst volgt een snelle uitleg over de opbouw van een code.

Code:

 

/*

Blink

Lichtje brandt voor een seconde, lichtje isuit voor een seconde en dit herhaalt zich.

Dit is de eerste code die je leert begrijpen.

*/

 

// Geef de led een naam: je koppelt de led aan een pin op je Arduino board. Je kunt nu het woord led gebruiken in je code. Zou je dit niet doen dan moet je overal in je code het getal 13 gebruiken.

int led = 13;

 

//void setup wordt niet herhaald. Als de code wordt geüpload voert de Arduino slechts eenmaal deze commando’s uit. Dit gebeurt ook als je Arduino wordt gereset.

void setup()

{

pinMode(led,OUTPUT);

//geeft aan dat de led een output is, dat wil zeggen dat je er signalen naar toe stuurt en dat er niet gereageerd mag worden op signalen die er vanaf komen.

 

 

} // De haakjes geven aan dat binnen de haakjes de code staat die uitgevoerd moet worden.

 

 

// the loop routine wordt in tegenstelling tot de setup wel keer op keer herhaald.

void loop()

In bovenstaande code staat met ‘//’ (twee schuine streepjes) een aantekening weergegeven. Deze staat hier in een andere kleur om duidelijk te maken wat code is en wat niet. Als men een echte code zou krijgen geven de aantekeningen veel handige informatie over wat welke regel doet en op deze manier kan men de denkstappen van de programmeur volgen. In deze code hebben we een paar begrippen al uitgelegd, maar dit voorbeeld was vooral om de algemene opbouw van een code te laten zien. 

Het begin

Om te beginnen met code schrijven, leer je eerst hoe een code eruit moet zien. Bij de Arduino gebruik je altijd de volgende volgorde (ook te zien in de voorbeeldcode op pagina 4): eventueel extra informatie bovenaan, setup en daarna loop. Je kunt ook nog extra functies toevoegen, dit wordt onder het kopje “Overig” op pagina 7 verder uitgelegd.

Je begint met het hernoemen van je pins (ingangen op je Arduino board) van een nummer naar een naam of functie, in dit geval dus led. Dit doe je met int. Int of voluit integer gebruik je om variabelen te declareren van het type int. In ons stuk boven de setup hebben wij twee soorten variabelen. De ene is wat de naam doet vermoeden, een variabele die verandert, omdat hij in ons geval gemeten wordt. Bij ons zijn dat dan ook de variabelen cm, Leftcm, Rightcm. De andere soort variabele is een zogenaamde constante. Dat zijn variabelen die constant hetzelfde blijven en dus nooit van waarde veranderen. Bij ons zijn dat Forward, Backward, Right en Left. Alle variabelen moeten gedeclareerd worden voordat ze opgeroepen kunnen worden in het programma. De variabelen die wij declareren in onze code zijn vaste variabelen, ook wel globale variabelen. Deze globale variabelen moeten voor de setup worden ingevoerd. Anders werken ze als lokale variabelen en werken ze alleen binnen hun functie. Deze lokale variabelen worden ook wel tijdelijke variabelen genoemd.

 

In het stuk van de code boven de setup voeg je ook libraries toe. Deze “bibliotheken” voegen een voorgeprogrammeerde code toe die met bepaalde commando’s kan worden gebruikt. 

Een voorbeeld hiervan is een servo, een kleine motor die 180 graden kan draaien. Met een servo library kun je veel makkelijker de servo naar een bepaald aantal graden laten draaien. Zonder servo library zal jij zelf moeten timen hoe lang je een elektrisch signaal moet sturen om een draaibeweging van een bepaald aantal graden te verwezenlijken. Om een library toe te voegen aan je code gebruik je het commando #include (=toevoegen). De vertaling geeft een duidelijk idee wat dit commando doet. Dit commando wordt alleen gebruikt om libraries toe te voegen. 

Setup

In je setup zet je de dingen die slechts een keer aangegeven hoeven te worden, deze worden ook maar 1 keer uitgevoerd. Zoals een bepaalde pin als input of output aangeven. Dit doe je met pinMode. Hierdoor kan men of signalen ergens naar toe zenden (output) of signalen van deze pin ontvangen (input). Bij output kun je denken aan een pin die stroom geeft om een led te laten branden. En bij een input kun je denken aan een pin die een signaal dat hij van buiten (bijvoorbeeld een knopje) krijgt en aan de Arduino doorgeeft. 

 

Ook serial commando’s komen voor in de setup. Het serial commando gebruik je voor communicatie tussen de Arduino en de computer. Als je in het programma zit waar je de code schrijft, kun je een scherm op je computer openen, waarmee je waarden af kan lezen. Hierdoor kun je bijvoorbeeld kijken hoeveel cm je sensor afleest of je kunt je Arduino als rekenmachine gebruiken en de antwoorden op je computerscherm laten verschijnen. 

In onze code hebben we het vooral gebruikt om te kijken of alles goed werkte. Door de seriële verbinding met de computer te maken, konden we kijken of de sensor goed draaide met de servo als je te dicht bij kwam. Ook konden we de verbinding gebruiken om de auto te testen. 

In een oudere code hadden we namelijk de auto uitgezet, maar een serial.print met de tekst ‘auto naar rechts’ als hij de Rightturn had uitgevoerd en ‘auto naar links’ als hij de Leftturn had uitgevoerd, hierdoor konden we zien of de code vloeiend werkte. 

In de setup gebruik je eigenlijk alleen ‘Serial.begin(getal)’. Dit vertelt de Arduino een verbinding te beginnen met je computer. Het getal tussen haakjes (zie bijlage voor voorbeelden) is de snelheid van deze “praat”verbinding met je computer. Dit getal is in de eenheid baud (bits per seconde).

 

In het setup gedeelte koppel je ook de servo aan een bepaalde pin. Dit gebeurt met het commando servo.attach(nummer van de pin).

Loop

Hier staat meestal de grootste hoeveelheid tekst en zie je ook de meeste commando’s. De loop wordt meestal oneindig vaak doorlopen. Daarom heeft het hier veel meer nut dan in de setup om het commando delay te gebruiken. De loop wordt pas uitgevoerd nadat de setup is doorlopen.

 

De commando’s digitalWrite en digitalRead worden gebruikt afhankelijk van het soort pin waar zij bij horen (input of output). ‘DigitalWrite’ zend een signaal en hoort dus bij de output en digitalRead leest een signaal af en hoort dus bij input. 

 

In het loop gedeelte kan men met het serial commando de Arduino opdragen stukken tekst naar je computer te sturen, dit kan ook in een willekeurige andere functie. Het serial commando is dan ‘Serial.print’ of ‘Serial.println’. De ln staat voor line oftewel regel, hiermee sluit je één regel af en zorg je dat de volgende Serial.print op een andere regel is. De ‘Serial.print’ is alleen handig als de Arduino aan je computer gekoppeld zit anders heeft dit commando geen nut. Maar als de Arduino wel aan je computer verbonden is kan je met de ‘Serial.print’ testen of je sensor goed werkt of je kunt een soort rekenmachine maken(zie bijlage).

 

In de loop wordt ook veel gebruik gemaakt van het if statement. Het commando hiervoor is ‘if’ . Met een if statement kan men voorwaardes (als, dan) stellen waaraan voldaan moet worden voordat een bepaalde handeling uitgevoerd wordt. Hierin kan men ook het ‘while’ statement gebruiken. Tijdens die handeling moet aan de achter de while gestelde voorwaarde voldaan worden. Wordt er niet aan die waarden voldaan, dan stopt de handeling. Het verschil tussen de twee is dat bij het if statement van tevoren aan de waarden voldaan moet worden en daarna niet meer, maar bij het while statement moet er constant aan de voorwaarden voldaan worden. Aan het einde van je if statement kan je ook een ‘else’ invoeren, voor het geval dat er niet aan de if voorwaarden voldaan wordt. Wat er dus achter else staat wordt uitgevoerd als er niet aan de if voorwaarden is voldaan. Bij onze code is het noodzakelijk dat er een else staat, maar er kan ook voor gekozen worden deze niet toe te voegen en dan doet de Arduino gewoon niks.

 

Het ‘do’ commando komt ook voor in de loop en is ook vrij makkelijk te begrijpen. Het ‘do’ commando zit geïntegreerd in je ‘while’ statement.

Het vertelt de Arduino simpelweg te doen wat je achter het ‘do’ commando hebt getypt, bijvoorbeeld do standardscan(). 

Overig

Als men een grote code moet schrijven en de loop overzichtelijk wil houden, kan er voor gekozen worden om voor elk stuk code dat veel herhaald wordt of erg lang is, een aparte functie te schrijven. Dit zou je kunnen doen omdat de loop het meest ingewikkelde stukje programma is. Hier moet alles goed op elkaar aansluiten om de code goed te laten werken. En omdat het bij programmeren heel nauw komt kijken wat betreft details: een simpele puntkomma of dubbele haakjes vergeten maakt je code onwerkzaam. 

 

Hierom hebben wij er ook voor gekozen deze extra functies te gebruiken. Eigenlijk geeft je een stukje code een naam, bijvoorbeeld standardscan. In plaats van de hele serie commando’s van standardscan op te schrijven op elke plaats in de code waar een standardscan uitgevoerd moet worden, geef je de commando’s die samen standardscan vormen een naam en dat noem je dan een functie. In dit geval standardscan maar dit zou ook taart of stoel kunnen zijn. Vervolgens zet je void plus deze naam (standardscan) gevolgd door () (dubbele haakjes) in je loop, dus: void standardscan(). En dan heet het pas officieel een functie. Hierdoor hoef je de standardscan commando’s slechts 1 keer op te schrijven.

Je kunt nu deze functie overal in je code aanroepen. 

 

We hebben het telkens over loop en setup terwijl in de code toch echt void loop en void setup staat. Je gebruikt void alleen voor een functie. Daarom staat het ook bij bijvoorbeeld void standardscan. Wat void precies doet is er voor zorgen dat de functie geen waarde teruggeeft. Dat betekent dat die specifieke functie geen invloed heeft op andere functies. 

Let op: dit betekent niet dat variabelen niet meer gebruikt kunnen worden! De variabelen staan voor de void setup gedeclareerd en kunnen daarom in alle functies gebruikt worden en kunnen op deze manier toch verschillende functies op elkaar in laten spelen. Bijvoorbeeld met de Leftcm en Rightcm die gemeten worden in respectievelijk Leftscan en Rightscan en daarna via de variabelen informatie doorgeven aan de loop, terwijl voor alle functies void staat. 

 

Bij het berekenen van de afstand door de sensor staat: 

cm= uS / US_ROUNDTRIP_CM. Dit kan zo geschreven worden door de informatie die is toegevoegd aan de code met de sensorlibrary. We hebben besloten voor deze manier te kiezen, omdat dit de kortste manier is om de Arduino de afstand te laten berekenen, die gemeten wordt door de sensor, ondanks dat je hieruit weinig kan aflezen. Wat er ook had kunnen staan is: 

cm = (uS/10^6/2 )* (vgeluid * 100). Wat gewoon een uitgewerkte vorm is van 

x = v * t . cm = x, t = microseconden/10^6/2 en v = vgeluid * 100. Het aantal microseconden (uS) wordt gedeeld door een miljoen omdat je dan de tijd in seconden krijgt en hij wordt dan nog door 2 gedeeld omdat de sensor een geluidspuls uitzendt en de echo hiervan weer ontvangt. Dat betekent dat er 2 keer de afstand is afgelegd en daarom deel je dus door 2. Je vermenigvuldigt de geluidssnelheid met 100 om de geluidssnelheid van m/s naar cm/s om te zetten.   

 


Werkplan

Voor ons profielwerkstuk hadden we allereerst een microcontroller nodig. Bij ons is dit de Arduino Uno Rev 3 geworden. Je hebt om de Arduino Uno met de computer te verbinden een USB A to B kabel nodig.

Daarnaast hadden we een starter kit besteld met hierin een aantal weerstanden, lampjes, draden, een schakelbord, een servo en verschillende knoppen. Deze waren heel handig voor het tutorial over het programmeren die we gevolgd hebben, maar voor de robot hebben wij de helft niet echt gebruikt.

We hebben een multimeter gekocht om voltages, ampères en weerstanden te kunnen meten. Zo’n multimeter werd aangeraden op het internet, maar we hebben hem uiteindelijk nauwelijks gebruikt.

Bedrading gemonteerd op CarDuino

Als onderstel hebben wij een radiografisch bestuurbaar autootje gebruikt dat verkrijgbaar is bij de Intertoys, omdat dat een goedkopere en uitdagendere variant is op de voorgefabriceerde karretjes die je op het internet kan bestellen.

Verder hebben we een SRF04 ultrasone sensor gebruikt voor het detecteren van obstakels.

Voor stroomtoevoer aan de computer kan men gewoon de USB kabel gebruiken, maar omdat we hem ook los van de computer wilden zien rijden hebben we een universele adapter gekocht en een 9V batterij snap, die ervoor zorgt dat we de Arduino met een batterij van spanning kunnen voorzien.

Ook hebben we wat hout gebruikt als standaard om de sensor op te monteren en deze standaard vervolgens aan de servo te verbinden.

Als laatste hebben we soldeer, tape, schroeven, spijkers en ijzerdraad gebruikt om dingen vast te zetten.

Wat gereedschap betreft hebben we een soldeerbout, een schroevendraaier, een tang, een kniptang, een hamer en een zaag gebruikt.

 

Hieronder een schematische tekening van onze elektrische opstelling:

 

Om een robot gestuurde auto te maken die zelf door een kamer kon rijden en objecten kon ontwijken hadden we eerst een cursus programmeren nodig, want wij zouden deze code zelf gaan schrijven en waren allebei nog beginners op het gebied van programmeren. Dus besloten we als eerst een cursus te doen op het internet om de basis onder de knie te krijgen.

De eerste les ging over de “Blink” (een simpele opstelling waar je de Arduino periodiek een lampje laat aan en uitzetten). Daarna kwamen de velen begrippen die wij bij de theoretische achtergrond hebben uitgelegd. De derde les ging over het maken van schakelingen met het schakelbord en weerstanden. In les vier leerden we alles wat je met ‘Serial’ commando’s (zie theoretische achtergrond) kan doen. Ook schreven we in deze les onze eerste code: “Hello World!”. Deze code doet niets anders dan herhaaldelijk de Arduino op te dragen de woorden “Hello World” naar de computer te sturen. Verder leer je in deze les om van je Arduino een rekenmachine te maken en kun je de Arduino de stelling van Pythagoras laten gebruiken. 

Hierna, nog steeds in dezelfde les, ga je rekenen met geheugen, oftewel met kilobytes, megabytes, gigabytes en gewoon bytes (zie bijlage). 

De laatste les ben je bezig met schakelaars en knopjes. 

 

Hierna leerden we met het if statement werken en gingen hier diep op in, omdat het if statement een van je belangrijkste commando’s is bij het programmeren. Hierna was de cursus voorbij en hadden we voldoende kennis van het programmeren om zelf onze robot van code te kunnen voorzien. 

 

Toen begon de ideeënfase voor het bouwen. De servo was er al dus eerst leerden we met deze te werken. Daarnaast waren we bezig met ideeën voor het onderstel. Een onderstel kopen was te duur dus toen kwam het op onze doe het zelf vaardigheden aan. Later kwamen we erachter dat het slimmer was om gewoon een radiografisch bestuurbare auto om te bouwen, dus vonden we een oud exemplaar dat niet meer zo goed werkte en gingen hiermee experimenteren. We schroefden het autootje uit elkaar en met een zelfgemaakte accu gingen we spanning op verschillende plaatsen van de printplaat zetten, op zoek naar de knopjes die voor de besturing zorgen.  

Printplaat 'knopjes'

 Nadat we hier bezig mee waren geweest, gingen we aan de slag met een nog wel werkende auto. Hier maakten we echter de fout om de printplaat eruit te halen en daar kwam nog bovenop dat hij niet goed stuurde.

 

Gekozen RF auto

We moesten dus op zoek naar een ander onderstel. We besloten meer onderzoek te doen en toen vonden we de site matsimitsu.com (volledige link staat in de bronnen) waar een bepaald type radiografisch bestuurbare auto werd aangeraden. Uiteindelijk hebben we inderdaad zo’n autootje gebruikt.

 

Hierna hadden we geregeld dat we bij het bedrijf Voltium mochten werken aan een van hun werkbanken en gebruik mochten maken van hun gereedschap en kennis. De eerste dag dat we hier waren hebben we vooral gesoldeerd aan de printplaat van de auto en hebben we de auto aangepast door er stukken vanaf te schroeven en weg te zagen.

 

De tweede keer dat we er kwamen was het om kapotte draden te repareren en hebben we de auto weer in elkaar gezet met de printplaat in een andere positie en deze goed vastgezet met tape. Ook hebben we toen het schakelbord achterop vastgezet. Bij Voltium hebben we ook advies gekregen over de keuze van een sensor. Ze zeiden dat het aan te raden was een ultrasone sensor of een infrarood sensor te nemen. Uiteindelijk hebben we gekozen voor de ultrasone sensor omdat deze makkelijker verkrijgbaar was en we aantal modellen wisten die zeker zouden werken met de Arduino. We hebben uiteindelijk een SRF04 sensor besteld.

 

Toen hebben we een thuisklusdag ingelast. We hebben allerlei houders gezaagd voor de sensor en verschillende stellages om de houder met de servo te verbinden. Het uiteindelijke resultaat is redelijk simpel maar wel effectief en sterk. Ook hebben we toen de servo op de auto gemonteerd en bepaalde stukken van de auto opnieuw vastgezet. 

 Sensormontage op autoSensorhouderSensor vooraanzicht

Hierna zijn we nog een laatste keer bij Voltium geweest om twee zelfgemaakte accu’s van 6V te maken. Ook hebben we hier nog een laatste reparatie gedaan omdat een draadje van de printplaat was afgebroken. Dit was echter makkelijk te verhelpen.

Later ’s avonds braken nog 2 draden af, maar in plaats van een ramp bleek dit eerder een redding, we hadden namelijk de eerste keer een draad op een verkeerde knop van de printplaat gesoldeerd. Voltium was helaas al dicht dus hebben we thuis ’s avonds het nog even gesoldeerd met eigen soldeerbout. 

 

De dag hierna was de grote programmeerdag. Op internet hadden we een library gevonden voor de sensor en nadat we de sensor getest hadden, moesten we code gaan samenvoegen. Eerst schreven we in aparte programma’s losse stukken en testten deze, daarna voegden we ze toe aan de grote code. Dus eerst programmeerden we de sensor los, daarna voegde we deze code samen met servo code. Daarna voegde we dit weer aan iets groters toe en zo door totdat de code af was.

 

Het schrijven van de code die dient voor de besturing van de wielen was niet zo moeilijk: dat is bijna geheel te doen met digitalWrite, waarmee we 5 Volt op het corresponderende knopje zetten. Het moeilijkste is alles op elkaar laten inspelen. 

 

Aan het eind van de dag was de code af, maar hij werkte niet. Hoe hard we die avond ook zochten, de fout konden we niet ontdekken. Ook de volgende ochtend lukte het ons niet direct de fout op te sporen. Net voordat we hulp wilden gaan vragen op een forum, bleek dat we vergeten waren ergens dubbele haken achter te zetten. Dit soort fouten horen door een correctie programma gemarkeerd te worden, maar door onbekende redenen bleef ook deze fout verborgen voor de ‘compiler’. Nadat we deze haken hadden toegevoegd hebben we het nog een keer getest, en toen bleek de code te werken. 

 

Toen hebben we de Arduino vast gezet met ijzerdraad, er een 9V batterij aan gekoppeld en laten rijden. De rest van de dag zijn we bezig geweest met testen en finetunen op het gebied van afstandsdetectie en remtijd. Dit hebben we gedaan aan de hand van ‘trial and error’. We lieten de Arduino door de kamer rijden en als een probleem zich voordeed (klemrijden e.d.), losten we dit op door de code aan te passen.  Ook het patroon voor de bocht nemen is meerdere malen aangepast en uiteindelijk reed de Arduino feilloos door de kamer.

Uiteindelijke programmacodeUiteindelijke programmacodeUiteindelijke programmacode


Meetresultaten

Aangezien wij zelf niet actief hebben gemeten, komen hier de testresultaten. 

Ten eerste zijn wij bezig geweest met het testen van de sensor. De sensor zendt een geluidsgolf en ontvangt vervolgens de echo hiervan en hij noteert de tijd dat dit duurde. Deze tijd kan omgerekend worden naar afstand met een simpele regel, die gevonden kan worden in onze uiteindelijke code (zie Werkplan). Vervolgens kan men die berekende afstand gebruiken in de code. Wij hebben uiteindelijk gekozen om de "activeringsafstand", dat wil zeggen de maximale afstand tot een obstakel voordat de Arduino gaat remmen en draaien, in te stellen op 35cm. We zijn op deze afstand gekomen door gewoon de auto neer te zetten en hem te laten rijden. Als je dit in verschillende scenario's doet, met verschillende omgevingen wat betreft het aantal obstakels dat de robot onderweg tegenkomt, dan vindt men vanzelf een soort gulden middenweg. 

 

Maar voordat de auto kan rijden, moet de code wel kloppen en omdat programmeren, zoals eerder verteld, heel erg om de details gaat, is één verkeerd teken al genoeg om de code onwerkzaam te maken. En natuurlijk gebeurde het ook bij ons. Het waren maar 2 haakjes en toch deed de code het al niet meer. 

 

Ook ondervonden we een probleem bij het minimaliseren van de remweg van de robot, wat met de afstanddetectie te maken heeft. Want toen we net dachten dat de code goed in elkaar zat, deden we de volle snelheidstest en knalde de auto tegen de muur. Dus terug naar de computer om alle waarden aan te passen. Grotere "activeringsafstand" en langere delay in het stukje void carstop() , zodat de auto langer zou remmen.

We testen het nog een keer, de auto knalt weer vol tegen de muur. Na nog een keer proberen valt het op dat de auto tegen de muur aanrijdt en dan nog een stukje achteruit rijdt terwijl het de bedoeling is dat hij alleen remt. Dus in de gang testen waar geen parket ligt maar een stoffen mat. We proberen de oude instellingen en hij werkt perfect. Conclusie: auto heeft niet zo veel grip. 

 

We hebben ook aardig wat moeten testen met de bochten maken. Eerst hadden we een code geschreven die zorgde dat de auto ongeveer 90 graden draaide als hij een object had gedetecteerd. In de praktijk bleek dit niet zo handig, omdat hij hierdoor soms veel te ver door draaide als hij halverwege langs een nieuw obstakel draaide. Als dat gebeurt begint hij opnieuw met 90 graden te draaien. Dus toen moesten we de ‘rightturn()’ en de ‘leftturn()’ herschrijven. Hiervoor de juiste code te schrijven nam ook weer een paar testen in beslag en uiteindelijk hebben we er voor gekozen om de auto achteruit de bocht te laten beginnen, omdat de robot op die manier meer ruimte heeft om te draaien. 


Conclusie 

De code die we hebben geschreven werkt en na verscheidene testen reed onze CARduino feilloos door de kamer. 

Het doel van de proef is wat ons betreft behaald, omdat hij ook werkelijk door de kamer rijdt en nergens tegen opbotst, mits de auto goede grip heeft. Tevens wordt hij door de Arduino bestuurd en niet door ons. 

 

Onze verwachtingen klopten grotendeels, want we hebben veel moeite moeten doen om het programmeren onder de knie te krijgen. Gelukkig ging het een stuk beter toen we de basis kenden. Hierna konden wij zelf ook makkelijke en moeilijke codes van elkaar onderscheiden, terwijl eerst alle codes nog moeite kostten om volledig te begrijpen. 

 

Het bouwen viel meer tegen dan we hadden verwacht. Hierin hadden we verschillende tegenslagen zoals het loslaten van gesoldeerde bindingen, het breken van de stellage van onze sensor en het afbreken van draadjes. 

 

We hebben in totaal veel meer tegenslagen gehad dan verwacht, want behalve alle dingen hiervoor genoemd, was ook de USB kabel kapot gegaan. Hierdoor konden we meerdere keren niet doen wat we hadden willen doen. Het is ook erg jammer dat we er pas heel laat achter kwamen dat het ook echt de USB kabel was die gebroken was. Eerst dachten we namelijk dat het aan onze  servo lag: dat deze door een soort defect te veel stroom trok waardoor de Arduino uitviel. Toen dit niet bleek te kloppen verdachten wij de Arduino van een of ander defect, maar bij toeval kwamen wij er achter dat het aan de USB kabel lag. 

 

Toen dit eenmaal opgelost was duurde het niet lang voor we ons project konden afsluiten. Al met al zijn we erg blij met het resultaat en voldoet de CARduino aan al de eisen die we eraan gesteld hadden.

CARduino resultaat


Meet-onnauwkeurigheid 

Ondanks dat meten bepaald niet centraal staat in ons profielwerkstuk, zouden we te hard van stapel lopen als we zouden zeggen dat er helemaal niet in gemeten is. Dus kunnen we er ook niet van uit gaan dat er geen meetfouten zijn gemaakt. 

 

De meest invloedrijke meetfout is tot stand gekomen doordat onze servo nooit helemaal naar voren kijkt, hij heeft een afwijking van ongeveer 10 graden, dit komt doordat de servo niet precies genoeg gemonteerd is, waardoor uiteindelijk de sensor nooit helemaal in de richting kijkt waarheen de auto ook werkelijk rijdt.

Dit probleem had verholpen kunnen worden als we meer aandacht hadden geschonken aan het gebruiken van rechte hoeken, of als we een ander onderstel hadden gebruikt waar makkelijker andere onderdelen op gemonteerd kunnen worden.

 

Een andere constante meetfout ontstaat doordat wij onze robot met geïmproviseerde materialen hebben gemaakt. Omdat wij ervoor hebben gekozen om niet alle onderdelen van onze robot voorgefabriceerd te kopen, waren wij gedwongen om sommige onderdelen zelf te maken. Denk bijvoorbeeld aan het aanhechtpunt van de servo en de houder van de sensor die wij zelf met hout hebben gemaakt. Een nadeel hiervan is dat de onderdelen niet altijd goed recht op elkaar zitten, waardoor de sensor niet helemaal waterpas is. Dit heeft natuurlijk een negatief effect op de verkregen meetwaarden. En hiervan zijn nog meer voorbeelden.

Om deze meetfout te voorkomen hadden wij wel voorgefabriceerde onderdelen kunnen gebruiken, die beter op elkaar aansluiten waardoor er een stabielere en rechtere constructie ontstaat. Ook hadden wij meer tijd en aandacht kunnen besteden aan het maken van onze eigen onderdelen door bijvoorbeeld beter gereedschap aan te schaffen.

 

Ook had onze radiografisch bestuurbare auto, die wij als onderstel hebben gebruikt, al bij de aankoop last van een zeker stuurafwijking. De auto heeft namelijk een lichte afwijking naar links en als we deze proberen te verhelpen schieten we door en ontstaat er een afwijking naar rechts. Dit probleem had verholpen kunnen worden als wij een duurdere radiografisch bestuurbare auto hadden gekocht.

 

De laatste waarneembare meetfout wordt ook veroorzaakt door de radiografisch bestuurbare auto. De auto was nooit bedoeld om abrupt te remmen en van richting te veranderen aangezien de banden weinig grip hebben op de ondergrond, hierdoor kan onze robot op bijvoorbeeld parket nooit geheel tot stilstand komen voordat hij begint met scannen. Soms is het zelfs zo erg dat hij tegen een muur aanknalt als hij met de maximale snelheid aankomt.

Ook dit probleem had verholpen kunnen worden als wij een duurdere radiografisch bestuurbare auto hadden gekocht.

 


 Bronnen

www.reddit.com/r/robotics

www.reddit.com/r/Arduino

www.reddit.com/user/littlefield20

floris.cc

www.ladyada.net/learn/arduino

arduino.cc/en/tutorial

arduino.cc/en/reference

arduino.cc/en/Main/ArduinoBoardUno

arduino.cc/forum

http://matsimitsu.com/blog/2011/05/21/control-an-rc-car-with-arduino.html

playground.arduino.cc

 

Tevens zijn wij langs geweest bij:

Voltium logo

Hoogvlietsekerkweg 124a

3194 AM Hoogvliet

www.voltium.nl

 

Wij hebben advies ontvangen omtrent de elektronica die toegepast is in ons project en wij mochten gebruik maken van hun wijde assortiment aan gereedschappen.


Bijlage 1: Oorspronkelijke codes

Code om met de sensor te oefenen en deze te testen

 

De ‘rekenmachine’; hier rekenen we met gigabytes, megabytes en kilobytes.

 

Een led disco

 

De eerste code die wij geschreven hebben

 


Bijlage 2:  Pakket van Eisen

Onze robot, gebouwd met de Arduino microcontroller, moet zelfstandig kunnen rijden en objecten ontwijken door middel van een ultrasone afstandssensor. We zullen hiervoor zelf de Arduino programmeren. We bouwen de robot zelf, maar als onderstel gaan we waarschijnlijk een radiografisch bestuurbare auto gebruiken, die we ombouwen zodat de Arduino hem autonoom zal besturen.

 

Om aan deze eisen te voldoen zullen we eerst het programmeren van de Arduino onder de knie moeten krijgen. Als we voldoende kennis wat betreft coderen hebben verkregen, zullen we aan de slag gaan met het maken van de robot zelf. Wij zullen een radiografisch bestuurbare auto ‘hacken’ en aanpassen zodat wij deze als onderstel voor onze robot kunnen gebruiken. De ultrasone afstandssensor zullen we op het internet bestellen samen met de servo, die als een soort nek (draaipunt) zal fungeren. De rest van de onderdelen zullen wij ook proberen zelf te maken. Als de robot af is zullen wij zelf de robot programmeren zodat hij precies alles kan wat in de bovenstaande alinea is beschreven.

 

Mogelijke obstakels onderweg zullen overwegend te maken hebben met de elektronica, denk bijvoorbeeld aan verkeerde schakelingen of brekende soldeerverbindingen. Deze problemen zijn echter vrij makkelijk te verhelpen/repareren.

Ook kunnen we fouten maken in de code, maar omdat dit geen blijvende schade aan de Arduino aanricht zullen ook deze problemen betrekkelijk eenvoudig te verhelpen zijn.

We zijn van plan alles samen te doen, omdat er bij ons project altijd meer dan genoeg te doen en nooit een overschot aan helpende handen is. We zullen proberen regelmatig samen te komen om zo op tijd ons project af te kunnen maken.


Bijlage 3: Logboek

Datum

Tijdsduur

Ondernomen activiteiten en behaalde resultaten

6 september 2012

15 min

Gesprek met Van Dijk over het kiezen van een onderwerp.

18 september 2012

5 uur

Zoeken op het internet naar mogelijke onderwerpen van ons profiel werkstuk. Gezocht naar bouwprojecten die ons ook leuk leken om te doen. En uiteindelijk hebben we een onderwerp gevonden.

23 september 2012

3,5 uur

Zoeken op het internet naar een winkel waar we een Arduino kunnen kopen. En uiteindelijk op floris.cc een Arduino UNO met aanvullende hardware gekocht.

30 september 2012

4 uur

De Arduino is binnengekomen, we hebben de Arduino en de hardware gecontroleerd op beschadigingen en hun functioneren getest door te experimenteren met bijgeleverde codes en het maken van kleine elektrische circuitjes. Alles werkt als het hoort.

2 oktober 2012

4 uur

Gezocht op het internet naar kleine cursussen (tutorials) voor het programmeren van een Arduino. Uiteindelijk een website gevonden www.ladyada.net/learn/Arduino. En we zijn direct begonnen met het door nemen van basisbegrippen.

8 oktober 2012

40 min

Presentatie over PWS natuurkunde bijgewoond.

11 oktober 2012

5 uur

Leren programmeren met de Arduino aan de hand van de tutorial. Aan het eind van de dag beheersen we de basis van het programmeren en hebben we al een aantal kleine programma’s geschreven en bijhorende elektrische circuits opgesteld.

13 oktober 2012

3 uur

We hebben een oude radiografisch bestuurbare auto open geschroefd en een beetje rond geneusd in de elektronica om te kijken of we het eventueel zouden kunnen gebruiken als onderstel voor onze robot. De auto bleek te veel slijtage te hebben om nog te kunnen gebruiken.

19 oktober 2012

4,5 uur

We hebben nog een andere oude radiografisch bestuurbare auto open geschroefd. Deze reed nog goed, maar het vermogen om te sturen was zo afgetakeld dat ook deze niet bruikbaar bleek te zijn. Tevens zijn we verder gegaan met de Arduino tutorial, waar we meer inzicht hebben gekregen in de signaalverwerking van de Arduino.

23 oktober 2012

3,5 uur

Afmaken van de Arduino tutorial, we hebben nu alle programmeer vaardigheden verworven die we nodig hebben om de robot te programmeren.

28 oktober 2012

3 uur

We hebben een begin gemaakt aan het programmeren van de robot door te experimenteren met de servo (klein motortje dat de sensor van de robot moet laten rondraaien). Al snel bleek dat de servo meer stroom trok dan de usb kabel kon geven, waardoor de Arduino uitviel.

12 december 2012

7 uur

We hebben op het internet gezocht naar wat voor soort radio grafische auto we makkelijk kunnen ombouwen om te gebruiken als onderstel. We hebben een website gevonden waar uitgelegd staat hoe je zo’n auto dan moet ‘hacken’. We zijn vervolgens naar een elektrotechnisch bedrijf gegaan waar we gebruik mochten maken van hun faciliteiten om de auto te hacken.

27 december 2012

4,5 uur

We zijn verder gegaan met het klaarmaken van het autootje. We hebben onderdelen verwijderd die in de weg staan, en met hout een staanplaats gemaakt voor de servo en de sensor.

28 december 2012

4 uur

We zijn terug gegaan naar het bedrijf om meerdere onderdelen van het karretje te repareren. Tevens hebben wij ons het hoofd gebroken over het probleem met de servo die te veel stroom trok.

29 december 2012

4 uur

We hebben ontdekt dat het probleem met de servo veroorzaakt werd doordat onze usb kabel, waarmee de Arduino stroom krijgt, kapot bleek te zijn. We hebben een nieuwe usb kabel gekocht.

30 december 2012

6 uur

De hardware van de robot afgemaakt, nu moet de Arduino alleen nog geprogrammeerd worden. Het onderstel, de servo en de sensor zijn gebruiksklaar.

2 januari 2013

4,5 uur

We zijn begonnen met het programmeren van de Arduino. We hebben een algemeen idee opgebouwd hoe de code eruit zal zien. We hebben vervolgens besloten om de code in kleinere stukjes te knippen om die later samen te voegen. Dit is om slordigheidfouten te voorkomen, en tevens is het makkelijker om fouten op te sporen.

3 januari 2013

10 uur

Eerst zijn we teruggegaan naar het bedrijf om daar van acht AA batterijen twee zes volt accu’s voor de servo te maken en een draad te repareren. Daarna zijn we verder gegaan met het schrijven van de code. ’s Avonds moesten we weer reparaties uitvoeren omdat twee draden los hadden gelaten van de printplaat. Daarna hebben we de code op een paar kleine foutjes na afgeschreven

4 januari 2013

8 uur

We hebben de code afgeschreven. Vervolgens konden we beginnen met het testen van de robot. Hij bleek op een paar kleine dingetjes na goed te werken. We hebben de code nog wat bijgeschaafd en uiteindelijk is de robot op deze dag afgemaakt.

5 januari 2013

7 uur

We zijn begonnen met het schrijven van het verslag. Theoretische achtergrond, werkplan, logboek, meetonnauwkeurigheid en bijlagen zijn grotendeels af.

6 januari 2013

 

8 uur

We hebben het concept versie van het verslag afgeschreven.

17 januari 2013

4 uur

Verbeteringspunten doorgevoerd en de uiteindelijke versie van het verslag afgemaakt.

Totaal: 103 uur en 25 minuten