Ontwerp van data-aquisisiesysteem met webinterface voor het bewaken en sturen van elektrische en chemische processen
H
Promotor: Tim Saillé Begeleider: Charles Van den Berghe Masterproef ingediend tot het behalen van de academische graad van Master of Science in de industriële wetenschappen: elektrotechniek
Vakgroep Industriële Technologie en Constructie Voorzitter: prof. Marc Vanhaelst Faculteit Ingenieurswetenschappen en Architectuur Academiejaar 2014-2015
Ontwerp van data-aquisisiesysteem met webinterface voor het bewaken en sturen van elektrische en chemische processen
H
Promotor: Tim Saillé Begeleider: Charles Van den Berghe Masterproef ingediend tot het behalen van de academische graad van Master of Science in de industriële wetenschappen: elektrotechniek
Vakgroep Industriële Technologie en Constructie Voorzitter: prof. Marc Vanhaelst Faculteit Ingenieurswetenschappen en Architectuur Academiejaar 2014-2015
Woord vooraf Deze thesis was voor ons beiden een interessante uitdaging omdat er veel verschillende aspecten samen kwamen: elektronica, data-aquisitie en programmatie. De onderlinge samenwerking verliep heel goed met een goede verdeling van het werk en productief overleg bij de knelpunten die we tegenkwamen. Wij willen onze oprechte dank betuigen aan onze promotor Tim Saillé voor de technische en morele ondersteuning en voor de vlotte samenwerking. Geen enkele vraag was hem te veel, we konden steeds bij hem terecht. We willen ook docent Luc Colman danken voor zijn elektronische ondersteuning. Hij heeft ons van nabij geholpen bij het ontwikkelen van het Arduino shield. Verder willen we ook Prof. Danny Geelen danken. Het was heel interessant om parallel met deze thesis de reeds verworven kennis toe te kunnen passen in de praktijk van het hydrophonic system. We willen ook assistent Bert Hannon danken voor het delen van zijn kennis bij de uitwerking van het framework. Dit betekende voor ons een hele ruggensteun. Tenslotte willen we ook onze ouders en familie danken voor de morele steun, het kritisch meedenken en het taalkundig nalezen van deze thesis.
Uitgebreide samenvatting Wat is het doel van deze thesis? Processen worden steeds meer gecontroleerd. De bedoeling van dit onderzoek was het realiseren van een compact data-aquisitiesysteem om een relaislift te controleren. Dit systeem moest potentiaalpunten van de lift uitlezen, nagaan of er een fout optrad en de fout loggen naar een database. Er moest ook een visualisatie voorzien worden om de fouten weer te geven.
Wat zijn de problemen? De problemen die zich voordoen binnen het data-aquisitiesysteem zijn deels elektronisch en deels software gerelateerd. Op elektronisch vlak moest er bepaald worden welke potentiaalpunten van de lift wel of niet nuttig waren om uit te lezen. Er moest eveneens bepaald worden hoe dit op een veilige manier kon gebeuren, met name moest er een galvanische scheiding tussen het liftcircuit en het controlesysteem voorzien worden. Deze data diende softwarematig verwerkt te worden en gecontroleerd op fouten, en er moest een passend systeem gezocht worden waarop de software kon draaien. Indien er zich fouten voordeden in de werking van de lift, moesten deze opgeslagen worden zodat de operator deze kon uitlezen opdat de goede werking van de lift kon verzekerd blijven.
Op welke manier zijn deze problemen aangepakt? De schema’s van de relaislift werden grondig bestudeerd. Op basis van deze studie werden enkele potentiaalpunten gekozen waarmee kon nagegaan worden of het grendelslot van de lift al dan niet goed werkte (dit is de meest voorkomende fout bij dit soort liften). Om deze potentiaalpunten uit te lezen werden verschillende optocouplers vergeleken en getest in de opstelling van de lift. Er werden ook enkele shift-registers getest waarmee verschillende parallelle signalen serieel konden doorgestuurd worden. Voor de verwerking van IO’s moest een keuze gemaakt worden tussen verschillende programeerbare platformen zoals Arduino of Raspberry Pi. De Arduino Yún is een nieuwe, zeer geschikte versie van Arduino met als grote voordeel dat hij beschikt over twee processors: een Atmega-processor en een Atheros-processor. De Atmega-processor kan geprogrammeerd worden met de Arduino IDE. De Atheros-processor beschikt over een kleine versie van Linux, waarop verschillende programma’s geïnstalleerd kunnen worden. Dit betekent dat er op het vlak van software een keuze kan gemaakt worden uit een zeer ruim aanbod van programma’s. Er wordt gebruik gemaakt van Python, een wijd verspreide object-georiënteerde programmeertaal die gemakkelijk te leren is en geïnstalleerd kan worden op Linux. MySQL is de meest populaire open-source database en kan eveneens op Linux geïnstalleerd worden. Daarenboven voorziet Linux reeds een
omgeving om lokale websites beschikbaar te maken. Deze website zou dienst doen als visualisatie.
Wat is het resultaat? Door deze componenten samen te voegen, bekomt men een geheel dat feilloos samenwerkt. Arduino is voorzien om met shields te werken, er werd dan ook een specifiek shield ontwikkeld voor de optocouplers en de shift-registers. De potentiaalpunten worden zonder fouten binnengelezen uit de shift-registers door een Arduino-programma waarin de data tijdelijk opgeslagen wordt. De data wordt dan gezamenlijk doorgestuurd naar een Python-programma op de Atheros-processor. Hier wordt de data nagekeken op fouten en bij een fout doorgestuurd naar de MySQLdatabase. Om de fouten weer te geven moet de operator zich aanmelden op een website op de Arduino Yún. Hij krijgt dan een tabel met alle fouten die zich voorgedaan hebben.
Bijkomend project Binnen het onderwerp van deze thesis was het ook mogelijk om verschillende aspecten die hier aan bod kwamen (data-aquisitie, data logging, ...), toe te passen op een opstelling in de faculteit Bio-ingenieurswetenschappen van de UGent waar in een gecontroleerde groeikamer plantjes gekweekt worden. Daarbij worden sensoren gebruikt die de groei opvolgen en waarmee die groei verder kan geoptimaliseerd worden. De opdracht bestond eruit de sensoren elektrisch aan te sluiten en een gebruiksvriendelijk framework te programmeren. De opstelling werd gecontroleerd met een Compact RIO van National Instruments, dit betekende dat het framework uitgewerkt moest worden in LabVIEW, een grafische programmeertaal.
Installatie Arduino Linux programma’s ............................................................ 101
8.9.1
Installatie van MySQL op de Arduino Yún............................................................. 101
8.9.2
Installatie van PHP5 op de Arduino Yún ................................................................ 103
8.9.3
Connectie tussen MySQL en PHP5 ......................................................................... 105
Lijst met figuren Figuur 1: Overzicht van het controlesysteem ............................................................................ 9 Figuur 2: Afbeelding Arduino Yún ........................................................................................... 12 Figuur 3: Foto shift-in register shield ........................................................................................ 14 Figuur 4: Logisch diagram van een optocoupler ..................................................................... 14 Figuur 5: Grafiek werking CNX67a en LTV827 ..................................................................... 14 Figuur 6: Grafiek werking MOC3020 ....................................................................................... 15 Figuur 7: Aansluiting MOC3020 ............................................................................................... 16 Figuur 8: Functie diagram shift-register 74hc597 .................................................................... 17 Figuur 9: Bodemlaag PCB bord ................................................................................................. 18 Figuur 10: Elektrisch shema shift-in shield .............................................................................. 18 Figuur 11: Toplaag PCB bord .................................................................................................... 18 Figuur 12: Overzicht Arduino Yún ........................................................................................... 19 Figuur 13: Knoppen op de Arduino Yún ................................................................................. 20 Figuur 14: Tijdsdiagram shift register 74HC597 ..................................................................... 26 Figuur 15: Tabel input ................................................................................................................. 38 Figuur 16: Database Lift ............................................................................................................. 39 Figuur 17: Opbouw website ....................................................................................................... 40 Figuur 18: URL ............................................................................................................................ 43 Figuur 19: De webpagina ............................................................................................................ 47 Figuur 20: Signup webpagina ..................................................................................................... 49 Figuur 21: Database webpagina ................................................................................................. 51 Figuur 22: HTTP communicatie ................................................................................................ 53 Figuur 25: Terminal arduino....................................................................................................... 82 Figuur 26: Ubuntu software center ........................................................................................... 82 Figuur 27: Arduino icon.............................................................................................................. 83 Figuur 28: Main menu ................................................................................................................. 83 Figuur 29: Ubuntu Arduino........................................................................................................ 83 Figuur 30: Lamp ........................................................................................................................... 84 Figuur 31: Apache2...................................................................................................................... 84 Figuur 33: PHPmyadmin interface ............................................................................................ 85 Figuur 32: PHPmyadmin ............................................................................................................ 85 Figuur 34: Terminal netbeans..................................................................................................... 86 Figuur 35: Netbeans .................................................................................................................... 86 Figuur 36: Default-ssl.conf ......................................................................................................... 87 Figuur 37: Nano 000.default.conf.............................................................................................. 87 Figuur 38: Netbeans echo script ................................................................................................ 88 Figuur 39: Arduino Ubuntu........................................................................................................ 88 Figuur 40: Boom structuur webpagina ..................................................................................... 90 Figuur 41: Selecteren Arduino poort......................................................................................... 91 Figuur 42: Inhoud sd op webpagina.......................................................................................... 92 Figuur 43: SD webpagina............................................................................................................ 93 Figuur 44: COM poort ................................................................................................................ 94 Figuur 45: Board select ............................................................................................................... 94 Figuur 46: Sketch SD kaart ......................................................................................................... 95
Figuur 47: Configureren SD kaart ............................................................................................. 95 Figuur 48: Wifi ............................................................................................................................. 96 Figuur 49: Arduino webpanel..................................................................................................... 96 Figuur 50: Wifi configuratie ....................................................................................................... 97 Figuur 51: IP-adres Arduino Yún .............................................................................................. 97 Figuur 52: PuTTY interface ....................................................................................................... 98 Figuur 53: PuTTY terminal ........................................................................................................ 99 Figuur 54: Terminal Linux ........................................................................................................ 100 Figuur 55: Login MySQL .......................................................................................................... 102 Figuur 56: Configureren van MySQL ..................................................................................... 102 Figuur 57: Configureren van uHTTPd ................................................................................... 103 Figuur 58: Bewerken van het configuratiebestand ................................................................ 104
Inleiding De bedoeling van deze thesis is het ontwikkelen van een compact, autonoom datadata aquisitiesysteem om een relaislift te controleren. Door deze controle uit te voeren zou een operator gemakkelijk fouten ten moeten kunnen opsporen in het liftcircuit bij een defect. In deze thesis wordt eerst de keuze van het ontwikkelinsplatform besproken, daarna zal de werking van het data-aquisitiesysteem aquisitiesysteem overlopen worden. Het overzicht van de werking is weergegeven in Figuur 1: Overzicht van het controlesysteem. Dit begint bij het uitlezen van de potentiaalpunten op de lift,, waar er eerst een stroombegrenzing toegepast wordt om dan het signaal via een optocoupler door te sturen. De optocouplers zijn parallel aan een shiftshift register aangesloten zodat de uitgelezen data serieel serieel doorgestuurd kan worden. Voor de optocouplers en de shift-registers registers werd een shield ontwikkeld voor Arduino. De seriële data wordt opgevraagd door de Atmega-processor Atmega op de Arduino Yún. n. Hiervoor werd 1 een programma ontwikkeld met het Arduino IDE . Dit programma zal de ontvangen data in pakketten doorsturen naar de Atheros-processor, Atheros waar een Python-script script deze data nakijkt op fouten. Indien er een fout voorkomt zal de foutcode opgeslagen worden in de MySQL-database. database. Om de fouten gemakkelijk weer te geven werd er een website ontwikkeld waar een operator zich kan aanmelden. Eenmaal aangemeld wordt er een tabel weergegeven met de foutcodes.
Figuur 1:: Overzicht van het controlesysteem
1
Arduino Integrated Development Environment, dit is een specifieke programmeeromgeving van Arduino.
Er werd gekozen om de Arduino Yún te gebruiken als platform om het systeem op te bouwen omdat deze beschikt over een extra processor met een Linux-distributie. Deze keuze wordt verder verantwoord in deel 1. Om een controle op de lift uit te kunnen voeren is eerst een dieper inzicht nodig van de liftstructuur. Het volledige onderzoek wordt uitgebreid besproken in hoofdstuk 2 over de Liftstudie. Hier wordt een kort overzicht gegeven van de werking van de lift. Het relaiscircuit bestaat uit een vermogenskring en een stuurkring. De vermogenskring zal zorgen voor het voeden van de liftmotor en werkt op 3x400V wisselspanning. De stuurkring zorgt voor de sturing van de lift en werkt op een gelijkgerichte éénfasige wisselspanning van 90V. Er moeten bepaalde potentiaalpunten gekozen worden waarmee een logica opgesteld kan worden om vaak voorkomende problemen vast te kunnen stellen. Om veiligheidsredenen mogen deze potentiaalpunten enkel uit de stuurkring genomen worden en moet er een galvanische scheiding voorzien worden tussen het liftcircuit en het meetsysteem. Eén van de meest voorkomende defecten bij dit soort liften is het grendelcontact dat soms niet meer reageert. Het grendelcontact zorgt ervoor dat de deur van de lift vergrendelt wordt tijdens de lift. Om dit probleem vast te stellen werden vier potentiaalpunten gekozen. Deze potentiaalpunten staan op een spanning van 90V DC. Deze stroom is veel te hoog om rechtstreeks met behulp van elektronica uit te lezen, daarom werd er een stroombegrenzing voorzien waardoor de stroom beperkt wordt tot 15mA. De galvanische scheiding wordt verwezenlijkt met behulp van optocouplers. Dit is een elektronische component waarin een elektrisch signaal omgezet wordt in een lichtsignaal. Op deze manier wordt het elektrisch signaal veilig overgebracht naar het meetsysteem. Er moesten minstens 20 signalen ingelezen kunnen worden. Dit zorgt ervoor dat het systeem uitgebreid kan worden om meerdere fouten na te gaan. Omdat de Arduino Yún niet over zoveel inputs beschikt moet er een uitbreiding van de IO voorzien worden. Hiervoor werden shift-registers gekozen omdat deze gemakkelijk zijn in het gebruik en omdat er al een functie voor bestaat in Arduino. Later bleek echter dat deze functie enkel bij specifieke shift-registers werkt. De functies om het shift-register uit te lezen moesten dus zelf ontwikkeld worden. De uitwerking van het elektronische aspect wordt besproken in hoofdstuk 3 Shift-in-register shield. De Atmega-processor interfaced met de shift-registers om de potentiaalpunten uit te lezen. Deze data wordt verwerkt zodat deze kan doorgestuurd worden naar de Atherosprocessor. Om deze verbinding op te zetten moet gebruik gemaakt worden van de Bridge library. Dit is een library die speciaal werd ontworpen door Arduino voor de Arduino Yún. Eens de communicatie opgezet is kan er met een ander commando een Pythonscript gestart worden in Linux. Dit kan op twee manieren gebeuren: synchroon en asynchroon. Als het Python-script synchroon gestart wordt, zal het Arduino-programma wachten tot het Python-script volledig doorlopen is voordat er verder wordt gegaan. Als het echter asynchroon opgestart wordt zal de Arduino-sketch wel verder uitgevoerd worden, los van het Python-script. Er kan met een ander commando nagegaan worden of het script nog steeds uitgevoerd wordt. Deze asynchrone methode wordt gebruikt om de
samenwerking zo dynamisch mogelijk te maken. De sketch zal nagaan of er nieuwe data uitgelezen is en of het Python-script afgelopen is. Indien één van beide voorwaarden niet in orde is zal de sketch nieuwe data van de shift-registers uitlezen. Deze data wordt tijdelijk opgeslagen in een array. Als beide voorwaarden in orde zijn zal alle data uit de array doorgestuurd worden naar het Python-script. Op deze manier zal er geen data verloren gaan als het Python-programma iets langer duurt dan normaal. Het volledige Arduino-programma wordt besproken in onderdeel 4.2 . Het Python-script is zo opgebouwd dat hij de doorgestuurde data één voor één zal nagaan op fouten. Als er zich een fout voordoet, wordt de foutcode doorgestuurd naar de MySQL-database. Het Python-script komt uitgebreid aan bod in onderdeel 4.3.1. In deel 4.3.2 wordt besproken hoe deze MySQL-database ingesteld moet worden zodat hij de data kan opslaan. Er worden nog 2 extra tabellen aangemaakt in deze database om een tabel met gebruikers bij te houden. Deze gebruikers zijn de personen die toegang hebben tot de website. Er werd een website ontwikkeld waar een gebruiker zich op het startscherm moet aanmelden voordat de tabel met fouten weergegeven wordt. Op deze manier wordt het gebruik beperkt tot bevoegde personen. Deze website wordt volledig besproken in hoofdstuk 4.3.3. Doorheen deze thesis werden verschillende bronnen gebruikt. Deze bronnen zijn samengebundelt in de Referentielijst.
1
Keuze ontwikkelingsplatform
Eerst werd er gezocht naar een compact systeem dat gemakkelijk te configureren is om IO’s te verwerken. Er zijn verschillende programmeerbare platformen op de markt zoals Arduino en Raspberry Pi. De keuze viel snel op de Arduino Yún. Dit is een nieuwe, zeer geschikte versie van Arduino met als grote voordeel dat hij beschikt over twee processors: een Atmega-processor en een Atheros-processor. De Atmegaprocessor is een kleine microcontroller met een beperkt geheugen en een klokfrequentie Figuur 2: Afbeelding Arduino Yún van 16MHz. Deze microcontroller kan geprogrammeerd worden met de Arduino IDE. De Atheros-processor heeft veel meer geheugen, een klokfrequentie van 400MHz, beschikt over RAM-geheugen en komt voorgeprogrammeerd met een Linux-distributie. Deze Linux-distributie is OpenWRT, een kleine versie zonder grafische interface. Dit betekent dat veel programma’s die op Linux werken ook op de Arduino Yún kunnen geïnstalleerd worden. Het idee achter de twee processors is dat de Atmega-processor zich beperkt tot het uitlezen van de inputs en dat de Atheros-processor hogere taken zal uitvoeren zoals de controle van de data en het loggen van de fouten. Om de data te controleren moet er een programma geschreven worden. Er werd gekozen om Python te gebruiken. Dit is een wijd verspreide object-georiënteerde programmeertaal die gemakkelijk te leren is en kan op Linux geïnstalleerd worden. Als er fouten voorkomen moet dit programma de fouten opslaan. Hiervoor werd de MySQL-database gekozen. Dit is de meest populaire opensource database en kan eveneens op Linux geïnstalleerd worden. Als laatste moet een operator de mogelijkheid hebben om deze fouten na te kijken. Hiervoor werd een website ontwikkeld waarop de operator kan inloggen. Eenmaal ingelogd wordt een tabel met de voorgekomen fouten weergegeven.
2
Liftstudie
3
Shift-iin-register shield
Het shift-in-register register shield werd ontworpen om het aantal mogelijke ingangskanalen uit te breiden. Er werd opgelegd om minstens twintig kanalen te kunnen kunnen inlezen. Aangezien er maar dertien digitale kanalen aanwezig zijn op de Arduino Yún, Y n, was het nodig om een IO-uitbreiding uitbreiding te voorzien. Deze twintig kanalen moesten galvanisch gescheiden zijn van het lift circuit. Hiervoor worden optocouplers gebruikt. Mett dit shield is het mogelijk om 24 ingangskanalen serieel door te sturen. Het shield bestaat uit: • • • • • • •
Optocouplers zijn kleine IC's die gebruik maken van licht om een digitaal signaal van een circuit naar een ander galvanisch gescheiden circuit over te brengen. Hij bestaat uit een diode en een lichtgevoelige transistor. De diode wordt gevoed door het circuit van de lift en de transistor door de Arduino Yún. Y n. Bij het aansluiten van de primaire zijde moet er rekening gehouden worden met de inverse werking van de lift: de ground staat hier op hoog potentiaal.
Figuur 4:: Logisch diagram van een optocoupler tocoupler
Om een zo goed mogelijke optocoupler te vinden voor deze applicatie werden er drie optocouplers getest: CNX67a, LTV827 en MOC3020. Elk van deze Figuur 5:: Grafiek werking CNX67a en LTV827 optocouplers heeft specifieke eigenschappen, zo heeft bijvoorbeeld de LTV827 twee optocouplers per IC en maakt de MOC3020 gebruik van een triac in plaats van een transistor. Tijdens de test werd opgemerkt dat de spanning van de lift geen continue spanning is, maar een gelijkgerichte sinus. Dit houdt in dat de spanning steeds naar nul gaat, t, waardoor een normale optocoupler opto pler een pulserend signaal produceert. Dit signaal wordt weergegeven in Figuur 5.
Aangezien de shift registers op bepaalde momenten uitgelezen worden, kan het zijn dat er een fout signaal gemeten wordt als dit binnen de tijd valt waar het signaal nul is, wanneer er eigenlijk wel spanning op het meetpunt staat. Zoals reeds aangehaald werd, gebruikt de MOC3020 een triac aan de secundaire kant. Deze zal dus blijven geleiden tot zijn voedingsspanning wegvalt. Zijn werking is weergegeven weergegeve in Figuur 6. Het nadeel hiervan is dat de uitgang nog steeds hoog zal blijven als het ingangssignaal weggevallen is. Daarom moet deze optocoupler zeker gereset worden voordat de shiftshift registers uitgelezen worden. Omdat deze werking we beter controleerbaar is en de kans op een fout veel kleiner is, werd er gekozen om de MOC3020 te gebruiken.
Figuur 6:: Grafiek werking MOC3020
Deze optocoupler heeft 10mA nodig om te schakelen, de DC spanning is 90V, via de wet van Ohm wordt de weerstand berekend:
90 0,010
9000Ω
Het vermogen dat deze weerstand verbruikt, is: . ²
9000Ω . 0,010
²
0,9
De meest gebruikte weerstanden kunnen echter maar 1/4W aan, daarom worden er 4 identieke weerstanden in serie geplaatst. Deze weerstanden zouden zouden elk 2250Ω 2250 moeten zijn, de weerstand die deze waarde het meest benaderd in de E12 reeks is deze van 2200Ω. Ω. Om er zeker van te zijn dat deze weerstanden de stroom beperken tot 10mA en maximum 1/4W verbruiken, worden bovenstaande formules opnieuw gebruikt: gebrui 90 4 . 2200Ω . ²
0,01023
2200Ω. 0,01023
0,010
0,23
0,25
Deze weerstanden voldoen aan de voorwaarden en kunnen gebruikt worden. Om het systeem nog meer op punt te stellen is het mogelijk om de spanning in deze berekening ening te herzien. De gebruikte 90V is een DC-spanning, DC spanning, die overeenkomt met de gemiddelde waarde van het signaal. Deze waarde kan berekend worden aan de hand van de topwaarde van de gelijkgerichte sinus: .
2
. 0,6366
De DC-spanning spanning is bij een gelijkgerichte sinus gelijk aan 63,7% van de topwaarde. De ogenblikkelijke spanning kan bijgevolg 57% groter zijn dan de gemeten DC-spanning. DC Als de gelijkgerichte sinus zijn top bereikt zal er 141V aan de ingang van de optocoupler staan: 141 4 . 2200Ω
0,01606
0,016
Op deze kortstondige momenten vloeit er 16mA door de weerstand, wat ruim voldoende is om de optocoupler te ontsteken. Dat betekent dat de weerstand nog vergroot kan worden, waardoor het gemiddelde vermogen vermogen kleiner zal worden. Er wordt gebruik gemaakt van 130V als topwaarde om een marge te hebben waarin de optocoupler kan ontsteken:
90 13000Ω . ²
130 0,010
13!Ω
0,00692
13000Ω . 0,007
²
0,007 0,637
Dit betekent dat drie weerstanden van elk een kwart watt voldoende zijn om het vermogen op te vangen. De optocouplers worden aan de secundaire zijde gevoed door een uitgangspin van het Arduino-bord. bord. Dit maakt het mogelijk om de optocouplers te resetten resetten en zorgt ervoor dat er een hoog signaal aan de secundaire zijde staat. Als de optocoupler ontsteekt zal de triac in de secundaire kring schakelen en het hoog signaal doorgeven aan het shift-register. shift Om ervoor te zorgen dat het shift-register shift een laag signaal ignaal uitleest als de triac niet geschakeld is, wordt er een weerstand naar de ground voorzien:
5 0,001
5000Ω
De weerstand wordt berekend op de voedingsspanning van de Arduino Yún omdat dit de spanning is die op een digitale uitgang staat als deze hoog staat. Om zo weinig mogelijk stroom uit één pin te trekken wordt de stroom zeerr klein genomen. Een pin kan maximum 40mA leveren, maar er wordt aangeraden om niet meer dan 20mA uit één pin te trekken. Er worden telkens acht optocouplers op één pin aangesloten zodat er maximum 8mA uit één poort gebruikt wordt. Figuur 7:: Aansluiting MOC3020
3.2
Shift-in in-registers
Er werd gekozen voor shift-registers registers omdat deze goedkoop zijn en er al een functie voor voorzien is in Arduino. Later bleek echter dat deze functie gebruik maakt van een andere, duurdere component. Daarom werden er specifieke functies geprogrammeerd zodat de shift-registers registers toch gebruikt konden worden. De uitwerking van deze functies wordt uitgelegd in het programma van Arduino. Figuur 8 geeft de werking van het shift-register shift weer. De uitgangen van de optocouplers worden aangesloten n op de parallelle ingangen D0 tot D7. Deze worden op de input flip-flops flip geladen door gebruik te maken van de STCP-pin. STCP Dit is een tijdelijke opslagplaats voor ze naar het shiftshift register doorgestuurd worden. Het shift-register shift moet gereset worden met behulp beh van de MR-pin voordat deze inputs doorgegeven worden met de PL-pin. pin. Dit is nog steeds een parallelle werking, het kloksignaal op de SHCP--pin is hier in principe nog niet nodig. Verder wordt de uitgang Q van het voorgaande register aangesloten op de seriële ser ingang DS. Nu kan het serieel signaal uigelezen Figuur 8:: Functie diagram shiftshift worden op de uitgang Q door een klokpuls te register 74hc597 sturen naar de SHCP-pin. pin. De eerste acht bit zullen van het dichtste shift register komen, de volgende acht bit komen van het tweede shiftshift register en de laatstee van het derde. Shift 3 8 bit Q D0-7
Shift 2 8 bit Q D0-7
Arduino DS DS DS Shift1GND shift2shift3GND Omdat de seriële ingang van het laatste shift-register shift register met de ground verbonden wordt, zal alles wat na het derde shift-register register uitgelezen wordt nul zijn.
3.3
Shift 1 8 bit Q D0 D0-7
Printplaat
De printplaat werd ontworpen met behulp van het ontwerpprogramma Eagle. Hier kan een elektrisch schema getekend worden dat de opstelling weergeeft met alle componenten die overgezet moeten worden naar een Printed-Circuit-Board-ontwerp. ontwerp. Om ervoor te zorgen dat het PCB-bord bord uiteindelijk op de Arduino Yún n zou passen, werd een volledig ArduinoArduino bord ingeladen in Eagle als een library. Deze werd aangepast zodat enkel de contouren en de pinheaders over bleven. Nadien Nadien werden de overige componenten op de printplaat geschikt zodat de verbindingen gemakkelijk verwezenlijkt konden worden.
Figuur 9:: Bodemlaag PCB bord
Figuur 11:: Toplaag PCB bord
Figuur 10:: Elektrisch shema shift-in shift shield
4
De Arduino Yún
4.1
Inleiding
De Arduino Yún is een microcontroller gebaseerd op een ATmega32u4 en een Atheros AR9331. De Atmega32u4-processor is een processor die geprogrameerd kan worden met de Arduino IDE. De Atheros-processor is reeds voorgeprogrameerd met een Linux omgeving gebaseerd op OpenWrt genaamd OpenWrt-Yún. De Arduino Yún beschikt over een micro-USB om de Atmega-processor te programmeren. Daarnaast heeft hij ook een ethernetpoort, Wifi, een Micro SD slot en een USB aansluiting die beheerd worden door de Atheros-processor. De Atheros-processor is gemakkelijk te beheren via de webinterface.
Figuur 12: Overzicht Arduino Yún Door middel van de Bridge-library in de Arduino IDE, kan er communicatie tussen de twee processors voorzien worden. Het geeft de mogelijkheid om Python-scripts te starten vanuit een Arduino-programma (sketch). Er kan door gebruik te maken van deze library ook informatie ontvangen worden van de Atheros-processor.
De Arduino Yún beschikt over drie reset knoppen met verschillende functies: de linino reboot knop, de 32u4 reset knop en de wifi reset knop. Met de Linino reboot knop wordt de Atheros-processor gereset. Hierdoor zal het Linux systeem opnieuw opstarten, de tijdelijke data in het RAMgeheugen gaat verloren en lopende programma’s worden beëindigd. Door op de 32u4 reset knop te drukken zal de Atmegaprocessor gereset worden. Dit betekent dat het Arduino-programma gestopt wordt en Figuur 13: Knoppen op de Arduino volledig opnieuw wordt gestart. De wifi reset Yún knop heeft twee functies: de eerste functie dient om de wifi-instellingen terug naar fabrieksinstellingen te brengen, de tweede functie dient om de Atheros-processor terug naar fabrieksinstellingen te brengen. Om de wifi-instellingen te resetten dient men vijf seconden op de wifi reset knop te drukken. Hierdoor zal de blauwe led beginnen pinken, pas als de instellingen volledig teruggezet zijn, zal deze led doven. De wifi-fabrieksinstellingen zorgen ervoor dat de wifiinterface als access point ingesteld zal worden. Dit betekent dat een gebruiker rechtstreeks met deze wifi verbinding kan maken. De SSID2 van dit netwerk zal bestaan uit de naam “Arduino Yún” en het MAC3-adres van de wifi-module. Zo heeft elke Arduino Yún zijn eigen SSID. Aangezien deze wifi nu zijn eigen netwerk is moet hij zelf DHCP-server zijn, hij kent zichzelf altijd het vast IP-adres 192.168.240.1 toe. Door naar dit IP-adres of ‘arduino.local’ te surfen kan men inloggen in de webinterface. Als men de Atheros-processor volledig naar fabrieksinstellingen wil terugbrengen moet men 30 seconden op de wifi reset knop drukken. Dit zorgt ervoor dat alle handmatig geïnstalleerde programma’s en alle opgeslagen bestanden in Linux verwijderd worden.
2 3
Service Set Identifier (SSID) Media Access Control address (MAC-address)
4.2
Het Arduino-programma
De Arduino-sketch werd ontwikkeld met behulp van het Arduino IDE. Deze sketch kan in de Arduino Yún geladen worden via USB of via WiFi. Het gebruik van de WiFi verbinding heeft als voordeel dat er extra bestanden ge-upload kunnen worden. De manier waarop een sketch ingeladen kan worden, wordt uitgelegd in bijlage 8.5.
4.2.1
Bridge
Het is mogelijk om de ATmega32U4 te laten communiceren met Atheros 9331 Linux processor. Om de communicatie tussen deze twee makkelijker te laten verlopen, wordt er gebruik gemaakt van de bridge library. De bridge commando's van de ATmega32U4 worden door Python geïnterpreteerd op de AR9331 processor. Bridge zorgt ervoor dat de programma’s op Linux worden uitgevoerd wanneer dit gevraagd wordt door de ATmega32U4 (Arduino). Ook is bridge van een gedeeld datageheugen voorzien, voor het delen van data tussen de Arduino en het internet, het ontvangen van commando’s van het internet en het onmiddellijk doorsturen naar de Arduino. Bridge laat communicatie in beide richtingen toe. Het doet zich voor als een interface voor de commando’s van Linux.
4.2.2
De Arduino-sketch
4.2.2.1
Importeren van libraries en declaratie van de variabelen
#include #include Process p; const int pl_pin = 9; //parallel load in (13) const int stcp_pin = 10; //storage register clock in (12) const int shcp_pin = 11; //shift register clock in (11) const int mr_pin = 12; //master reset in (10) const int q_pin = 13; //serial data out (9) const int oc1_pin = 3; const int oc2_pin = 5; const int oc3_pin = 6; const String hyphen = "-"; const int wait = 5000; String message[50]; byte shift1 = 0; byte shift2 = 0; byte shift3 = 0; int i = 0; boolean datasend = true; De libraries Bridge en Process worden geïmporteerd zodat er een connectie van de Atmega32u4 microprocessor naar de Atheros AR9331-processor aangemaakt kan worden. Het proces wordt ook onmiddellijk ‘p’ genoemd zodat het gebruik in het programma eenvoudiger wordt. De gebruikte pinnen van de Arduino Atmega-chip worden gedefinieerd als constante aangezien deze niet zullen veranderen in het programma. Er wordt ook een constante string voorzien die gebruikt zal worden om de data van de verschillende shift-registers te scheiden. De wait variabele wordt later gebruikt bij de communicatie met de shiftregisters. Er wordt een array aangemaakt om tijdelijke data in op te slaan zodat deze gezamenlijk kunnen doorgestuurd worden naar de Atheros-processor. De verschillende bytes worden aangemaakt om de data uit de shift registers in te lezen. De integer i en de boolean datasend worden gebruikt om de programflow te bewaken.
4.2.2.2
Void setup
void setup() { // put your setup code here, to run once: //start serial communication Serial.begin(9600); //start bridge communication Bridge.begin(); //empty current table p.begin("/mnt/sda1/arduino/python/Purge.py"); p.run(); //power the optocouplers pinMode(oc1_pin, OUTPUT); pinMode(oc2_pin, OUTPUT); pinMode(oc3_pin, OUTPUT); digitalWrite(oc1_pin, HIGH); digitalWrite(oc2_pin, HIGH); digitalWrite(oc3_pin, HIGH); } De void setup in Arduino is een functie die slechts eenmaal uitgevoerd wordt bij het opstarten van de Atmega-processor. Dit onderdeel wordt gebruikt om initiële waarden in te stellen die later in het programma gebruikt zullen worden. Hier wordt de seriële communicatie via USB naar de computer en de seriële communicatie naar de Atherosprocessor opgestart. Om met de Atheros-processor te communiceren wordt de library Bridge gebruikt die reeds geïmporteerd is. Er wordt ook een Python-script opgestart dat de tabel in de database zal legen. Dit wordt enkel gebruikt tijdens het testen, later zal dit verwijderd moeten worden. Als laatste wordt de voeding naar de optocouplers voorzien. De aangesloten pinnen worden als output ingesteld en hoog gezet. De pinnen die de sturing van de shift-registers verzorgen worden in latere functies als output ingesteld. Dit moet hier dus niet meer gebeuren.
4.2.2.3
Void loop
void loop() { // put your main code here, to run repeatedly: if (p.running() or datasend) { //if python is still running or the values have been send already: //read inputs again and store them in an array //read the shift registers reset_shift(shcp_pin, mr_pin, pl_pin); load_input_reg(shcp_pin, mr_pin, pl_pin, stcp_pin); parallel_load_shift(shcp_pin, mr_pin, pl_pin, stcp_pin); shift1 = serial_shift(shcp_pin, mr_pin, pl_pin, stcp_pin, q_pin); shift2 = serial_shift(shcp_pin, mr_pin, pl_pin, stcp_pin, q_pin); shift3 = serial_shift(shcp_pin, mr_pin, pl_pin, stcp_pin, q_pin); //convert the bytes to an array-string //syntax: [Byte1]-[Byte2]-[Byte3] message[i] = String(shift1, DEC); message[i] += hyphen; message[i] += String(shift2, DEC); message[i] += hyphen; message[i] += String(shift3); Serial.println(message[i]); Serial.println(); i++; //reset optocouplers digitalWrite(oc1_pin, LOW); digitalWrite(oc2_pin, LOW); digitalWrite(oc3_pin, LOW); delayMicroseconds(500000); digitalWrite(oc1_pin, HIGH); digitalWrite(oc2_pin, HIGH); digitalWrite(oc3_pin, HIGH); datasend = false; } else { //if python is ready and new values have been stored: //send string to python script p.begin("/mnt/sda1/arduino/python/Ar_Py_Input_multi.py"); for (int q = 0; q <= i; q++) { p.addParameter(message[q]); message[q] = ""; } p.runAsynchronously(); i = 0; datasend = true; } }
In de void loop wordt het eigenlijke programma geschreven dat continu in een lus zal uitgevoerd worden. Hier worden de data uit de shift registers uitgelezen en doorgestuurd naar een Python script, die op zijn beurt de data zal loggen in de MySQL-database. Eerst kijkt het programma of de data reeds doorgestuurd isen of dat het Python script nog actief is op de Linuxprocessor. Als een van de twee voorwaarden voldaan is zal het programma opnieuw data uit de shift registers uitlezen. Om data uit te lezen moeten de registers eerst gereset worden, dan moet de data op de flipflops overgezet worden en nadien in het shift register geladen worden. Hiervoor werden drie aparte functies geschreven: Reset_shift, load_input_register en parallel_load_shift (dat later uitgebreid uitgelegd wordt). Pas nadat het shift register gereset is kan de data byte per byte uitgelezen worden met de functie serial_shift. Aangezien Arduino enkel tekst kan toevoegen als parameter van een Python-script worden deze bytes in een string samengevoegd met een koppelteken als delimiter. Nadien worden ze tijdelijk in een array opgeslagen om ze later gezamenlijk door te sturen naar het Python-script. Op deze dynamische manier wordt er voorkomen dat er data verloren gaat als het Python-script nog actief is. Als het Python-script afgerond is en er nieuwe data uitgelezen is, kan de array met nieuwe data doorgestuurd worden. Hier wordt eerst opnieuw de locatie van het Pythonscript opgegeven, nadien wordt de array volledig doorlopen en wordt de data één voor één aan het commando toegevoegd als parameter. Na elke waarde die toegevoegd is, wordt deze plaats in de array leeg gemaakt zodat er nieuwe data ingeschreven kan worden. Pas als alle data toegevoegd is, zal het script gestart worden. In tegenstelling tot het proces om de tabel leeg te maken, zal dit proces asynchroon lopen met de Arduino-processor. Dit zorgt ervoor dat de programmaflow niet onderbroken wordt zolang het Python script actief is.
4.2.2.4
Werking shift-registers shift
Figuur 14: Tijdsdiagram shift register 74HC597 In bovenstaande illustratie wordt word weergegeven hoe een shift-register register werkt. Aan de hand van deze illustratie werden de functies ontworpen om het shift-register shift register te gebruiken. Bij het begin van elke functie wordt er een initialisatiestap voorzien zodat de aansluitingen zeker op de gewenstee beginwaarde staan. Er werd gekozen om dit telkens apart te doen zodat de functies ook in andere projecten gebruikt kunnen worden. Eerst worden de pinnen op het Arduino-bord bord ingesteld als uitgang. Nadien wordt de gewenste beginwaarde ingesteld. Voor de clock c (shcp) is dit 0 (false), voor de reset (mr) en de parallel load (pl) is dit 1 (true). Dan wordt er nog een bepaalde tijd gewacht zodat de instellingen zeker uitgevoerd zijn voordat er verder gegaan wordt.
4.2.2.5
Reset shift
void reset_shift(int clock, int reset, int pl) { //init pinMode(clock, OUTPUT); pinMode(reset, OUTPUT); pinMode(pl, OUTPUT); digitalWrite(clock, 0); digitalWrite(reset, 1); digitalWrite(pl, 1); delayMicroseconds(wait); //reset digitalWrite(clock, 1); delayMicroseconds(wait); digitalWrite(reset, 0); digitalWrite(clock, 0); delayMicroseconds(wait); digitalWrite(clock, 1); delayMicroseconds(wait); digitalWrite(clock, 0); delayMicroseconds(wait); digitalWrite(reset, 1); digitalWrite(clock, 1); delayMicroseconds(wait); } Om het shift register te resetten moet gedurende één clockcycle de master reset (MR) laag staan. Als het shift-register klokpulsen krijgt, zal het serieel register ook doorschuiven zodat de parallelle inputs één voor één doorgestuurd worden. Het register zal bij het doorschuiven opgevuld worden met de data die op de seriële ingang toekomt. Op deze manier is het mogelijk om meerdere shift-registers achter elkaar te zetten. Het laatste shift-register zal zijn seriële ingang aan de ground moeten hangen om alle shift-registers op 0 te zetten. Door de reset-functie te gebruiken kan er met zekerheid gesteld worden dat alles gereset wordt. Zo wordt er voorkomen dat er foutieve waarden in de het shift-register kunnen staan.
4.2.2.6
Load input register
void load_input_reg (int clock, int reset, int pl, int stcp) { //init pinMode(clock, OUTPUT); pinMode(reset, OUTPUT); pinMode(pl, OUTPUT); pinMode(stcp, OUTPUT); digitalWrite(clock, 0); digitalWrite(reset, 1); digitalWrite(pl, 1); digitalWrite(stcp, 0); delayMicroseconds(wait); //load input register digitalWrite(stcp, 1); digitalWrite(clock, 1); delayMicroseconds(wait); digitalWrite(stcp, 0); digitalWrite(clock, 0); delayMicroseconds(wait); } Door de STCP even hoog te zetten worden de parallelle inputs overgezet naar de input flip-flops waar ze tijdelijk onthouden worden voordat ze doorgegeven worden aan het shift-register.
4.2.2.7
Parallel load shift
void parallel_load_shift (int clock, int reset, int pl, int stcp) { //init pinMode(clock, OUTPUT); pinMode(reset, OUTPUT); pinMode(pl, OUTPUT); pinMode(stcp, OUTPUT); digitalWrite(clock, 0); digitalWrite(reset, 1); digitalWrite(pl, 1); digitalWrite(stcp, 0); delayMicroseconds(wait); //parallel load shift digitalWrite(pl, 0); digitalWrite(clock, 1); delayMicroseconds(wait); digitalWrite(pl, 1); digitalWrite(clock, 0); delayMicroseconds(wait); } Als de parallel load pin laag gezet wordt zal de tijdelijke data van de flip-flops overgezet worden op het seriële shift-register.
4.2.2.8
Serial shift
byte serial_shift (int clock, int reset, int pl, int stcp, int data) { //init int temp = 0; byte data_in = 0; pinMode(clock, OUTPUT); pinMode(reset, OUTPUT); pinMode(pl, OUTPUT); pinMode(stcp, OUTPUT); pinMode(data, INPUT); digitalWrite(clock, 0); digitalWrite(reset, 1); digitalWrite(pl, 1); digitalWrite(stcp, 0); delayMicroseconds(wait); //serial shift for (int i = 7; i >= 0; --i) { temp = digitalRead(data); digitalWrite(clock, 0); delayMicroseconds(wait); data_in = data_in | (temp << i); digitalWrite(clock, 1); delayMicroseconds(wait); } return data_in; } Het seriële shift-register zal bij elke klokpuls doorgeschoven worden. Na de initialisatie staat de correcte data klaar om door de Arduino-processor ontvangen te worden. Per klokpuls wordt de seriele uitgang uitgelezen en opgeslagen in een tijdelijke variabele. Deze wordt afhankelijk van de iteratie doorgeschoven en toegevoegd aan een byte. Zo wordt er per shift-register een byte gemaakt die later door het programma doorgestuurd zal worden.
4.3
OpenWRT–Yún
De Arduino Yún draait een versie van Linux genaamd OpenWRT-Yún, gebaseerd op OpenWrt. Het systeem kan op twee manieren beheerd worden: via de webinterface of via de command line interface. De webinterface bestaat uit een basis interface en een geavanceerde interface. De basis interface kan gebruikt worden om de WiFi-verbinding te configureren, de geavanceerde interface geeft de mogelijkheid om via een grafische interface heel het systeem te beheren. Om rechtstreeks in de command line interface te werken moet er eerst een SSH-verbinding opgezet worden. Op deze Linux-distributie is het mogelijk om verschillende programma’s te installeren. Er werd gekozen om de controlelogica in Python te programmeren. Daarom moest Python eerst geïnstalleerd worden. Dit wordt uitgelegd in bijlage 8.9. De Python-programma’s moeten op een duidelijke locatie op de Arduino Yún opgeslagen worden omdat het pad naar deze programma’s gebruikt wordt in de Arduino-sketch. Er werd gekozen om deze op een micro-SD kaart op te slaan zodat het gemakkelijk is om ze op een computer aan te passen. Het pad naar het input-programma is ‘/mnt/sda1/arduino/python/input.py’, het pad naar het purge-programma is hetzelfde maar dan met purge.py achteraan.
4.3.1
Python
4.3.1.1
Input.py
#!/usr/bin/python import MySQLdb as mdb import sys host = '127.0.0.1' user = 'lift' pw = 'lift' db = 'lift' con = mdb.connect( host, user, pw, db) with con: cur = con.cursor(mdb.cursors.DictCursor) argvs = len(sys.argv) - 1 print argvs state = 0 for n in range(len(sys.argv)): if n > 0: arg = sys.argv[n] print n, arg arg.split('-') arg_int = [int(i) for i in arg.split('-')] if state == 0: #check bit 0 / port 66 if arg_int[0] & 1: state = 1 else: state = 6 if state == 1: #check bit 1 / port 41-42 if arg_int[0] & 2: state = 4 else: state = 2 if state == 2: #check bit 2 / port 045
if arg_int[0] & 4: state = 4 else: state = 3 if state == 3: #check bit 3 / port 68 if arg_int[0] & 8: state = 5 else: state = 6 if state == 4: #check bit 3 / port 68 if arg_int[0] & 8: state = 6 else: state = 5 if state == 5: #error state -- log error cur.execute("""INSERT INTO input(shift1, shift2, shift3) VALUES(%s, %s, %s)""", (arg_int[0], arg_int[1], arg_int[2])) state = 6 if state == 6: #endstate -- no error -- close connection if con: con.close() Aan het begin van het Python script worden er eerst enkele modules geïmporteerd. De MySQLdb-module zorgt ervoor dat er gecommuniceerd kan worden met de MySQLdatabase. Om in het script niet telkens deze lange naam te gebruiken wordt er een alias, namelijk mdb, gebruikt. De sys-module maakt het mogelijk om de toegevoegde parameters uit te lezen. Nu wordt eerst de communicatie met de MySQL-database opgesteld. Hiervoor wordt de connect-functie gebruikt uit de mdb-module. De nodige parameters zijn het IP-adres, de login-naam, het wachtwoord en de gebruikte database in MySQL. Deze functie heeft enkele objecten als antwoord, waarvan ‘cursor’ er één is. Een cursor definieert de manier waarop de data uit de MySQL-database verkregen wordt. DictCursor zorgt ervoor dat de rijen uit een tabel doorgestuurd zullen worden als dictionaries. Aangezien hier geen data uitgelezen zal worden is dit een vrije keuze. Er moet echter wel een cursor aangemaakt zijn om later een Query uit te kunnen voeren. Nadat de connectie geïnitialiseerd is, zal het script nagaan hoeveel parameters het Arduino-programma meegestuurd heeft. Elke parameter zal apart verwerkt worden en doorgestuurd worden naar de database. De parameters worden opgeroepen met de
functie argv uit de sys-module, wat staat voor argument values. Het is een lijst met alle argumenten van het Python-commando en bevat dus de naam van het script en alle toegevoegde parameters. Een lijst in Python lijkt zeer sterk op een array in C, zo zijn de waarden in een lijst eveneens plaatsafhankelijk. Het grote verschil is dat een lijst niet uit één specifiek datatype hoeft te bestaan. Hier kunnen dus strings, integers, reals, enz. door elkaar gebruikt worden. Aangezien het aantal parameters in de lijst niet gekend is, zal er overgeschakeld worden naar nummers die overeenkomen met de plaats in de lijst. Eerst wordt de lengte van de lijst bepaald met de functie len(). Dit geeft een integer als antwoord. Als er m parameters toegevoegd zijn, zal de lengte m+1 zijn omdat de naam van het script ook geteld wordt. Van deze integer wordt dan terug overgeschakeld naar een lijst om een for loop te kunnen gebruiken. Hier is de range(x) functie de meest geschikte functie. Deze zal een lijst aanmaken beginnend bij 0, waarbij elke volgende waarde één hoger zal zijn en het totaal aantal waarden gelijk is aan de parameter x. Range(5) heeft dus als antwoord [0, 1, 2, 3, 4]. Op deze manier zullen alle parameters in de for loop doorlopen worden door gebruik te maken van de waarde van 'n', welke de iteratie weergeeft. Sys.argv[] range(len(sys.argv))
Script.py 0
a1-b1-c1 1
a2-b2-c2 2
a3-b3-c3 3
An-bn-cn n
Aangezien de sys.argv functie als eerste de naam van het script bevat, en dit niet gebruikt wordt in het script, zal deze overgeslagen worden door enkel de waarden in de range te gebruiken die groter zijn dan 0. Na deze voorwaarde wordt de n-de parameter uit de argument values tijdelijk opgeslagen in de variabele arg. De syntax opmaak die in het Arduino-programma bepaald werd, moet nu ontward worden. Aangezien elke waarde van het shift-register gescheiden wordt van een andere waarde door een koppelteken kunnen we in Python de split-functie gebruiken. Deze functie zal de string opdelen in aparte strings en ze opslaan in een lijst. De waarden zijn echter nog steeds strings die niet kunnen gebruikt worden in mathematische bewerkingen. Daarom wordt nu elke string in de opgedeelde lijst door middel van de int()-functie omgezet naar een integer. Nu de waarden van de drie shift-registers apart in een lijst staan, kunnen deze nagekeken worden door de controlelogica. Aangezien momenteel enkel het grendelcontact gecontroleerd wordt, moeten er maar 4 bits nagekeken worden. Deze bits stemmen overeen met potentiaalpunten 41, 045, 66 en 69. De werking van de potentiaalpunten wordt weergegeven in onderstaande tabel: Potentiaalpunt Hoog Laag 41 Lift niet op verdiep Lift stilstaand op verdiep 045 Rem uitgeschakeld Rem aangeschakeld 66 Spanning op de veiligheidskring Geen spanning op veiligheidskring 69 Grendelcontact geschakeld Grendelcontact onderbroken Aan de hand van deze punten kunnen twee fouten opgesteld worden: ))))) + 69 = 1001 = 9 )))) + 045 #$%&1: 66 + 41 )))) = 0*11 = 4 $+ 7 #$%&2: 66 + 41 + 69
Fout 1
Errorcode 9
2
4 of 7
Uitleg De lift is gestopt op een verdiep maar het grendelcontact is niet onderbroken, waardoor de deur niet open kan. Het grendelcontact is onderbroken tijdens een rit, waardoor de deur open kan. (Rit wordt automatisch door de lift uitgeschakeld)
De flowchart voor de controlelogica is toegevoegd in bijlage 0. Er werd gekozen om de controlelogica op te stellen op basis van if-structuren. Op deze manier wordt een statuswaarde steeds nagekeken. Indien de statuswaarde gelijk is aan de gecontroleerde status, zal één bit uit de volledige byte gecontroleerd worden. Dit gebeurt op basis van de bitsgewijze AND-functie. Op basis van het antwoord wordt er beslist welke status de volgende zal zijn. Bij het gebruik van de if-structuur moet er extra aandacht besteed worden aan de sequentie van de statussen, deze moeten steeds in oplopende volgorde zijn. Deze controlelogica wordt per input slechts eenmalig uitgevoerd, er is dus geen mogelijkheid om terug te keren naar een status die reeds overgeslagen is. Als er een error voorkomt moet deze doorgestuurd worden naar de MySQL-database. Hier wordt teruggekeerd naar de reeds opgestelde connectie met de database. De cursor die eerder aangemaakt werd, wordt nu gebruikt om de query uit te voeren waarmee de waarden in de database geplaatst worden. De Query bestaat uit een INSERT INTOcommando met daaropvolgend de tabel met de kolommen die gebruikt worden. Daarna worden de waarden gespecificeerd met het VALUES-commando. De waarden worden echter niet rechtstreeks in de query ingevuld aangezien ze opgeslagen zijn in een variabele lijst. Er wordt gebruik gemaakt van de %s-functie, die op de plaats waar hij gebruikt wordt de overeenkomstige waarde van de toegevoegde variabele zal plaatsen. Op de plaats van de eerste %s zal de waarde van het eerste argument komen, op de plaats van de tweede %s komt de waarde van het tweede argument, enzovoort. Hier zijn de argumenten de lijst van integers. Er wordt 0, 1, 2 gebruikt om aan te duiden dat het bij het eerste argument om de eerste waarde gaat, welke overeenstemt met het eerste shiftregister. In principe kunnen deze waarden door elkaar geplaatst worden zolang de overeenkomstige kolom mee verplaatst wordt. Kolom Waarde Argument
Shift1 %s1 arg_int[0]
Shift2 %s2 arg_int[1]
Shift3 %s3 arg_int[2]
Als laatste wordt de verbinding met de MySQL-database afgesloten met het con.close()commando
4.3.1.2
Purge.py
#!/usr/bin/python import MySQLdb as mdb host = '127.0.0.1' user = 'lift' pw = 'lift' db = 'lift' con = mdb.connect(host, user, pw, db) with con: cur = con.cursor(mdb.cursors.DictCursor) cur.execute("TRUNCATE input") if con: con.close() Het Pythonprogramma ‘Purge’ zorgt ervoor dat de database leeg wordt gemaakt. Het arduinoprogramma roept dit script op tijdens zijn Setup-loop, dit zal dus enkel uitgevoerd worden tijdens het opstarten van de Arduino Yún. Het hele script is een gereduceerde versie van het Input-script, zo wordt er ook een connectie opgesteld met de MySQLdatabase, maar zal er niet gekeken worden naar de toegevoegde parameters. Het grote verschil met het Input-script is het MySQL-query. Hier wordt gebruik gemaakt van het TRUNCATE-commando, deze zal ervoor zorgen dat de opgegeven tabel volledig leeg gemaakt wordt.
4.3.2
MySQL database
MySQL is een database management systeem voor webservers. De voordelen van MySQL zijn dat het volledig open source is. Het is ook enorm snel en het werkt ook op de Arduino Yún.
4.3.2.1
Connectie maken met de database
Om verbinding te maken met MySQL start PuTTY of de terminal in Linux op en geef deze commando’s in. mysql -u root -p arduino In dit voorbeeld wordt een database aangemaakt met de naam Lift. De database lift wordt onderverdeeld onder drie tabellen. Tabel I: Database Lift input
u_new
u_current
1. input: deze tabel wordt gebruikt om alle foutcodes van de lift in op te slaan. Dus als de Arduino Yún een fout detecteert, wordt deze fout opgeslagen in deze tabel. 2. u_new: deze tabel wordt gebruikt om alle nieuwe gebruikers in op te slaan. Als er zich iemand met de website wil registeren worden alle gegevens van deze persoon in deze tabel toegevoegd. 3. u_current: In deze tabel staan alle gebruikers die toegang tot de database verkrijgen. Als er ingelogd wordt op de website wordt er gekeken of de gebruiker zich al dan niet in deze tabel bevindt. Is dit niet het geval moet deze gebruiker zich eerst registeren. Wordt dit goedgekeurd door de administrator, dan wordt deze gebruiker in u_current tabel geplaatst. Nu krijgt hij wel toegang tot de database.
4.3.2.2
De database aanmaken
Uitleg commando’s 1 2 3 4
4
MySQL commando CREATE DATABASE Lift; SHOW DATABASES; USE Lift; CREATE TABLE input ( timestamp TIMESTAMP, shift1 BINARY(255), shift2 BINARY(255), shift3 BINARY(255)) ENGINE MyISAM; DISCRIBE input;
Figuur 15: Tabel input
De database Lift wordt aangemaakt. De database wordt weergegeven weergegev in de terminal. Selecteer database Lift. Maak een tabel input aan met vier rijen. Elke rij heeft zijn eigen datatype
De eigenschappen van de tabel worden weergegeven.(Figuur weergegeven.( 16: Database Lift)
Voor de twee andere tabellen kan net hetzelfde toegepast worden (Figuur Figuur 16: Database Lift) 1
BLE u_new( CREATE TABLE n_id INT UNSIGNED NOT NULL AUTO_INCREMENT KEY, n_username varchar(50), n_email varchar(128), n_first_name varchar(100), n_last_name varchar(128), n_password varchar(128)) ENGINE MyISAM;
2
CREATE TABLE u_current ( u_id INT UNSIGNED NOT NULL AUTO_INCREMENT KEY, u_name varchar(128), u_password varchar(128)) ENGINE MyISAM;
Unsigned not null auto_increment key: dit is om ervoor te zorgen dat iedere gebruiker uniek is, ook al zijn er twee gebruikers met dezelfde naam.
3
SHOW TABLES;
De tabellen worden weergegeven.
Figuur 16: Database Lift
4.3.3
Website
De website bestaat uit drie belangrijke delen: index.php, signup.php en database.php. database.php Het index.php is een script die een webpagina is voor het controleren van de gebruikersnaam en het passwoord met de MySQL database. Het index.php index.php script neemt de inlog gegevens van de gebruiker. Gaat in MySQL op zoek naar de tabel u_current en kijkt of de inlog gegevens daar instaan. Indien de login en passwoord correct zijn, wordt er doorverwezen naar de database. Ook kan er worden doorverwezen wezen naar Signup.php. Op deze webpagina heeft de gebruiker de mogelijkheid om zich te registeren. Bij registratie worden de gegevens van de gebruiker met MySQL in de tabel u_new geplaatst. In de onderstaande Figuur 17: Opbouw website is een overzicht te zien hoe de website in elkaar zit.
Figuur 17: Opbouw website
4.3.3.1
PHP
PHP is een taal die ervoor zorgt dat de server een dynamische output weergeeft. Telkens wanneer de browser een pagina opvraagt, kan deze pagina er anders uitzien.
4.3.3.1.1
Connectie tussen PHP en MySQL
PHP wordt gebruikt als interface van MySQL. Dit is om ervoor te zorgen dat de SQL queries weergegeven worden op de webpagina. Een query is een opdracht die bedoeld is om een database een bepaalde actie te laten uitvoeren. In de website worden er queries gebruikt om gegevens in een database te plaatsen en deze er terug uit te halen en om die terug weer te geven in de webpagina. In dit PHP script is het de bedoeling om te kijken of de inlog gegevens van de gebruiker al dan niet in de database zitten. Dit PHP script zal de gebruiker al dan niet doorverwijzen naar de juiste webpagina. //login.php Om connectie tussen PHP en MySQL te maken, wordt er eerst een login.php script aangemaakt. Het voordeel van dit script is dat met de functie require_once naar dit script kan verwezen worden, zodat deze gegevens niet elke keer opnieuw moeten geschreven worden in het PHP script. In de login script wordt het localhost, wachtwoord, username en de naam van de database opgeslagen. Met mysql_connect wordt er via de login file connectie gemaakt met MySQL. mysql_select_db wordt gebruikt om de database te selecteren in MySQL. Indien dit niet lukt, zal er automatisch een fout verschijnen op de webpagina.
if (isset($_POST["login"])&& isset($_POST["password"])) { $user = get_post("login"); $password = get_post("password"); $query1 = "SELECT u_name,u_password FROM u_current WHERE u_name='$user'"; $login = mysql_query($query1); $login1 = mysql_fetch_assoc($login); $login2 = $login1['u_name']; $pass = $login1['u_password']; if ($user == $login2 && $password == $pass && $user != '' && $pass != ''){ session_start(); $_SESSION['username'] = $login2; $_SESSION['password'] = $pass; header( "Location: Database.php" ); } else{ header( "Location: Loginwrongpass.html" ); } } In dit deel van de PHP code wordt het wachtwoord en de login die ingevuld zijn van de webpagina opgehaald. Password en login worden vergeleken met de database u_current. Als beiden correct zijn, wordt er doorverwezen naar Database.php. Indien dit niet het geval is, wordt er doorverwezen naar loginwrongpassword.html. Met het POST request zal de web server alle gebruikers' inputs verzamelen en in een array $_POST plaatsen. Met get_post wordt de login naam uit het array $_POST genomen en in $user gestoken. De $user wordt met een query in MySQL in de tabel u_current opgezocht.De query wordt uitgevoerd met mysql_query(). Het passwoord en de name worden geselecteerd en opgeslagen in $login. De data die opgeslagen is in $login van de MySQL query is niet het resultaat dat verkregen wordt in PHP. $login bestaat uit een bron die kan gebruikt worden om resultaten van de query te verkrijgen. Met mysql_fetch_assoc wordt een associatieve array in $login1 gestoken. Met dit soort array kan een element uit het array gehaald worden met een naam in plaats van een nummer. Bijvoorbeeld. u_name,u_password kan de login en het passwoord uit de array gehaald worden.
4.3.3.1.2
Session
Eenmaal het paswoord en de login overeenkomen wordt er van arduino.local/sd/index.php doorverwezen naar arduino.local/sd/Database.php. arduino.local/sd/Database.php Om te voorkomen dat een gebruiker toch op de database webpagina kan zonder zich te moeten inloggen, wordt er een session bij het paswoord en login toegevoegd.
Figuur 18: URL Indien er geen session zou zijn, zou zou de browser automatisch naar de database worden doorverwezen. Dit zonder dat er moet ingelogd worden. Een webbrowser kan niet weten welke variables var ables er wel of niet ingevuld zijn in de vorige webpagina. Om ervoor te zorgen dat dit wel mogelijk is wordt er gebruik gemaakt van sessions. In dit voorbeeld worden er twee variables toegevoegd aan het session array namelijk $login en $pass. Eerst moet session_start() opgeroepen worden om toegang te krijgen tot het session array. Daarna worden de twee variables toegevoegd toegevoegd aan het session array onder de naam username en password. session_start(); require_once 'Login.php'; if (!isset($_SESSION['username'])){ header("location: Sessiondestroy.html"); } else{ destroy_session_and_data(); } De sessions in de array kunnen unnen in de pagina Database.php terug opgehaald worden. Eerst moet session_start() opgeroepen worden om toegang te krijgen tot het session array. Daarna word er gekeken of het session array een waarde heeft. Een waarde is genoeg om te weten dat de gebruikerr zich heeft ingelogd, omdat session variables op de server opgeslagen worden kunnen ze vertrouwd worden. Als er een waarde in het session array zit zal de database worden weergegeven en zal de session verwijderd worden. Als de pagina verlaten wordt zal er e opnieuw moeten worden ingelogd om de database terug te zien. Bij geen session waarde zal er worden doorverwezen naar Sessiondestroy.html.
4.3.3.2
SQL injection
Het is mogelijk om SQL query te gaan manipuleren. Stel dat je met een query gegevens van een gebruiker wil ophalen. mysql_query(“SELECT * FROM 'u_new' WHERE 'n_username' ='”.$_POST[login].”'”); Stel dat de gebruiker niet de URL laat staan maar 'OR '1'='1 invult. Dan zal de SQL query er anders gaan uitzien. mysql_query(“SELECT * FROM 'u_new' WHERE 'n_username' ='OR '1'='1”); Met deze query zullen alle gebruikers geselecteerd worden in plaats van deze ene gebruiker. Er zijn ook mogelijkheden om de volledige database te verwijderen. Om tegen te gaan dat de query gemanipuleerd kan worden zijn er twee oplossingen. • Quotes plaatsen tussen alle values die manipuleerbaar zijn. • Het escapen van quotes mysql_real_escape_string() is een functie die voor alle tekens een backslash plaatst die eventueel schadelijk kunnen zijn voor een MySQL query. Doordat er een blackslash voor ieder schadelijk teken geplaatst wordt zal het teken als een string worden beschouwd. function get_post($var) { return mysql_real_escape_string($_POST[$var]); } get_post is een aangemaakte functie. Dit is makkelijker om te programmeren. Indien dit niet wordt gedaan moet er elke keer een mysql_real_escape_string() ingevuld worden.
In het volgende PHP script wordt de database van de MySQL server opgehaald. Als de gebruiker is ingelogd zal met een query de data uit de tabel input worden opgehaald. Daarna wordt er met het commando mysql_num_rows() het aantal rijen van de tabel opgehaald en in de variable $rows geplaatst worden. De headers van de tabel die moeten worden weergegeven op de webpagina worden met behulp van HTML op de webpagina weergegeven. Dit wordt later nog besproken. Met behulp van een for lus worden de rijen onder verdeeld in twee delen dit is om database duidelijker leesbaar te maken. Hierbij wordt er gebruik gemaakt van een class even en een class odd. Om dit te verwezenlijken moet er CSS gebruikt worden dit wordt later nog besproken. Met het commando mysql-result() worden op volgorde gegevens uit de array $result genomen en met behulp van echo weergegeven op de webpagina.
4.3.3.3
HTML
HTML staat voor HyperText Markup Language. Deze taal dient om de opmaak van v een website te maken.
Figuur 19: De webpagina Tekst ekst tussen en beschrijft het HTML document. Tekst tussen
en
beschrijft de hoofding. Tekst tussen
en
beschrijft de paragrafen. Tekst tussen en voorziet informatie over het document. docume Bijvoorbeeld login Arduino Tekst tussen en beschrijft de inhoud van de webpagina. <style> body { background-image: url(images/UGent.jpg); background background background-repeat: no-repeat; background background-size: 100%; background background-attachment: fixed; background background-position: top; } <style> en ieder HTML document heeft een standaard style. Om deze style aan te passen worden deze twee tags gebruikt. Om het logo van universiteit Gent weer te geven is er gebruik gemaakt van style.(Figuur style. 19: De webpagina)
4.3.3.3.1
HTML tabel tags
Hannes
Denil
250
Jonas
Verstraete
250
Thomas
Carlier
200
Alle informatie die in de tabel moet komen, moet tussen deze twee tags
komen te staan. In CSS is het mogelijk om de grote van de tabel te bepalen. Alles tussen deze
twee tags wordt op dezelfde rij geplaatst. De tags
tags
zijn voor de opmaak van alle data in de tabel. Resultaat Tabel II: CSS
4.3.3.4
Html tml in combinatie met PHP
Forms worden gebruikt om aan de gebruiker de mogelijkheid te bieden om informatie in te voeren. Deze informatie wordt dan verzonden naar de webserver. Om een form te maken moet je over een paar elementen beschikken: 1. 2. 3. 4.
Een opening van een form Methode van de informatie overdracht bv. bv POST (zie PHP script) Een input veld (bv. het login veld zie Figuur 19: De webpagina) De plaats waar de form data moet naar gestuurd worden.
Als voorbeeld wordt Signup.php genomen. Met deze webpagina is het de bedoeling dat de gebruiker zich h kan registeren. In de webpagina worden er veel forms gebruikt. Omdat de gebruiker een groot aantal van zijn gegevens moet doorsturen naar de MySQL database.
Figuur 20:: Signup webpagina
De delen tussen de tags zorgen voor alle benamingen zoals Username, Email, First name,... (Figuur 20: Signup webpagina) 3. De delen tussen de tag zorgen voor de tekstvakken die de gebruiker kan invullen. Met input type kan er gekozen worden hoe de tekst wordt afgebeeld. Bijvoorbeeld bij het intypen van het wachtwoord zal alleen ****** te zien zijn.
4.3.3.5
CSS
CSS staat voor cascading stylesheet. Met CSS wordt alles in één opmaak stylesheet geplaatst. eplaatst. Dus welke kleur en welke rand een kader moet hebben. Je kan dit ook allemaal met HTML. Maar als er veel pagina's zijn moet dit voor iedere pagina apart ingevuld worden. Terwijl met CSS moet je enkel maar naar één pagina verwijzen. In dit voorbeeld ld wordt de database genomen. Zoals u in de figuur kan zien, worden de kleuren per rij omgewisseld. gewisseld. Dit wordt gedaan met een stylesheet genaamd forum.
Figuur 21:: Database webpagina
table { /* Size and position */ width: 340px; margin: 60px auto 30px; padding: 20px; position: relative; text-align: center; /* Styles */ background: #fffaf6; border-radius: 4px; color: #7e7975; box-shadow: 0 2px 2px rgba(0,0,0,0.2), 0 1px 5px rgba(0,0,0,0.2), 0 0 0 12px rgba(255,255,255,0.4); } In het eerste deel van het CSS programma wordt de lay-out van de tabel weergegeven. Bijvoorbeeld. de breedte, de achtergrondkleur, de positie.... .even { background-color: lightyellow; } .odd { background-color: lightblue; } Classes bieden een groot voordeel. Je kan dezelfde style gebruiken zoals bv. de table zonder dat de elementen van de tabel opnieuw ingetikt moeten worden. Met een class kan er iets specifiek aan toegevoegd worden zonder dat dit bv. bij de table aangepast wordt.In class even zal de achtergrondkleur lichtgeel zijn. Bij de class odd zal de achtergrondkleur lichtblauw zijn (Figuur 21: Database webpagina). echo '
'; Code 1: Dit is voorbeeld genomen uit database.php
4.3.3.6
Headers.
Om headers goed te begrijpen is het belangrijk te weten hoe de communicatie tussen de Arduino server en de webbrowser werkt. De headers in index.php worden gebruikt om van de ene naar de andere pagina over te gaan. Voorbeeld index.php if ($user == $login2 && $password == $pass && $user != '' && $pass != ''){ session_start(); $_SESSION['username'] = $login2; $_SESSION['password'] = $pass; echo 'you are logged in'; header( "Location: Database.php" ); } else{ header( "Location: Loginwrongpass.html" ); }
4.3.3.6.1
HTTP request.
Figuur 22: HTTP communicatie Als de URL in de webbrowser wordt ingevuld, gaat hij op zoek naar de server waar deze webpagina zich bevindt. In dit geval is de server de Arduino Yún waar de webpagina op staat. De webbrowser stelt dan de vraag aan de Arduino server 'geef me index.php'. De Arduino server stuurt dan de webpagina door naar de webbrowser. Dit wordt de HTTP request genoemd. De webbrowser stuurt meer dan alleen de plaats van de webpagina door. Het IP adres wordt ook meegestuurd. Het antwoord van de server wordt het HTTP response genoemd. De server stuurt de inhoud van de pagina en wat headers door naar de webbrowser. De headers worden altijd als eerste gestuurd en daarna wordt pas de inhoud van de pagina weergegeven. Dus als een PHP script een header aanroept moet dit gebeuren vooraleer de inhoud van de webpagina te zien is. Van zodra het HTTP response verzonden is, kunnen geen headers meer meegenomen worden. Is dit toch het geval, dan zal de Arduino server een foutmelding geven 'headers already send'.
Hoe op te lossen. Eerste fout.
if ($user == $login2 && $password == $pass && $user != '' && $pass != ''){ session_start(); $_SESSION['username'] = $login2; $_SESSION['password'] = $pass; echo 'you are logged in'; header( "Location: Database.php" ); } else{ header( "Location: Loginwrongpass.html" ); } In dit voorbeeld zit de fout in de echo die voor de header komt. De echo zorgt ervoor dat de inhoud eerst op het scherm komt en dan pas de headers. Dit probleem kan je oplossen door de echo achter de headers te plaatsen of de echo weg laten. Tweede fout. <meta charset="UTF-8" /> <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"> <meta name="viewport" content="width=device-width, initialscale=1.0">
5
Toepassing: Hydrophonic system
6
Conclusie
Om de werking van de lift beter te kunnen begrijpen is het schema volledig getekend en gesimuleerd met het programma automationstudio. Op deze manier was het makkelijker om te zien welke potentiaal er gebruikt moesten worden bij de controle van het grendelslot. Om de werking van het grendelslot te controleren zijn vier potentiaalpunten voldoende. Omdat de spanning op deze potentiaalpunten bestaan uit gelijkgerichte sinusspanningen, waarbij er nuldoorgang, is wordt de MOC3020 als optocoupler gekozen. Deze optocoupler bestaat uit een diode en een triac. Het in te lezen potentiaalpunt wordt verbonden met de diode van de optocoupler als deze aanstaat zal de triac geschakeld worden. De triac kan enkel nog gedoofd worden als deze zich onder de houdstroom bevindt. De signalen van de triacs worden parallel ingelezen door een shift register. Die de informatie serieel doorstuurt naar de Arduino Yun. Zowel het shiftregister als de triacs van de optocouplers worden aangestuurd met het programma in de Arduino Yun. De Arduino Yun bestaat uit een microcontroller gebaseerd op de ATmega32u4 en een Atheros die gebaseerd is op Linux. De Atheros chip zorgt voor Wifi, python en de webpagina. De microcontroller op de Arduino Yun dient voor het aansturen van de triacs , het shiftregister , serieel inlezen van de informatie van het shiftregister en het door geven van de informatie naar de Atheros chip. Het programma in de microcontroller maakt gebruik van de bridge en process libraries. Deze libraries worden gebruikt om connectie met de Atheros chip te maken. Verder leest het programma de shiftregisters byte per byte uit en steekt deze waarden samengevoegd met een koppelteken in een string array. Omdat het programma enkel tekst als parameter kan toevoegen aan het python script moet een string gebruikt worden. Het programma bepaald wanneer het python script moet gestart worden. Als het python script gestart is draait het asynchroon met het Arduino programma zodat de programflow niet beïnvloed wordt. In het python script wordt eerst de verbinding gemaakt met de MySQL database. De doorgestuurde parameter string van het Arduino programma wordt in het python programma binnen gehaald en in een lijst geplaatst. Deze lijst bestaat uit een string die gescheiden wordt met behulp van een koppelteken die meegestuurd is met parameter string. De gescheiden string wordt opgeslagen in een lijst en omgezet naar een integer. Alleen op integers kunnen er mathematische bewerkingen gemaakt worden bij een string is dit niet mogelijk. Wanneer de waarden van de shift registers in een lijst staan, kan er gekeken worden naar de controle logica van de lift sturing. Als er een fout in de controle logica gebeurt wordt deze fout opgeslagen in de MySQL database. De database genaamd lift wordt opgedeeld in drie tabellen u_new, u_current en input. In de tabel u_new worden alle nieuwe gebruikers opgeslagen. Als er een gebruiker zich registreert zal deze gebruiker in deze tabel terecht komen. De beheerder kan dan kiezen of hij de nieuwe gebruiker toegang verleend naar de database. In de tabel u_current worden alle gebruikers opgeslagen die toegang krijgen tot de database. In de tabel input worden alle fouten van het python script opgeslagen. Het toegang verlenen aan de database, het registeren van een nieuwe gebruiker en weergeven van de database wordt met een website weergegeven. Om de website te maken wordt er gebruikt gemaakt van drie verschillende talen PHP,HTML en CSS. PHP dient als interface van de MySQL database en zorgt ervoor dat de SQL queries weergegeven worden op de website. Ook
controleert PHP of de login gegevens van de gebruiker overeen komen met de tabel u_current en beslist of deze gebruiker al dan niet toegang krijgt tot de database. PHP zorgt ook voor het registeren van de gebruiker en zorgt ervoor dat die gegevens in de tabel u_new geplaatst worden. HTML dient enkel en alleen voor de opmaak van de website. CSS dient ook als opmaak voor de webpagina maar maakt dit een stuk gemakkelijker. Hoewel de opstelling volledig werkt zijn er nog enkele kleine punten die verbeterd kunnen worden. Bij het ontwikkelen van het shield werd een prototype gemaakt. In de testfase beek dat er zwevende spanningen waren die foute waarden veroorzaakten. Verder bleek dat het vergrendelslot niet onmiddellijk schakelt. In het Python-programma werd er echter geen tijdsvertraging voorzien. Dit betekent dat er verkeerde gegevens gelogd worden. De Atheros-processor kan het Python-script zeer snel uitvoeren. Elk pakket gegevens dat doorgestuurd wordt zal bijna altijd binnen de seconde verwerkt en eventueel gelogd worden. De timestamp wordt automatisch toegevoegd als er data naar de MySQLdatabase geschreven wordt. Dit betekent dat alle foutieve waarden uit een pakket eenzelfde timestamp krijgen, hoewel de meest recente gegevens later uitgelezen werden dan de oudste gegevens. Er wordt nu enkel naar de werking van het grendelcontact van de lift gekeken dit zijn vier potentiaal punten. Bij het ontwerpen van het Arduino-shield is het mogelijk om naar 24 verschillende potentiaal punten te kijken. Deze potentiaal punten worden per acht optcouplers doorgestuurd naar 1 shiftregister. Het Arduino programma is gemaakt om drie shift registers in te lezen kan eventueel nog uitgebreid worden. Het probleem die voorkwam met het Arduino-shield is dat de shift registers niet verbonden waren met de massa. Telkens wanneer een optcoupler van een shift-register niet geschakeld was werd er een zwevende spanning uitgelezen. Hierdoor was het onmogelijk om te detecteren of het potentiaal punt nu hoog of laag was. Omdat er niet genoeg tijd was om opnieuw een nieuwe printplaat te maken, is er een prototype-shield gemaakt. Dit shield is geschikt om 4 potentiaal punten binnen te lezen in plaats van 24 punten. Het bevat ook maar één shiftregister. Het programma in Arduino is wel ontworpen om 3 shift-registers in te lezen. De twee andere shift registers worden als 0 weergegeven. De fout in het Arduino shield schema is aangepast, de printplaat moet enkel nog gemaakt en gesoldeerd worden en de Arduino is klaar om 24 potentiaal punten binnen te lezen. Bij het controleren van de fout logica in het python script wordt er niet gekeken naar de tijd die het vergrendelings slot nodig heeft om te openen. Als de lift een oproep krijgt om naar een verdieping te gaan moet het vergrendelings slot eerst gesloten staan voor de rem van de lift open gaat. Daarna zal de lift naar een verdiep terug tot stilstand komen de rem zal terug sluiten. Daarna zal de motor van het vergrendelings slot geschakeld worden. Dit kost enige tijd, het python script houd hier geen rekening mee waardoor er al een fout zal gedetecteerd worden. Dit kan opgelost worden door in het python script een timer te plaatsen en te gaan kijken hoeveel tijd er nodig is om het vergrendelings slot te openen. In MySQL wordt bij het invoegen van data een timestamp genomen. Het nadeel van dit systeem is, dat dit eigenlijk de tijd is die gegeven wordt als het python script al doorgelopen is. De tijd wordt niet vanuit het Arduino programma meegestuurd met de string parameter naar het python programma. Hierdoor wordt de tijd niet exact weer
gegeven in de database. Om dit probleem op te lossen kan gebruik gemaakt worden van een real time clock. De tijd van de real time clock kan dan met de string parameters mee verzonden worden.
7
Referentielijst
74HC597; 74HCT597 8-bit shift register with input flip-flops Product data sheet. (2014). Geraadpleegd op 01/06/2015 via http://www.nxp.com/documents/data_sheet/74HC_HCT597.pdf Arduino Yún. (2015). Geraadpleegd op 01/06/2015 via http://www.arduino.cc/en/Main/ArduinoBoardYun?from=Products.ArduinoYUN Bridge Library for Arduino Yún. (2015). Geraadpleegd op 01/06/2015 via http://www.arduino.cc/en/Reference/YunBridgeLibrary Camilo.n1012. (2014) “Control Access of Arduino YÚN with MySQL, PHP5 and Python” [forum]. Geraadpleegd op 01/06/2015 via http://www.instructables.com/id/Control-Access-of-Arduino-Y%C3%9AN-withMySQL-PHP5-and-/?ALLSTEPS CSS Tutorial. (z.j.). Geraadpleegd op 01/06/2015 via http://www.w3schools.com/css Guide to the Arduino Yún. (2015). Geraadpleegd op 01/06/2015 via http://www.arduino.cc/en/Guide/ArduinoYun HTML(5) Tutorial. (z.j.). Geraadpleegd op 01/06/2015 via http://www.w3schools.com/html Language Reference. (2015). Geraadpleegd op 01/06/2015 via http://www.arduino.cc/en/Reference Lutz, M. (juni 2013, vijfde druk). Learning Python. Verenigde Staten van America: O’REILLY.PHP 5 Tutorial. (z.j.). Geraadpleegd op 01/06/2015 via http://www.w3schools.com/php MOC3020 TRU MOC3023 OPTOCOUPLERS/OPTOISOLATORS. (1998). Geraadpleegd op 01/06/2015 via http://www.ti.com/lit/ds/symlink/moc3020.pdf Nixon, R. (augustus 2012, tweede druk). Learning PHP, MySQL, JavaScript, & CSS. Verenigde Staten van America: O’REILLY.
Wouter, J. (2010). PHP hulp, Header already sent. (z.j.). Geraadpleegd op 01/06/2015 http://www.phphulp.nl/php/tutorial/php-algemeen/header-already-sent/738/
8
Bijlagen
8.1
Arduino programma
#include #include #include YunServer server; Process p; const int pl_pin = 12; const int stcp_pin = 11; const int shcp_pin = 10; const int mr_pin = 9; const int q_pin = 8; const int oc1_pin = 3; const int oc2_pin = 5; const int oc3_pin = 6; const String hyphen = "-"; const int wait = 5000;
//parallel load in (13) //storage register clock in (12) //shift register clock in (11) //master reset in (10) //serial data out (9)
String message[50]; word shift = 72; byte shift1 = 0; byte shift2 = 0; byte shift3 = 0; int i = 0; boolean datasend = true; void setup() { // put your setup code here, to run once: //start website server.listenOnLocalhost(); server.begin(); //start serial communication Serial.begin(9600); //start bridge communication Bridge.begin(); //empty current table p.begin("/mnt/sda1/arduino/python/Purge.py"); p.run();
//power the optocouplers pinMode(oc1_pin, OUTPUT); //pinMode(oc2_pin, OUTPUT); //pinMode(oc3_pin, OUTPUT); digitalWrite(oc1_pin, HIGH); //digitalWrite(oc2_pin, HIGH); //digitalWrite(oc3_pin, HIGH); } void loop() { // put your main code here, to run repeatedly: if (p.running() or datasend) { //if python is still running or the values have been send already: //read inputs again and store them in an array //read the shift registers reset_shift(shcp_pin, mr_pin, pl_pin); load_input_reg(shcp_pin, mr_pin, pl_pin, stcp_pin); parallel_load_shift(shcp_pin, mr_pin, pl_pin, stcp_pin); shift1 = serial_shift(shcp_pin, mr_pin, pl_pin, stcp_pin, q_pin); //shift2 = serial_shift(shcp_pin, mr_pin, pl_pin, stcp_pin, q_pin); //shift3 = serial_shift(shcp_pin, mr_pin, pl_pin, stcp_pin, q_pin); //convert the bytes to an array-string //syntax: [Byte1]-[Byte2]-[Byte3] message[i] = String(shift1, DEC); message[i] += hyphen; message[i] += String(shift2, DEC); message[i] += hyphen; message[i] += String(shift3); Serial.println(message[i]); Serial.println(); i++; //reset optocouplers digitalWrite(oc1_pin, LOW); digitalWrite(oc2_pin, LOW); digitalWrite(oc3_pin, LOW); delayMicroseconds(500000); digitalWrite(oc1_pin, HIGH); digitalWrite(oc2_pin, HIGH); digitalWrite(oc3_pin, HIGH); datasend = false; }
else { //if python is ready and new values have been stored: //send string to python script p.begin("/mnt/sda1/arduino/python/Input.py"); for (int q = 0; q <= i; q++) { p.addParameter(message[q]); message[q] = ""; } p.runAsynchronously(); i = 0; datasend = true; } } void reset_shift(int clock, int reset, int pl) { //init pinMode(clock, OUTPUT); pinMode(reset, OUTPUT); pinMode(pl, OUTPUT); digitalWrite(clock, 0); digitalWrite(reset, 1); digitalWrite(pl, 1); delayMicroseconds(wait); //reset digitalWrite(clock, 1); delayMicroseconds(wait); digitalWrite(reset, 0); digitalWrite(clock, 0); delayMicroseconds(wait); digitalWrite(clock, 1); delayMicroseconds(wait); digitalWrite(clock, 0); delayMicroseconds(wait); digitalWrite(reset, 1); digitalWrite(clock, 1); delayMicroseconds(wait); } void load_input_reg (int clock, int reset, int pl, int stcp) { //init pinMode(clock, OUTPUT); pinMode(reset, OUTPUT); pinMode(pl, OUTPUT);
#!/usr/bin/python import MySQLdb as mdb import sys host = '127.0.0.1' user = 'lift' pw = 'lift' db = 'lift' con = mdb.connect( host, user, pw, db) with con: cur = con.cursor(mdb.cursors.DictCursor) argvs = len(sys.argv) - 1 print argvs state = 0 for a in range(len(sys.argv)): if a > 0: arg = sys.argv[a] print a, arg arg.split('-') arg_int = [int(i) for i in arg.split('-')] if state == 0: #check bit 0 / port 66 if arg_int[0] & 1: state = 1 else: state = 6 if state == 1: #check bit 1 / port 41-42 if arg_int[0] & 2: state = 4 else: state = 2 if state == 2: #check bit 2 / port 045 if arg_int[0] & 4: state = 4
else: state = 3 if state == 3: #check bit 3 / port 68 if arg_int[0] & 8: state = 5 else: state = 6 if state == 4: #check bit 3 / port 68 if arg_int[0] & 8: state = 6 else: state = 5 if state == 5: #error state -- log error cur.execute("""INSERT INTO input(shift1, shift2, shift3) VALUES(%s, %s, %s)""", (arg_int[0], arg_int[1], arg_int[2])) state = 6 if state == 6: #endstate -- no error -- close connection if con: con.close()
8.2.2
Controlelogica Python
8.2.3
Purge
#!/usr/bin/python import MySQLdb as mdb host = '127.0.0.1' user = 'lift' pw = 'lift' db = 'lift' con = mdb.connect(host, user, pw, db) with con: cur = con.cursor(mdb.cursors.DictCursor) cur.execute("TRUNCATE input") if con: con.close()
Om de Arduino software te installeren is het belangrijk om eerst te weten welke versie van Ubuntu op de computer staat. In de terminal: uname –m X86 is de 32-bit Ubuntu versie. X86_64 is de 64-bit Ubuntu versie. Ga naar deze onderstaande link en download de 32 of 64 Arduino versie voor Linux. http://www.arduino.cc/en/Main/Software Als de software gedownload is, moet deze worden uitgepakt. In Ubuntu kan dit door dubbel te klikken en te extracten naar de gewenste map. Om de Arduino software te installeren moet eerst Java geïnstalleerd worden. Open de terminal. sudo add-apt-repository ppa:webupd8team/java sudo apt-get update sudo apt-get install oracle-java8-installer java –version Als Java correct geïnstalleerd is zou dit in de terminal moeten te zien zijn. Java version "1.8.0_45" Ga nu naar de map waarin de Arduino software is uitgepakt en voer het volgende in: Sudo ./arduino
Figuur 23:: Terminal arduino Na dit commando zal de Arduino software software worden geopend. Om niet telkens de terminal te gebruiken om de Arduino software te openen, wordt er gebruik gemaakt van main menu. Dit is een stukje software die in Ubuntu het opstarten van programma’s, zoals Arduino, makkelijker maakt. Deze software kan kan gedownload worden in Ubuntu software center.
Figuur 24:: Ubuntu software center Open het programma Main menu en klik op new item. Geef als naam Arduino, geef als commando de plaats waar de Arduino software zich bevindt en voeg als icon een afbeelding toe. Opgelet: de extensie van deze afbeelding afbeelding moet .JPEG zijn, anders zal het icoon niet zichtbaar zijn. Klik dan op ok.
Figuur 25:: Arduino icon Figuur 26: Main menu Zoek in de zoekfunctie van Ubuntu naar Arduino en sleep het icon naar de programmabalk. Als er op het Arduino icon wordt geklikt, zal het programma worden gestart zonder er dat er telkens de terminal gebruikt moet worden.
Figuur 27:: Ubuntu Arduino
8.4.2
PHP & netbeans
Om netbeans te installeren moet Java geïnstalleerd zijn. Is Java nog niet geinstalleerd ga naar Arduino software. Eerst moet de lamp server geïnstalleerd worden. Met het onderstaande commando c wordt MySQL, PHP5, apache2,php5-MySQL apache2,php5 geïnstalleerd. Sudo apt-get update Sudo apt-get install tasksel Sudo taskel install lampserver Na deze commando’s is onderstaande afbeelding in de terminal te zien.
Figuur 28: Lamp Volg verder de instructies op p het scherm. Na de installatie voer in de webbrowser 127.0.0.1(het lokaal IP-adres adres van de computer) in. Als de installatie correct is uitgevoerd moet de onderstaande afbeelding in de webbrowser verschijnen.
Figuur 29: Apache2
Type in de terminal: Sudo apt-get install phpmyadmin yadmin Met dit programma is het makkelijker om databases te beheren. Dit wordt weergegeven in de webbrowser. Na het invoeren van het commando volgen de stappen verder in de terminal: kies voor apache2. Let op dat de asterisk ernaast verschijnt door op de spatiebalk te duwen.
Figuur 30: PHPmyadmin Klik daarna op enter en type in de webbrowser het volgende: 127.0.0.1/phpmyadmin. 127.0.0.1/phpmyadmin Het onderstaande scherm verschijnt in de webbrowser.
Figuur 31:: PHPmyadmin interface
Ga naar onderstaande link en n download netbeans. https://netbeans.org/downloads/index.html Ga in de terminal naar de map waar netbeans is opgeslagen en voer het volgende in: Sudo chmod +x netbeans-8.0.2 8.0.2-linux.sh Sudo ./netbeans-8.0.2-linux.sh linux.sh
Figuur 32:: Terminal netbeans
De onderstaande afbeelding verschijnt in de terminal. Volg de instructies verder.
Figuur 33: Netbeans
Apache2 maakt gebruik van de map var/www/html. Enkel uit deze map zal de server de ontworpen scripts uitvoeren. Netbeans slaat automatisch de gemaakte gemaakte bestanden op in var/www/. De doorverwezen map in apach2 zal in de config file veranderd moeten worden. Type in de terminal: Cd /etc/apache2/sites-available available
Figuur 34: Default-ssl.conf Hier zijn twee config bestanden terug te vinden 000-default.conf default.conf en default-ssl.conf. default Open beide config files met nano en verander naast document root var/www/html naar var/www/. Type: Sudo nano 000-default.conf
Figuur 35:: Nano 000.default.conf
Druk op (ctrl+o) om op te slaan en daarna op enter. Open netbeans en kies voor een nieuw project. Kies als source folder voor var/www/ en druk op finisch. Daarna klik tussen en type echo ‘test’; (Figuur 55)
Figuur 36:: Netbeans echo script Klik op het groene pijltje en de webbrowser zal openen. Als alles correct geïnstalleerd is , is onderstaande afbeelding te zien de browser.(Figuur browser.( 37: Arduino Ubuntu) Ubunt
Figuur 37: Arduino Ubuntu
8.5
Inladen van de Arduino sketch De Arduino Yun kan zowel met usb als met Wifi geprogrammeerd worden. Sketches en andere scripts kunnen worden ingeladen met Wifi. Met usb is het enkel mogelijk om sketches in te laden. Natuurlijk moet de Arduino Yun eerst geconfigueerd worden. Is dit niet het geval zie (hoofdstuk 8
Wifi configuren).
Als de Arduino Yun verbonden is met Wifi kan de sketch worden ingeladen met Wifi. Een Arduino sketch heeft als extensie .ino, dat in een map moet zitten met dezelfde naam. In deze map moet er nog een map aangemaakt worden, genaamd 'www'. De inhoud van deze map zal automatisch atisch in de SD-kaart SD kaart van de Arduino Yun worden ingeladen. Dit lukt alleen maar met Wifi.
Figure 138:: Boom structuur webpagina Figuur Het is ook manueel mogelijk om de website op de SD-kaart SD kaart op te slaan. Dit heeft als nadeel dat de Arduino Yun telkens gereset moet worden, omdat de helft van de Arduino Yun software op de SD-kaart kaart staat. Als de SD-kaart SD kaart uit de Arduino Yun wordt verwijderd en terug wordt geplaatst vindt de Arduino Yun de SD-kaart SD kaart niet meer. De Arduino Yun moet gereset worden.
8.5.1
Uploaden ploaden van de sketch en www map
Open een nieuwe sketch tch en ga naar sketch → show sketchfolder. Als er nog geen ‘www’ map is, kan deze nu worden aangemaakt. Vergeet niet om de inhoud van de webpagina in deze map te plaatsen. Kies bij tools → Board → Arduino Yun en kies bij port voor de network ports, dit is het IP-adres adres van de Arduino Yun (zie afbeelding). Daarna mag het programma worden ingeladen. Bij het inladen van de sketch zal er een wachtwoord worden gevraagd, standaard is dit arduino.
Figuur 39:: Selecteren Arduino poort
8.5.2
Sketch inhoud met de webbrowser
Als de sketch is ingeladen kan de sketch map bereikt worden door dit in de URL in te tikken: http//:arduino.local/sd/webpagina Dit omdat de naam van de Arduino 'Arduino' genaamd is en omdat de sketch 'webpagina' genaamd is. Moest de naam van de Arduino 'Jonas' zijn en de sketch 'Hannes', 'Hannes' dan moet de URL in de webbrowser http//:jonas.local/sd/hannes op deze manier ingevoerd worden. Het gebeurt soms dat http//:arduino.local/sd niet werkt, als oplossing kan het IP-adres adres ingevuld worden. http//:192.168.240.1/sd. Dit IP-adres IP adres is terug te vinden vind in het configuratiemenu van de Arduino Yun. In de webbrowser moet de map worden weergegeven zijn met alle geïmporteerde bestanden van de gemaakte webpagina.
Figuur 40:: Inhoud sd op webpagina
8.5.3
Aanmaken van de Arduino URL
Om ervoor te zorgen dat de URL http//:arduino.local/sd/webpagina http//:arduino.local/sd/webpagina automatisch wordt doorverwezen naar de webpagina in plaats van de lijst die de inhoud van de map weergeeft, moet de extensie van index.php worden aangepast naar index.html.
Als index.php vervangen is door index.html mag de sketch terug in de Arduino Ard Yun worden ingeladen. Voer in de URL http//:arduino.local/sd/webpagina in en de webpagina zal in de browser weergeven worden.
Figuur 41: SD webpagina
8.6
YúnDiskSpaceExpander
Om het geheugen van de Linux processor te vergroten word een deel van zijn geheugen op een SD kaart geplaatst. In deze opstelling wordt de helft gebruikt om het geheugen te vergroten van de Linux processor. Het andere deel van het geheugen wordt gebruikt om bv. een website of foto’s op te plaatsen. Download het Arduino programma http://arduino.cc/en/uploads/Tutorial/YunDiskSpaceExpander.zip. Pak de zip file uit en open het programma in Arduino. Verbind de Arduino Yún zowel met de USB-kabel als met het internet. Klik dan de juiste COM poort aan.
Figuur 42: COM poort Klik vervolgens het juiste board aan.
Figuur 43: Board select
Daarna mag het programma worden ingeladen. Open de Serial monitor en stel de baudrate op 9600.
Figuur 44: Sketch SD kaart Volg de instructies verder op het scherm.
Figuur 45: Configureren SD kaart
Opgelet, wanneer de Arduino Yún opgestart wordt, moet de SD er altijd in zitten, omdat een deel van Linux zijn geheugen op de SD kaart staat.
8.7
Wifi fi configuren
De Arduino Yún heeft de mogelijkheid om als acces point gebruikt te worden, maar kan ook verbonden worden met een bestaand netwerk. Dit kan zowel met onbeveiligde netwerken als WEP-, WPA- en WPA2-beveiligde netwerken. Wanneer de Arduino Yún voor oor de eerste keer aangezet wordt, staat alles nog in fabrieksinstellingen. Dit betekent dat de wifi-interface wifi interface als access point ingesteld staat met SSID ‘ArduinoYun-90A2DAF01250’. 90A2DAF01250’. Maak verbinding met dit netwerk.
Figuur 46: Wifi Ga naar de browser en tik het vast IP adres in 192.168.240.1. Op de web browser zal deze webpagina verschijnen.
Figuur 47:: Arduino webpanel Tik het wachtwoord ‘arduino’ in en log in. Klik daarna op configureren. Op de volgende pagina gina kan er ingesteld worden met welk netwerk er verbinding kan gemaakt worden. Klik op configure & Restart, de Arduino Yún verbindt zich met het ingestelde netwerk.
Figuur 48: Wifi configuratie Maak met de computer verbinding met het ingestelde netwerk. Type in de webbrowser arduino.local/ o.local/ en de webpagina van Arduino zal op het scherm verschijnen. Log in en het nieuwe IP adres zal te zien zijn. Het nieuwe IP adres wordt gebruikt om verbinding te maken met OpenWrt-Yún.
Figuur 49: IP-adres adres Arduino Yún
8.8
SSH verbinding opstellen
Open de terminal: • In Windows kan dit met PuTTY. Dit is een applicatie die als terminal emulator werkt en SSH voorziet. • In Linux kan de terminal geopend worden met (CTRL+ALT+T). SSH staat voor Secure Shell, een terminal protocol voor beveiligde verbinding tussen twee computers. Windows: Open PuTTY en type het IP adres van de Arduino Yún in. Opgelet, zorg ervoor dat zowel de Arduino Yún als de computer op hetzelfde netwerk verbonden zijn.
Figuur 50: PuTTY interface
Klik op open en op yes. Login as: root [email protected] password: arduino
Figuur 51: PuTTY terminal Voor Linux open de terminal. Zorg er ook voor dat beide met hetzelfde netwerk verbonden zijn. Een andere manier om het IP adres van de Arduino Yún terug te vinden : type arp in de terminal en alle IP adressen die verbonden zijn met de router zullen in de terminal verschijnen. Type in de terminal: Ssh [email protected] De eerste keer dat er verbinding wordt gemaakt met de Arduino Yún vanuit een computer verschijnt in de terminal een bericht zoals hier weergegeven: The authenticity of host '172.16.1.190 (172.16.1.190)' can't be established. RSA key fingerprint is d2:f2:e1:23:d7:29:dc:f1:68:48:58:99:ae:c3:64:6f. Are you sure you want to continue connecting (yes/no)? Type yes en geef daarna het wachtwoord arduino in. Als alles goed verlopen is wordt dit scherm weergegeven(Figuur 52: Terminal Linux):
Figuur 52: Terminal Linux Een lijst met veel gebruikte commando’s in linux is hier terug te vinden: http://www.debianhelp.co.uk/commands.htm Om bijkomende software te installeren, te updaten en te verwijderen in OpenWrt-Yún OpenWr kan er gebruik gemaakt worden van een package manager. In plaats van het downloaden en het compileren van de broncode van het programma dat geïnstalleerd moet worden, is de bron al geconfigureerd en gecompileerd tot het gebruikte systeem. In dit geval geva is het de OpenWrt-Yún versie die de Arduino Yún gebruikt. Op OpenWrt-Yún Linux systeem is de package manager genaamd ‘opkg’. De package manager moet altijd eerst geüpdatet worden, om te kijken welke packages er beschikbaar zijn voor het gebruikte systeem. systee Door opkg update in de terminal in te tikken wordt een geüpdatete lijst met beschikbare packages weergegeven. Door het kleine flashgeheugen dat beschikbaar is op de Arduino Yún, wordt de database met de lijst van packages alleen opgeslagen in het RAM geheugen heugen van de Arduino Yún. Dit betekent dus dat het opkg update commando telkens moet worden ingegeven als de Arduino Yún herstart of als het RAM geheugen wordt gewist. Dit moet alleen gebeuren als er een nieuw programma geïnstalleerd wordt.
8.9
Installatie Arduino Linux programma’s
8.9.1
Installatie van MySQL op de Arduino Yún
Verbind de Arduino Yún met het internet en open in Linux (Ctrl+Alt+t) de terminal of met het programma PuTTY in Windows. Om de Arduino Yún via SSH te verbinden met de compter. 1) Met dit commando kan de package manager van het besturingssysteem OpenWrt software laten updaten. Hierbij is ook te zien of de Arduino Yún wel degelijk verbonden is met het internet. Als alles goed verlopen is verschijnt ‘Signature check passed’ op de terminal. 2) Dit zijn alle packages die geïnstalleerd moeten worden voor de MySQL database. 3) Dit is om in de my.cnf file te zoeken naar s^datadir.*. (De asterisk staat voor alles wat er na s^datadir komt.) Dit moet vervangen worden door datadir =/srv/mysql/ 4) Er wordt een hoofdmap aangemaakt in /srv/ met de naam MySQL. 6) Bij de Arduino Yún moeten alle programma's gestart en geactiveerd worden. 7) Met deze code wordt de gebruiker en het paswoord ingesteld om in te loggen in MySQL. (Figuur 39) 8) Inloggen in MySQL (Figuur 40) 1 2 3 4 5 6 7 8
Verbind de Arduino Yún met het internet. Communiceer via SSH met de Arduino Yún door middel van PuTTY off de terminal in Linux. Wanneer de Arduino Yún verbonden is met de computer, kan de opkg package gedownload en geïnstalleerd worden. opkg update opkg install php5 php5-cgi opkg install php5-mod-session session Wanneer PHP5 gedownload en geïnstalleerd is op de Arduino Arduino Yún , moet het root bestand uHTTPd worden geconfigureerd, omdat de standaard http server van de Arduino Yún minder uitgebreid en minder makkelijk te configureren is. Om het root bestand uHTTPd te configureren wordt er gebruik gemaakt van het programma ma nano. Dit programma is te vergelijken met een text editor. Ga eerst naar het configuratiebestand in de Arduino Yún. 1) Change directory 2) Met dit commando wordt de inhoud van de map config weergeven. 3) Het config bestand openen met nano. 1 cd /etc/config 2 ls 3 nano uhttpd
Figuur 55:: Configureren van uHTTPd
Als het con fig
bestand geopend is, druk op (Ctrl+shift+_). ( Nano zal vragen “enter line number”. Voer lijn 40 in en duw op Enter. Op lijn 40 is deze code te zien (fig. 5): # list interpreter ".php=/usr/bin/php ".php=/usr/bin/php-cgi". Het hashtag-karakter karakter moet worden verwijderd. Als het '#' karakter verwijderd is, druk dan op (Ctrl+o) ( en daarna op Enter. Het oude configuratiebestand wordt vervangen door het nieuwe.
Figuur 56:: Bewerken van het configuratiebestand
Druk op (Ctrl+x) om uit het programma nano te gaan. Om alles goed goed te laten werken moet de server herstart worden. /etc/init.d/uhttpd restart
8.9.3
Connectie tussen MySQL en PHP5
Om ervoor te zorgen dat de communicatie tussen de MySQL database en de PHP scripts foutloos verlopen, moet er nog een extra package worden geïnstalleerd. opkg update opkg install php5-mod-mysql sed -i 's,;extension=mysql.so,extension=mysql.so,g' /etc/php.ini De Arduino Yún kan nu gebruikt worden om databases te maken en deze via PHP te verbinden met bv. een website.
