Instructable

Hierin vind u de stappen die u moet volgen indien u ook deze line-follower wilt produceren.

 

Stap 1 : Bestel alle componenten die op de stukkenlijst aangegeven zijn. ( blog : stukkenlijst)

Stap 2 : Laat een printplaat afdrukken zoals gegeven in de blog. (blog: elektrische schema's / printplaten) Daar kiest u volledige printplaat.

Stap 3 : Soldeer alle componenten die je besteld hebt op de printplaat aan de hand van het schema. (blog : elektrische schema's /printplaat)

Stap 4 : Instellen en programmeren van de microcontroller (blog :configureren en uploaden microcontroller 16Mhz) en voor het programma die in uw microcontroller moet programmeren (blog: Eindprogramma)

Stap 5 :  Pas de Kp, Ki, Kd, pwmvooruit, pwmachteruit, delayachteruit aan in het programma. En load deze dan terug op.

Extra informatie + foto's

Via de volgende link vindt u alle documenten die we gebruikt hebben voor het project, van het volledige eindprogramma tot de nodige datasheets.
Alle benodigde documenten

Hieronder vindt u extra informatie over de aansluitingen aan de onderkant van de robot en de pin map van de microcontroller. Verder zijn er ook foto's te vinden over de verloop van ons project.Exta informatie + foto's

Eindprogramma

Hieronder ziet u het volledige programma waarmee onze robot het parcour volledig afgelegd heeft tegen gemiddeld 0,23m/s. Eindprogramma

Atmega 328 Bootloader tutorial

Hier vind u de bootloader tutorial voor een Atmega 328p adhv een ftdi chip. Deze tutorial werd opgesteld door Jonas Verstraete. Wij mochten deze gebruiken als basis voor onze toepassing, waarvoor dank. Best leg je deze naast onze blog: "configureren en uploaden microcontroller 16MHZ". We verspringen constant waarbij we deze tutorial als basis gebruiken en de onze bevat de aanpassingen. Indien de bug in Scribd weer opspringt betekend dit dat onze pdf in een andere taal zal komen te staan. Door "view in full screen" aan te klikken word dit opgelost en zal u de pdf in de correcte taal zien. Arduino Atmega328p bootloader tutorial

configureren en uploaden microcontroller 16 MHz

In deze blog vind u hoe wij onze atmega 328 configureerden adhv een ftdi-chip, aangezien onze controller op 3,3V werkt. Indien u deze blog gebruikt gelieve dan ook de atmega 328 bootloader tutorial te gebruiken. Deze is ook op deze site terug te vinden en is opgesteld door Jonas Verstraete. De ftdi-chip kan u aankopen of zelf maken . Alles is terug te vinden onder deze link hieronder de pdf met de aanpassingen ten opzichte van deze van Jonas Verstraete configureren microcontroller

Informatief:draaggolf 38KHz met 20MHz controller

In volgende pdf vind u de uitleg en extra verduidelijking hoe we te werk zijn gegaan om een 38KHz draaggolf te maken met behulp van bepaalde timer instellingen van een microcontroller werkend op 20MHZ. Echter hebben we door problemen de 20MHz kristal vervangen door een 16MHz kristal. Deze blog is dus informatief tenzij u wenst de 20MHz kristal te gebruiken.Door een bug in Scribd, het programma om pdf's te weergeven op een blog, kan het zijn dat de pdf in een verkeerde taal wordt weergeven. Gelieve op full screen te klikken en u zal de correct pdf te zien krijgen. draaggolf configureren met een microcontroller werkend op 20MHz

draaggolf 38KHz met een microcontroller van 16MHZ

Onze controller wegens tijdsgebrek en problemen nu op een 16 MHz kristal. Hierdoor moeten de programma's voor het genereren van de draaggolf ook gewijzigd worden. we hadden reeds een blog over het genereren van een draaggolf met behulp van een microcontroller op 20MHz, we zullen deze niet meer gebruiken. Beide blog's blijven toch online zodat u vrij bent te kiezen. Door een bug in Scribd, het programma om pdf's te weergeven op een blog, kan het zijn dat de pdf in een verkeerde taal wordt weergeven. Gelieve op full screen te klikken en u zal de correct pdf te zien krijgen. draaggolf configureren met een microcontroller op 16MHz

Informatief: Programmeren Microcontroller op 20MHZ met behulp van commandline

In onderstaande pdf vind u hoe we geprobeerd hebben ons programma op een atmega 382p werkende op 20MHz up te loaden. De resultaten waren niet altijd even bevredigend, maar geven een goed beeld van de mogelijkheden. Wegens aanhoudende problemen hebben we onze controller laten werken op een 16MHz kristal. U kan de nieuwe manier van programmeren terugvinden op de blog. We vonden het echter intressant deze doorlopen stappen te weergeven, al dan niet ter informatie voor derden. Door een bug in Scribd, het programma om pdf's te weergeven op een blog, kan het zijn dat de pdf in een verkeerde taal wordt weergeven. Gelieve op full screen te klikken en u zal de correct pdf te zien krijgen. programmeren van microcontroller op 20MHz

H-brug

H-brug

Inleiding

De H-brug wordt ook wel een motor-driver genoemd of een motor-ic. Dit omdat ze onlosmakelijk verbonden is met de aansturing van onze motoren. We willen het toerental van onze motoren kunnen wijzigen , net als het bepalen van de draairichting. Hiervoor zullen we dus gebruik maken van een H-brug.

Vereisten

De keuze van de H-brug , hangt af van een aantal factoren. Ten eerste de stahl current van onze motor. Dit is de piekstroom die de motor trekt als de wielen geblokkeerd worden. Onze H-brug moet deze stroompiek aan kunnen. Daarnaast moet het mogelijk zijn om via de H-brug met behulp van PWM het toerental van onze motoren te wijzigen. En dan bestaan er nog H-bruggen waar je maar 1 motor mee kan regelen en andere waar je er 2 mee kan regelen.

Keuze H-brug

De stahl current van onze motor bedraagt 1600mA, daarnaast hebben we PWM regeling nodig en beschikken we over 2 motoren waarbij we enerzijds een H-brug per motor kunnen gebruiken, maar anderzijds ook één H-brug kunnen kiezen die 2 motoren aankan.

Onze keuze viel op de L298, hij kan 2 motoren sturen waardoor we maar één H-brug nodig hebben.
Er kan ook gebruikt worden gemaakt van PWM-signalen voor de aansturing en daarnaast kan hij de stahl current van onze motoren aan want hij kan DC stromen van 4A aan en spanningen tot 46V . Hij voldoet dus ruim aan de vereisten.

Werking L298

Gelieve de Datasheet erbij te nemen , met name de pinmap van de L298.
Pin 4 en pin 9 dienen voor de spanningsvoorziening van onze H-brug. Pin 4 voor de voeding van de vermogenketen en pin 9 voor de voeding van het logische gedeelte. Bij ons hangen beide aan de batterij. Pin 6 en pin 11 zijn de signalen waarop we een PWM signaal kunnen sturen voor het toerental te regelen. Pin 1 en 15 moeten met de ground verbonden worden door een weerstand.

Pin 5 en pin 7 zijn respectievelijk input 1 en 2. Dat zijn de inputs van motor A. We kunnen hiermee de draairichting bepalen alsook een fast stop genereren afhankelijk van de signalen die we aan deze pinnen hangen. Motor B heeft ook dergelijke inputs namelijk 3 en 4 op pin 10 en pin 12. De waarheidstabel met de verschillende aanstuurmogelijkheden van deze pinnen is terug te vinden in de datasheet. Analoog met de input’s hebben beide motoren ook output’s. Output 1 en 2 voor motor A op pinnen 2 en 3, daarnaast output 3 en 4 voor motor B op pinnen 13 en 14.
Op pin 8 bevind zich de ground.

Voor verder informatie in verband met specifieke details, zoals optimale elektrische karakteristieken verwijs ik u door naar de datasheet.
Er zijn echter wel nog enkele componenten die u dient aan te sluiten aan de H-brug voor een correct werking. RsensA en RsensB zijn weerstanden die langs de ene zijde aan pin 1 en 15 hangen en de andere zijde aan de ground. Wij gebruiken hiervoor 10kOhm weerstanden. Aan pin 4 en 9 wordt ook een condensator van 100nF gehangen waarvan de andere zijde met de ground verbonden wordt.
Er worden ook Fast recovery diodes( 1A en tr≤ 200ns) geplaats rond de aansluitpunten van de motoren.  
Schema  op pagina 6 van de datasheet geeft u een voorbeeld hoe de aansluiting verloopt bij het aansturen van één enkele motor.

Bronnen

Datasheet L298

PID regeling

Waarom PID regeling?

We maken gebruik van een PID regeling zodat onze auto acceptabel zou reageren op de wijziging van de lijn zonder dat er instabiliteit ontstaat in het rijgedrag.

                  Met PID

               

                       Zonder PID

U ziet dat bij PID regeling de lijn constanter wordt gevolgd en geen grote wijzigingen optreden in het rijgedrag van de auto.

De formule

We starten bij de algemene formule voor een PID regeling :

<!--[if !vml]--><!--[endif]-->

Waarbij :

Kp = proportionele actie

Ki = integratie actie

Kd = differentiërende actie

Nu we deze formule weten kunnen we het programma schrijven.

Het programma

/*working variables*/

double Output;

double errSum, lastErr;

double Kp, Ki, Kd;
 

void Compute()
 

{

  

      /*Compute all the working error variables*/

      errSum += afwijking;

      double dErr = (afwijking - lastErr);

      /*Compute PID Output*/

      Output = kp * afwijking + ki * errSum + kd * dErr;

      /*Remember some variables for next time*/

      lastErr = afwijking;

}

 

Uitleg programma

De gebruikte variabelen

Output :            De waarde die na onze PID formule zal uitgekomen worden.
                         Met deze waarde gaan we de verdere berekening maken zodat we de lijn kunnen volgen.

 

afwijking :              De fout die tussen de input en de setpoint zit. Omdat onze setpoint gelijk is aan 0 is de error gelijk aan de input.

Errsum :           Is gelijk aan de error + errsum deze hebben we nodig om de integratie van onze PID te kunnen berekenen.

dErr :               Is de error – de laatste error. Deze wordt gebruikt om de defferentiatie te kunnen berekenen van onze PID.

uitleg

Voor dit programma, zullen we het programma van de sensors plaatsen. Nadat de sensoren uitgelezen zijn zal dit programma in werking treden.

De uitkomst van onze PID wordt berekend met volgende formule :

Output = kp * error + ki * errSum + kd * dErr

Output = Proportional + integral + Differential

Proportional :    Positie van de lijn – de gemeten waarde  = het verschil

                               Het verschil * kp = proportional

Integral :             Integral + het verschil = Integral

                               Integral  * ki = integral

Differential :      Verschil – het vorig verschil = Rate van het verschil

                               Rate verschil * kd = differential

Daarna zetten we het verschil vast, als het vorig verschil om de volgende waarde te kunnen berekenen.

Daarnaast zullen we ook een programma schrijven waarbij we Kp, Ki en Kd kunnen veranderen aan de hand van infrarood communicatie. Aan de hand van deze manier moeten we de microcontroller niet elke maal opnieuw programmeren om waardes aan te passen.

De Kp waarde zal ervoor zorgen dat bij een rechte lijn de lijn constant en stabiel gevolgd wordt zonder oscillatie.

De Ki waarde zal worden gebruikt om te reageren op het einde van een bocht. Deze is een heel gevoelige waarde en zal voor veel oscillatie zorgen indien het verkeerd is ingesteld.

De Kd waarde zal ervoor zorgen dat de lijn mooier gevolgd word in het begin van een bocht.

Informatief: PWM sturing

PWM signaal met ATMEGA 328

Inleiding

Er zijn 6 PWM signalen beschikbaar bij de Atmega 328, dit komt voor uit volgende redenering. We beschikken over 3 inwendige timers: T0,T1,T2 ; welke elke 2 uitgangssignalen (A en B) bezitten.  Waarbij timer 0 en 2 8bit timers zijn en timer 1 een 16bit timer. Uiteraard kunnen we ook PWM signalen generen met behulp van delays of analogwrite().
Wanneer we gebruik maken van PWM signalen met behulp van timers zijn er nog 2 methodes, namelijk fast PWM en Phase correct PWM. Deze laatste methode lijkt mij het meest aangewezen voor de sturing van onze motoren. Meer informatie over de PWM phase correct vind u in de datasheet, verder in dit document vervat, op pg 128. Deze methode is echter redelijk tijdrovend en bevat enkele ingewikkelde instellingen. De methode met delays is heel eenvoudig maar lijkt voor onze toepassing niet zo gebruiksvriendelijk. Vandaar dat wij vermoedelijk zullen gebruik maken van de analogwrite methode, namelijk : efficiënt, nauwkeurig, betrouwbaar en eenvoudig.

PWM met behulp delays

 void setup ()
{
pinMode(13,OUTPUT); // output pin 13 defineren
}
void loop ()
{
digitalWrite(13,HIGH); //13 hoog zetten
delayMicroseconds(900);// vertraging van 70 % dutycycle
digitalWrite(13, LOW);//13 laag zetten
delayMicroseconds(400);// vertraging van 30 % dutycycle
}

Een frequentie van 20MHZ geeft ons een periode van 50ns vandaar de verdeling in 0,035µs en 0,015µs.

 

Phase correct PWM

Hierbij basseer ik mij op volgende tutorial PWM. Het gebruik maken van PWM met behulp van timers vergt wel wat werk ivm instellen van registers. Verdere uitleg ivm de instelling van de registers ben ik dan ook gaan zoeken in de datasheet van de Atmel Atmega 328.

Timer output	Arduino output	Chip pin	Pin name
OC0A	6	12	PD6
OC0B	5	11	PD5
OC1A	9	15	PB1
OC1B	10	16	PB2
OC2A	11	17	PB3
OC2B	3	5	PD3

 

Vereiste instellingen :

WGM: waveform generation mode : 001
COMnA/COMnB :10 voor een niet geïnverteerd PWM signaal op uitgang A en B
OCRnA/OCRnB: output control register (vergelijkingsregister) : bv 180
                 timer0 en 2 tellen van 0-255 , bij OCR register zeg je met welke waarde hij  in zijn timerregister moet vergelijken. Hierbij dus goed kijken welke timer je gebruikt (0 en 2 = 8bit en 1=16bit)
CS : clock select, hiermee selecteer je de prescaler van je timer bijvb voor 64 moet je de waarde 100 hebben
TCCRnA/TCCRnB: timer counter control registers bevatten bovenstaande instellingen.
TCCRnA bevat de COMnA/COMnB en WGM instellingen
TCCRnB bevat de CS instelling
Merk op dat den A en B hier niet verwijzen naar output A en B maar gewoon 2 registers zijn van 1 timer.  De waardes die je moet instellen verschillen voor de verschillende timers.
Een voorbeeld, WGM moet 001 zijn , voor T0 is dat WGM00, voor T1 is dat WGM 10, Voor T2 is dat WGM 20
Dit is terug te vinden in de datasheet.
in bovenstaande afkortingen moet de “n” steeds vervangen worden door 0,1,2 afhankelijk van de keuze van de timer.

 

PWM gebruik van analogwrite

Dit is volgens mij een eenvoudige, correcte en gebruiksvriendelijke manier. Vandaar dat deze methode zal gebruikt worden in ons prototype. Op een tutorial arduino pwm vind je hierover een duidelijke uitleg.

Als je weet dat een analogwrite() commando zich situeert tussen 0-255 dan kan je hierop je dutycycle berekenen. Analogwrite(127) zal een dutycycle van 50% omvatten. Hieronder een schematische weergave.

 

Ook vind je een voorbeeld programma voor het dimmen van een led in de arduinosoftware.
Via volgende weg, file>examples> analog menu, kom je tot bovenvermeld bestand.
Hieronder de code die ervoor zorgt dat we een led met pwm signaal kunnen aansturen.

int led = 5;
void setup(){
 pinMode(led, OUTPUT);
}

void loop () {
  analogWrite(led, 255);
  delay(5000);
  analogWrite(led,50);
  delay(5000);
  analogWrite(led,100);
  delay(5000);
  analogWrite(led,200);
  delay(5000);
  analogWrite(led,0);
  delay(5000);
 
}

 

Verwerkingssnelheid

Tijd die beschikbaar is om waarden uit te lezen

Hier gaan we de tijd berekenen waarin dat de sensoren zullen moeten verwerkt worden indien we aan 2m/s rijden en door een bocht gaan zonder de zwarte lijn te verliezen.  De sensoren staan elk 15mm van elkaar. We gebruiken 6 sensoren zoals u kunt zien op de tekening. De dikte van de lijn is ook 15mm. In het programma om de lijn te volgen merkt u dat we 3 sensoren nodig hebben om het programma correct te laten werken. Daardoor zullen we in de helft van de buitenste 2 sensoren een lijn trekken die zal gebruikt worden om waarden uit te lezen. Want als de buitenste sensors de laagste waarde zouden hebben kan er alleen een vergelijking met 2 sensorwaarden uitgevoerd worden wat leidt tot een verkeerde oplossing van het programma. De afstand die maximaal kan worden afgelegd totdat we de zwarte lijn zullen verliezen moeten we berekenen. Dit kunnen we gemakkelijk met de stelling van pythagoras. De kromtestraal is 100mm, met alle gegevens die we beschikken kunnen we concluderen dat het verste punt op 70 mm van het middelpunt zal mogen liggen. Daarnaast is de schuine zijde van onze driehoek 100mm (onze kromtestraal + 7,5mm (de helft van onze zwarte lijn) = 107,5mm. Als we dan met de stelling van pythagoras de 2de rechthoekzijde berekenen : 107,5² + 70² = ?² => ? = 81,585mm. Dit is gemeten vanaf het begin van de bocht totdat de helft van de 2 buitenste sensoren de zwarte lijn verliest. We willen dat in deze 81,585mm toch zeker 10 keer de sensorwaarden zullen worden gecontroleerd, doorgestuurd en verwerkt wordt. Dus 81,585mm /10 = 8,1585mm. De auto kan maximaal 2m/s. Daardoor zullen we de tijd moeten berekenen dat de auto over deze afstand rijdt. Dus 8,1585mm/2000mm/s = 0,00408s

Dus de verwerkingsnelheid moet zeker onder de 4,08ms liggen als de auto aan 2m/s rijdt.

Elektrische schema's / printplaten

Inleiding

Als prototype zijn we van 3 printplaten uitgegaan.

1. printplaat met de microcontroller, voltage regulator en de IR-communicatie
2. printplaat met de H-bruggen (sturing van de motoren)
3. printplaat met de lijnsensor

We kwamen tot deze configuratie, aangezien het gaat om een prototype en we dus rekening houden met eventuele problemen. Indien alles direct aan elkaar gekoppeld is , is het moeilijker om aan fouten opsporing te doen en kunnen niet correct werkende zaken , correct functionerende onderdelen negatief gaan beïnvloeden.
Het uiteindelijke doel is wel om één complete printplaat te maken die ook dienst zal doen als chassis.
Hieronder vind u een beschrijving van de gebruikte werkmethode. Merk op dat wij zowel met Through hole - als SMD componenten werken. Vandaar de rode (smd) /blauwe (through hole) kleur in onze prints. Dit omdat Through hole-componenten altijd op de andere kant dan SMD componenten worden geplaatst.

CAD programma

Zowel voor de elektrische schema's als de printplaten hebben we gebruik gemaakt van "Eagle".
Wij gebruiken de free version van deze cadsoftware, die u eenvoudig kan downloaden op het internet.
Eerste stelden we de electrische schema's op. We kozen de hoofdcomponenten en via de datasheets hiervan konden we de benodigde extra componenten opzoeken. Belangrijk hierbij is dat je rekening houdt het type component (package) , dit omdat je bij de omzetting van schema naar print al direct de juiste afmetingen van je componenten hebt. Indien de package die je nodig hebt, zich niet bevind in de standaard bibliotheek, kan je altijd een bibliotheek zoeken op het internet die deze package bevat. Als dit nog geen oplossing bied is het altijd mogelijk zelf de component aan te maken.
Hierbij de link naar de site waar u Eagle volledig legaal kan downloaden.

Korte Bespreking Elektrische schema's prototype

microcontroller/ IR communicatie

Het hart van onze Linefollower bevind zich hier.
Als belangrijkste component vind u hier de µc " Atmega 328 " terug, die uitgebreid besproken word in de specifieke blog over de µc. Ook op deze print staat de schakeling omtrent de IR communicatie, waarvan de Belangrijkste componenten de TSOP1138 en IR led zijn. Dit om communicatie over infrarood tussen PC en Linefollower mogelijk te maken. U zult ook wel de Low drop 3,3V voltage regulator hebben opgemerkt. Deze zorgt dat de spanning van de batterij 6V( aangesloten via pinheads) wordt omgezet naar een 3,3V die we gebruiken voor het voeden van onze microcontroller. De verschillende Pinheads die u terugvind op de print dienen om de verschillende prints aan elkaar te kunnen koppelen of om bepaalde pinnen naar buiten te brengen voor externe toepassingen. één van die toepassingen is het programmeren van onze microcontroller of de batterij aansluiting. Een kleine maar toch belangrijke component is de kristal. Deze bepaald de kloksnelheid van onze Microcontroller,  Ons type Microcontroller kon werken met kristal met een maximumgrootte van 20Mhz. We hebben deze dan ook genomen aangezien wij zo snel mogelijk alles willen uitlezen en dus een maximale kloksnelheid willen.   Al de andere componenten zijn gekozen met behulp van de datasheets van de hoofdcomponenten. Misschien nog even het nut van de Zenerdiode vermelden die gebruikt wordt in de schakeling bij de TSOP. U ziet dat de TSOP gevoed word door 6V, maar de µc werkt maar op 3,3V . Aangezien deze toch aan elkaar gekoppeld zijn moeten we de µc beschermen door gebruik te maken van een Zenerdiode van 3,3V.

klik hier voor schema

lijnsensor

De lijnsensor bestaat uit 2 hoofdschakelingen. De ene schakeling voor het zorgen van licht de andere voor de reflectie van wit/zwart -waarden uit te lezen. Onze lichtbronnen zijn witte LED's en de sensoren rode. Dit hebben we proefondervindelijk bepaald. Voor de werking en keuze van de componenten verwijs ik u verder door naar de blog die specifiek hiervoor is opgesteld.
Naast de LED's zien we ook Transistors die als elektronische schakelaars dienst doen en weerstanden die ervoor zorgen dat we LED's niet gaan doorbranden. De pinheads staan in voor de koppeling van de uitgelezen waarden naar de analoge inputs van de µc daarnaast vinden we ook nog een VCC en ground terug. Hier had de positie en het aantal LED's een belangrijke achtergrond, ook deze vind u terug in desbetreffende blog.


klik hier voor schema

H-brug

Als laatste print , de print van de H-bruggen. Deze print bevat 2 schakelingen, een logicaschakeling en een vermogenschakeling. Deze opsplitsing vinden we ook terug in de baandikte van de verbindingen. De H-brug maakt de samenwerking tussen beide mogelijk. Via logica wordt er aangegeven met welk toerental en draairichting de motor moet draaien. Dit wordt dan door de H-brug omgezet zodat men met volledig vermogen de motoren kan aansturen. Naast de twee H-bruggen , voor elke motor één , vind men ook nog enkele pinheads terug. Zie de 2 aparte koppelingen voor de motoren. Daarnaast een reeks pinheads waar zowel logica als vermogen toekomen.
klik hier voor schema

besluit prototype

Deze beknopte uitleg zou u meer inzicht moeten geven in onze gebruikte schakeling. Laat mij duidelijk stellen dat deze schakelingen dienen voor de eerste fase van het prototype en eventueel nog verder dienen uitgewerkt te worden.

Volledige printplaat (defentieve versie = eindproduct)

Via volgende link kan je de volledige printplaat downloaden (te openen met Eagle).
klik hier voor de printplaat

Microcontroller

Microcontroller

We hebben voor de atmega328 microcontroller gekozen.
Om de datasheet te bekijken klik hier

We kiezen de atmega328 omdat we dan genoeg ingangen zullen hebben :

We hebben 6 analoge ingangen nodig voor de sensoren. Dit komt doordat we 6 sensoren zullen gebruiken om de lijn te volgen. Het moeten analoge ingangen zijn zodat we een waarde kunnen inlezen, en deze dan te kunnen vergelijken met de andere ingelezen waarden. De schema's van hoe deze sensoren aan de analoge ingangen worden aangesloten vind u terug in elektrische schema's

Daarnaast hebben we  pwm ingangen nodig voor de H-brug, we sluiten de enable A en B aan aan de pwm ingangen van de microcontroller. We hebben PWM (Pulse Width Modulation) ingangen nodig, zodat we de snelheid van de motor kunnen instellen. Ook hebben we 2 digitale pinnen nodig. Dit is om de richting van de motor te bepalen. Deze digitale pinnen sluiten we aan aan de INPUT 1, 2, 3 en 4. Waarbij we INPUT 1 en 3 samen verbinden, en 2 en 4 samen verbinden. Op deze manier zal de auto ofwel vooruit, ofwel achteruit kunnen rijden. Op deze manier sluiten we het wel uit dat een wiel vooruit rijd en de andere achteruit rijd, waardoor we niet zo kort kunnen draaien.

Ook zullen we infrarood communicatie hebben tussen onze microcontroller en de computer hiervoor hebben we ook een digitale ingang nodig en een TX (transmitter) en RX (reciever) ingang nodig. Dit heeft de atmega328 ook.

Seriele communicatie zal ook gebruikt worden om de microcontroller te programmeren. Hiervoor hebben we een MISO, MOSI, RX, GND, RESET nodig. Deze zijn ook allemaal aanwezig op de microcontroller.

Daarnaast is deze microcontroller ook groot en snel genoeg om ons programma te verwerken. Ook zullen we een crystal van 16Mhz gebruiken.

Waar welke aansluitingen zijn verricht, kun je bekijken op het elektrisch schema. Dit elektrisch schema vind je onder de title, elektrische schemas.

Sample tijd berekenen

Doel
We willen berekenen of onze microcontroller voldoende snel is om binnen een cyclus de sensorwaarden uit te lezen en ze te verwerken. De PID regeling laten we voorlopig buiten beschouwing aangezien we afhankelijk van de tijd die we nog over hebben  van onze cyclus nog kunnen beslissen of we de PID regeling nog door een andere microcontroller laten uitvoeren.
We maken dus een vergelijking tussen de sample tijd en de cyclustijd.

Berekening van de tijd voor de verwerking van de meetwaarden
Normaliseren
We krijgen van elke sensor een verschillende meetwaarde, en omdat we geen peren met appels kunnen vergelijking gaan we deze normaliseren. Dit omdat we de verschillende sensorbereiken en de gemeten meetwaarden in éénzelfde schaal willen zetten.
Hiervoor zit er een functie in de arduino-programeertaal: map(a,b,c,d,e,).
De variabelen zijn:
- a: de gemeten waarde
- b: de minimum grens van het oude meetbereik
- c: de maximum grens van het oude meetbereik
- d: de minimum grens van het nieuwe meetbereik
- e: de maximum grens van het nieuwe meetbereik

Minimum uit een array halen 

We hebben per sensor een waarde, in ons geval 6 waarden.
Nu moeten we echter de sensor met de kleinste meetwaarde en de meetwaarde van deze links en rechts ernaast weten om deze straks in onze interpollatie te gebruiken.Hierbij komen we tot de conclusie dat onze buitenste sensoren nooit de kleinste meetwaarde mogen leveren. We hebben namelijk 3 referentiepunten nodig. Waarvan het middenste referentiepunt de kleinste moet zijn. Wanneer dit één van de buitenste sensoren is , hebben we maar 1 referentie bij nl. links of rechts ervan. Daarom dat we van sensor 1 tot en met 4 de kleinste zoeken. Sensor 0 en sensor 5 zijn onze buitenste sensoren die enkel als referentiepunt mogen dienen. Hieronder vind u het gebruikte algoritme.

kleinste=100
For (sensor1meetwaarde to sensor4meetwaarde)
If sensor(x)meetwaarde<kleinste
then
kleinste=sensor(x)meetwaarde

Interpoleren 

sensorLocatie=sensor(x)locatie
end if
end for 

Interpoleren

We weten nu waar in de buurt onze lijn zich bevind. We willen echter exact weten waar het midden van onze lijn zich bevind om ons te perfect boven de lijn te positioneren. Met behulp van volgende formule en de 3 sensors in de buurt van de lijn is dit mogelijk.

=[(Y1-Y3)/2 ]* (1/Y1+Y3-2Y2)

Zoals je weet wordt een parabool gedefinieerd door een kwadratische vergelijking van de vorm y=ax²+bx+c. Elke parabool wordt gedefinieerd door 3 punten. Hier Y1,Y2,Y3 met respectievelijke x-waarden -1,0,1

Na subtitutie van volgende waarden in de vergelijkingen komen we op :

Y1=a-b+c
Y2=c
Y3=a+b+c

We willen echter het minimum want zoals reeds gezegd ligt daar ons lijn. Het minimum bekomen we door een afleiding temaken van de basis formule.
y' = (y=ax²+bx+c)' = 2a+b => x= -b/2a

nu proberen we Y1,Y2,Y3 via subtitutie in deze vergelijking te krijgen

-b=> Y1-Y3= a-b+c-a-b+c=-2b =>-2b/2 = (Y1-Y3)/2

2a=> Y1+Y3-2Y2= a-b+c+a+b+c-2c=2a

 -b/2a=[(Y1-Y3)/2 ]* (1/Y1+Y3-2Y2)

Merk op dat de rode 1 die we hier gebruiken is de afstand tussen de sensoren in het programma. We zetten deze als een variable zodat we hierin kunnen variëren om zo de beste instelling te kiezen.

Lengte programma

De lengte van het programma verschilt per test. Dit is omdat de berekeningen licht anders zijn als de lijn zich onder de buitenste sensors bevindt.

De maximumtijd die het programma duurt is 1200 microseconden.

Code

int sensorPin[] = {A0,A1,A2,A3,A4,A5};
int sensorValue[6];
int minimum[] = {0,0,0,0,0,0};//minimum waarde per sensor
int maximum[] = {1023,1023,1023,1023,1023,1023};//maximum waarde per //sensor
int sensorWaarden[] = {-250,-150,-50,50,150,250};
int kleinste=100;
int sensorLocatie=1;
int lijnValueTeller,lijnValueNoemer,lijnValue;

void setup() {
  Serial.begin(9600);
}

void loop() {
 
  //uitlezen en normaliseren per sensor
  for (int i=0;i<6;i++) {
    sensorValue[i]=analogRead(sensorPin[i]);//waarde uitlezen
    sensorValue[i]=map(sensorValue[i],minimum[i],maximum[i],0,100); 
    //waarden in range [0-100] omzetten
    // sensorValue[i]=constrain(sensorValue[i],0,100);//waarden 
    // buiten range aanpassen
    // (waarde<0 => waarde=0, waarde>0 => waarde=100)
  }
 
  //kleinste uit array halen, sensor 0 en 5 worden niet meegerekend omdat deze de buitenste sensoren zijn

  kleinste=100;
  for (int i=1;i<5;i++) {
    if (sensorValue[i]<kleinste) {
      kleinste=sensorValue[i];
      sensorLocatie=i;
    }
  }
 
  //positie lijn berekenen (interpoleren)
  lijnValueTeller=(sensorValue[sensorLocatie-
    1]-sensorValue[sensorLocatie+1])*100;
  lijnValueNoemer=(sensorValue[sensorLocatie-
    1]+sensorValue[sensorLocatie+1]-2*sensorValue[sensorLocatie])*2;
  lijnValue=lijnValueTeller/lijnValueNoemer;
  lijnValue+=sensorWaarden[sensorLocatie];
}

Stukkenlijst

Stuklijst

Sensors

Inleiding

Voor de keuze van de sensors die de lijn waarnemen zijn er verschillende mogelijkheden. In volgend stukje ga ik wat dieper in op de verschillende opties en waar wij voor gekozen hebben.

Detectie via infrarood licht

De eerste mogelijke optie is via infrarood licht. Wij hebben bewust niet voor deze optie gekozen om volgende redenen:
- Niet al het infrarood licht wordt weerkaatst door het papier op de ondergrond, wat het uitlezen van het resultaat moeilijker maakt.

- Bij onderzoek op internet naar eerder gemaakte line followers tref je geen robots aan die infrarood gebruiken.

Detectie via zichtbaar licht

De tweede mogelijke optie is via zichtbaar licht. Dit is de optie waar wij voor gekozen hebben.

Bij deze vorm van detectie bestaan er nog verschillende methoden. De eerste is door dezelfde led te gebruiken om licht uit te zenden en te ontvangen. Als eerste wordt de led als gewone led gebruikt om er licht mee uit te stralen (figuur 1a), als volgt wordt de led ‘opgeladen’ volgens de hoeveelheid licht die hij terug ontvangt (figuur 1b), en daarna wordt de led ontladen en wordt die ontlaadtijd genomen als waarde van de kleur onder de led (figuur 1c). Als je dit zou programmeren, zou dit echter redelijk veel tijd innemen, en aangezien de robot zo snel mogelijk moet werken hebben we hier dus niet voor gekozen.

                                  1a                           1b                          1c

Figuur 1: led als zender en ontvanger van licht

Waar we wel voor gekozen hebben is om de led voortdurend als een fototransistor te gebruiken. De led wordt met de cathode aan de voedingsspanning verbonden, en met de anode aan de basis van de transistor. Deze transistor hangt met de collector aan de voedingsspanning en met de emitter via een weerstand van 10 kilo ohm aan de ground. Naast elke led die als sensor gebruikt wordt is een witte led bevestigd die zorgt voor de belichting van de ondergrond. Zo moet de led die als sensor werkt niet zelf zijn licht uitstralen, en dit scheelt veel in tijd voor het eindprogramma. Vooral als je bedenkt dat er meerdere leds nodig zijn.

Testen van de leds

Tijdens de tests hebben we zes verschillende leds getest, wat telkens een ander resultaat leverde. De verschillende leds die getest werden zijn:

-          Rood (goedkoop): een goedkope rode led (0.03€)

-          Rood (duur): een duurdere rode led (0.15€)

-          Rood (doorzichtig): een rode led met doorzichtig glas

-          Groen

-          Oranje (doorzichtig): een oranje led met doorzichtig glas

-          Wit

In volgende tabel ziet u alle gemeten waarden per sensor. Bij wit en zwart werd telkens de ruis (afstand tussen maximum en minimum) genoteerd. Dan wordt het grootste ruis in procent tot de afstand tussen de gemiddelde waarden genomen. Hoe kleiner dit procent, hoe meer geschikt de sensor is.

	Wit				Zwart				Resultaat
	Maximum	Minimum	Gemiddelde	Ruis	Maximum	Minimum	Gemiddelde	Ruis	Afstand	Individuele ruis	Totaal ruis
Wit	Te duur
Rood	0	0	0	0	0	0	0	0	0	0	0%
Groen	26	21	23	5	5	0	2	5	21	5	24%
Rood (duurder)	13	8	10	5	1	0	0	1	10	5	50%
Oranje (doorzichtig)	60	54	57	6	4	0	1	4	56	6	11%
Rood (doorzichtig)	238	232	235	6	20	15	17	5	218	6	3%

Testopstelling:

Rechtlijnigheid sensors

 

Besluit

Uit de testgegevens kunnen we afleiden dat de rode leds met doorzichtige behuizing het beste geschikt zijn. Dit is erg goed te zien, vooral door de grote afstand tussen de gemiddelden van de witte en zwarte waarden. We hebben beslist om ons prototype uit te rusten met zes sensors die onderling op een afstand van anderhalve centimeter liggen, wat de breedte van de lijn op de ondergrond is.

technische verantwoording en keuze van de motor en de gearbox

Keuze motor

Inleiding

We willen dat onze Linefollower het streefdoel van 2m/s kan halen.
Met behulp van de diameter van de banden en de verschillende toerentallen van de motor kunnen we kijken of dit mogelijk is.
Daarnaast moeten we ook nog het gewenste koppel kunnen leveren. Hiervoor volgen ook nog een aantal berekeningen. Als onze motor de snelheid van 2m/s van onze bot kan verwezenlijken en hij heeft voldoende koppel kunnen we zeggen dat hij voldoet voor de toepassing

toerental

We maken gebruiken van banden met een diameter van 70 mm, dit zijn we overeengekomen door het toerental van de motor die we op oog hadden te bekijken en een vlugge berekening te maken in functie van de snelheid die we nodig hadden.

De omtrek van de band is: 70mm x PI = 219,911mm

nodige toerental => (2000mm/s)/(291,911mm/tr)  = 9,094tr/s =>546 tr/min
Het toerental dat wij bereiken met onze motor ( micro metal gearmotor)

 is  630tr/min, dit met de gearbox volgens de tandwielverhouding 50:1.

We zien dat het nominaal onbelast toerental hoger ligt dan het gewenste toerental. Dit is niet erg omdat het toerental zowiezo een beetje zal zakken naar gelang de belasting, daarnaast kunnen we ook nog steeds gebruik maken van PWM om ons toerental naar omlaag te brengen.

Koppel
We weten nu al dat het toerental goed is , maar kan de motor ook voldoende koppel leveren? Dit wil zeggen:  zal hij voldoende kracht hebben?
Hiervoor moeten we het benodigde koppel vergelijken met het geleverde koppel.

Het benodigde =1/2 x m x v^2 =0,5x400x(2m/s)^2=0,8J

Het gewicht is een schatting gebaseerd op het gewicht van de batterijen+printplaat+wielen, te vermenigvuldigen met 2. we kwamen hierbij op 400g.

het geleverde koppel = nominaal koppel x rendement x tandwielverhouding

 Nominaal koppel: 0,10592328 Nm
Rendement : 50 %
Tandwielverhouding: 50
het geleverde = 0,10592328Nmx 0,5 x 50= 2,64Nm=2,64J

We weten dat 1joule = 1Nm vandaar kunnen we besluiten dat ons koppel aanvaardbaar is voor de toeppassing

Besluit
De motor zorgt ervoor dat we het streefdoel van 2m/s halen. Daarnaast is ons koppel voldoende groot voor de toepassing. De opbouw lijkt ons redelijk eenvoudig omdat het mogelijk is van fixatiemogelijkheden bij te bestellen. Meer technische informatie vindt u bij onderstaande links.

Links&datasheets

wielen
micro metal gearmotor
fixatie motor