Pws de juiste balans vinden csg liudger raai

De juiste balans vinden Egbert Dijkstra & Tom Bax (v6) CSG Liudger, Drachten (2015)

Inhoudsopgave: 1. Samenvatting................................................................................................................................................4 2. Inleiding .........................................................................................................................................................5 Theoretische uitwerking van de balancerende robot.......................................................................6 3. Rotatiegrootheden: Koppel en hoeksnelheid ..................................................................................6 4. Beschrijving dynamica .......................................................................................................................... 11 4.1 De stator............................................................................................................................................... 11 4.2 De rotor ................................................................................................................................................ 12 4.3 De motor .............................................................................................................................................. 13 4.4 Beschrijving totale systeem.......................................................................................................... 13 4.5 Opwaartse balans ............................................................................................................................. 17 5. Regeling....................................................................................................................................................... 18 5.1 Algemene vorm van differentiaalvergelijkingen met demping...................................... 18 5.1.1 Discriminant > 0 ....................................................................................................................... 19 5.1.2 Discriminant = 0 ....................................................................................................................... 19 5.1.3 Discriminant < 0 ....................................................................................................................... 19 5.1.4 Overzicht van systeemgedrag ............................................................................................. 20 5.2 Regelsystemen................................................................................................................................... 21 5.3 Regelsysteem voor de robot......................................................................................................... 22 6. Simulaties ................................................................................................................................................... 25 6.1. Neerwaartse modus ....................................................................................................................... 25 6.2 Opwaartse modus ............................................................................................................................ 28 6.3 Realistisch model.............................................................................................................................. 32 Praktische uitwerking van de balancerende robot......................................................................... 35 7. Bouw............................................................................................................................................................. 35 7.1 De motor .............................................................................................................................................. 35 7.1.1 MFA 919D501............................................................................................................................ 36 7.2 De stator............................................................................................................................................... 37 7.3 De rotor ................................................................................................................................................ 40 7.4 Totaal overzicht ................................................................................................................................ 41 8. Elektronica ................................................................................................................................................. 42 8.1 Motorstaansturing ........................................................................................................................... 42 8.1.1 H足Bridge....................................................................................................................................... 42 8.1.2 PWM .............................................................................................................................................. 43 8.1.3 printplaat..................................................................................................................................... 44 8.1.4 Logische poorten...................................................................................................................... 45 8.1.5 Verwerking ................................................................................................................................. 46 8.2 Sensor ................................................................................................................................................... 48 8.2.1 MEMS ............................................................................................................................................ 48 8.2.2 Accelerometer ........................................................................................................................... 48 8.2.3 Gyroscoop ................................................................................................................................... 50 8.2.4 MPU 6050.................................................................................................................................... 50 8.3 Arduino................................................................................................................................................. 51 8.4 Raspberry Pi ....................................................................................................................................... 51 9. Software ...................................................................................................................................................... 52 9.1 Protocollen.......................................................................................................................................... 52 9.1.1 I2C .................................................................................................................................................. 52 9.1.2 HTTP ............................................................................................................................................. 53 2

9.1.3 WebSocket .................................................................................................................................. 55 9.1.4 Communicatie Raspberry Pi – Arduino ........................................................................... 56 9.2 programma’s ...................................................................................................................................... 58 9.2.1 Raspberry Pi............................................................................................................................... 58 9.2.2 Android ........................................................................................................................................ 62 9.2.3 Arduino ........................................................................................................................................ 68 10. Proeven en resultaten ......................................................................................................................... 73 10.1 Energieverbruik ............................................................................................................................. 73 10.2 Balanceren met de versnellingssensor in neerwaartse modus ................................... 75 10.3 Balanceren met de versnellingssensor in opwaartse modus ....................................... 77 10.4 Balanceren met de MPU6050 in opwaartse modus ......................................................... 80 11. Conclusie .................................................................................................................................................. 84 12. Bronvermelding..................................................................................................................................... 85 13. Bijlage ........................................................................................................................................................ 86 A. Afleiding Vergelijking 9. ................................................................................................................... 86 B. Simulatiewaarden.............................................................................................................................. 87 C. Specificaties Raspberry Pi ............................................................................................................... 89 D. paragraaf 9.1.1 : ASCII tabel ........................................................................................................... 90 E. HTML codes........................................................................................................................................... 91 F. Library’s bij de Raspberry Pi .......................................................................................................... 91 G. Library’s bij android .......................................................................................................................... 92 H. Library’s bij Arduino ......................................................................................................................... 92 I. Software................................................................................................................................................... 92 14. Logboek..................................................................................................................................................... 93 Tom ............................................................................................................................................................... 93 Egbert ........................................................................................................................................................... 99

3

1. Samenvatting Onze robot bestaat in dynamisch opzicht uit drie delen: o Een rotor: de wielen. o De stator: de massa die zich buiten het draaipunt bevindt. o De motor: de verbinding tussen stator en rotor.

Wanneer deze drie onderdelen samengevoegd worden volgt er een differentiaal vergelijking, waaruit blijkt dat systeem van zichzelf onstabiel is.

Om dit systeem te stabiliseren is een regeling nodig, die het systeem bij een afwijking kan corrigeren. o Dit de regeling meet continu de hoek waarin het systeem zich bevindt. o Deze regeling bevat twee variabelen die het systeem be誰nvloeden.

De versterkende factor (kp) En de integrerende factor (tau) o Het systeem vertoont vijf soorten karakteristieken, het systeem kan: Exponentieel toenemen.

Slingerend exponentieel toenemen.

Constant slingeren Gedempt slingeren Exponentieel afnemen.

Onze robot wordt geregeld door een gyroscoop en een versnelling sensor o Een versnelling sensor alleen geeft een afwijkende hoek.

Factoren die, naast een verkeerd gekozen kp en tau, voor instabiliteit zorgen zijn: o De massa van de robot. o Het soort sensor. o De speling in de constructie Uiteindelijk is het ons gelukt om de robot in onstabiele opwaartse toestand, zo te regelen dat deze stabiel wordt.

4

2. Inleiding De juiste balans vinden, we doen het allemaal. Tijdens het lopen, fietsen en zelfs tijdens het lezen van dit verslag is je lichaam continu bezig om zich in evenwicht te houden.

Ondanks dat je dit doet zonder er bij na te denken, is de balansregeling in het lichaam zeer complex. Een beweging wordt in het lichaam geregistreerd door het evenwichtsorgaan, deze stuurt een signaal naar de hersenen en de hersenen moeten vervolgens de juiste spieren aansturen om in balans te blijven. Ook in de techniek wordt veel gebruik gemaakt van het regelen van balans. Een bekend voorbeeld hiervan is de Segway, zie Afbeelding 1. De Segway is een voertuig dat in 2001 werd geĂŻntroduceerd.

Afbeelding 1: Segway

Het doel van ons onderzoek is het maken van een robot die zichzelf in evenwicht kan houden. Hierbij stellen we onszelf de volgende voorwaarden: ten eerste moet de robot van zichzelf onstabiel zijn en dus over een regelsysteem beschikken om stabiel te zijn.

Ten tweede moet de robot, net als de Segway, beschikken over twee wielen, waardoor deze slechts in ĂŠĂŠn dimensie onstabiel is. Tot slot moet de robot geheel draadloos werken.

We beginnen het rapport met de theoretische uitwerking van de robot. Hierin leggen we uit wat koppel en hoeksnelheid inhoudt. Vervolgens beschrijven we de dynamica van de robot, hier worden de eigenschappen van de bewegende onderdelen van de robot beschreven. Daarna kijken we aan de hand van de dynamische eigenschappen hoe de regeling van de robot er uit moet komen te zien. Verder simuleren we een theoretisch model van onze robot met regeling, om te kijken welk gedrag deze vertoont. Vervolgens werken we het praktische gedeelte van de robot uit. Hierin bespreken we de bouw, elektronica en software van de robot. We leggen uit hoe en waarom we bepaalde dingen gedaan hebben. Vervolgens doen we een aantal proeven met de robot en tot slot trekken we onze conclusie.

5

Theoretische uitwerking van de balancerende robot Voordat we de robot gaan bouwen moeten we eerst uitzoeken wat er in de theorie allemaal bij dit onderwerp komt kijken. We beginnen met het uitleggen van de rotatiegrootheden, koppel en hoeksnelheid, waarbij in onze robot sprake is. Vervolgens beschrijven we de verschillende onderdelen van de robot, in dynamisch opzicht, te beschrijven. Aan de hand hiervan kijken we of het mogelijk is om een regeling te bedenken die robot in balans kan houden. Tot slot laten we doormiddel van simulaties het gedrag van de robot bij de gevonden regeling zien.

3. Rotatiegrootheden: Koppel en hoeksnelheid Op dit moment hebben we alleen nog maar met translerende systemen gewerkt op school. Translerend betekent dat alle punten in een voorwerp na een verplaatsing, allemaal een beweging in dezelfde richting hebben ondergaan. Een voorbeeld van een translerend systeem is hieronder afgebeeld:

Afbeelding 2 Massa met krachten

De krachten F1 en F2 grijpen beide aan in de massa M. We nemen aan de rechts de positieve richting is, hieruit volgt dat de kracht F2 negatief is. Wanneer de som wordt genomen van beide krachten, blijft er een resulterende kracht over:

De tweede wet van Newton zegt wanneer er een resulterende kracht op een voorwerp werkt, dit voorwerp versnelt [1]. Deze versnelling is in dezelfde richting als de resulterende kracht. Er zijn echter ook gevallen waarbij krachten zich niet in de massa aangrijpen, maar deze wel versnellen. Een koppel is hiervan een voorbeeld. Een koppel doet zich voor wanneer er verschillende krachten op een voorwerp werken die op verschillende plaatsen aangrijpen, waardoor het voorwerp gedraaid wordt [2].

Afbeelding 3 Koppel

6

In Afbeelding 3 is een voorbeeld van een koppel te zien. F1 en F2 grijpen beide in een massaloze staaf aan en niet in de massa. Toch zorgen beide krachten er wel voor dat de massa versneld wordt. Om beter te begrijpen hoe een koppel werkt, kijken we eerst naar een staaf waar slechts één kracht op werkt. In Afbeelding 4 is een zo’n staaf getekend.

Afbeelding 4 Koppel met één kracht. De gestippelde vectoren zijn de krachten die door de staaf veroorzaakt worden.

Op de staaf wordt een kracht F1 uitgeoefend. De derde wet van Newton zegt dat wanneer een voorwerp A een kracht op voorwerp B uitoefent, voorwerp B dezelfde maar een tegengestelde kracht op voorwerp A uitoefent.

Derde wet van Newton: ⃗

= −⃗

Dit betekent dus dat de staaf ook een kracht F1 uitoefent, maar dan in tegengestelde richting. Wanneer we naar het draaipunt kijken zien we dat het draaipunt een kracht Fd van de staaf ondervindt. Omdat het draaipunt een vast punt is dat niet verplaatst wordt, zal deze ook een tegengestelde, maar gelijke kracht aan Fd op de staaf hebben. Hetzelfde geldt voor de massa M. Op massa M werkt de kracht F, dus hij versnelt. Maar de massa M levert eveneens een gelijke, maar tegengestelde kracht op de staaf. Overigens als de staaf toch een massa zou hebben geldt hier precies hetzelfde voor, er werkt een kracht van de massa op de staaf en andersom. Als we vervolgens alleen naar de krachten kijken die de staaf ondervindt, is het volgende te zien:

7

Afbeelding 5 Krachten die de staaf ondervindt

Omdat de staaf geen massa en een eindige versnelling heeft, betekent dat de krachten die op de staaf werken in evenwicht moeten zijn, oftewel: =

+

Wanneer dit object draait is het moment de kracht die op een bepaald punt werkt keer de lengte van de arm (draaipunt tot punt waar de kracht op werkt) [3].

Omdat de krachten in evenwicht zijn geldt het volgende:

Waaruit volgt:

Wanneer de arm draait, staan een aantal eenheden in verhouding met de verschillende stralen.

Afbeelding 6

Afgelegde weg:

8

Snelheid:

Versnelling:

De snelheid gedeeld door de straal is altijd dezelfde waarde, deze waarde wordt de hoeksnelheid (Ď&#x2030;) genoemd. Hetzelfde geldt voor de versnelling: de versnelling gedeeld door de straal heeft ook een constante waarde, dit wordt de hoekversnelling (dĎ&#x2030;/dt) genoemd.

Wanneer er een kracht wordt uitgeoefend op de plaats waar de massa zich bevindt, op straal r, dan geldt:

Echter als de kracht zich op een andere straal r1 aangrijpt, zal de massa die deze kracht ervaart, anders zijn. Dit is af te leiden met behulp van de volgende formules:

is ook te schrijven als:

Dit is weer in te vullen in de tweede wet van Newton,

Vervolgens herschrijven we

:

:

Nu kunnen we de volgende twee formules samenvoegen en herschrijven: en

tot:

9

Vergelijking 1

Dit betekent dat je vanuit straal r1 een andere massa ervaart dan vanuit straal r. Op het punt waar F1 aangrijpt ervaar je een versnelling a1. De relatie tussen F1 en a1 wordt . Samen met Vergelijking 1 bepaald door de massa die je in dat punt ervaart: volgt hieruit dat de ervaren massa in punt op straal r1, gelijk is aan:

In het geval van Afbeelding 4 betekent dat naarmate r1 kleiner wordt, de ervaren massa toeneemt. Het is niet handig om in krachten, massaâ&#x20AC;&#x2122;s en snelheden te blijven rekenen: vanuit elk punt moet de massa steeds opnieuw beschreven worden. Het is beter om het op de volgende manier op te schrijven:

wordt:

Links van het gelijkteken is nu het koppel T1 en

is gelijk aan de hoekversnelling. De

nieuwe formule is ook te schrijven als:

Vergelijking 2

J is gelijk aan , en wordt ook wel het massatraagheidsmoment genoemd [4].

Vergelijking 2 is handiger dan Vergelijking 1 omdat het niet meer belangrijk is waar de kracht zich aangrijpt. Het gaat er om dat er een koppel T1 wordt geleverd. Ook de hoekversnelling is onafhankelijk van de straal. Vergelijking 2 zou je kunnen beschouwen als de tweede wet van Newton in het roterende domein.

10

4. Beschrijving dynamica Nu we de rotatiegrootheden behandeld hebben, kunnen we doorgaan met de beschrijving van de dynamica. De robot bestaat verschillende bewegende onderdelen, in dit hoofdstuk behandelen we deze onderdelen en hun samenhang één voor één. Het gehele systeem is erg complex. Om het overzichtelijk te houden, laten we in de beschrijving een aantal dingen weg, echter de essentie van het verhaal blijft wel in stand.

De onderdelen die we beschrijven, spelen in de regeling van onze robot, in tegenstelling tot de weggelaten onderdelen, een belangrijke rol. De robot bestaat globaal gezien uit de volgende onderdelen: De motor, de rotor en de stator (de motorbehuizing, batterijen en elektronica), deze onderdelen zijn te zien in Afbeelding 7. We behandelen deze onderdelen van buiten naar binnen, dus eerst de stator en als laatst de motor. Het uitgangspunt van deze beschrijving is die van de neerwaarts regelende robot. Voor de opwaarts balancerende robot geven we zonder afleiding de resultaten, echter de afleiding hiervan gaat op een soortgelijke manier.

Afbeelding 7: Stator, motor en rotor

4.1 De stator In Afbeelding 8 is een vereenvoudigde weergave gegeven van de krachten en de koppels die op de stator werken. De stator is hierbij voorgesteld als een massa die zich op afstand r buiten de draai­as bevindt.

Afbeelding 8 Een schematische weergave van de stator, waarbij: T = koppel, αs = hoeksnelheid,

11

We kunnen voor de stator vergelijkingen opstellen voor zowel het roterende, als op het translerende gebied. Voor het roterende domein (domein is gebruikelijker) kunnen we de volgende vergelijking opstellen:

Vergelijking 3

Voor het translerende domein geldt:

Vergelijking 4

4.2 De rotor In Afbeelding 9 is net als bij de stator een vereenvoudigde weergave gegeven van de krachten en koppels die op de rotor werken.

Afbeelding 9

Net als bij de stator is de rotor op te delen in het translerende en roterende domein.

Voor de rotor gelden de volgende formules (waarbij R gelijk is aan de straal van het wiel): Translerend: Vergelijking 5

Roterend: Vergelijking 6

Bovendien kunnen we nog iets zeggen over de rotatiesnelheid en de snelheid van de rotor, zie Afbeelding 9. Uit deze afbeelding blijkt dat het laagste punt, waar het wiel de grond raakt, een snelheid heeft ter grootte van: . Wanneer de wrijving tussen wiel en grond zodanig is, dat er geen slip optreedt. Dan kunnen we stellen:

Vergelijking 7

12

4.3 De motor Als laatst behandelen we de dynamica van de motor. De motor is in het roterende domein de verbinding tussen rotor en stator. De motor geeft het koppel door van rotor naar stator en brengt de rotatiesnelheden van de rotor en stator in verband. De motorsnelheid is het verschil tussen de rotatiesnelheden van stator en rotor:

Vergelijking 8

4.4 Beschrijving totale systeem In de voorgaande paragrafen hebben we de afzonderlijke delen van het dynamisch besproken. In deze paragraaf worden de afgeleide formules (Vergelijking 3 tm Vergelijking 8) samengevoegd. Het doel is om te komen tot een vergelijking waarin alleen de positie en de hoeksnelheid van de stator worden meegenomen, evenals de hoeksnelheid van de motor. Hierbij komen we tot de volgende formule [Uitwerking in bijlage A]:

Vergelijking 9

Deze formule is eenvoudiger te schrijven.

Vergelijking 10

waarbij:

Vervolgens delen we in Vergelijking 10 links en rechts door Jt. Verder is bekend dat de afgeleide van de hoek gelijk is aan de hoeksnelheid:

Daarmee komen we tot de volgende vergelijking:

Vergelijking 11

13

Het is interessant om te kijken wat er gebeurt wanneer er voor αs een kleine waarde gekozen wordt. In dat geval geldt: . Vergelijking 10 is dan als volgt te schrijven:

Ook te schrijven als:

Vergelijking 12

Dit is een tweede orde differentiaalvergelijking. Een differentiaal vergelijking is een vergelijking waarin een functie met één of meer van zijn afgeleiden in verband wordt gebracht [5]. Naar Vergelijking 12 kan op de volgende manier gekeken worden. Links van het gelijkteken zien we een uitdrukking met uitsluitend de hoek van de stator (αs).

Deze hoek beschrijft de reactie van het systeem: het is het resultaat van een actie die van buiten op het systeem heeft ingewerkt. Rechts van het gelijkteken staat een uitdrukking met de rotatiesnelheid van de motor. Dit beschrijft een actie die op het systeem wordt uitgeoefend. Dus samenvattend: links van het gelijkteken staat het gevolg, rechts staat de oorzaak. Vervolgens is het ook leuk om te bekijken hoe het systeem reageert op een actie die in het verleden is gebeurd. Deze reactie is te beschrijven met de volgende vergelijking:

In deze vergelijking is de rechterkant van het gelijkteken nul gemaakt. Dit komt omdat er geen actie meer op het systeem wordt uitgeoefend, want deze was uit het verleden.

Een algemene oplossing voor deze vergelijking is:

Vergelijking 13

Uit die vergelijking blijkt dat αs een slingerend karakter heeft, met ωe als hoekfrequentie, dit wordt ook wel de eigenfrequentie van het systeem genoemd. Dit is terug te zien in een simulatieresultaat in Afbeelding 10 en Afbeelding 11.

14

Afbeelding 10: In deze afbeelding is te zien wat de eigenfrequentie is van de slingering van de stator, namelijk freq (510mHz)

De frequentie van uit de simulatie bedraagt 510 mHz (Afbeelding 10). We kunnen ook een formule afleiden van de eigen frequentie van het systeem. De ωe uit Vergelijking 12 is ook te schrijven als: (hoekfrequentie)

Met de waarden [bijlage B] die in deze simulatie gebruikt zijn, komen we op eigenfrequentie van 513 mHz. Het verschil is te verklaren omdat de formule van de hoekfrequentie komt uit Vergelijking 12, in deze vergelijking bevindt zich geen sinus.

Terwijl de simulatie wel gebruik maakt van de sinus in de differentiaalvergelijking.

Afbeelding 11: Dit is een simulatieresultaat van een robot die gedurende één seconde door de motor is aangestuurd, dit is te zien aan de lichtblauwe piek in de bovenste grafiek. Na de puls slingert de stator nog na, zie de groene grafiek. De hoek van de rotor is de donkerblauwe grafiek en de afgelegde weg is gegeven door de rode grafiek.

Ook kunnen we kijken wat het systeem doet wanneer de motor aangezet wordt, dit kan op verschillende manieren. Een manier is de motor een constante snelheid laten geven.

Als dit ingevuld word in differentiaalvergelijking Vergelijking 12 zien we dat de hoek

15

van de stator niet veranderd is in vergelijking tot de vorige situatie (Afbeelding 11). Dat is logisch want de Ď&#x2030;0 is constant. En de afgeleide van een constante is nul. Dus de differentiaal vergelijking is gelijk aan die van de vorige situatie. De stator zal om de nul­ positie blijven slingeren. Zie Afbeelding 12.

Afbeelding 12: Simulatieresultaat waarvan de motor een constante snelheid geeft.

Wat opvalt is dat de hoek van de rotor is bevat ook de slingerende component, die ook in de stator is te zien. De motor geeft een lineaire component en de stator geeft de slingerende component. Ook in de afgelegde weg van de robot is te zien dat er een combinatie is van een slingerende en lineaire component: de robot beweegt zich slingerend vooruit en is dus instabiel.

Als laatst kunnen we kijken wat er gebeurt als de motor eenparig versnelt. De motorsnelheid is in dat geval te schrijven als een constante keer tijd: . Dit vullen we vervolgens in, in Vergelijking 12. De simulatieresultaten hiervan zijn te zien in Afbeelding 13.

16

Afbeelding 13: Simulatie van een eenparig versnelde motor.

De hoek van de stator slingert om een constante waarde die niet gelijk is aan nul. De afgelegde weg is een parabool als functie van de tijd geworden. De slingering is nog steeds aanwezig, alleen lastig te zien door de schaling van het plaatje.

4.5 Opwaartse balans Tot nu toe hebben we de neerwaarts balancerende robot besproken. In deze paragraaf geven we de vergelijkingen van de opwaarts balancerende robot. De afleiding van deze formules gaan op dezelfde manier, zoals die van de neerwaarts balancerende robot. De differentiaal vergelijking van de opwaartse robot is:

Vergelijking 14: Differentiaalvergelijking: hoek Îąs is nu ten opzichte van de opwaartse stand (bij Îąs wijst de stator omhoog).

Wanneer je deze formule vergelijkt met Vergelijking 12 valt op dat het plusteken is veranderd in een minteken.

17

5. Regeling In het vorige hoofdstuk hebben we gezien dat het systeem niet stabiel te krijgen is, door alleen de motor aan of uit de zetten. Uit de differentiaalvergelijking bleek dat deze onstabiliteit een eigenschap van het systeem zelf was (eigenfrequentie). In dit hoofdstuk kijken we of dit probleem opgelost kan worden. Dit doen we door een regelsysteem voor de robot te ontwerpen. Maar eerst moeten we ons meer verdiepen in differentiaalvergelijkingen. Daarna kunnen richten we ons op het regelsysteem.

5.1 Algemene vorm van differentiaalvergelijkingen met demping De differentiaalvergelijking die tot nu toe het systeem beschrijft, Vergelijking 12, leert ons dat het systeem zich altijd slingerend zal gedragen. Echter deze vergelijking staat niet in de algemene vorm, het is namelijk een bijzonder geval van de volgende vergelijking:

Vergelijking 15

Voor het gemak hebben we de rechterkant van het gelijkteken nul gemaakt. Dit mag, omdat de vergelijking het systeem op zoâ&#x20AC;&#x2122;n manier beschrijft dat reageert op een verstoring uit het verleden. Voor Vergelijking 15 gaan we proberen een oplossing te vinden. Er wordt een functie beschreven die een relatie heeft met zijn eigen afgeleide en zijn eigen dubbele afgeleide. Een functie waarvan we weten dat de afgeleide gelijk is aan de functie zelf, is y=ex. Daarom proberen we de volgende oplossing:

In te vullen in Vergelijking 15:

Vergelijking 16

Amplitude term p is niet nul (kan wel, maar betekent dat er geen slingering is), de e­ macht is ook niet nul. Dus kan Vergelijking 16 ook geschreven worden als:

Vergelijking 17

Qua vorm is Vergelijking 17 niet anders dan Vergelijking 15: het nemen van de afgeleide is vervangen door een factor s. Vergelijking 17 is een kwadratische vergelijking waarvan nulpunten bepaald kunnen worden. Bij het bepalen van de nulpunten zijn drie mogelijkheden.

1. Discriminant > 0 2. Discriminant = 0 3. Discriminant < 0

18

5.1.1 Discriminant > 0 In dit geval zijn er twee oplossingen, deze zijn te vinden d.m.v. de ABC­formule:

Vergelijking 18

De algemene oplossing voor Vergelijking 15 is dan:

Vergelijking 19

Op het moment dat de gevonden waarde van s positief is, zal αs exponentieel toenemen, naarmate de tijd vordert. Wanneer s negatief is, zal αs exponentieel afnemen en zal αs naar nul toe gaan, αs sterft dus uit.

5.1.2 Discriminant = 0 In dit geval is er maar één oplossing te vinden:

Vergelijking 20

Hieruit volgt dan een oplossing:

Dit is niet de enige oplossing voor de differentiaalvergelijking. Deze oplossing kan ook [5]:

De algemene oplossing voor Vergelijking 15 is dan:

Vergelijking 21

Ook hier geldt: Op het moment dat de gevonden waarde van s positief is, zal αs exponentieel toenemen, naarmate de tijd vordert. Wanneer s negatief is, zal αs exponentieel afnemen en zal αs naar nul toe gaan.

5.1.3 Discriminant < 0 In dit geval zijn er geen reële oplossingen voor s te vinden. Er zijn twee complexe oplossingen te vinden: waarbij: Vergelijking 22

19

In dit geval is de oplossing voor Vergelijking 15:

Vergelijking 23

Met behulp van de formule van euler [6]:

kunnen we dit

herschrijven in:

oftewel:

Vergelijking 24

Deze vergelijking bestaat uit twee delen. Het deel tussen de haakjes is te zien als een slinger. En het deel voor de haakjes bepaalt de amplitude. Deze amplitude is tijdsafhankelijk. En ook hierbij is weer onderscheid te maken tussen een gedempte (b>0)en een versterkte (b<0) slingering. Voor b is nul is er sprake van een constante slingering.

5.1.4 Overzicht van systeemgedrag In Afbeelding 14 is de parabool waarin b is uitgezet ten opzichte van c. De vergelijking die hier bij hoort is: . De waarde van c en b, die bij deze parabool horen, hebben in Vergelijking 17 altijd een discriminant gelijk aan nul. De grafiek is grofweg in vijf stukken te verdelen.

3 2

1

Afbeelding 14: Parabool

20

4

5

Gebied: 1. In dit deel is de discriminant positief. Omdat b negatief is zal αs in dit deel van de parabool exponentieel toenemen.

2. In gebied 2 is de discriminant positief, b is echter negatief. Dit betekent dat αs hier slingerend zal toenemen.

3. De discriminant en c zijn hier positief, b is gelijk aan nul. is dus gelijk aan één, met als gevolg dat αs slingert maar niet in amplitude veranderd.

4. In gebied 4 is de discriminant positief, b is echter negatief. Dit betekent dat αs hier slingerend zal afnemen.

5. In dit deel is de discriminant positief. Omdat b positief is zal αs in dit deel van de parabool exponentieel afnemen.

Duidelijk is dat we willen dat αs afneemt, dat betekent dus dat we een positieve b moeten kiezen. Wat we niet willen is dat αs onstabiel is, dus de discriminant moet groter of gelijk aan nul zijn. Wenselijk is dat de response zo snel mogelijk is, daarom kiezen voor een positieve b en c, waarbij geldt dat de discriminant gelijk is aan nul.

5.2 Regelsystemen Deze paragraaf gaat over het regelsysteem in het algemeen. Een regelsysteem wordt gebruikt om een bepaald proces precies te kunnen besturen, oftewel bij een afwijking zelfstandig een correctie uitvoeren [7]. Een bekend voorbeeld van een regelsysteem is het instellen van de temperatuur doormiddel van een thermostaat. Wanneer er in een ruimte, waarin geen warmte verlies plaatsvindt, een verwarming voortdurend aanstaat, zal de temperatuur in deze ruimte na verloop van tijd gelijk zijn aan die van de verwarming. Omdat je graag zelf wilt bepalen wat de temperatuur in deze ruimte is, moet de verwarming aangestuurd worden door een regelsysteem. In Afbeelding 15 is een algemeen regelsysteem te zien.

Afbeelding 15: Algemeen regelsysteem [7]

Het systeem dat geregeld wordt moet op een of andere manier een terugkoppeling kunnen geven, die door een sensor te meten is [7]. Bij het voorbeeld van de verwarming is dit de temperatuur die deze aan de omgeving afgeeft. De temperatuur kan gemeten worden door een sensor. Vervolgens wordt het sensorsignaal vergeleken met het ingangssignaal. Het ingangssignaal is de gewenste waarde. Uit deze vergelijking volgt een foutsignaal (ε), waarvoor geldt: ε = ingangssignaal – sensorsignaal. Wanneer het foutsignaal gelijk is aan nul, is het ingangssignaal dus gelijk aan het uitgangssignaal.

Terug komend op het voorbeeld van de verwarming: stel de gewenste waarde staat ingesteld op 20 graden en de temperatuur in de ruimte is 18, dit betekent een foutsignaal van twee. De verwarming moet dus aangezet worden om de gewenste temperatuur te bereiken. Hiervoor is de regeling verantwoordelijk. De regeling bepaalt

21

aan de hand van het foutsignaal, wat er met het systeem moet gebeuren. De regeling probeert de uitgangswaarde zo goed mogelijk aan de ingangswaarde gelijk stellen. De regeling moet hiermee rekening houden met verschillende eigenschappen van het systeem. Bijvoorbeeld: wanneer de temperatuur in de kamer omhoog moet, kan de verwarming ervoor kiezen om net voordat de temperatuur gelijk is aan de gewenste waarde, de verwarming uit te zetten, zodat wanneer de verwarming afgekoeld is de temperatuur precies gelijk is aan de gewenste waarde. Het signaal dat de regeling aan de verwarming geeft heet het regelsignaal (Ω0).

5.3 Regelsysteem voor de robot Hierin bespreken we het regelsysteem dat ervoor moet zorgen dat de robot stabiel blijft.

Het is belangrijk om als eerste af te spreken welke grootheid we gaan regelen. Wij hebben gekozen voor de stand van de stator ten opzichte de loodrechte lijn (loodrecht op aard oppervlak). We hebben hiervoor gekozen omdat bij elke stand van de stator een aandrijfkracht hoort.

Afbeelding 16: Het regelsysteem van onze robot

In Afbeelding 16 is een blokschema weergegeven. Het uitgangsignaal is de stand van de stator (αs) en het ingangssignaal is αi. Het ingangssignaal is de gewenste stand van de stator. Het regelsysteem moet ervoor zorgen dat de stand van de stator zo goed als mogelijk de gewenste stand moet volgen, oftewel αs moet zo goed als mogelijk αi volgen.

Blok A bevat motorstuur­elektronica, de motor en de tandwieloverdracht. Blok H bevat een filter dat de regeling zo effectief en stabiel mogelijk maakt. Het gewenste signaal en het gemeten signaal worden met elkaar vergeleken, het verschil ε (foutsignaal) wordt gebruikt om het systeem te corrigeren.

A: Motor en het dynamische systeem van de robot die beschreven wordt met Vergelijking 12.

H: Filter; voor het filter is gekozen voor twee functies, een versterkend deel en een integrerend deel. De bijbehorende vergelijking is:

Vergelijking 25

: Comparator, deze vergelijkt het ingangssignaal met het gemeten signaal. En levert het foutsignaal ε: Vergelijking 26

22

Wanneer Vergelijking 12, Vergelijking 25 en Vergelijking 26 worden samengevoegd, krijg je een nieuwe differentiaalvergelijking voor de neerwaarts geregelde robot: Systeem karakter

Actie op systeem

Vergelijking 27

De linkerkant van de vergelijking beschrijft het systeemkarakter en de rechterkant beschrijft de verwerking van Îąi. De stabiliteit van het systeem wordt door het linkerdeel bepaald. Daarom bekijken we het linkerdeel:

Vergelijking 28

Vervolgen vervangen we de afgeleide door s, zodat we weer een kwadratische vergelijking krijgen:

Vergelijking 29

Dit hebben we ook al een keer gedaan (5.1. Algemene vorm van differentiaal­ vergelijkingen met demping), Vergelijking 17. Wanneer deze twee vergelijkingen met elkaar vergeleken worden, kan het volgende gezegd worden:

Vergelijkingen 30

Als we het slingeren willen voorkomen, moet het systeem kritisch gedempt worden. Dit betekent dat op de rechter tak van de parabool uit Afbeelding 14 moeten zitten. In dat geval geldt: (discriminant gelijk aan nul) Terugkomend op Vergelijkingen 30 betekent dit, dat het systeem kritisch gedempt is bij:

Vergelijking 31

We introduceren nu ook een parameter die zegt in welke mate het ingangssignaal gevolgd wordt door het uitgangssignaal. Deze parameter geeft aan in hoeverre het ingangssignaal gaat lijken op het uitgangssignaal. Om aan te geven wat een systeem op lange termijn doet, gaan we weer kijken naar Vergelijking 27. Wanneer er geen

23

veranderingen meer optreden, zullen alle afgeleide termen naar nul gaan, Vergelijking 27 zal dan overgaan in:

Vergelijking 32

De verhouding van de niet­veranderende alfa’s kan nu geschreven worden als:

Vergelijking 33

Uit deze vergelijking blijkt dat wanneer het systeem stabiel is, het ingangssignaal nooit gelijk kan zijn als het uitgangssignaal, dat komt omdat de noemer is groter dan de teller.

Dit heet de volg­kwaliteit. Als we eisen dat het systeem kritisch gedempt wordt kunnen we de Kp en de τi schrijven als de functie van de systeemparameters en de volgkwaliteit.

Vergelijking 34

Vergelijking 35

In het geval van een opwaarts geregelde robot geldt:

Vergelijking 36

De Kp blijft voor de opwaarts geregelde robot gelijk.

Later in het verslag gaan we voor onze robot (praktische geval) een juiste kp en tau zoeken. Dit gaan we op een proefondervindelijke manier doen. Hierbij is het handig om te weten wat de invloed is van het veranderen van deze waarden op de robot. Ten eerste moet teken (+/­) zodanig gekozen worden dat er sprake is van tegenkoppeling. Ten tweede moet de waarde zodanig gekozen worden dat het systeem snel reageert, zonder instabiel te worden. De kans op instabiliteit neemt doorgaans toe wanneer de kp te groot wordt en de tau te klein. Het systeem kan te traag worden bij een te lage kp. In de praktijk kunnen hier echter uitzonderingen op bestaan. Daarom gaan we bij de praktische test (10. Proeven en resultaten) verschillende waarden voor kp en tau proberen, en kijken wat hiervan het resultaat is.

24

6. Simulaties In dit hoofdstuk worden een aantal simulaties van regelsystemen behandeld. Deze systemen gaan zowel over de neer­ als opwaartse modus. Bij elke simulatie voeren we de complexiteit op. Dit betekent dat we met steeds meer dingen rekening gaan houden.

Het doel van deze simulaties is het bestuderen van de stabiliteit.

6.1. Neerwaartse modus We hebben eerder in het verslag al gekeken naar het gedrag van het systeem. Door Kp en τi op een bepaalde manier te kiezen, kun je op verschillende plekken in het b,c­diagram komen, zie Afbeelding 14. Als eerste kiezen we een Kp en τi op zo’n manier dat het systeem kritisch gedempt (groene lijn in Afbeelding 14) is en dat er een volgkwaliteit van 90 procent is, zie Vergelijking 33 en Vergelijking 34. Het resultaat van deze simulatie is te zien in Afbeelding 17.

Afbeelding 17: Een simulatieresultaat van een kritisch gedempt systeem met een volgkwaliteit van 90 procent. In de bovenste grafiek is het stuursignaal (groen) en het de statorhoek (blauw) weergegeven. De rode grafiek stelt de rotorhoek voor en de lichtblauwe grafiek is de positie van de robot. Eerst wordt er een positief en daarna negatief stuursignaal gegeven. De statorhoek reageert snel en eindigt op 90 procent van het ingangssignaal. Zolang de statorhoek ongelijk aan nul is, zal de robot versnellen/vertragen. Is het ingangssignaal nul, dan is de snelheid constant of nul.

De simulatieresultaten van Afbeelding 17 zijn afkomstig van een punt op de parabool van het b,c­diagram in Afbeelding 14. Nu kijken we wat er gebeurt als we van de parabool afstappen. In de volgende simulatie veranderen we Kp zodat het werkpunt in gebied 4 terecht komt, het systeem zal dus slingerend afnemen, zie Afbeelding 18.

25

Afbeelding 18: De situatie is gelijk aan die van Afbeelding 17, alleen de Kp is verkleind tot een tiende van zijn oorspronkelijke waarde. Het resultaat is dat er een gedempte afname te zien is.

Vervolgens brengen we het werkpunt in gebied 3, de c­as van het b,c­diagram. We weten dat hiervoor Vergelijking 24 geldt. Ook is gelijk aan één, omdat b gelijk is aan nul.

Dus zal de simulatie een ongedempte slingering moeten tonen. Zie Afbeelding 19.

Afbeelding 19: Simulatie resultaat waarbij het werkpunt van het systeem op de c­as ligt. De stator zal ongedempt blijven slingeren. Ook slingert de rotorhoek en de verplaatsing met de stator mee, maar dit is niet zo goed in het plaatje te zien, omdat de grafiek erg ver is uitgezoomd.

26

Nu wordt het werkpunt naar gebied 2 verschoven. Net als de vorige simulatie zitten we nog steeds in het slingerend gebied, alleen zal de amplitude nu toenemen met de tijd.

Het resultaat van deze simulatie is te zien in Afbeelding 20.

Afbeelding 20: Het systeem is slingerend instabiel (toenemend) geworden. De simulatie is afgebroken omdat de signalen exponentieel toenemen.

Als laatst simuleren we een werkpunt in gebied 1. De functie zal niet meer slingeren, maar zal exponentieel toe of afnemen (naar plus of min oneindig). Resultaat hiervan is te zien in Afbeelding 21.

Afbeelding 21: Te zien is een exponentiele afname (naar min oneindig) van de statorhoek.

27

Al deze simulaties hebben nog een relatief simpel motormodel. In de volgende simulatie is een meer realistisch model gemaakt van: de batterijen, de elektronica, de motor en de tandwiel overbrenging. Ook zorgen we ervoor dat de Kp en Ď&#x201E;i op zoâ&#x20AC;&#x2122;n manier gekozen dat het systeem kritisch gedempt (groene lijn van Afbeelding 14) is en dat er een volgkwaliteit van 90 procent is. De resultaten van deze simulatie zijn weergegeven in Afbeelding 22. Wat opvalt zijn de grote verschillen tussen de ideale situatie van Afbeelding 17 en deze situatie. Maar de situatie is nog steeds werkbaar, dit betekent dat de robot in het meer realistische model nog steeds goed presteert.

Afbeelding 22: Simulatie gelijk in kritisch gebied en een volgkwaliteit van 90 procent, maar met een realistisch aandrijfmodel. In dit model zijn slingeringen te zien, dit betekent dus dat het systeem niet helemaal meer kritisch gedempt is.

6.2 Opwaartse modus Bij de simulaties van de opwaartse modus zijn we begonnen met het modelleren van een ongeregeld systeem. Hiermee laten we zien dat het systeem van nature onstabiel is. In deze simulatie is de stator omhoog gezet en de motor wordt geblokkeerd. In alle simulaties van de opwaartse modus, betekent een statorhoek van nul graden, dat de stator precies omhoog wijst. In het theoretische geval zou de stator met een statorhoek van nul in dezelfde positie blijven staan. In de volgende simulatie geven we de statorhoek een hoek die bijna gelijk is aan nul (0.06 graad). De resultaten van deze simulatie zijn in Afbeelding 23 te zien. Te zien is dat de statorhoek toeneemt, dit betekent dat de stator naar beneden valt. Daarna richt de stator zich op, totdat hij bijna weer nul is (op 0.06 graden na). Als hij dit punt bereikt heeft zal de stator weer terugvallen en in zijn oude positie terecht komen. Omdat er een verliesvrij systeem wordt gesimuleerd zal dit zich blijven herhalen.

28

Afbeelding 23: Simulatieresultaat van een ongeregeld systeem in de opwaartse modus. De groene lijn is de hoekpositie van de stator. Omdat stator en rotor vast aan elkaar zitten, zal de rotorhoek (blauwe lijn) precies die van de stator volgen. De positie van de robot wordt weergegeven door de rode lijn. Omdat de stator en rotor in het begin een positieve hoek maken, zal de robot zich naar links in de negatieve richting bewegen.

In de volgende simulatie doen we bijna hetzelfde als de vorige, maar nu start de stator precies in de stand nul (naar boven wijzend). Na één seconde geeft de motor een heel korte puls. Daardoor wordt het evenwicht verstoord en zal de rotor naar beneden vallen. De rotor en stator zullen 360 graden draaien, maar als de stator hoek nul bereikt heeft, heeft deze nog een beetje kinetische energie over. Daardoor zal hij doordraaien, en zal deze beweging zich blijven herhalen. Dit is te zien in Afbeelding 24.

Afbeelding 24: Simulatieresultaat van de robot waarbij de stator in de nulstand begint en waarbij de motor na één seconde een korte puls levert. De stator (groen) en rotor (blauw) hoek nemen trapsgewijs toe. De robot zal zich dus ook trapsgewijs in naar links (negatieve richting) bewegen.

29

In de volgende simulaties is de regeling verwerkt. Net zoals we in de neergaande modus hebben gedaan, gaan we nu weer alle gebieden in Afbeelding 14 langs. De gewenste instelling van de regelvariabelen (kp en tau, Vergelijking 34 en Vergelijking 35), levert een kritisch gedempt systeem op. Dit komt overeen met gebied 5 van het b,c足diagram van Afbeelding 14. Dit is te zien in Afbeelding 25.

Afbeelding 25: Simulatieresultaat van de kritisch gedempte opwaartse modus. De resultaten zijn vergelijkbaar met die van Afbeelding 17 van de neerwaartse modus. Het verschil met de simulatie van Afbeelding 17 is dat de volgkwaliteit nu op 110 procent staat in plaats van 90 procent.

Net als bij de simulaties van de neerwaartse modus lopen we alle gebieden in het b,c足 diagram van Afbeelding 14 langs. In de volgende afbeeldingen zijn de simulatieresultaten te zien van de robot in opwaartse modus, bij elke simulatie hoort een gebied van Afbeelding 14.

Afbeelding 26: simulatieresultaat van gebied 4, het systeem is slingerend gedempt.

30

Afbeelding 27: Simulatieresultaat van een systeem dat zich in gebied 3 bevindt.

Afbeelding 28: Simulatieresultaat van het systeem in gebied 2. Het systeem neemt slingerend toe.

31

Afbeelding 30: Simulatieresultaat van een realistisch model van de robot in opwaartse modus. De regelparameters die voor het ideale model nog een kritisch gedempt systeem opleverden, blijken voor dit model niet te kloppen: er is instabiliteit.

In plaats van dat we Vergelijking 14 aanpassen aan het realistische model, hebben we ervoor gekozen om de kp en tau zo te kiezen dat het realistische model stabiel wordt.

Afbeelding 31: Realistisch systeem, waarbij de kp en tau zo gekozen zijn dat het systeem stabiel is. Echter er blijft een kleine slingering aanwezig, deze is niet weg te krijgen.

We hebben nu een aantal simulaties van de opwaartse modus gezien, allemaal begonnen de stator omhoog en de regeling meteen aan. Het mooiste is wanneer de robot vanuit neerwaartse modus zou kunnen starten en in de opwaartse modus brengen. Met de

33

volgende simulatie gaan we kijken of dit mogelijk is, dit is te zien in Afbeelding 32. De simulatie begint in de opwaartse stand met de regeling uitgeschakeld. Na vijf seconden geeft de motor een kleine verstoring aan het systeem, zodat de stator naar beneden valt.

Op tijdstip 20 seconden zetten we de regeling aan en brengt de regeling de stator in de opwaartse modus. Hiervoor is veel kracht nodig, daardoor is de robot gaan rijden. Vanaf 42 seconden geven we een kleine stuurpuls, die de robot weer terug laat komen in de richting van zijn oude positie.

Afbeelding 32: De bovenste grafiek, V(controlled) geeft de regeling aan, laag betekent dat de regeling uitstaat en hoog betekent dat de regeling aanstaat. De groene lijn (alphas) is de statorhoek, de blauwe lijn (alphain) is het stuursignaal, de rode lijn (alphar) is de hoek van de rotor, de grijze lijn (motorvoltage) geeft de spanning over de motor weer, de groene lijn (Ix) geeft aan hoeveel stroom de motor vraagt en de lichtblauwe lijn (xpos) geeft de positie van de robot aan.

34

Praktische uitwerking van de balancerende robot In het theoretische gedeelte hebben we de dynamica van onze robot beschreven, ook hebben we uitgezocht hoe het regelsysteem van onze robot eruit moet zien. Vervolgens hebben we simulaties gedraaid om te kijken wat van een gedrag de robot vertoont. Nu we deze informatie hebben is het tijd om de robot te bouwen! In dit gedeelte gaan we een aantal punten bij langs die van belang zijn voor het bouwen van onze robot. We beginnen met ‘de bouw’. In dit hoofdstuk leggen we uit hoe de robot in elkaar zit en waarom we hem op deze manier gebouwd hebben. Vervolgens leggen we de elektronica in de robot uit. Daarna behandelen we de software die we hebben geschreven hebben om het regelsysteem en aansturing werkend te krijgen. En tot slot gaan we de proeven, die we met de robot hebben gedaan, bij langs en leggen we de bijbehorende proefresultaten uit.

7. Bouw Onze robot bestaat grofweg uit drie delen: de motor, de stator en de rotor. In dit hoofdstuk lopen we elk deel bij langs en leggen we uit waarom we het op onze manier hebben gedaan.

7.1 De motor Het eerste wat we gedaan hebben is een geschikte motor uitgezocht. Aan deze motor moest twee eigenschappen hebben: ten eerste moest de motor erg krachtig zijn. We weten van het hoofdstuk ‘koppel en hoeksnelheid’ dat de kracht die motor moet leveren heel erg groot is, zie Afbeelding 33.

ͫ

Afbeelding 33: De kracht die de motor moet leveren (Fm) is: ̵ ͫ

ῗ

ͬ

En ten tweede moet de motor zowel voor­ als achteruit kunnen draaien. Want om in evenwicht te blijven moet de robot voor­ en achteruit kunnen rijden. Een motor die aan deze eisen voldoet is de MFA 919D501.

35

Afbeelding 34: MFA 919D501 met tandwielvertraging.

7.1.1 MFA 919D501 Deze motor draait zowel voor­ (twaalf volt) als achteruit (min twaalf volt) [8] en heeft een tandwielvertraging van 50:1. Deze vertraging zorgt er voor dat de motor veel kracht kan leveren. Volgens de datasheet heeft deze motor zonder vertraging een ‘stall torque’ van 1000 g – cm. Omgerekend is dit 9,81*10­2 Nm. Dat betekent dat met de vertraging van 50:1, de motor in staat is om een arm van één meter waar op het uiteinde een kracht van 4,91N wordt uitgeoefend, in stand te houden (door de tandwielvertraging van motor en as wordt dit zelfs nog meer). Wij gaan er van uit dat dit ruim voldoende is voor onze robot, de proeven zullen uitwijzen of dit inderdaad zo is. Door deze 50:1 vertraging heeft de motor op twaalf volt een toerental van slechts 316 rpm (ongeveer 5 rondjes per seconde). De tandwielen die we gebruiken voor de overdracht van motor naar as hebben een vertraging van 8:3. Dit betekent dat de wielen van de robot een maximale snelheid hebben van 118,5 rpm (ongeveer 2 rondjes per seconde). Ook hier zijn wij er weer van uit gegaan dat deze snelheid voldoende is om de robot in evenwicht te houden, de proeven moeten uitwijzen of dit ook echt zo is.

De MFA 919D501 verbruikt op vol vermogen 34,2 W en levert een vermogen 21,2 W, dat geeft een rendement van 62%. Het energieverbruik van deze motor lijkt erg hoog, vooral omdat de robot op batterijen moet rijden. Dit zou betekenen dat 10 batterijen van 1,2V en 2000mAh, wanneer de motor op vol vermogen draait, na 42 minuten op zijn. Alleen omdat de motor bij een goede regeling slecht heel kleine correcties hoeft uit te voeren, zal het energieverbruik veel minder zijn en is de robot in staat om veel langer te doen met één batterijlading.

36

7.2 De stator Een ander deel van de robot is de stator. Zoals al eerder is genoemd bestaat de stator uit: de motor, de elektronica, de behuizing en de batterijen. Nadat de motor besteld was en de motorsturing op een printplaat gezet was, konden we bepalen hoe de stator eruit moest zien en waaraan deze moest voldoen. Omdat we niet alles kunnen voorspellen, hebben we dit deels op gevoel gedaan en deels op logica. De stator moet aan de volgende eisen voldoen: Omdat de krachten die op de robot komen te staan erg groot zijn, is het belangrijk dat het materiaal van de behuizing erg stevig is.

Er moet ruimte zijn voor de motor en motorsturing.

Er moet ruimte zijn voor een Raspberry Pi, Arduino, sensoren en overige elektronica. Het is belangrijk dat je makkelijk bij de elektronica kunt komen, om op deze manier simpel onderdelen kunt toevoegen of vervangen.

Er moet een compartiment voor de batterijen aanwezig zijn. Omdat de batterijen vaak opnieuw opgeladen moeten worden, is het belangrijk dat deze er makkelijk in en uit te halen zijn.

Rekening houdend met deze eisen zijn we op het ontwerp in Afbeelding 35 gekomen.

Afbeelding 35: Het eerste ontwerp van de robot

37

Aan de hand van het ontwerp zijn we de stator gaan bouwen. We begonnen bij het motorhuis. Als materiaal hebben we voor aluminium gekozen. Aluminium is om een aantal redenen een geschikt materiaal: het is erg sterk, ten tweede het is goed te buigen en het is ook nog eens erg licht. Dat aluminium makkelijk buigbaar is, is ook weer een nadeel, het moet bestand zijn tegen grote krachten. Om te voorkomen dat het aluminium buigt, is het met popnagels bevestigd aan holle aluminium staven, dit is te zien in Afbeelding 36.

Afbeelding 36: Het motorhuis met motor.

In de opstelling van de elektronica hebben wel een paar wijzigingen plaatsgevonden ten opzichte van het ontwerp. Omdat we de robot ook op afstand willen besturen hebben we een Raspberry Pi nodig hebben, komt het qua ruimte beter uit wanneer de motorsturing en Arduino met Raspberry Pi van plaats wisselen. Omdat de Arduino en Raspberry Pi regelmatig uit de robot gehaald moeten worden, bijvoorbeeld voor programmeren of kabels aansluiten, is het handig dat deze er gemakkelijk uit gehaald kunnen worden. Daarom hebben we deze op een aluminium plaat gezet, deze plaat is gemakkelijk uit de robot te halen. Ook hebben we de sensor op deze plaat bevestigd, om deze zo dicht mogelijk bij de Arduino te hebben. Deze plaat met elektronica wordt op zijn beurt weer aan het batterij足compartiment gezet. Het batterijcompartiment is helemaal onderaan geplaatst (het verst van de as), dit hebben we gedaan om zo gemakkelijk bij de batterijen te kunnen. De afbeeldingen hiervan zien hieronder te zien.

Afbeelding 37: Het batterij足compartiment

38

1

Batterij足compartiment Afbeelding 38: Op de afbeelding links boven is te zien hoe de aluminium plaat (1) aan het batterij足 compartiment zit. De afbeelding rechtsboven laat zien hoe de elektronica hierop bevestigd zit. De onderste afbeelding laat zien hoe de elektronica in de robot zit.

Omdat tijdens het testen van de robot het vaak voorkwam dat er even snel wat elektronica toegevoegd moest worden en omdat de robot over een aantal knoppen moest beschikken, hebben we er voor gekozen om de robot te voorzien van een aantal breadboards. Een breadboard is een bord waar elektronica in geprikt kan worden, het voordeel van een breadboard is dat er gemakkelijk elektronische schakelingen op gemaakt kunnen worden, zonder dat er gesoldeerd hoeft te worden. In Afbeelding 39 is te zien hoe de stator er uiteindelijk uit is komen te zien.

Afbeelding 39: De uiteindelijke stator met motor, motorsturing, elektronica, breadboards en batterij足 compartiment.

39

7.3 De rotor Als laatste hebben we wielen (rotor) nodig. Nu de stator af is weten we hoe groot de wielen minimaal moeten zijn. De wielen moeten groot genoeg zijn, zodat de stator de grond nooit mag raken. Ook moeten de wielen voldoende grip hebben met de grond.

Uiteindelijk bleken de wielen van een tweedehands kinderwagen hier het meest geschikt voor. Vervolgens moesten de wielen aan de as van de stator bevestigd worden.

In Afbeelding 40 is te zien hoe de wielen bevestigd zijn.

Afbeelding 40: Kinderwagenwielen voor en achter (links) en bevestigd aan de stator (rechts).

Het is erg belangrijk dat de wielen zo vast mogelijk op de as van de stator zitten, dit om speling te voorkomen. Speling zorgt ervoor dat de stabilisatie moeilijker verloopt. Om de speling tussen de wielen en de as te voorkomen hebben we het volgende bedacht: op de as hebben we voor beide wielen een tandwiel gezet. Het tandwiel is aan de as vast te zetten doormiddel van een schroef. Vervolgens zetten we de wielen op de as en wikkelen nylon draad om de spaken van het wiel en de tanden van het tandwiel heen.

Tot slot doen we een tie wrap tussen het tandwiel en het wiel van de kinderwagen, wanneer we deze aantrekken, spannen de nylon draden zich, waardoor er bijna geen speling meer is tussen het wiel en de as. Het resultaat hiervan is te zien in Afbeelding 41.

Afbeelding 41: het nylon tussen het wiel en het tandwiel zorgt ervoor dat er geen speling tussen het wiel en de as is.

40

7.4 Totaal overzicht In deze paragraaf laten we de fotoâ&#x20AC;&#x2122;s van de uiteindelijke robot zien, om zo een indruk te geven van de robot.

Afbeelding 42: Vooraanzicht (links) en achteraanzicht (rechts) van de robot.

Afbeelding 43: onderaanzicht (links) en bovenaanzicht (rechts) van de robot. Bij het onderaanzicht wijst de stator naar de grond, bij het bovenaanzicht staat de stator rechtop.

Afbeelding 44: Zijaanzicht van de robot. De stator wijst omhoog.

41

8. Elektronica We hebben de natuur­ en wiskunde achter de robot besproken alswel de robot in elkaar gezet. Nu gaan we verder in op de elektronica die wij hebben gebruikt.

8.1 Motorstaansturing Zoals eerder verteld beschikt onze robot over één motor. Aan deze motor hadden wij enkele eisen gesteld: 1. Hij moet krachtig genoeg zijn 2. Hij moet in beide richtingen (voor & achteruit) kunnen draaien Wij hebben de motor MFA 919D501 gekozen (zie paragraaf 7.1.1). Deze motor kan op zijn piek 34.2 watt vragen. De motoraansturing moet dit ook aankunnen. Tevens kan deze motor in beide richtingen draaien. Om dit goed aan te sturen maken wij gebruik van een H­Bridge.

8.1.1 H­Bridge Een H­Bridge heeft zijn naam te danken aan zijn visuele uiterlijk, H vormig, zoals te zien in afbeelding 45.

Afbeelding 45: de H­Bridge

Je ziet hier 4 ‘knopjes’ (in de motorsturing zijn dit FET’s), S1 tot en met S4. Door een combinatie van knopjes in te drukken kan je de stroomrichting door de motor regelen.

42

Afbeelding 46: De geactiveerde H­Bridge

Zoals zien is in afbeelding 46 zijn er 2 situaties ontstaan: 1. S1 en S4 ingedrukt 2. S3 en S2 ingedrukt In situatie 1 is de plus pool van de motor verbonden aan de plus pool van de batterij, evenals de negatieve polen. Dit resulteert erin dat de motor rechtsom gaan draaien. In situatie 2 is het tegenoverstelde aan de hand. De positieve pool van de batterij is nu verbonden aan de negatieve pool van de motor en de negatieve pool van de batterij aan de positieve pool van de motor. Hierdoor gaat de stroom in de tegenovergestelde richting lopen, en gaat de motor dus linksom draaien.

Om de snelheid van de motor te bepalen gaan wij de knopjes op een frequentie indrukken en weer loslaten. Hierdoor verandert de effectieve spanning die op de motor komt te staan, en dus de snelheid. Dit signaal (PWM), wordt gemaakt door de input vanaf de Arduino te verwerken.

8.1.2 PWM PWM staat voor Pulse Width Modulation. PWM is een manier om de hoogte van een spanning te regelen. Stel je wil een motor aansturen. Je zou de snelheid van de motor kunnen bepalen door een weerstand. Deze weerstand wordt vervolgens warm, omdat hij die extra energie kwijt moet. We hebben in dit geval dus energie verlies. We kunnen de motor ook aan sturen met een PWM signaal. Een PWM signaal pulseert tussen de maximale en minimale spanning (bijvoorbeeld 12V â&#x20AC;&#x201C; 0V). Als wij vervolgens pulseren tussen 12 en 0 volt, waarbij het per periode 50% 12 volt is geweest en 50% 0 volt, zal de motor een spanning ervaren van 6 volt. Door dit percentage te veranderen kan men dus de ervaren spanning aanpassen, zonder energie verlies [10].

43

8.1.3 printplaat

Afbeelding 47: De printplaat van de motoraansturing

Op afbeelding 47 is de printplaat van de motoraansturing te zien. Deze printplaat kunnen we opdelen in 2 delen: 1. Gedeelte wat 12 volt omzet in 5 volt voor de Raspberry Pi en Arduino.

2. Gedeelte voor de signaal verwerking.

Het eerste gedeelte (blauw) maakt van de 12 volt van de batterijen 5 volt voor de Arduino en Raspberry Pi. Dit gebeurt door de voltage regulator aangegeven met #2.

Deze regulator kan maximaal 2 ampère verwerken. Het tweede gedeelte (groen) regelt de verwerking. Dit wordt geregeld door een aantal ICâ&#x20AC;&#x2122;s die nader worden benoemd in de bijlage [Bijlage C].

44

8.1.4 Logische poorten Wij maken gebruik van een aantal logische poorten. Deze poorten doen allemaal hetzelfde, namelijk signaal vergelijken. Dit doet elke poort op zijn eigen specifieke manier. Dit kan je ook mooi zien in de waarheidstabellen van elke poort (1 correspondeert met hoog, 0 correspondeert met laag).

AND poort Ingangen 0 1 0 1

0 0 1 1

Uitgang 0 0 0 1

De AND poort geeft dus hoog als beide ingangen ook hoog zijn, in alle andere gevallen geeft hij laag. [11] XOR poort Ingangen 0 1 0 1

0 0 1 1

Uitgang 0 1 1 0

De XOR poort is een variant op de OR poort. Een normale OR poort geeft hoog als één óf allebei de ingangen hoog is/zijn. De XOR poort, wat staat voor Exclusive OR poort, geeft hoog als slechts 1 van de ingangen hoog is. Het verschil met de normale OR­poort is dus dat de XOR poort laag geeft als allebei de ingangen hoog zijn. [12] NAND poort Ingangen 0 1 0 1

0 0 1 1

Uitgang 1 1 1 0

De NAND­poort kan worden opgevat als een AND­poort, gevolgd door een invertor. In de waarheidstabel is de kolom voor de uitgang van de NAND daarom precies geïnverteerd vergeleken met die van de AND­poort. [13]

45

Comparator Een comparator is een vergelijker. Hij heeft twee input spanningen, één dient als richtlijn (V­) en de andere als te vergelijken spanning (V+). Je hebt hierbij 3 verschillende vergelijk mogelijkheden [14]: 1. V+ < V­ 2. V+ = V­ 3. V+ > V­ Ingangen V+ < V­ V+ = V­ V+ > V­

Uitgang 0 0* 1

* In het geval dat beide ingangen gelijk zijn, zal de comparator, die in feite een versterker is met zeer hoge versterkingsfactor, vaak toch een ‘hoog’ of een ‘laag’ geven. Als V+ dichtbij V­ ligt, kan de comparator een onrustig gedrag krijgen, omdat de uitgang steeds ‘omklapt’.

8.1.5 Verwerking De motoraansturing krijgt het signaal van de Arduino binnen via poort C (Afbeelding 47). De Arduino heeft een bereik van 0 – 5 volt, echter wilden wij de motor zowel voor­ als achteruit laten rijden. De ruststand, het moment dat de motor niet beweegt, ligt dus bij 2.5 volt. Hierdoor hebben we evenveel kracht voor (2.5 – 5.0 volt) alswel achteruit (0 – 2.5 volt). Echter moet de uitkomst van 2.0 volt gelijk zijn aan de uitkomst bij 3.0 volt (allebei een verschil van 0.5 volt van de rusttoestand). Om dit signaal te verwerken maken we twee zaagtanden, die elkaars inverse zijn (IC #8 , zie Afbeelding 48).

Afbeelding 48: de twee (elkaars inverse) zaagtanden.

Deze zaagtanden hebben 2.5 volt als evenwichtsstand. De comparator vergelijken vervolgens de inputspanning van de Arduino met deze twee zaagtanden (Wij kijken nu eerst naar de stilstand, waar de inputspanning van de Arduino 2.5 Volt is, deze uitkomst vergelijken wij later met andere inputspanningen.). Wij stellen V+ als de zaagtand en de V­ als de signaalspanning. Dit resulteert in een twee blokgolven die hoog zijn als de betreffende zaagtand boven de input spanning van de Arduino komt (zie abeelding 49).

Afbeelding 49: De twee blokgolven die we krijgen na de comparator

46

De twee blokgolven en ook het richtingssignaal worden geïnverteerd. Dit gebeurt door NAND­poorten die als invertors geschakeld zijn. Het resultaat voor de blokgolven is weergeven in Afbeelding 50.

Afbeelding 50: de twee geïnverteerde blokgolven.

We hebben nu dus twee blokgolven, die gaan we samenvoegen tot één blokgolf. Dit doen wij doormiddel van de XOR poort, met beide blokgolven als ingangen. Hierdoor wordt de uitgang een blokgolf die laag is als beide ingangen hoog of laag zijn en hoog is als één ingang hoog en de andere ingang laag is. In dit bijzondere geval dat de ingangsspanning 2.5 V is, zal het resultaat van de XOR poort dus een hoog signaal opleveren (zie Afbeelding 51). De blokgolf die we hier eruit krijgen is het uiteindelijke PWM signaal wat naar de H­Bridge wordt gestuurd.

Afbeelding 51: de resulteerende blokgolf na het samenvoegen in het geval van 2.5 volt.

In afbeelding 52 en afbeelding 53 zijn twee simulaties weergegeven, de één met een ingangssignaal van3.5 volt en de ander 1.5 volt.

Afbeelding 52: simulatie met een input spanning van 3.5 volt.

47

Afbeelding 53: simulatie met een input spanning van 1.5 volt

Allebei een afwijking van 1.0 volt ten opzichte van het rustpunt (2.5 volt). Je ziet ook dat het uitgang signaal (de laatste blauwe blokgolf) bij allebei identiek zijn. Dit moet ook omdat de motor in beide gevallen even hard moet rijden. We hebben hier echter geen verschil in voor en achteruit, iets wat wel een eis was. Om dit mogelijk te maken gebruiken we de comparator. Als V+ gebruiken wij het inputsignaal van de Arduino en als V­ nemen wij 2.5 volt. Het signaal van de comparator wordt dus hoog als het input signaal hoger is dan 2.5 volt (vooruit) en wordt laag als het input signaal lager is dan 2.5 volt (achteruit). Dit signaal wordt doorgestuurd naar de H­Bridge, die er vervolgens voor zorgt dat de motor in de goede richting draait.

8.2 Sensor Om de hoek te meten gebruiken wij een sensor. Deze sensor zet de gemeten hoek om in een elektrisch signaal. De sensor zit op een klein printplaatje die het elektrisch signaal door stuurt. Wij gaan hier bespreken hoe deze sensor is opgebouwd.

8.2.1 MEMS Als je kijkt naar de printplaat van een sensor zie je een klein IC. In dit IC zit de meet apparatuur waarmee de sensor zijn waarnemingen doet. Dit IC wordt geproduceerd volgens het MEMS principe. MEMS staat voor Micro­elektromechanische systemen, kleine elektronische, mechanische systemen. In zo’n systeem zitten onderdelen die bewegen.

Die beweging zorgt voor een verandering, wat zorgt voor een meetbaar verschil. Dit verschil wordt vervolgens versterkt en naar de gebruiker van de sensor gestuurt. De twee type sensoren die wij gebruiken zijn ook gemaakt volgens dit principe. De accelerometer en de gyroscoop [15].

8.2.2 Accelerometer Een accelerometer (ook wel versnellingsmeter genoemd) meet de versnelling die de sensor ondervindt. De accelerometer wordt gemaakt op basis van de MEMS techniek. Bij een accelerometer wordt er condensator nagemaakt. Een condensator is een component waarin een elektrische lading wordt opgeslagen [9]. Dit gebeurt doormiddel van 2 48

geleidende platen waar een isolator tussen zit. Je laadt een condensator op door er spanning op te zetten. Hierdoor raakt ĂŠĂŠn plaat verzadigd met elektronen (verbonden met de negatieve pool) terwijl de andere plaat geen elektronen heeft (verbonden met de positieve pool). Op ten duur springen de elektronen over. Hoe lang dit duurt hangt af van de capaciteit van een condensator. De capaciteit hangt af van de ruimte tussen de twee geleidende platen.

Afbeelding 54: een MEMS accelerometer in ruststand.

In afbeelding 54 is een versimpelde weergave te zien van een accelerometer. Je ziet hier een zwart blok met een rechthoekig uitsteeksel en twee grijze rechthoeken. Alle drie de rechthoeken zijn geleidend. Echter kan het zwarte object los bewegen en zitten de grijze rechthoeken vast. Je hebt hier dus twee condensatoren, de linker grijze rechthoek met de zwarte rechthoek en de rechter grijze rechthoek met de zwarte rechthoek. Op het moment dat de accelerometer zich in ruststand begeeft hebben beide condensatoren dezelfde capaciteit omdat de afstand tussen beide platen gelijk is. Echter wat er gebeurd als de accelerometer wordt bewogen kan je zien in afbeelding 55.

Afbeelding 55

Hier wordt de accelerometer bewogen. Het zwarte object komt hierdoor ook in beweging. Als gevolg van dit wordt afstand tussen de zwarte en grijze rechthoeken anders en dus verandert ook de capaciteit. Een MEMS accelerometer meet dit verschil in capaciteit. [15].

49

8.2.3 Gyroscoop Een ouderwetse gyroscoop is een kleine cilinder met een staaf door het middelpunt. Als je deze cilinder met een grote snelheid aandraait zal je merken dat de gyroscoop zich verzet tegen veranderingen van hoek [16]. Denk hierbij aan je fietswiel of een tol. Dit principe werkt ook op een object wat heen en weer slingert. De slinger van Foucault bijvoorbeeld. De slinger van Foucault is slinger met een lengte van 67 meter en een gewicht van 27 kilogram aan de onderkant [17]. Hierdoor kan de slinger zich zelf erg lang laten oscilleren zonder dat er hulp bij nodig is, dit is de eerste wet van Newton. Je zou verwachten dat de slinger in een rechte lijn bleef oscilleren, want niemand oefende er een andere kracht op uit. Toch veranderde de slinger van baan. Dit kwam door de draaiing van de aarde. Het gebouw, waaraan het touw van de slinger bevestigt was, draaide namelijk mee met de aarde. Door deze draaiing en het oscillerende patroon ontstond er een kracht. Deze kracht heet de corioliskracht. [18]. In een MEMS gyroscoop gebeurt dit ook. Er zit een oscillerende massa in. Als je vervolgens de gyroscoop draait ondervind deze een corioliskracht, de massa beweegt naar links of rechts. Deze kracht is elektronisch te detecteren.

8.2.4 MPU 6050 De sensor die wij gebruiken voor de robot is de MPU­6050. Wij hebben voor deze sensor gekozen omdat deze zowel een accelerometer als een gyroscoop bevat. Wij hadden beide sensoren nodig. Als de robot valt, ondervindt de sensor een versnelling. Deze versnelling wordt waargenomen door de accelerometer. Maar omdat de accelerometer normaal de hoek bepaald doormiddel van de valversnelling, wordt deze nu verstoort door de versnelling door de robot. Hierdoor is de waargenomen hoek niet meer accuraat. Hierdoor was de sensor niet accuraat genoeg. Door de toevoeging van de gyroscoop, welk de mate van hoekverandering meet, kan de mpu6050 dit eruit filteren.

De MPU6050 is een digitale sensor. Dit wil zeggen dat je moet communiceren tegen de sensor om waarden terug te krijgen. Dit in tegenstelling tot een analoge sensor, welk voltages teruggeeft welk evenredig is met de desbetreffende hoek. Het communiceren met de sensor gebeurd volgens het I2C protocol. Hoe dit in zijn werk gaat bespreken wij in paragraaf 9.1.1 . Doormiddel van dit protocol krijgen wij 3 hoeken binnen, de ‘yaw’, ‘pitch’ en de ‘roll’ (zie afbeelding 56).Omdat wij onze robot stabiliseren in één dimensie en wegens de plaatsing van de sensor maken wij alleen gebruik van de roll.

Afbeelding 56: De yaw, pitch en roll met de respectievelijke assen.

50

8.3 Arduino De Arduino is een microcontroller. Deze microcontroller stelt je instaat om elektrische signalen te verwerken om zo bijvoorbeeld lampjes aan te sturen. Mede doordat dit apparaat niet zo duur is wordt het voor veel toepassingen gebruikt. Echter doet de Arduino niets als je hem niet hebt geprogrammeerd. Dit gebeurt in een dialect van C++, hierdoor heb je geen toegang tot de library’s van C++ omdat de Arduino te weinig RAM geheugen heeft [19]. Het programmeren kan je in verscheidene programma’s doen [20].

Wij hebben gekozen voor de officiële Arduino IDE omdat deze direct op de site van Arduino werd aangeboden en wij hierbij geen problemen ondervonden. Twee functies in de code zijn van belang voor de Arduino: 1. void setup(){} 2. void loop(){} In de setup() wordt tegen de Arduino gezegd wat hij moet uitvoeren als hij opstart. Dit houdt in dat je bijvoorbeeld digitale pinnen als in­ of uitgang definieert en eventuele variabelen een eerste waarde geeft. Vervolgens komt de loop(). In deze functie schrijf je wat de Arduino, herhaaldelijk, moet uitvoeren. Herhaaldelijk, want als deze functie klaar is wordt hij opnieuw aangeroepen totdat de Arduino wordt uitgeschakeld of wordt gereset.

Wij gebruiken de Arduino voor de regeling van de robot (Afbeelding 16) en de input die de Arduino krijgt van de Raspberry. Die input kan twee dingen doen: 1. De robot starten/stoppen 2. De robot vooruit / achteruit laten bewegen Wij beschrijven de verdere werking van de Arduino in onze robot in het hoofdstuk: Software

8.4 Raspberry Pi De Raspberry Pi is een singleboardcomputer. Dit wil zeggen dat het een volledige computer is op 1 pcb. Je hebt verschillende versies van de Raspberry; 1. Raspberry A 2. Raspberry B 3. Raspberry B+ 4. Raspberry 2 B Hoe nieuwer het model is, hoe uitgebreider de specificaties zijn (zie bijlage). Zoals eerder vermeld is dit een computer. Je kunt hier dus een Operating System op zetten, een Linux variant. Hierdoor zijn de mogelijkheden die je ermee kan doen oneindig, je hebt netwerk mogelijkheden, alle programmeertalen die je op een Linux omgeving hebt.

Ook heb je beschikking over GPIO (general­purpose input/output) pins, waarmee je een soortgelijke functionaliteit hebt als de Arduino.

Wij gebruiken de Raspberry Pi B+ in onze robot om 2 redenen: 1. De robot aan te kunnen sturen van buitenaf 2. Informatie over de robot naar buiten sturen De Raspberry is hier de geschikte kandidaat voor omdat hij ten eerste niet duur is, hij is klein en verbruikt niet veel energie en je kan er Linux op draaien waardoor je qua software ook alle keuze hebt. Hoe wij deze software aanpakken beschrijven wij in paragraaf 9.2.1.

51

9. Software Nu wij weten hoe de elektronica werkt beschrijven wij de gebruikte protocollen en onze geschreven software.

9.1 Protocollen Software zonder protocollen bestaat niet. Protocollen leggen vast hoe je acties moet uitvoeren. Hierdoor weet je wat je kan verwachten en wat je moet verzenden. In deze paragraaf gaan we de protocollen uitleggen die wij hebben gebruikt.

9.1.1 I2C Om te kunnen communiceren met onze MPU­6050 sensor maken wij gebruik van het I2C protocol. Je kan je dit protocol voorstellen als een kantoor. Je hebt 1 baas, de master node, en die is de baas over een aantal werknemers, de slave nodes. Er kunnen echter maar 127 werknemers tegelijkertijd aan het werk zijn omdat elk werknemer zijn eigen unieke nummer heeft, het adres. Dit adres is opgemaakt uit 7 bits. Hiermee kan je de nummers 0 tot en met 127 maken (0000000 tot en met 1111111 in binear).

De communicatie tussen de master en de slaven nodes gebeurd volgens een vast schema.

Je hebt hiervoor 2 fysieke connecties nodig, de SCL en de SDA. Beide connecties kunnen zowel hoog als laag zijn. Dit komt overeen met een voltage die wordt vastgesteld door de master node (hoog zijnde maximum voltage, laag zijnde 0 volt). In het begin zijn zowel de SDA als de SCL hoog. Als de master data wil ontvangen of sturen maakt hij de SDA laag. Hierdoor weten de slave nodes op de I2C bus dat de master iets wil doen. Dit wordt het start signaal genoemd/ (Afbeelding 57)

Afbeelding 57: S: start­bit, elk blauw vlak kan de SDA veranderen naar hoog/laag als de te schrijven bit 1/0 is.

Als laatst komt de stop bit.

Als dit start signaal is gegeven gaat de SCL pulseren, hoog – laag – hoog – laag – hoog – etc. Telkens als de SCL laag is mag de SDA veranderen. De data wordt verstuurt in bytes.

Een byte is opgemaakt uit 8 bits. Een bit is een 1 of een 0. Elk karakter is opgemaakt uit een byte. Zo komt de letter a overeen met de byte 01100001 (dit komt overeen met het getal 97 (2^0 + 2^5 + 2^6)). Alle overige karakters staan in de bijlage. Als de te verzenden bit 1 is, wordt de SDA hoog. Als de te verzenden bit 0 is, wordt de SDA laag.

De communicatie tussen de master en de slave node begint met het adres van de betreffende slave node. Zoals eerder gezegd bestaat het adres uit 7 bits. Om er een byte van te maken wordt er een bit achter geplakt. Deze bit is 1 als de master data wil ontvangen van de slave node en is 0 als de master data wil sturen naar de slave node. Dit wordt vervolgens opgestuurt naar de slave node. De slave node stuurt op zijn beurt een bevestegings bit terug, een bit die 1 is als het bericht goed is ontvangen en 0 is als er iets mis is gegaan. Nu kan het twee kanten op; 1. De master wou informatie ontvangen 2. De master wou informatie sturen

52

In het eerste geval gaat de slave node eerst de informatie verpakken in bytes omdat de informatie in bytes verzonden moet worden. Nadat een byte verstuurt is moet de master node een bevestegings bit sturen om aan de slave node te laten weten dat alles goed of niet goed is gegaan. Dit gaat door tot dat het hele bericht is verstuurt. In het tweede geval gaat de master node de informatie verpakken in bytes, om die vervolgens byte voor byte naar de slave node te sturen. De slave node stuurt na elke byte een bevestegings bit terug naar de master node om te laten weten of alles goed is gegaan of niet. Dit gaat door tot dat het hele bericht is verstuurt. Als in beide gevallen het hele bericht is verstuurt wordt er een stop signaal gegeven door de master node. Hierdoor weet de slave node dat zijn taak klaar is, en de andere slave node’s die verbonden zijn met de master node weten dat zijn weer kunnen worden aangeroepen. Een stop signaal is het tegenovergestelde van het start signaal. De master node maakt de SCL hoog terwijl de SDA laag is. Als de SCL hoog is maakt de master de SDA ook hoog. Dit is het stop signaal.

9.1.2 HTTP Voor de communicatie tussen twee apparaten via het internet ontkom je bijna niet aan het HTTP protocol. HTTP staat voor HyperText Transfer Protocol en wordt gebruikt voor de communicatie tussen een server en een client. In dit protocol is vastgesteld hoe je iets moet vragen aan de server, de request, en hoe de server hierop antwoordt, de response.

De request is opgebouwd uit een voorgeschreven recept: 1. Het soort request 2. De URL van de server 3. Extra informatie (ookwel Headers genoemd) 4. (optioneel) inhoud Het soort request beschrijft het type vraag. Je hebt 6 soorten: 1. GET (ontvang informatie / bestand van de server) 2. POST ( zend gegevens / bestand naar de server) 3. PUT ( vervang gegevens / bestand door de verzonden inhoud ) 4. DELETE ( verwijder gegevens / bestand van de server) 5. OPTIONS ( ontvang de mogelijke functies van de server) 6. HEAD (ontvang alleen de Headers (extra informatie) van het gevraagde bestand) De URL moet je mee sturen omdat de communicatie tussen server en client gebeurt met IP adressen. Een IP adres kan je zien als het adres van een huis voor je computer op het internet. Om deze adressen georganiseerd te houden heeft het internet een adressenboek, dit heet het DNS systeem [23]. Hier staan de URL’s in met het corresponderende IP adres. Om het IP adres te achterhalen vraagt de computer aan het DNS systeem welk IP adres er hoort bij het gegeven URL. Vervolgens wordt de request doorgestuurd naar het goede IP adres. De headers geven extra informatie die nodig kan zijn voor de verwerking van de request.

Enkele belangrijke headers zijn: ­ Content­Length ( dit geeft de lengte van de (optionele) inhoud. Hierdoor kan de server kijken of alles al is binnen gekomen / niet beschadigdis.) ­ Location ( Stel je klikt op een link die je naar een andere website toebrengt. Dan wordt de URL van naarverwezen website doorgegeven via de Location header.)

53

­

User­Agent ( In deze header stuur je informatie mee over de software die je gebruikt om de website te bezoeken zodat de server hier eventueel specifieke acties mee kan uitvoeren). ­ Accept ( Deze header beschrijft wat voor soort response de client wil hebben (bv. ‘tekst/html’ voor een website of ‘image/png’ voor een foto met een .png extensie)).

En als laatst de inhoud. Dit hangt af van het soort request dat je stuurt. Zo bevat een GET Request geen inhoud, maar een POST Request, waar je informatie naar de server stuurt, wel. Als dit alles verwerkt is ziet een request er als volgt uit: GET /index.html HTTP/1.1 Host: www.csgliudger.nl User-Agent: Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)

Chrome/41.0.2272.43 Safari/537.36

Accept: text/xml,text/html,text/plain,image/png,image/jpeg,image/gif Accept-Charset: ISO-8859-1,utf-8

Als deze request verzonden is, wordt hij verwerkt door de server. In dit geval willen wij een website pagina bezoeken. De server zoekt naar dit bestand en stuurt vervolgens een response terug. Een response is opgebouwd uit 3 onderdelen: 1. een resultaat code 2. Headers 3. (optioneel) De informatie (ook wel Body genoemd) Een resultaatcode is opgebouwd uit 3 cijfers en laat de status van het antwoord zien. Je kan deze codes verdelen op hun eerste cijfer, elk met een andere betekenis: ­ 1xx : informatie van de server, dat bijvoorbeeld de request goed is binnen gekomen, hierbij wordt geen body mee terug gezonden. ­ 2xx: De request is succesvol afgerond. ­ 3xx: De client wordt naar een andere locatie gestuurd (bijvoorbeeld Omdat het bestand al ingeladen is). ­ 4xx: De client heeft een fout gemaakt waardoor de request niet uitgevoerd kon worden (bijvoorbeeld verkeerde URL verstuurd). ­ 5xx: De server heeft een fout gemaakt, dit kan bijvoorbeeld gebeuren door foutieve code of hardware problemen.

Dit eerste getal wordt opgevolgd door een uniek getal voor een specifieke status.

Bijvoorbeeld als je een verkeerde URL hebt gestuurd, en daardoor kan de server de webpagina niet vinden, dan krijg je een statuscode 404 teruggestuurd. Of als alles goed is gegaan, dan krijg je een statuscode 200 teruggestuurd. Enkele andere kunt u terug vinden in de bijlage E. De headers die worden meegestuurd hebben dezelfde functie als de headers van de request, extra hulp bij de verwerking door de client.

54

Optioneel kan er ook informatie worden mee gestuurd. Dit gebeurt alleen als de request een request soort meestuurt die verklaart dat de client data wil ontvangen.

Een mogelijke response kan er als volgt uitzien: HTTP/1.1 200 OK Date: Fri, 10 Feb 2015 18:24:33 GMT Server: Apache/1.3.29 (Unix) PHP/4.3.4 X-Powered-By: PHP/4.3.4 Content-Language: nl Content-Type: text/html; charset=iso-8859-1 X-Cache: MISS from wikipedia.org Connection: close Content-Type: text/html Content-Length: 49 <html> <head> </head> <body> </body> </html>

9.1.3 WebSocket Met onze robot wilden wij realtime kunnen communiceren met de robot, zowel om nieuwe parameters te zetten, als wel data uitlezen. Er moet dus data naar de robot gestuurd worden en data worden verstuurd vanaf de robot. Dit zouden wij kunnen doormiddel van POST en GET requests zoals wij dat hierboven beschreven hebben.

Echter een nadeel van deze oplossing is dat voor elke keer dat je informatie wil sturen je een nieuwe vraag moet stellen, een nieuwe connectie maken. Dit vergt tijd want voor elke vraag en antwoord (request en response) moet je extra informatie meesturen, wachten voor de server de request heeft behandeld en vervolgens wachten op de response. Om dit proces zo snel mogelijk te maken zochten wij dus een ander protocol.

Hierbij kwamen wij uit bij websockets. Om een websocket connectie te beginnen sturen we, net zoals met HTTP, een request: GET ws://192.168.2.9 HTTP/1.1 Host: 192.168.2.9 Connection: Upgrade Upgrade: websocket

In deze request vragen wij aan de server of hij van protocol wil veranderen doormiddel van de Connection: Upgrade en Upgrade: websocket header.

Als alles goed is ingesteld aan de server kant krijgen wij een response terug die er zo uitziet: HTTP/1.1 101 WebSocket Protocol Handshake Date: Fri, 10 Feb 2015 18:24:33 GMT Connection: Upgrade Upgrade: websocket

55

In deze response krijgen wij de resultaatcode 101 terug gestuurd. Dit houdt in dat wij van protocol zijn veranderd (HTTP ­> websocket).

Nu de connectie is opgestart en wij van protocol zijn veranderd kan er data worden verstuurd, van zowel de client ­> server als wel client <­ server.

Om data te versturen moet je net zoals bij I2C beginnen met een start signaal. Dit is in het geval van websocket de byte 0x00. Hierna volgt de te verzenden data. De data wordt afgesloten met een stop signaal, de byte 0xFF. Vervolgens wordt deze data verwerkt door de server/client.

9.1.4 Communicatie Raspberry Pi – Arduino Voor de communicatie tussen de Raspberry Pi en de Arduino hebben wij ons eigen protocol ontwikkeld. Dit protocol schrijft voor, hoe een zin moet zijn opgebouwd om specifieke informatie over te brengen. Wij kunnen deze informatie onderverdelen in 2 delen: 1. Informatie naar de Raspberry Pi toe.

2. Informatie van de rasperry Pi af.

Het algemene protocol ziet er als volgt uit: Commando_karakter parameters

9.1.4.1 Informatie naar de Raspberry Pi toe De informatie die naar de Raspberry Pi toe komt over de seriële bus vanaf de Arduino.

Dit kan 2 situaties bevatten: 1. Statistieken 2. Waarschuwing In het eerste geval stuurt de Arduino de statistieken van de robot door. Hieronder valt de hoek, de motorsnelheid, de integrerende en de versterkende factor. Het commando karakter is vastgestelt op a. De tekst die de Arduino vervolgens stuurt ziet er dus als volgt uit: a hoek motorSnelheid integrerendeFactor versterkendeFactor

In het tweede geval stuurt de Arduino informatie over abrupte wijzigingen (bijvoorbeeld dat de IR sensor is ingedrukt). Het commando karakter is in dit geval vastgesteld op b. De tekst die de Arduino vervolgens stuurt ziet er dan als volgt uit: b “informatieve zin”

9.1.4.2 Informatie van de Raspberry Pi af De informatie die van de Raspberry Pi af gaat, wordt naar de Arduino gestuurd. Dit kan xx aantal situaties bevatten: 1. De robot wordt gestart.

2. De tau en kp worden bijgewerkt.

3. De setpoint (gewenste hoek) wordt bijgewerkt.

4. De gecalibreerde hoek wordt bijgewerkt.

56

Als de Raspberry het signaal binnen krijgt dat de robot gestart moet komen, stuurt hij die informatie door naar de Arduino. Deze informatie bestaat uit de tau en kp die beide worden meegestuurt door de app/website, een startcode (deze code is 1 als de robot gestart moet worden en 0 als de robot gestopt moet worden). Het commando karakter is vastgesteld op c. De tekst die de Raspberry verstuurt ziet er dan alsvolgt uit; c startcode tau kp

Er is ook de mogelijkheid om de tau en kp te wijzigen, zonder daarbij de robot te stoppen of te starten. Hierbij krijgt de Raspberry de tau en kp van de website/app.

Het commando karakter is hierbij vastgesteld op d. De tekst die de Raspberry vervolgens stuurt ziet er als volgt uit: d tau kp

Ten derde kan er een setpoint worden doorgegeven voor acceleratie van de robot. Deze setpoint wordt gestuurd naar de Raspberry. Het commando karakter is vast gesteld op e.

De tekst die wordt verstuurt door de Raspberry ziet er vervolgens zo uit; e setpoint

Als laatst kan er een gecalibreerde hoek worden bijgewerkt. Hierbij wordt de hoek gestuurd naar de Raspberry. Het commando karakter is vastgesteld op f.

De tekst die wordt verstuurt door de Raspberry ziet er vervolgens zo uit: f nieuwe_gecalibreerde_hoek

57

9.2 programma’s Zoals uitgelegd in het hoofdstuk Elektronica bestaat onze robot, en de aansturing hiervan, uit 3 delen: 1. Raspberry Pi 2. Android 3. Arduino De samenwerking tussen deze 3 apparaten is te zien in afbeelding 58. Echter om tot deze samenwerking te komen moet er software geschreven worden.

Afbeelding 58: De samenwerking tussen de Raspberry Pi, Arduino en de website / android app.

9.2.1 Raspberry Pi Zoals te zien in afbeelding 58 is de Raspberry Pi het centrale onderdeel het softwarematig aansturen van de robot. Het verwerk input van buitenaf, hetzij een website, hetzij een android app, en stuurt dit naar de Arduino. Ook stuurt hij statistische informatie van de Arduino naar de website. Om dit mogelijk te maken moet er dus een webserver draaien op de Raspberry Pi. Wij hebben hierbij gekozen voor NodeJS. Wij hebben hiervoor gekozen omdat het ons interessant leek hoe dit relatief nieuwe pakket werkt. In NodeJS schrijf je je code in JavaScript. Wij zijn met onze NodeJS code afhankelijk van een paar libraries [bijlage F]: ­ Express ­ http ­ socket.io ­ serialport De code op de Raspberry is ‘event­driven’. Dit wil zeggen dat gedeelte van de code pas wordt aangeroepen als er een actie is gebeurd (bijvoorbeeld een knop op de website is ingedrukt). We kunnen dan de code opdelen in twee delen: 1. Code die wordt uitgevoerd bij het opstarten.

2. Code die wordt uitgevoerd bij een event.

Code die wordt uitgevoerd bij het opstarten van de Raspberry Pi wordt één keer uitgevoerd. var var var var

58

app = require('express')(); http = require('http').Server(app); io = require('socket.io')(http); serialport = require("serialport");

Wij creëren dus eerst enkele variabelen. In dit stukje code initiëren wij de library’s die wij gebruiken. Hier wordt bijvoorbeeld de express library weer gebruikt door de http library. Dit doen wij omdat express het makkelijk maakt om de client de goede webpagina te geven. http.listen(3000, function(){ console.log('listening on *:3000'); }); app.get('/', function(req, res){ res.sendFile(__dirname + '/index.html'); });

Hier wordt in de eerste aangeroepen method, de HTTP server gestart op poort 3000. Wij doen dit op poort 3000 in plaats van de gebruikelijke poort 80 zodat niet Jan en allemaal er bij kan komen. Vervolgens zeggen wij dat als iemand een request doet op de URL: “ipaddres:3000/”, het bestand index.html krijgt. In dit bestand staat de opmaak van de website (zie afbeelding 59).

Afbeelding 59: de website die de Raspberry Pi genereerd.

59

if (ArduinoConnected){ serialPort.on("open", function () { console.log('serialport has made connnection'); serialPort.on('data', function(data) { console.log('data received: ' + data); var arr = data.split(" "); switch(arr[0]){ case "a": var msg = {a:arr[1], o:arr[2], i:arr[3], p:arr[4]}; io.emit("stat", msg); break; case "b": console.log(arr[1]); break; default: break; }; }); serialPort.on('error', function (err) { console.error("error", err); }); }); }

Vervolgens zeggen wij wat de Raspberry moet doen als de Arduino is ingeschakeld. Als dit gebeurt zeggen we wat de Raspberry moet doen als de Arduino data verstuurt. Dit gebeurt volgens het protocol beschreven in paragraaf 9.1.4.1 . Wij kijken eerst wat het commando karakter is. Als dit een ‘a’ is verpakken wij alle statistische informatie en sturen die vervolgens door naar de website en android app. Als dit commando karakter een ‘b’ is dan geeft de Arduino het waarschuwingsbericht weer in de terminal. Ook zeggen wij hier dat als er een error is, met betrekking tot het communiceren met de Arduino, de Raspberry de foutcode moet weergeven in de terminal. Als deze code aangeroepen is wacht de Raspberry af. Totdat er iemand is verbonden via de websockets.

60

io.on('connection', function(socket){ socket.on('updateTauKp', function(msg){ var tau = parseInt(msg.tau,10); var kp = msg.kp;

pushStringToArduino(commandUpdateTauKp + " " + tau+" "+kp+"\n"); }); socket.on('setpoint', function(msg){ var setpoint = msg.deltaHoek; setpoint = parseFloat(setpoint,10); pushStringToArduino(commandSetSetpoint + " " + setpoint + "\n"); }); socket.on('hoek', function(msg){ var hoek = msg.hoek; pushStringToArduino(commandSetCalibratedHoek + " " + hoek +"\n"); }); socket.on('start', function(msg){ var startCode = msg.startCode; var tau = msg.tau; var kp = msg.kp;

" });

pushStringToArduino(commandSetSettings + " " + startCode + " "+tau+" +kp+"\n");

});

Hierboven staat alle ‘event­driven’ code. Als er iemand is verbonden via websockets dan zetten wij een paar methods vast. Er kan volgens ons protocol vier soorten informatie verstuurd worden naar de Raspberry Pi. Voor elk soort stellen wij speciale code vast. Bij elk soort verkrijgt de Raspberry eerst de benodigde informatie. Vervolgens roept de Raspberry de method pushStringToArduino aan met de te verzenden informatie als parameter. var pushStringToArduino = function(msg){ console.log(msg); if (ArduinoConnected){ serialPort.write(msg, function(err, results) { if(err != null){ console.log('results ' + results + " err : "+err); } }); } }

In de method pushStringToArduino versturen wij eerst de informatie naar de terimal.

Hierdoor kunnen wij visueel zien of er data wordt verstuurd en of deze data ook klopt.

Vervolgens kijken wij of de Arduino verbonden is. Zo niet, dan hoeven wij niks te versturen. Als dit wel zo is dan roepen wij serialPort.Write aan. Dit is een method uit de SerialPort library. Deze method verstuurt de parameter msg over de seriële bus naar de 61

Arduino. Als hierbij een error optreed sturen wij ook deze error naar de terminal zodat wij dit kunnen zien.

9.2.2 Android Zoals te zien in afbeelding 58 kan je vanaf android de Raspberry commando’s sturen, en ontvangt het android apparaat informatie van de Raspberry. Wij maken gebruik van de library; socketIO. Deze library zorgt ervoor dat het websocket protocol correct wordt uitgevoerd (Dit protocol hebben wij besproken in paragraaf 9.1.4). Hoe deze library te downloaden staat in de bijlage [Bijlage G]. De app bestaat uit 2 schermen: een scherm om het IP­adres van de Raspberry door te geven (afbeelding 60.a) en het ‘commando scherm’, waar je alle acties in uitvoert (afbeelding 60.b).

Afbeelding 60.a Afbeelding 60.b

Een android scherm wordt ook wel een activity genoemd. Zo’n Activity beschrijft wat de telefoon moet doen als er iets gebeurd. Wij maken hierbij gebruik van 2 ingebouwde methods van zo’n activity.

1. onCreate 2. onStop 9.2.2.1. onCreate() In de onCreate method beschrijf je wat de activity moet doen als hij wordt gestart. Eerst zeggen wij dat de activity een gegeven bestand moet gebruiken voor het uiterlijk. In dit bestand staat beschreven wat voor views het scherm heeft. Een view kan van alles zijn, een knop, een textvak, een plaats om een foto neer te zetten. Deze views geef je ook een id mee in dit bestand, zodat je ze later in de code weer kan opzoeken.

Button btnSetIp = (Button) findViewById(R.id.btnConnect); 62

Het opzoeken van een view gebeurd doormiddel van de method findViewById( id ). Deze method geeft een view terug als het id gevonden is in het bestand. Zo niet geeft het een null terug. Omdat wij ook weten dat dit een knop (Button) is, forceren wij dit ook met het zoeken. Hierdoor kunnen wij specifieke code aanroepen die alleen mogelijk is bij buttons. Zo gaan wij alle views bij langs. Vervolgens gaan wij specifieke code aan de buttons toe kennen.

btnSetIp.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { try { ipAdress = etIpAdress.getText().toString(); Toast.makeText(getApplicationContext(), "Ip adress : " + ipAdress, Toast.LENGTH_SHORT).show(); mSocket = new SocketIO("http://" + ipAdress + ":" + portServer+"", mSocketCallback); }catch (MalformedURLException e){ e.printStackTrace(); } } });

In deze code zeggen wij doormiddel van de clickListener vast wat de btnSetIp knop moet doen als hij ingedrukt wordt. Allereerst verkrijgen wij het ingetypte IP­adres van het textveld ipAdress. Om te controleren of dit goed is gegaan zetten wij voor 2 seconden dit IP­adres voor even op het scherm, als een waarschuwing. Vervolgens starten wij het websockets protocol op het gegeven IP­adres. De port is hierbij een constante omdat deze ook constant is op de Raspberry Pi. Ook geven wij hier een ‘callback’, mSocketCallback, door. In deze callback zitten methods die worden aangeroepen als er iets gebeurd bij de sockets.

63

btnStart.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { try { if (isStarted) { btnStart.setText("Start"); btnStart.setBackgroundColor(Color.GREEN); isStarted = false; tau = Float.valueOf(etTau.getText().toString()); kp = Float.valueOf(etKp.getText().toString());

JSONObject o = new JSONObject(); o.put("startCode", 0); o.put("tau", tau*100); o.put("kp", kp*100); mSocket.emit("start", o); } else { btnStart.setText("Stop"); btnStart.setBackgroundColor(Color.RED); isStarted = true; tau = Float.valueOf(etTau.getText().toString()); kp = Float.valueOf(etKp.getText().toString()); JSONObject o = new JSONObject(); o.put("startCode", 1); o.put("tau", tau*100); o.put("kp", kp*100); mSocket.emit("start", o); } }catch (JSONException e){ e.printStackTrace(); } } });

Deze code beschrijft wat er moet gebeurden als de btnStart wordt ingedrukt (dit is de groene knop op afbeelding 60.b). Allereerst kijken wij of de robot is gestart via de variabele isStarted. Als isStarted ‘true’ is veranderen we allereerst de tekst en kleur van de knop terug naar ‘Start’ en de kleur groen. Vervolgens zetten wij isStarted gelijk aan false. Hierdoor weet de app dat de robot uitgeschakeld is. Vervolgens verkrijgen wij de tau en kp, die zijn ingevuld in hun respectiefelijke tekstboxen (zie afbeelding 60.b). Deze waarden vermenigvuldigen wij vervolgens met 100. Hierdoor kunnen wij een tau en kp invullen op een 100ste nauwkeurig. Wij stellen startCode gelijk aan 0. Hierdoor weet de Arduino uiteindelijk dat de robot gestopt moet worden. Vervolgens sturen wij een bericht naar de Raspberry Pi toe. Als isStarted echter false is moet de robot gestart worden. Wij veranderen de tekst en kleur van de knop naar ‘Stop’ en de kleur rood.

Vervolgens stellen wij isStarted gelijk aan true, verkijgen wij wederom de tau en kp, die vermenigvuldigen wij weer met 100. Echter stellen wij de startCode gelijk aan 1.

Hierdoor weet de Arduino uiteindelijk dat de robot gestart moet worden. Dit bericht wordt vervolgens naar de Raspberry Pi toegestuurt.

64

btnMoveRobot.setOnTouchListener(new View.OnTouchListener() { @Override public boolean onTouch(View view, MotionEvent motionEvent) { try { switch (motionEvent.getAction()) { case MotionEvent.ACTION_DOWN: calibrateSensors(); if(timerForComms == null) { timerForComms = new Timer(); timerForComms.scheduleAtFixedRate( geefOrientatieAanRaspberry, 0, interval); } break; case MotionEvent.ACTION_UP: OrientationIsGemiddeld = false; JSONObject o = new JSONObject(); o.put("deltaY", "0"); mSocket.emit("setpoint", o); break; } }catch (JSONException e){ e.printStackTrace(); } return true; } });

Deze code beschrijft wat er gebeurt als de btnMoveRobot wordt ingedrukt. Dit is de grootte knop met de tekst ‘move’ in afbeelding 60.b. Deze code verschilt iets met de andere ‘code bij indrukken’. Wij moeten in dit geval onderscheid maken tussen het indrukken en het weer loslaten van de knop. Wij maken hierom gebruik van de onTouchListener. Wij kijken allereerst wat voor actie er gebeurd is. Dit kunnen twee acties zijn: 1. ACTION_DOWN 2. ACTION_UP Als de actie ACTION_DOWN is, is de knop ingedrukt. Wat wij dan willen doen is de robot voor en achteruit laten bewegen op de beweging van de telefoon. Dit doen we door de setPoint, de gewenste hoek, van de robot te veranderen. Hoe wij dit doen wordt verder besproken in paragraaf 9.2.3. Wij roepen eerst de method calibrateSensors aan.

Vervolgens kijken wij of er al eerder een timer is gestart. Als dit niet het geval is maken wij een nieuwe timer aan. Deze timer gaat de method geefOrientatieAanRaspberry om een vast aantal milliseconden aanroepen. Dit interval stellen wij vast doormiddel van de variabele interval. Echter als de actie gelijk was aan ACTION_UP, dan is de knop los gelaten. Nu willen wij dat de robot weer normaal gaat stabiliseren. Wij sturen dus een setPoint van 0 graden naar de Raspberry Pi.

65

Om een gemiddelde waarde te maken van de hoeken van het android apparaat wordt deze functie aangeroepen. public void calibrateSensors(){ float R[] = new float[9]; float I[] = new float[9]; boolean success = SensorManager.getRotationMatrix(R, I, mAccelData, GeomagneticData); if (success) { float orientation[] = new float[3]; SensorManager.getOrientation(R, orientation); gemOrientatie[0] = orientation[0] * (float) (180 / Math.PI); gemOrientatie[1] = orientation[1] * (float) (180 / Math.PI); gemOrientatie[2] = orientation[2] * (float) (180 / Math.PI); OrientationIsGemiddeld = true; } }

Wij creëren hier eerst 2 float array’s. Deze zijn nodig voor de eerst volgende method die wij aanroepen. Dit is de SensorManager.getRotationMatrix. Deze method vult een rotatie matrix (array R) aan de hand van de waarden van de accelerometer en de magnetometer (bron 21). Deze method stuurt een boolean terug. Deze noemen wij success. Als success true is, dan is de method correct uitgevoerd, als success false is, dan is er ergens een fout opgetreden, en willen wij niet verder gaan. Als success dus gelijk is aan true gaan we een nieuwe array aanmaken: orientation. Om vervolgens de hoek van het android toestel te krijgen roepen wij de method SensorManager.getOrientation aan. Als parameter sturen wij de net gevulde rotatie matrix R mee. Deze method vult vervolgens de 2de parameter, de array orientation met de hoeken (in de volgorde Z , X , Y , bron 22). Echter zijn deze waarden in radialen, en wij wouden ze graag in graden hebben. Hiervoor moeten wij de ϸᴆϷ waarde vermenigvuldigen met . Nu wij de hoek van het apparaat hebben zetten wij de variabele orientationIsGemiddeld gelijk aan true.

66

Vervolgens wordt de timer gestart en wordt om een gegeven aantal milliseconden de volgende method aangeroepen. public TimerTask geefOrientatieAanRaspberry = new TimerTask() { public void run() { try { float R[] = new float[9]; float I[] = new float[9]; boolean success = SensorManager.getRotationMatrix(R, I, mAccelData, mGeomagneticData); if (success && OrientationIsGemiddeld) { float orientation[] = new float[3]; SensorManager.getOrientation(R, orientation); float deltaX = 0.0f, deltaY = 0.0f, deltaZ = 0.0f; deltaZ = (orientation[0] * (float) (180 / Math.PI)) gemOrientatie[0]; deltaX = (orientation[1] * (float) (180 / Math.PI)) gemOrientatie[1]; deltaY = (orientation[2] * (float) (180 / Math.PI)) gemOrientatie[2]; if (mSocket.isConnected()) { JSONObject o = new JSONObject(); o.put("deltaY", deltaX); mSocket.emit("setpoint ", o); } } }catch (JSONException e){ e.printStackTrace(); } } };

Om de hoek van het apparaat te krijgen, doen wij eerst hetzelfde als in de method calibrateSensors. We maken twee arrayâ&#x20AC;&#x2122;s, roepen de method SensorManager.getRotationMatrix aan, kijken of die succesvol was, en vullen dan de array orientation met de rotatie hoeken van het apparaat. Dit doen wij echter alleen als de variabele OrientationIsGemiddeld gelijk is aan true. Hierdoor wordt deze code niet uitgevoerd als de knop is losgelaten, want dan stellen we de variabele OrientationIsGemiddeld gelijk aan false. Vervolgens zetten wij de hoek om van radialen naar graden. Hierna trekken wij de gekalibreerde hoek af van de net gemeten hoek.

Vervolgens kijken wij of de app verbonden is met de Raspberry Pi doormiddel van de method isConnected op de websocket variabele. Deze method geeft true terug als de app en de Raspberry Pi verbonden zijn en false als dit niet het geval is. Als de Raspberry Pi en de app verbonden zijn stuurt de app de hoek naar de Raspberry Pi. Wij gebruiken hier de hoek van de X­as omdat wij wouden kijken naar voorwaarts en achterwaartse beweging.

67

9.2.2.2. onStop In de onStop method staat de code die wordt uitgevoerd wanneer de app afgesloten wordt.

@Override public void onStop() { super.onStop(); timerForComms.cancel(); mSocket.disconnect(); }

Wij doen hier twee dingen. Ten eerste stoppen wij de timer die ervoor zorgt dat de informatie over de Raspberry stuurt, Hierdoor gaat deze timer niet in de achtergrond door met aanroepen van de method geefOrientatieAanRaspberry. Vervolgens verbreken wij de connectie met de Raspberry Pi. 9.2.3 Arduino Wij gebruiken de Arduino om zowel de αs , als de commando’s van de rasberry Pi te verwerken. In paragraaf 8.2 hebben wij besproken hoe we de αs verkrijgen. De commando’s van de Raspberry Pi krijgen wij binnen via de Seriële bus. Dit alles verwerken wij in het algoritme zoals die wordt beschreven in afbeelding 61.

Afbeelding 61

Zoals genoemd in paragraaf 8.3, is de Arduino afhankelijk van 2 methoden. De setup() en de loop().

68

void setup(){ Serial.begin(115200); //1 Wire.begin(); //2 delay(5); sensor.init(); //3 delay(5); pinMode(calButton, INPUT); // pinMode(stopButton, INPUT); // pinMode(IRSensor, INPUT); // 4 pinMode(calibrationLed, OUTPUT); // pinMode(startProgramLed, OUTPUT); // out = motorOffSet; // analogWrite(motorIn, out); // aSensor = 1; // 5 integral = 0; // setPoint = 0; // }

In de setup() beginnen we met het initiëren van de seriële bus voor de communicatie met de Raspberry Pi (1). Vervolgens wordt de I2C bus geopend voor de communicatie met de MPU6050(2). Dit geven wij even de tijd en daarna initiëren wij de sensor (3).

Vervolgens gaan wij de pinnetjes van de fysieke knopjes en LEDs bij langs om te zeggen of het een INPUT (ingang) of OUTPUT (uitgang) is (4). Hierna zetten 2.5V op de motoraansturing waardoor de motor stilstaat (paragraaf 8.1), tevens geven wij enkele belangrijke variabelen alvast een waarde (5).

Nu de setup() klaar is volgt de loop(). In deze herhaaldelijke functie wordt het algoritme uitgevoerd. Dit algoritme wordt bepaald door een aantal functies: 1. checkIfWeNeedToStop() 2. getAngle() 3. checkForDataFromPi () 4. doCalculations() 9.2.3.1 checkIfWeNeedToStop() void checkIfWeNeedToStop(){ if (digitalRead(IRSensor) == HIGH){ STOP(); } if (digitalRead(stopButton) == LOW){ STOP(); } }

Om de robot te kunnen laten stoppen in een noodgeval hebben wij 2 “Kill Switches” geïntegreerd. Ten eerste een IR Sensor die reageert op afstandsbedieningen (IRSensor) en ten tweede een fysieke knop op de robot zelf (stopButton). Deze 2 kill switches zijn verbonden met 2 digitale pinnen op de Arduino. In deze method kijken wij of één van de kill switches is ingeschakeld, als dit het geval is wordt de STOP() method aangeroepen.

69

void STOP(){ start = false; isCalibrated = false; Serial.println(F("b STOP")); out = motorOffSet; integral = 0; analogWrite(motorIn, out); digitalWrite(startProgramLed, LOW); }

In deze method stellen wij twee variabelen start en isCalibrated gelijk aan false. Hierdoor stoppen de berekeningen zoals te zien in afbeelding 61. Hierna zetten wij een bericht op de seriële bus voor de Raspberry Pi. Vervolgens zetten wij weer 2.5V op de motoraansturing en doen wij het programma ledje uit, waardoor wij visuele bevestiging krijgen.

9.2.3.2 getAngle() void getAngle(){ sensor.getYawPitchRoll(ypr); inputAngle = -ypr[2]; if(willCalibrate){ isCalibrated = true; willCalibrate = false; inputAngleOffset = 1.2; integral = 0; sensorOffSet = analogRead(0); } }

In de getAngle() method verkrijgen wij de hoek van de MPU6050. Dit gebeurt door het aanroepen van sensor.getYawPitchRoll(ypr);.Deze method vult ypr. Dit is een array bestaande uit 3 INT’s, de Yaw, Pitch en Roll (zie paragraaf 8.2). Wij gebruiken echter alleen de Roll. Omdat wij de sensor achterstevoren hebben gemonteerd krijgen wij de tegenovergestelde hoek binnen. Dit hebben wij opgelost door de hoek met ­1 te vermenigvuldigen. Vervolgens controleren wij of de robot gekalibreerd moet worden.

Als dit het geval is calibreren wij de hoek en zetten de variabele isCalibrated op True zodat de doCalculations kan beginnen (Afbeelding 61).

70

9.2.3.3 checkForDataFromPi() void checkForDataFromPi(){ while (Serial.available() > 0) { char incommingCommand = Serial.read(); if(incommingCommand == 'e'){ int newSetpoint = Serial.parseInt(); setPoint = newSetpoint / 10.0f; setPoint = newSetpoint; }else if(incommingCommand == 'c'){ int startCode = Serial.parseInt(); int tauInt = Serial.parseInt(); int kpInt = Serial.parseInt(); tau = tauInt / 100.0f; kp = kpInt / 100.0f;

if (Serial.read() == '\n') { if(startCode == 1){ startTest = true; }else if(startCode == 0){ startTest = false; STOP(); } } }else if(incommingCommand == 'd'){ int tauInt = Serial.parseInt(); int kpInt = Serial.parseInt(); tau = tauInt / 100.0f; kp = kpInt / 100.0f; }else if(incommingCommand == 'f'){ int mHoek = Serial.parseInt(); inputAngleOffset = mHoek / 10.0f; } } }

Zoals vernoemd in paragraaf 9.1.4.2, bestaat de communicatie tussen de Raspberry Pi en Arduino uit een zin met een vaste opbouw. Als er iets op de seriële bus aanwezig is kijken wij eerst naar het commando karakter. Vervolgens gaan we kijken welke code moet worden uitgevoerd. De drie commando’s worden op drie manieren uitgevoerd: c. Wij krijgen de drie waarden (start code, tau en kp) binnen. Om de tau en kp op 100ste nauwkeurig te krijgen moeten wij ze eerst weer delen door 100. Als alles is ingeladen, en dus het bericht is afgesloten met een nieuwe regel (‘\n’) verwerken wij de startcode. Als deze gelijk is aan 1 zetten wij de variabele start gelijk aan true (hierdoor kan doCalculations beginnen en start de robot dus). Als startcode gelijk is aan 0 moet de robot stoppen. Wij roepen dan de functie STOP(). d. Wij krijgen hier twee waarden binnen, een tau en een kp. Om deze twee waarden wederom op een 100ste nauwkeurig te krijgen moeten wij het weer delen door 100. Vervolgens slaan wij deze waarden op voor verdere verwerking.

71

e. Wij slaan de nieuwe setPoint op zodat die verder verwekt kan worden in doCalculations() f. Om de gecalibreerde hoek op een 10de nauwkeurig te krijgen moeten wij het gestuurde getal eerst delen door 10. Vervolgens wordt deze variabele opgeslagen in inputAngleOffset voor een verdere verwerking in doCalculations.

9.2.3.4 doCalculations() void doCalculations(){ hoek = aSensor*(inputAngle-inputAngleOffset); error = setPoint - hoek; prop = kp*error; integral = integral + error * (float(deltaT) / 1000) / tau; filterOut = prop + integral; conFilterOut = int(filterOut); out = motorOffSet - conFilterOut; out = checkOutput(out, maxLimit, minLimit); analogWrite(motorIn, out); }

Dit is de method die het regelsysteem verwerkt. Hij wordt alleen aangeroepen als de robot is gekalibreerd en je hem aan hebt gezet via de website / app. Zoals vernoemd in paragraaf 5.3 begint het regelsysteem met een foutsignaal ε. Dit signaal creëren wij door de daadwerkelijke hoek (hoek) aftetrekken van de gewenste hoek (setPoint). De daadwerkelijke hoek bepalen wij door het verschil tussen de hoek van de robot (inputAngle) en de gekalibreerde hoek (inputAngleOffset) te vermenigvuldigen met een constante aSensor. Deze constante is afhankelijk 1 of ­1 voor respectievelijk opwaartse modus en neerwaartse modus. Vervolgens berekenen wij de twee factoren, de versterkende factor en de integrerende factor. Vervolgens voegen wij de 2 factoren samen in de variabele filterOut. Tot nu toe hebben wij alles berekent in komma getallen, voor nauwkeurigheid. Echter maken wij nu de stap naar de uitgangssignaal en dit kan alleen in gehele nummers. We maken dus van het kommagetal filterOut een geheel getal conFilterOut. Om het uiteindelijke uitgangssignaal te verkrijgen moeten wij eerst conFilterOut aftrekken van de motorOffset. Om ervoor te zorgen dat wij niet een te hoge spanning naar de motor sturen wij het uitgangssignaal eerst door de method checkOutput().

int checkOutput(int out, int maxLimit, int minLimit){ if (out >= maxLimit){ out = maxLimit; } if (out <= minLimit){ out = minLimit; } return out; }

Deze method kijkt of de variabele out (het uitgangssignaal) binnen gegeven marges valt.

Mocht dit signaal hier boven of onder zitten dan corrigeert deze method dat. Nu wij er zeker van zijn dat ons uitgangssignaal niet te hoog of te laag is sturen wij dit signaal naar de motoraansturing.

72

10. Proeven en resultaten Nu we de robot helemaal afgebouwd hebben kunnen we kijken of deze ook daadwerkelijk in staat is om zichzelf in evenwicht te houden.

10.1 Energieverbruik Omdat de robot op batterijen werkt is het belangrijk om te weten hoe lang de robot kan rijden op één batterijlading. We maken onderscheid tussen twee vormen van activiteit: één waarbij de motor stilstaat en één waarbij de motor op volle snelheid draait. In beide gevallen is wel alle elektronica aangesloten. Het doel van deze proef is het verbruik van de robot te meten, zodat we een schatting kunnen maken van de batterijduur. Hieronder is de opstelling van deze proef te zien.

Afbeelding 62: Proefopstelling

In Afbeelding 62 is het volgende te zien: De robot Een multimeter die de spanning over de voeding meet Een multimeter die de stroom meet Een voeding die 12v geeft (spanning op teller klopt niet) Een stapel boeken om er voor te zorgen dat de wielen de grond niet raken.

Eerst hebben we het stroomverbruik van de robot gemeten wanneer deze in rust is: Robot in rust

Spanning (U) 12,46 V

Stroom (I) 0,397 A

73

Vervolgens hebben we hetzelfde gedaan, maar dan wanneer de motor op zijn hardst draait. Echter kwamen we hier op een probleem. Wanneer de motorsturing 0 of 5v krijgt, slaat de motor af. Dit komt omdat de ingangsspanning van de motorsturing boven de pieken van de ingangsspanning uitkomt (zie 8.1.5 Verwerking). Dus moesten we uitzoeken wat de maximale en minimale spanning was die de motorsturing mag hebben.

Om dit uit te zoeken hebben we een testprogramma voor de Arduino geschreven, dit is te zien in Afbeelding 62.

Afbeelding 62: testprogramma

De Arduino kijkt naar twee knoppen: speedUp en speedDown. Wanneer één van deze knoppen ingedrukt zal de Arduino een laag signaal binnenkrijgen. Wanneer speedUp is ingedrukt zal Arduino om de honderd milliseconde één bij de variabele motorIn optellen, wanneer speedDown is ingedrukt zal de Arduino om de honderd milliseconde één van de variabele motor aftrekken. Vervolgens wordt de waarde van motorIn naar de motorsturing en computer gestuurd.

Om de maximale spanning te bepalen die de motorsturing aankan, hebben we de knop speedUp net zo lang ingedrukt totdat de motor afsloeg, hetzelfde hebben we met de minimale spanning gedaan, maar dan met de knop speedDown. Vervolgens kunnen we bij beide waarden de spanning berekenen.

motorIn spanning

Minimaal 70 1,37 V

Maximaal 184 3,61 V

Nu we deze waarden weten, kunnen we het stroomverbruik van de robot meten waarbij de motor bij een maximale snelheid draait. Dit doen we door een spanning van 3,61 volt op de ingang van de motorsturing te zetten. In de volgende tabel zijn de resultaten hiervan te zien Robot in met motor Spanning Stroom (I) op volle snelheid (U) 12,33 V 1,068 A

74

Nu kunnen we de batterijduur van robot in beide gevallen berekenen. Wij maken gebruik van 10 batterijen van 1.2 volt en een lading van 2000 mAh. Hiervan kunnen we de totale energie in Joule van berekenen, er geldt: [3] Waarbij P het vermogen is in Joule per seconde (Watt), U de spanning in volt, en I de stroom in ampère is.

Vermogen robot bij motor in rust Vermogen robot met motor op volle snelheid

4,95 W 13,17 W

Wanneer tien batterijen van 1.2 volt een uur lang 2 ampère kunnen leveren betekent dat de totale energie gelijk is aan:

Nu kunnen we berekenen hoe lang de batterijen meegaan: Tijd bij motor in rust Tijd bij motor op volle snelheid

17454 sec (4,8 uur) 6560 sec (1.8 uur)

Natuurlijk zeggen deze waarden niets over het realistische verbruik van de robot, want de motor zal niet constant op volle snelheid draaien, of in rust zijn. Ook de het verbruik van de elektronica verschilt sterk. In het slechtste geval kan de motor 1.8 uur draaien op één batterijlading. Wij zijn hier niet ontevreden over en batterijen vinden dus geschikt als voeding voor de robot.

10.2 Balanceren met de versnellingssensor in neerwaartse modus In deze proef kijken we of de robot kunnen balanceren in neerwaartse modus. Eigenlijk is dit erg flauw, want de robot is in neerwaartse modus van zichzelf al stabiel. Toch voeren we deze proef uit. We willen kijken hoe de robot zich gedraagt en of we dezelfde karakteristieken terug zien als die in het hoofdstuk ‘simulaties’. We gaan de robot uittesten met verschillende waardes voor kp en tau. Na elke test kijken we of er verbetering is ten opzichte van de vorige en ook kijken of het gedrag van de robot overeen komt met één van de gebieden in de parabool van Afbeelding 14. Omdat we totaal geen idee hadden hoe de robot zou reageren op bepaalde waardes van kp en tau, hebben we zogenaamde ‘killswitch’ ingebouwd. Op het moment dat de robot ervandoor wil, kunnen wij hem uitzetten doormiddel van een IR­signaal. In de volgende tabel zijn de resultaten van deze proef te zien:

75

Meting kp tau

stabiliteit

Gebied van parabool

Stabiel, regeling niet zichtbaar 1

2

3

4

5

6

7

0,1 5,00E+07

0,1 5,00E+05

5

Stabiel, regeling niet zichtbaar

Stabiel, regeling 0,5 5,00E+05 zichtbaar, Stabieler dan meting 1 en 2 Stabiel, regeling zichtbaar, Iets beter 0,5 5,00E+04 dan meting 3 Stabiel, regeling duidelijk zichtbaar.

0,5 5,00E+02 Blijft stabiel bij verstoring van evenwicht.

Stabiel, regeling duidelijk zichtbaar, lichte slingering. Blijft 0,5 5 stabiel bij verstoring van evenwicht Zeer instabiel. Raakt instabiel door eigen 0,5 5,00E足02 regeling

5

5

5

5

4

1

Grens instabiliteit 8

0,5

0,5

3 Zeer instabiel

9

2,5

5

1 Zeer instabiel

10

1

5

1

Voor de volgende meting De regeling is niet zichtbaar. Dat kan betekenen dat de kp te klein is, of de tau te groot.

In de volgende meting maken we tau kleiner.

Geen resultaat. We gaan verder met het verkleinen van tau. Ook verhogen we kp een beetje.

Nog niet stabiel genoeg.

We gaan verder met het verlagen van tau.

Tau moet verder worden verlaagd.

We gaan verder met tau verlagen om te kijken of dit verbetering oplevert.

Deze lijkt tot nu toe het stabielst te zijn. Toch verlagen we de tau verder, om te kijken of we de robot nog stabieler kunnen krijgen.

We kiezen tau tussen meting 6 en 7.

Deze kp is te laag, de robot moet sneller reageren. We moeten kp dus verhogen De robot schokt heel erg.

Dit betekent dat de versterkende factor te grot is. Kp moet lager Kp moet nog lager, in dat geval kom je weer uit op meting 6. Meting 6 is dus het beste.

Tabel 1: Meetresultaten van robot in neerwaartse modus. Met een kp van 0,5 en een tau van 5 (meting 6) bleek de robot het best te stabiliseren.

76

Tijdens het testen van de robot waren, de karakteristieken die we eerder zagen in de simulaties, duidelijk terug te zien, uiteindelijk hebben we de robot in gebied 4 kunnen krijgen waardoor deze stabiel werd, ook wanneer de robot een duw kreeg reageerde hij op de juiste manier.

10.3 Balanceren met de versnellingssensor in opwaartse modus We maken het onszelf nu een stapje moeilijker door de robot te laten balanceren in opwaartse modus. Het grote verschil met de neerwaartse modus is dat de robot nu uit zichzelf niet meer stabiel is. We gaan net als in de vorige proef weer verschillende waardes van tau en kp bij langs. Bij elke test kijken we in welk gebied van de parabool (Afbeelding 14) de robot zich bevindt. Alleen stabiliseerde de robot zo ontzettend slecht dat deze zich, voor welke waarde we ook voor kp en tau hadden, in gebied 1 of 5 bevond.

Dit kan natuurlijk aan heel veel dingen liggen. Wij hadden het idee dat drie factoren heel erg bepalend waren, voor de mate van stabiliteit: Speling Zwaartepunt dat te hoog boven de as ligt De sensor Als eerste hebben we getest wat er zou gebeuren als we zo veel mogelijk speling uit de robot haalden. De robot had een aantal plekken waar speling voorkwam: ten eerste tussen de wiel en de as, tussen de motor as en het tandwiel en verschillende schroeven.

In paragraaf 7.4 (rotor) hadden we al laten zien dat de speling tussen de wielen en de as eenvoudig weg te halen was doormiddel van tandwielen en nylondraad. Omdat we al veel hadden gereden met de robot waren er door trillingen ook verschillende schroeven los komen te zitten, waaronder de schroef die het tandwiel aan de motor as bevestigt.

We zijn de hele robot nog een keer nagelopen en hebben alle schroeven nog een keer aangedraaid. Nu we de speling weggehaald hebben, herhalen we dezelfde proef nog eens. In de volgende tabel zijn de resultaten te zien van de proef met de spelingsvrije robot:

77

Meting

Kp

Tau

Stabiliteit

1

0,5

5

Instabiel, robot reageert te traag. regeling niet zichtbaar.

2

5

5

Instabiel, robot neemt slingerend toe.

3

0,5

0,5

4

2

0,5

5

1

0,5

6

0,5

0,1

7

0,5

0,25

8

0,5

0,17

Instabiel, robot reageert te traag. regeling is zichtbaar.

Instabiel, neemt slingerend toe.

Instabiel, toenemend slingerend. Beter dan meting 4.

Instabiel, toenemend slingerend. Beste resultaat tot nu toe.

Bijna stabiel, robot reageert net te traag Stabiel? Robot valt niet om, slingert wel.De robot heeft veel ruimte nodig om te stabiliseren

Gebied

5

2

2

Voor de volgende meting Robot reageert te traag, daarom verhogen we kp.

Robot is nog steeds te traag maar slingert wel. Dit betekent dat de versterkende factor hoog genoeg is. We verlagen daarom dit keer de tau. robot moet iets sneller reageren. We verhogen kp.

2

Kp is te hoog

2

Tau omlaag

2

robot reageert te heftig, tau moet hoger.

5

tau wat lager

4

Tabel 2 Meetresultaten van stabiliserende robot in opwaartse modus. Hierbij is de speling in de robot voor het grootste deel weggehaald. Hier bleek de robot het best te werken bij een kp van 0,5 en een tau van 0.17 (meting 8).

De robot valt niet meer om, maar heeft wel veel ruimte nodig om te stabiliseren (Afbeelding 63).

78

Afbeelding 63: stabilisatie足afstand robot, deze afstand willen we zo klein mogelijk hebben.

Vervolgens hebben we gekeken of er verbetering is, wanneer de batterijen uit de robot gehaald worden. De batterijen zitten relatief ver van de as, waardoor de robot veel kracht moet zetten om deze te verplaatsen, het verwijderen van de batterijen zou misschien een stabieler systeem opleveren. De robot wordt in dit experiment gevoed door een voeding (Afbeelding 64).

Afbeelding 64: Robot aan voeding

Proefresultaten van een batterij足loze robot:

Meting

1

2

Kp

0,5

0,5

Tau

0,17

0,25

Stabiliteit Instabiel, toenemend slingerend Instabiel, toenemend slingerend

Gebied

Voor de volgende meting Tau naar boven

2

2

Robot reageert te heftig, we verlagen dus kp.

79

3

0,25

0,25

4

0,3

0,17

Stabiel? robot is te traag, maar valt niet om Stabiel, gedempte slingering te zien.

Robot heeft aanzienlijk minder ruimte nodig om te stabiliseren in vergelijking met batterijen.

5

Tau een klein beetje omlaag.

4

Tabel 3: Meetresultaten van de robot in opwaartse modus. De batterijen zijn hierbij uit de robot verwijderd.

In dit geval stabiliseerde de robot het best bij een kp van 0,3 en een tau van 0,17.

Wat opvalt is dat de robot niet meer stabiel is bij de kp en tau, die bij een robot met batterijen wel goed waren. Kennelijk heeft het verwijderen van de batterijen voor een heel nieuw systeem gezorgd. Robot heeft aanzienlijk minder ruimte nodig om te stabiliseren in vergelijking met batterijen.

10.4 Balanceren met de MPU6050 in opwaartse modus De robot valt niet meer om in opwaartse modus. Het verwijderen van de speling en batterijen hebben invloed gehad op de stabilisering van de robot. Toch zijn we nog niet tevreden. We hebben aan het begin van het onderzoek de eis gesteld, dat de robot op batterijen moest gaan rijden, dus het weghalen van de batterijen is geen optie. En zelfs met batterijen zijn wij van mening dat de robot teveel ruimte nodig heeft om te stabiliseren. Daarom hebben wij naast de versnellingssensor nog een andere sensor gekocht, de MPU 6050. Deze sensor bevat een versnellingssensor en gyroscoop. In paragraaf 8.2.4 (MPU6050) hadden we al uitgelegd waarom deze sensor beter is dan alleen de versnellingssensor.

We gaan met deze sensor meteen proberen om de robot in opwaartse modus te stabiliseren. Het principe hiervan is hetzelfde als bij de voorgaande proeven. Dit keer hebben we bij een aantal testen een grafiek gemaakt van de hoek van de stator (Îąs) als functie van de tijd. De resultaten staan in Tabel 4:

Meting Kp Tau Stabiliteit 1 1,8 0,07 Stabiel

2

1,7

3

1,6

80

0,07 Stabiel, maar iets minder stabiel dan meting 1.

0,07 Stabiel, maar iets minder stabiel dan meting 2.

Gebied Voor de volgende meting 4 We kunnen niet echt zien of de robot te traag of te snel reageert. Daarom proberen we de kp te verlagen, hierdoor zal de robot trager reageren.

4 We gaan verder met het verlagen van de kp.

4 We gaan verder met het verlagen van de kp.

4

1,3

0,07 Stabiel, licht slingerend

5

1

0,07 Onstabiel, toenemend slingerend, de robot valt om.

6

1,8

0,1 Zeer stabiel, Zeer kleine stabilisatieafstand

7

1,8

8

1,8

9

1,8

0,12 Zeer stabiel, Zeer kleine stabilisatieafstand, Vergelijkbaar met meting 6.

0,14 Zeer stabiel.

Vergelijkbaar met meting 7.

0,16 Zeer stabiel, nog licht slingerend

10

1,8

0,18 Zeer stabiel. Beste meting tot nu toe.

11

1,8

0,2 Zeer stabiel, alleen minder stabiel dan meting 10.

4 Het wordt duidelijk dat de robot te traag reageerdt toch gaan we verder met het verlagen van de kp.

2 Robot reageert te traag, valt om. Een kp van 1.8 blijkt dus het beste te zijn. We gaan nu de tau veranderen.

4 Een grote tau heeft een positieve invloed op de regeling, we gaan verder met het verhogen van de tau.

4 We gaan verder met het verhogen van de tau.

4 We gaan verder met het verhogen van de tau.

4 De robot gaat steeds minder heftig reageren. We gaan dus door met het verlagen van de tau.

5 Het systeem is bijna kritsch gedempt, het verhogen van de tau zou ervoor kunnen zorgen dat het systeem te traag wordt. We verhogen de tau om te kijken of dit inderdaad zo is.

5 We gaan ervan uit dat we de juiste waarden voor een kp van 1.8 gevonden hebben, namelijk meting 10.

We hebben nu, voor een stabiel systeem, de juiste waarden voor kp en tau gevonden.

We gaan vervolgens kijken of we de robot ander gedrag kunnen geven.

12 2 0,2 Zeer stabiel, nog niet 5 We verhogen de kp, zodat heel veel vernandering de robot heftiger gaat ten opzichte van meting reageren op verstoring.

11 13 2,2 0,2 Zeer stabiel, 4 We verhogen de kp flink. vergelijkbaar met de vorige meting.

81

14

2,2

15

2,2

16

2,2

17

2,2

18

2,2

19 20

2,2 2,2

2,5 Stabiel, reageert snel

3 Stabiel, reageert sneller, slingerend gedempt 4,5 Nog steeds stabiel, robot reageert wel heftiger, nog steeds gedempt slingerend 5,5 Nog steeds slingerend stabiel 6 Slingerend, heel licht gedempt 6,75 Constant slingerend 7,25 Constant slingerend

5 Er is duidelijk te zien dat de robot sneller en heftiger reageert, toch vertoont hij nog steeds kenmerken van een gedempt systeem. Dus verhogen we de kp verder.

4 Kp verhogen Kp verhogen

4 Kp verhogen 4 Kp verhogen 3 Kp verhogen 3 Gelijk aan meting 19, Dit komt omdat de motor tegen zijn maximum en minumum waarden aanliep. Het verhogen van de kp heeft dus geen zin meer.

Tabel 4: Meetresultaten van de robot met de mpu6050. De robot stabiliseerde het best bij een kp van 1,8 en een tau van 0,18 (meting 10).

Naast dat we tijdens het experiment zelf naar de robot hebben gekeken, heeft dit keer de computer van het systeem (Raspberry) de hoek bijgehouden. Vervolgens heeft deze een grafiek gemaakt van de hoek als functie van de tijd. Hieronder staan een aantal van deze grafieken. Op elke afbeelding is het gedrag te zien dat bij een van de gebieden in Afbeelding 14 hoort:

Afbeelding 65: Deze grafiek hoort bij meting 5, er is hier sprake van een toenemende slingering (gebied 2).

82

Afbeelding 66: Deze grafiek hoort bij meting 10. Bij deze waarden van van kp en tau was de robot het stabielst. Op de grafiek is te zien dat de robot verstoord wordt (hij krijgt een duw), maar zich vrijwel meteen weer herstelt. Er is hier sprake van een kritische gedempt systeem (gebied 5).

Afbeelding 67: De grafiek hoort bij meting 16. Te zien is dat de robot verstoord wordt, vervolgens gaat hij slingeren, alleen het slingeren neemt af totdat de robot weer stabiel is. De robot slingert dus gedempt (gebied 4).

Afbeelding 68: Deze opname is gemaakt tijdens meting 19. Te zien is dat de robot continu slingert zonder dat deze verstoord word. Het slingeren blijft constant en de robot blijft overeind, dit is kenmerkend voor gebied 3 boven de parabool.

83

11. Conclusie De vraag waarop we in het verslag antwoord zochten luidde als volgt: Is het mogelijk om een onstabiel systeem doormiddel van een regeling in balans te brengen?. In ons geval is dit systeem een robot op twee wielen, dat van zichzelf onstabiel (opwaartse modus) is.

Voor de theoretische uitvoering van de robot is dit inderdaad mogelijk. Voor de theoretische uitvoering van de robot voldoet een regeling die bestaat uit twee variabelen: De versterkende factor (kp) en de integrerende factor (tau). Wanneer deze waarden op de juiste manier gekozen worden zal de robot kritisch gedempt zijn (en dus stabiel). Wat opviel is dat er grote afwijkingen zitten tussen de ideale robot en de (meer) realistische robot. Dit betekent dat elk systeem zijn eigen waarde voor kp en tau heeft.

In de praktische uitvoering bleken ook drie andere factoren een belangrijke rol te spelen in de stabiliteit van het systeem: het zwaartepunt van de robot, het soort sensor en de speling in de constructie. Het weghalen van de speling en het gebruiken van een combinatie van een versnellingssensor en gyroscoop hebben voor een enorme verbetering in stabiliteit gezorgd. Vervolgens is het ons gelukt om de juiste waarden voor kp en tau te vinden met als gevolg dat onze robot zichzelf perfect in evenwicht kon houden. Het is dus zowel theoretisch als in de praktijk heel goed mogelijk om een onstabiel systeem in evenwicht te houden met een regeling.

84

12. Bronvermelding 1. Baalen, H van, et al. Systematische Natuurkunde vwo 4 kernboek. Baarn, 2006.

2. Borghouts, A. N. Inleiding in de mechanica, derde druk. Delft, 1978.

3. Verkerk, G. Binas havo/vwo informatieboek voor natuurewtenschappen en wiskunde, vijfde druk. Houten, 2008.

4. Alonso, M. & Finn, J. E. Fundamental university physics (tweede druk). Addison­ Wesly Publishing Company, Inc (1967).

5. G. Zill, Dennis. A first Course in Differtial Equations with Applications, tweede druk.

Boston 1979.

6. Verdooren, H. W. Repetitorium netwerk­ en wisselstroomtheorie. Amsterdam, 1972.

7. Dorf, R. C. Modern control systems (derde druk). Davis (1980).

8. http://www.produktinfo.conrad.com/datenblaetter/200000­224999/222366­ da­01­en­Getriebemotor_MFA_919D_1481.pdf 9. Kluwer, E. Electrotechniek (vijfde druk). Deventer (1947).

10. http://nl.wikipedia.org/wiki/Pulsbreedtemodulatie 11. http://nl.wikipedia.org/wiki/AND­poort 12. http://nl.wikipedia.org/wiki/XOR­poort 13. http://nl.wikipedia.org/wiki/NAND­poort 14. http://nl.wikipedia.org/wiki/Comparator 15. http://mafija.fmf.uni­lj.si/seminar/files/2007_2008/MEMS_accelerometers­ koncna.pdf 16. http://nl.wikipedia.org/wiki/Wet_van_behoud_van_impulsmoment 17. http://nl.wikipedia.org/wiki/Slinger_van_Foucault 18. http://nl.wikipedia.org/wiki/Corioliseffect 19. http://Arduino.cc/en/Reference/HomePage 20. http://playground.Arduino.cc/Main/DevelopmentTools 21. http://developer.android.com/reference/android/hardware/SensorManager.ht ml#getRotationMatrix(float[], float[], float[], float[]) 22. http://developer.android.com/reference/android/hardware/SensorManager.ht ml#getOrientation(float[], float[]) 23. http://nl.wikipedia.org/wiki/Domain_Name_System

85

13. Bijlage A. Afleiding Vergelijking 9.

Formules: Vergelijking 3) Deze formule verkorten we omdat daarmee formule versimpeld wordt, het karakter van de robot blijft wel behouden. We schrijven deze formule als volgt: A. B.

(Vergelijking 4)

C.

(Vergelijking 6)

D.

(Vergelijking 5)

E. F.

Vergelijking 7) (Vergelijking 8)

Uitwerking: 1.

(B,D)

2.

(A,C)

3.

(2, F)

4.

(3)

5.

(1, E)

6.

(4,5)

7.

(6,F)

8.

(7)

9.

(8)

Vergelijking 9:

86

B. Simulatiewaarden De simulaties met het theoretische model van de robot zijn gemaakt met het programma LT Spice (http://www.linear.com/designtools/software/).

Waarden simulatie eigenfrequentie: (Afbeelding 10) Ms = 3 kg G = 10 m/s2 R = 0.16 m Js = 30 mKg m2 JR = 36 mKg m2 MR = 2kg Mtotaal = 5kg Jt = 0.194 Kgm2 Robot neerwaarts kritisch gedempt (Afbeelding 17): Kp = 29,4 Tau = 6.07 ms Slingerend gedempt (Afbeelding 18): Kp = 2,94 Tau = 6.07 ms Constant slingeren (Afbeelding 19): kp = 0 Tau = 6.07 ms toenemend slingeren (Afbeelding 20): kp = 足2,94 Tau = 6.07 ms exponentieel toenemen (Afbeelding 21): kp = 足29,4 Tau = 6.07 ms

Robot opwaarts kritisch gedempt (Afbeelding 25): Kp = 29,4 Tau = 4,97 ms Slingerend gedempt (Afbeelding 26): Kp = 2,94 Tau = 4,97 ms Constant slingeren (Afbeelding 27):

87

kp = 0 Tau = 4,97 ms toenemend slingeren (Afbeelding 28): kp = 足2,94 Tau = 4,97 ms exponentieel toenemen (Afbeelding 29): kp = 足29,4 Tau = 4,97ms Realistisch model (Afbeelding 30): Motorconstante plus tandwielen = 2,9 radialen per seconde per volt (Afbeelding 31): kritisch gedempt) Kp = (10*29,4)/2,9 Tau = 4,97*2,9 ms Opstart model (Afbeelding 32): kritisch gedempt) Kp = (10*29,4)/2,9 Tau = 4,97*2,9 ms

88

C. Specificaties Raspberry Pi Raspberry Pi A Prijs1

€28.95

CPU2

RAM2

Raspberry Pi B €29.95

Raspberry Pi B+ €26.49

Raspberry Pi A+ €24.95

512 mb

512 mb

€36.95 900 MHz quad core

700 MHz single core

256 mb

Raspberry Pi 2B

256 mb

1024 mb

1) prijzen komen van de site: http://www.sossolutions.nl, behalve de A+ variant: http://www.kiwi­electronics.nl/raspberry­pi­model­a­plus­256mb 2) specificaties: http://nl.wikipedia.org/wiki/Raspberry_Pi

89

D. paragraaf 9.1.1 : ASCII tabel

U ziet hier een tabel met de kollommen dec, hex en symbool. Als u van een sybmool de correspondeerende byte wilt maken moet u het volgende doen: 1. U neemt het getal wat in de dec kollom staat 2. U maakt hier een binear nummer van 3. Als dit getal niet uit 8 0’en en 1’en bestaat moet u er net zoveel 0’en voorzetten tot dat u 8 cijfers heeft.

90

E. HTML codes

HTTP resultaat codes

Uitleg

100 304 308 400 403 429 502

Doorgaan Informatie niet gewijzigd Permanente omleiding naar andere URL Foutieve request Geen toegang Er zijn teveel requests op dit moment Er is iets niet goed ingesteld in het datacenter 503 Server is niet beschikbaar 504 Server doet er telang over om een response te sturen Bron: http://nl.wikipedia.org/wiki/Lijst_van_HTTP­statuscodes

F. Library’s bij de Raspberry Pi Wij gebruikten een aantal library’s voor de code op de Raspberry Pi. Deze librarby’s komen uit een centrale market, npm. Als je nodeJS installeert installeer je ook automatisch NPM. Hieronder volgt het commando wat moet worden uitgevoerd om de library te installeren, samen met de link naar de library zelf.

Express: $ npm install express Link: https://www.npmjs.com/package/express

$ npm install socket.io Socket.IO: Link: https://www.npmjs.com/package/socket.io serialPort: $ npm install serialport Link: https://www.npmjs.com/package/serialport http: Deze library wordt standaart meegelevert met nodeJS

91

G. Library’s bij android Voor het volgen van het socketIO protocol hebben wij gebruik gemaakt van de volgende library: Socket.io­java­client. Deze library is beschikbaar op de url: https://github.com/fatshotty/socket.io­java­client

H. Library’s bij Arduino Om te kunnen communiceren met de MPU6050 sensor hebben wij gebruik gemaakt van de library: freeIMU v4. Deze library is te vinden op de url: http://www.varesano.net/projects/hardware/FreeIMU Deze hebben wij zelf nog aangepast om hem werkend te krijgen voor onze sensor. De aangepaste library kunt u terug vinden op onze eigen github pagina zoals eerder genoemd.

I. Software De programma’s die wij geschreven hebben, zijn te vinden op: https://github.com/eggied97/pws

92

14. Logboek Tom Idee Een pws kun je niet beginnen zonder dat je een onderwerp hebt bedacht. Ergens in v5 (2013­2014) kwamen we op het idee om voor het pws, in het examenjaar, een evenwichtsrobot te maken. Dit leek ons een geschikt onderwerp omdat er veel natuurkunde en informatica in voor komt.

(0 uur) Zomervakantie 5 juli tot 17 augustus Ontwerp motorsturing (05­07­2014) Een van de dingen die we van te voren wisten, is dat je voor het maken van een evenwichtsrobot een motor nodig hebt die zowel voor als achteruit kan draaien, dit is nodig om zichzelf te kunnen corrigeren. Op het internet hebben we naar zo’n motor gezocht en gevonden. Deze hebben we besteld en bij deze motor (12v) hebben we een schakeling ontworpen die bij een ingangsspanning van 0 tot 2.5 volt (geleverd door een Arduino) , ­12 tot o volt levert (voor de motor). En bij een ingangsspanning van 2.5 tot 5 volt, 0 tot 12 volt levert.

Afbeelding 69 Ontwerp motorsturing op printplaat

(6 uur) Robot ontwerpen (05­07­2014 & 06­07­2014) Nadat de motorsturing bekend was, en dus ook de afmetingen van deze printplaat, konden we de robot ook ontwerpen. De robot moest aan een aantal eisen voldoen: de motorsturing moet er in passen, er moet ruimte zijn voor 10 AA batterijen, er moet een Arduino en Raspberry in passen en de behuizing moet er stevig zijn. Het ontwerp maken was wel lastig omdat we niet precies wisten waar we allemaal rekening mee moesten houden, we gingen er vanuit dat er op bepaalde punten (dicht bij de as) heel veel kracht zou komen te staan, maar hoeveel dat exact was konden we alleen maar schatten.

(8 uur)

93

Onderdelen bestellen (07­07­2014) Toen we beide ontwerpen af hadden konden we de onderdelen bestellen, waarvan we dachten dat we die nodig hadden. Alleen konden we geen geschikte wielen vinden, dus die hebben we dus nog niet.

(0 uur) Onderdelen zijn binnen (10­07­2014) Solderen en testen van motorsturing (26­07­2014 & 27­07­2014) Dit weekend hebben we de motorsturing in elkaar gezet en de test wees uit dat hij werkte.

In elkaar zetten (solderen) van motorsturing: 8 uur Testen: 2 uur In elkaar zetten behuizing (10 tm 17–08­2014) De laatste week van de zomervakantie hebben we helemaal gebruikt om de behuizing in elkaar te zetten. Ook hebben we geschikte wielen gevonden (van een tweede hands kinderwagen gehaald). Een probleem met de wielen is dat we deze nog niet goed op de as kunnen vast maken, hiervoor moeten we nog een oplossing zoeken.

Afbeelding 70 Behuizing

Afbeelding 71 Behuizing met wielen

(28 uur) Eind zomervakantie 18­08­2014 Op de eerste schooldag werd verteld dat het pws in drietallen moest. Aangezien wij al begonnen waren met ons pws, hebben we met veel moeite het voor elkaar gekregen dat we het pws alsnog met z’n tweeën doen in plaats van drie.

Wielen vastzetten (23­08­2014) Oplossingen gezocht om de wielen aan de as vast te zetten, dit is nog niet gelukt. We hebben twee tandwielen besteld die je op de as vast kunt schroeven. Door de wielen aan deze twee tandwielen vast te zetten hopen we de wielen vast te kunnen zetten.

(3 uur)

94

Verder bouwen aan robot (15­10­2014) Egbert en ik hebben vandaag verder aan de robot gewerkt. De wielen zijn vastgezet. We hebben ook gekeken of we de robot voor en achteruit konden laten rijden. Verder hebben we uitgezocht hoe de versnellingsmeter werkt.

(4 uur) Nog verder bouwen aan de robot (03­11­2014) Vandaag hebben Egbert en ik de draadloze besturing ingebouwd in de robot. De telefoon kan gegevens sturen naar de Raspberry Pi via wifi.

(3 uur) Pws werkmiddag op school (04­11­2014) We hebben ons tot nu toe vooral geconcentreerd op het bouwen van de evenwichtsrobot. Maar omdat er ook een verslag moet komen, hebben we vandaag de deelvragen verzonnen. Ook hebben we nagedacht over een mogelijke opbouw van het verslag. Het leek ons het handigst om eerst de theorie te behandelen. Met theorie bedoelen we de natuurkunde die bij ons onderwerp te pas komt. En in het tweede deel de praktijk, hierin leggen we uit hoe onze robot is gemaakt, waarom we voor bepaalde keuzes gekozen hebben en de resultaten van verschillende testen.

(2 uur) Pws werkmiddag op school (05­11­2014) We hadden al uitgezocht hoe de versnellingssensor werkt. We hebben nu een programma gemaakt waarin de waardes die de sensor geeft gevisualiseerd worden. Dit om een idee te hoe de sensor reageert bij bepaalde bewegingen.

Afbeelding 72 Wanneer de versnelling zich in de x­richting bevind, beweegt de cirkel zich ook langs de x­as.

Hetzelfde geldt voor de y­richting, alleen beweegt de cirkel langs de y­as.

(2 uur) Gegevens versnellingssensor omrekenen naar hoek (24­12­2014) We hebben nu gekeken hoe we de gegevens (analoog) van de versnellingssensor konden omrekenen naar de hoek. Dit was lastig omdat de gemeten waarden van de sensor niet overeen kwamen met de gegevens die in de datasheet van de sensor stonden. We hebben zelf een schatting gemaakt wat het aantal volt per g bedraagt van de sensor.

Maar we moeten nog wel een manier verzinnen om dit op een exactere manier te bepalen.

(2.5 uur)

95

Motor laten draaien op uitlezing versnelling sensor (22­01­15) Vandaag hebben we voor de eerste keer de motor laten draaien, op de uitlezing van de versnellingssensor.

Afbeelding 73 opstelling van het draaien van de motor op waarden van de versnellingssensor, wielen zijn nog niet aanwezig, omdat het regelsysteem nog niet geprogrammeerd is.

We hebben ook nagedacht over een regelsysteem.

(4 uur) Regelsysteem programmeren en testen (24­01­15) Vandaag is het regelsysteem in de Arduino gezet. Ook zijn er verschillende proeven gedaan om de juiste kp en tau te vinden, zowel voor de modus onder als boven. Een probleem waar we tegen aan lopen is de vele speling die in het mechanisme zit, hierdoor is het systeem erg onstabiel. Ook zouden het gewicht van de batterijen vermoedelijk voor onstabieliteit kunnen zorgen. Ook hebben we er een beveiliging opgezet met een ir sensor, om de robot op afstand te kunnen stoppen (9 uur) Verslag en films maken van robot (25­01­15) Een deel van de theoretische uitwerking van het verslag gemaakt. Ook heb ik bij versc8hillende tau’s en kp’s films gemaakt. Ook heb ik een wijziging gemaakt in de elektronica gemaakt op de robot, nu zitten er aan beide kanten een breadboard voor de nodige elektronica. Een probleem waar ik tegen aan liep is dat het pwm signaal, de motorsturing verstoord, daarom heb ik een filter op de motorsturing gezet.

(8 uur) Hoeksnelheid en koppels (27­01­15) Deel van het hoofdstuk over hoeksnelheid en koppels geschreven.

(2 uur) Hoeksnelheid en koppels (28­01­15) Hoofdstuk over hoeksnelheid en koppels afgeschreven.

(1.5 uur)

96

Programma om kp en tau op afstand in robot te zetten (29­01­15) Vandaag hebben het programma voor de besturing op afstand in de Raspberry gezet.

Probleem is dat de voeding die op de motorsturing niet genoeg vermogen heeft om de elektronica, Arduino en Raspberry te voeden. Daarom hebben we niet kunnen testen of het programma ook werkt.

(2.5 uur) Nieuwe voeding (30­01­15) Nieuwe voeding gekocht en op het breadboard gezet.

(0 uur) Verslag (30­01­15) Eerste deel van het hoofdstuk “beschrijving van dynamica” geschreven.

(3 uur) Batterijen uit robot en speling weg (31­02­15) We zijn er achter gekomen dat niet de tandwieloverbrenging in de motor de oorzaak van de speling was, maar een schroefje op de motor­as die niet goed is aangedraaid.

Hierdoor hebben we een aanzienlijk deel van de speling weg kunnen krijgen. Ook hebben we de batterijen uit de robot gehaald, om het zwaartepunt dichter bij de as te krijgen. Hierna hebben we de testen met kp en tau overnieuw gedaan. Het is ons gelukt om de robot opwaarts te balanceren.

(6 uur) Besturing met website op Raspberry en films (01­02­15) Van Egbert heb ik de programma’s gekregen waarmee de robot via een website bestuurd kan worden, deze heb ik op de Raspberry gezet. Ook heb ik films gemaakt van de robot die aan het balanceren is op opwaartse modus.

(3 uur) Verslag en nieuwe sensor(03­02­15) “Beschrijving van dynamica” afgeschreven. Ook kwamen we tot het besef dat de onstabiliteit wel eens aan de sensor kon liggen en dat het beter is om een gyroscoop te gebruiken in plaats van een versnellingssensor. Dus hebben we een gyroscoop besteld.

(2 uur) Gyroscoop ontvangen (04­02­15) (0 uur) Uitzoeken hoe de gyroscoop werkt (05­02­15) Vandaag hebben Egbert en ik uitgezocht hoe de gyroscoop werkt. Egbert is hier later zelf ook nog mee bezig geweest.

(4 uur) Verslag (07­02­15) Vandaag het hoofdstuk “regeling” geschreven. Ook heb ik een aantal tekeningen voor het verslag gemaakt (grafieken, schema’s enz). En voor het hoofdstuk simulaties, hebben we een aantal simulaties in het programma LT­Spice gemaakt.

(7 uur)

97

Verslag (08­02­15) Theoretisch gedeelte van het verslag afgerond.

(4 uur) Gyroscoop (12­02­15) We hebben wat problemen met de gyroscoop. De gyroscoop heeft sterk de neiging om te crashen of verkeerde waardes af te geven.

(2 uur) Gyroscoop aan de praat gekregen!! (14­02­15) Eindelijk de gyroscoop werkend gekregen. Er is een sterke verbetering in stabiliteit.

Films gemaakt van de robot en verschillende waardes voor kp en tau uitgeprobeerd.

(2 uur) Presentatie (15­02­15) Egbert en ik zijn begonnen aan de presentatie.

(3 uur) Oefenpresentatie (18­02­15) Vandaag hebben we onze presentatie voor de begeleider gehouden. Hierbij hebben we nog wat handige feedback gekregen.

(1 uur) Verslag (19­02­15) Ik ben verder gegaan met het hoofdstuk over de bouw van de robot.

(1 uur) Verslag (20­02­15) Hoofdstuk over de bouw van de robot afgerond.

(2 uur) Simulaties maken en bewerken (21­02­15) Bij de presentatie was duidelijk geworden dat we heel goed met de tijd om moesten gaan. Daarom heb ik vandaag van de simulaties een film gemaakt, zodat we die snel kunnen afspelen.

(2 uur) Inleiding & samenvatting geschreven(22­02­15) (1 uur) besturing op afstand wekend gekregen (23­02­15) Vandaag hebben Egbert en ik aan de besturing op afstand gewerkt.

(3 uur) Verslag (24­02­15) Het hoofdstukken over proeven en resultaten voor een deel geschreven.

(3 uur)

98

Besturing robot & proeven (25­02­15) Vandaag hebben Egbert en ik de besturing helemaal werkend gekregen. Vervolgens hebben we nog proeven gedaan met de robot (kp en tau uitzoeken). Dit hebben we al een keer gedaan, maar nu konden we ook de hoek die de robot maakt op een grafiek laten zien.

Verslag (26­02­15) Mijn deel van het verslag uitgewerkt. Nu moeten de puntjes op de ‘i’ gezet worden.

(6 uur) Presentatie (27­02­15) Egbert en ik hebben aan de hand van de feedback die bij de proefpresentatie hebben gekregen, de presentatie verbeterd. Ook hebben we bedacht wat we allemaal van de robot gaan laten zien.

(5 uur) De laatste hand leggen aan het verslag (28­02­15) Laatste dingen verbeterd. Het werkstuk is af. Het enige wat we nog moeten doen is de presentatie.

(3 uur) Totaal aantal uur: 158.5

Egbert Raspberry en accessoires bezorgt (23­08­2014 – 24­08­2014) Vandaag kwam het pakketje met de Raspberry Pi, samen met de wifi dongle. Ik heb dit weekend de Rasbian geïnstalleerd op de Raspberry, om vervolgens de nodige software te installeren. De Raspberry word gebruikt voor de communicatie tussen het internet (Hetzij telefoon, hetzij een website). Dit doen we doormiddel van NodeJs. Hiermee maken wij een webserver, die doormiddel van http­Get requests zijn functies kan uitvoeren.

(13 uur) Raspberry en accessoires bezorgt vervolg(30­08­2014 – 31­08­2014) Ik heb dit weekend verder gewerkt aan de Raspberry Pi en de android app. Ik heb mij ook meer verdiept in het WebSockets protocol, omdat de GET requests aardig wat tijd nemen. Ook heb ik de eerste stappen gezet om de Raspberry te verbinden met de Arduino, en zo data van de telefoon via de Raspberry naar de Arduino te sturen.

(13 uur) Verder bouwen aan robot (15­10­2014) We vandaag verder aan de robot gewerkt. De wielen zijn vastgezet. We hebben ook gekeken of we de robot voor en achteruit konden laten rijden. Verder hebben we uitgezocht hoe de versnellingsmeter werkt.

(4 uur) Nog verder bouwen aan de robot (03­11­2014)

99

We hebben vandaag geprobeert de motors aan te sturen op de hoek van de telefoon. (het signaal via de Raspberry Pi naar de Arduino). Dit verliep goed.

(3 uur) Pws werkmiddag op school (04­11­2014) We hebben ons tot nu toe vooral geconcentreerd op het bouwen van de evenwichtsrobot. Maar omdat er ook een verslag moet komen, hebben we vandaag de deelvragen verzonnen. Ook hebben we nagedacht over een mogelijke opbouw van het verslag. Het leek ons het handigst om eerst de theorie te behandelen. Met theorie bedoelen we de natuurkunde die bij ons onderwerp te pas komt. En in het tweede deel de praktijk, hierin leggen we uit hoe onze robot is gemaakt, waarom we voor bepaalde keuzes gekozen hebben en de resultaten van verschillende testen.

(2 uur) Pws werkmiddag op school (05­11­2014) We hadden al uitgezocht hoe de versnellingssensor werkt. We hebben nu een programma gemaakt waarin de waardes die de sensor geeft gevisualiseerd worden. Dit om een idee te hoe de sensor reageert bij bepaalde bewegingen, en hoe wij hier op zouden moeten reageren om het recht te houden.

(2 uur) Iets zinnigs zeggen over de accelorometer (24­12­2014) Vandaag hebben we gekeken hoe wij de analoge waarden van de sensor konden omzetten naar de hoek. Dit zorgde echter voor wat problemen, omdat onze waarden niet overeenkwamen met de datasheet van de sensor. Hierdoor moesten wij wat schatten naar de Voltverandering per G. We moeten echter nog kijken hoe we dit nauwkeuriger krijgen.

(2.5 uur) Motor laten draaien op de versnelling sensor (22­01­15) Vandaag hebben we voor de eerste keer de motor laten draaien, op de sensor waarden van de versnellingssensor.

We hebben ook nagedacht over een regelsysteem, en de implementatie daarvan op de Arduino.

100

(4 uur) Nieuwe sensor, gyroscoop en accelorometer in 1 (05­02­2015) We hebben een nieuwe sensor besteld, omdat de oude sensor alleen een accelorometer bevatte en we ook wel een gyroscoop nodig hadden, om de uitschieters te verminderen.

Deze was gister bezorgt, en we hebben vandaag gekeken hoe we deze sensor moesten aanspreken, en hoe wij deze waarden konden gebruiken in ons programma.

(7 uur) Verslag en Fritzing (07­02­2015) Ik ben vandaag bezig geweest met het verslag, en hierbij ook een visualisatie gemaakt van een gedeelte van het circuit, dit doormiddel van het programma Fritzing.

(3 uur) PWS­werkdag (10­02­2015) Wij zijn vandaag de hele schooldag op school bezig geweest, dit om te kijken hoe de robot zou reageren op het netwerk van school. Hier liepen we tegen wat problemen aan, want wij konden niet op het netwerk van school, en door de beveiliging konden wij geen data verbinding krijgen op ons eigen opgezette netwerk. Die data was wel belangrijk, omdat wij een library,JQuery, van internet inladen, dit moeten we dus anders oplossen.

(5 uur) Tussenuur en problemen (12­02­2015) Tussenuur omdat er nederlands gesprekjes zijn, bezig geweest met het verslag. Ook gingen wij na school weer met de robot bezig, kijken hoe we de presentatie zouden aanpakken en hoe wij de demo zouden invullen. Nou hadden wij die nieuwe sensor ook en hier kregen wij soms nog gekke waarden uit, of crashde de hele Arduino, ik ben hier vervolgens thuis nog mee bezig geweest en bleek een snelheids issue te zijn geweest (8 uur) Verslag en presentatie (14­02­2015) Ik heb vandaag verder gewerkt aan het verslag, en nagedacht over wat de mooiste manier is om de code te weeregeven in het verslag.

(3 uur)

Presentatie (15­02­2015) Tom en ik zijn begonnen aan de presentatie.

(3 uur) Oefenpresentatie (18­02­2015) Vandaag hadden wij de proef presentatie. Hiervoor had ik nog wat laatste testjes uitgevoerd en ook de presentatie afgerond.

(2.5 uur) Eerste vakantie dag (23­02­2015) Vandaag zijn we bij Tom bezig geweest. We hebben ons voornamelijk gericht op de problemen die we hadden met de sensor. Ik ben hiermee thuis verder gegaan. Het probleem leek bij de library te liggen die wij gebruikten. Ik heb dit verandert door een andere en sindsdien hebben wij geen ‘gekke’ crashes meer gehad.

101

(6 uur) Tweede vakantie dag (24­02­2015) Vandaag stond in het teken van verslag afmaken. Ik ben bezig geweest met het software gedeelte. Ik heb hier enkele diagrammen bij gemaakt.

(6 uur) Derde vakantie dag (25­02­2015) Tom en ik zijn vandaag weer bij elkaar gekomen. Wij hebben de vernieuwde code op de Arduino gezet en dit werkte. Hierna hebben wij nog wat simulaties uitgevoerd met betrekking tot de regeling. Thuis ben ik vervolgens nog bezig geweest om de Raspberry code uit te breiden zodat wij ook statestieken konden zien als de hoek.

(7 uur) Vierde vakantie dag(26­02­2015) Vandaag ben ik verder gegaan met het verslag. Het hoofdstuk elektronica heb ik afgemaakt en commentaar verbeterd.

(5 uur) vijfde vakantie dag(27­02­2015) Vandaag zijn tom en ik weer bij elkaar gekomen. Nu hebben wij het commentaar wat we kregen bij de proefpresentatie verwerkt. Ook hebben we eigen commentaar verbeterd.

We hebben ook de variabelen voor de demo vast gesteld.

(5 uur) Zaterdag na de vakantie (28­02­2015) Laatste puntjes op de i voor het verslag. Voorkant gemaakt en erin verwerkt. Het verslag is hiermee afgerond.

(6 uur) Totaal aantal uur: 155.

102