1 Inleiding 12 Inleiding Woord Vooraf In het laatste jaar van mijn opleiding Master in de Electronica/ICT heb ik de mogelijkheid gekregen om een eindw...
Woord Vooraf In het laatste jaar van mijn opleiding Master in de Electronica/ICT heb ik de mogelijkheid gekregen om een eindwerk te maken over „het ontwerpen van een geautomatiseerd weerstation‟. De bedoeling is om een geheel te ontwerpen dat zelfstandig allerlei meteogegevens kan opmeten, verwerken, en weergeven op een display of verspreiden via het internet. Een heel boeiende opdracht die ik meteen met de nodige motivatie heb aangevat. Maar al snel merk je dan dat niet alles even gemakkelijk verloopt. Op zulke momenten is het geruststellend als men kan terugvallen op de raad en steun van anderen. Daarom wil ik op de eerste plaats mijn ouders bedanken, ze gaven me niet alleen de financiële, maar ook steeds morele steun gedurende mijn studies. Zonder hun was deze opleiding niet mogelijk geweest. Verder zou ik ook graag een woord van dank richten tot mijn promotoren. Enerzijds ing. Leo Rutten voor de mogelijkheid tot dit eindwerk en de deskundige begeleiding. En anderzijds dr. ir. Johan Baeten, voor het nalezen van de geschreven literatuur en het toevoegen van nuttige tips. En tenslotte wil ik ook mijn vriendin bedanken voor de steun en ontspanning tijdens het volbrengen van dit eindwerk.
2
Ontwerp van een weerstation
Inleiding
Inhoudsopgave 1.
Inleiding ............................................................................................................................. 7 1.1. Situering....................................................................................................................... 8 1.2. Globale Probleemstelling ............................................................................................ 8 1.3. Doelstellingen en methodes ......................................................................................... 9 1.3.1. Opmeting .............................................................................................................. 9 1.3.2. Verwerking ......................................................................................................... 10 1.3.3. Dataverspreiding- en opslag. .............................................................................. 10 1.3.4. Visualisatie van de meetgegevens ...................................................................... 10
Uitlezing en verwerking ................................................................................................... 27 4.1. Algemeen ................................................................................................................... 27 4.1.1. Connectiviteit ..................................................................................................... 27 4.1.2. Cross Compileren ............................................................................................... 28 4.1.3. Doorsturen naar het systeem .............................................................................. 29 4.1.4. Veranderen van rechten en uitvoeren. ................................................................ 29 4.2. De Hygrosens sensor ................................................................................................. 30 4.2.1. Connectie ............................................................................................................ 30 4.2.2. Datatype ............................................................................................................. 30 4.2.3. Structuur van een datablok ................................................................................. 30 4.2.4. Structuur van een waarde regel .......................................................................... 31 4.2.5. Verwerking van de datablokken in een C++ programma .................................. 32 4.3. De Kipp & Zonen stralingsmeter............................................................................... 37 4.3.1. Connectie ............................................................................................................ 37 4.3.2. Datatype ............................................................................................................. 37 4.3.3. Nauwkeurigheid ................................................................................................. 38 4.3.4. Verwerking van de spanning in een C++ programma ....................................... 38 4.4. De Mierij winddetecor ............................................................................................... 39 4.4.1. Interfacing van de meetmodule .......................................................................... 39 4.4.2. Verwerking van de gegevens in een C++ programma ....................................... 40 4.5. De Mierij neerslagmeter ............................................................................................ 44 4.5.1. Interfacing van de meetmodule .......................................................................... 44 4.5.2. Verwerking van de pulsen in een C++ programma ........................................... 44
5.
Dataverspreiding mbv Sockets ......................................................................................... 46 5.1. Inleiding ..................................................................................................................... 46 5.2. Socket Programming ................................................................................................. 47 5.2.1. De server ............................................................................................................ 47 5.2.2. De client ............................................................................................................. 49 5.3. Broadcasting .............................................................................................................. 50 5.3.1. De server ............................................................................................................ 51 5.3.2. De client ............................................................................................................. 52
6.
Visuele weergave van het eindresultaat ........................................................................... 53 6.1. De KHLim meteo website ......................................................................................... 53 6.1.1. De Khlim meteo website - statisch ..............Fout! Bladwijzer niet gedefinieerd. 6.1.2. Common Gateway Interface............................................................................... 53 6.1.3. De programma‟s ................................................................................................. 54 6.1.4. Het eindresultaat ................................................................................................. 58 4
Ontwerp van een weerstation
Inleiding
6.2. Een GUI mbv het Taskit display ............................................................................... 59 6.2.1. Het X Window System. ...................................................................................... 60 6.2.2. Nano-X ............................................................................................................... 60 6.2.3. Bijzonderheden................................................................................................... 64 7.
Algemene toepassing van SBC‟s voor automatisatie ....................................................... 70 8.1. Verwerkingseenheid op maat ?.................................................................................. 70 8.2. Toepasssingen ..................................................... Fout! Bladwijzer niet gedefinieerd.
10. Bibliografie....................................................................................................................... 74 11. Bijlages ............................................................................................................................. 76 A. Verwerking van de Hygrosens-sensor ....................................................................... 76 B. Broadcast server van het Taskit paneel ..................................................................... 76 C. Socket server van het Taskit paneel .......................................................................... 76 D. GUI van het Taskit paneel ......................................................................................... 76 E. Verwerking van de Windsensor en de pluviometer................................................... 76 F. Verwerking van de ADC ............................................................................................... 76 G. Cdata.cgi .................................................................................................................... 76 H. Rdata.cgi .................................................................................................................... 76 I. Pdata.cgi ........................................................................................................................ 76
5
Ontwerp van een weerstation
Inleiding
Lijst van Figuren Figuur 1: Een schotelhut .......................................................................................................... 12 Figuur 2: De Hygrosens module .............................................................................................. 13 Figuur 3: Aansluitschema van de Hygrosens sensor ................................................................ 14 Figuur 4: De anemometer ......................................................................................................... 15 Figuur 5: De windvaan ............................................................................................................. 15 Figuur 6: Stralingsverloop op dagbasis .................................................................................... 18 Figuur 7: De stralingsmeter ...................................................................................................... 19 Figuur 8: De pluviometer ......................................................................................................... 21 Figuur 9: Stappenoverzicht van de pluviometer ...................................................................... 21 Figuur 10: De Picotux .............................................................................................................. 24 Figuur 11: TS-7260 .................................................................................................................. 25 Figuur 12: Taskit Panel-Card starter kit ................................................................................... 26 Figuur 13: Standaard datablok ................................................................................................. 30 Figuur 15: Interne opbouw van de INA114 instrumentatieversterker ..................................... 37 Figuur 14: Aansluiting van de stralingsmeter .......................................................................... 37 Figuur 16: Schakelschema van de windsensor ......................................................................... 40 Figuur 17: Aansluitschema van de Neerslagmeter ............Fout! Bladwijzer niet gedefinieerd. Figuur 18: Socket Communicatie ............................................................................................. 46 Figuur 19: KHLim meteo website ............................................................................................ 58 Figuur 20: Online Sensoren...................................................................................................... 59 Figuur 21: Geschiedenis ........................................................................................................... 59 Figuur 22: Huidige meetgegevens............................................................................................ 59 Figuur 23: X Window System .................................................................................................. 60 Figuur 24: De GUI van het Taskit paneel ................................................................................ 64
6
Ontwerp van een weerstation
Inleiding
Abstract Om een goed beeld te krijgen van het weersverloop op de campus, stelde de KHLim de vraag naar een geautomatiseerd weerstation. Het weerstation moet beschikken over de nodige sensoren, verwerkingseenheden en bovendien dient het de verzamelde gegevens grafisch weer te geven op twee wijzen: enerzijds via een GUI op een zogenaamde weerserver en anderzijds via een website. Tenslotte dient dit eindwerk ook te bepalen of de gebruikte verwerkingseenheden, namelijk Single Board Computers, al dan niet algemeen toegepast kunnen worden bij de automatisatie van systemen. De verwerking van de meetgegevens zal gebeuren door zelf ontworpen programma‟s, uitgevoerd op Single Board Computers met Linux als open source-besturingssysteem. Twee extra applicaties, een broadcast „server‟ en een socket server zorgen voor een correcte communicatie tussen de verwerkingseenheden en een centrale unit, de weerserver. Hier worden alle meetgegevens ook opgeslagen. De actuele meetgegevens worden grafisch weergegeven op de weerserver via een gebruikersinterface op het aangesloten LCD display. Tenslotte huisvest de weerserver een website waar zowel de actuele als verlopen meetgegevens vermeld staan. Ook staan de sensoren die op dat moment actief zijn, vermeld. Nagenoeg alle programmatie op de SBC‟s is gebeurd in C++. Uit de testopstellingen blijkt dat de verwerking van de meetgegevens van de meerderheid van de sensoren vlekkeloos verloopt. Ook kunnen de client-SBC‟s, waaraan de sensoren gekoppeld zijn, de verwerkte data vlot verzenden naar de weerserver. Op de grafische gebruikersinterface worden de gegevens van de actieve sensoren ongeveer eenmaal per minuut geactualiseerd. Het is mogelijk om elke sensor afzonderlijk te selecteren om zo later eventueel extra informatie weer te geven over elke sensor. Dankzij het dynamisch ontwerp is het mogelijk om met een minimum aan programmeren extra sensoren toe te voegen aan het geheel. Aan de hand van dit ontwerp, en gekeken naar de overige mogelijkheden van de Single Board Computers, kunnen we besluiten dat SBC‟s erg geschikt zijn voor de automatisatie van een brede waaier aan systemen.
7
Ontwerp van een weerstation
Inleiding
1. Inleiding 1.1. Situering In het kader van mijn eindwerk voor industrieel ingenieur elektronica heb ik de mogelijkheid gekregen om voor de KHLim een geautomatiseerd weerstation te ontwerpen. Geautomatiseerd, omdat we in een maatschappij leven waarin efficiëntie, nauwkeurigheid, en snelheid continu aan belang winnen. Automatisatie maakt ons werk bovendien veel gemakkelijker. Want wie wil er elke ochtend de inhoud van het regenbakje van een regenmeter nauwkeurig opmeten? Of het aantal uren zonneschijn berekenen aan de hand van een zwartgebrand lijntje op een stuk papier? Om nog maar te zwijgen over hoeveel metingen nodig zijn om een duidelijk overzicht te krijgen van de temperatuursschommelingen. En dit zowel overdag als ‟s nachts. Maar een geautomatiseerd meetstation is niet de volledige oplossing. Men zou nog steeds ter plaatse moeten komen om de actuele gegevens te bekijken, of eventueel opgeslagen gegevens te raadplegen. Het zou nòg interessanter zijn, indien iedereen, waar dan ook, via het internet zou kunnen zien welk weer het op de KHLim is. Wie kent er namelijk niet het zalige gevoel om op vakantie te zijn in een stralend zonnig land, en te weten dat het thuis weer eens regent. Verder is dit eindwerk ook een maat voor de mogelijkheid tot automatisatie van een brede waaier van systemen aan de hand van Single Board Computers. En voor mij is het tenslotte ook een leerrijke ervaring op verschillende gebieden.
1.2. Globale Probleemstelling Om een weerstation te realiseren is er logischerwijze nood aan sensoren. Deze moeten voldoende nauwkeurig zijn, en een analoog of digitaal signaal uitsturen dat later verwerkt kan worden. Ook moeten ze binnen het budget vallen, waardoor de uiteindelijke keuze bepaald wordt door een goed evenwicht tussen prijs en nauwkeurigheid. Verder is ook een programma nodig dat alle meetmodules uitleest en de gegevens ervan verwerkt tot betekenisvolle waardes. De vorm waarin de data van de meetmodules ter beschikking gesteld wordt is nagenoeg elke keer verschillend. Daarom moeten ze eerst correct omgezet worden. De uitgestuurde signalen kunnen bijvoorbeeld analoge signalen zijn, of digitale signalen van TTL-niveau. Zelfs digitale signalen die ingebed zitten in een gestandaardiseerde datastroom kunnen voorkomen. Om de juiste handelingen uit te voeren bij de respectievelijke signalen is het grondig doornemen van de datasheets van de sensoren noodzakelijk.
8
Ontwerp van een weerstation
Inleiding
De uiteindelijke locatie van de sensoren is verschillend per op te meten grootheid. Hierdoor hebben we ook verschillende systemen nodig om de data te verwerken. Telkens opnieuw een pc gebruiken is zinloos omdat de hoeveelheid te verwerken data relatief klein is. Een sterk afgeslankte versie van een pc kan dit dus ook probleemloos aan. Meer zelfs, dergelijke mini pc‟s hebben een minimaal energieverbruik, en nemen een minimum aan plaats in beslag. De programma‟s die de data verwerken dienen zo overzichtelijk mogelijk geschreven te zijn, zodat eventueel latere wijzigingen zo eenvoudig mogelijk kunnen lopen. Het ontwerp van een website en een grafische gebruikersinterface zijn nodig voor de gevraagde visualisatie van de opgemeten data. Daarna rest er enkel nog het zoeken naar de meest geschikte locaties voor de sensoren, en het plaatsen ervan.
1.3. Doelstellingen en methodes 1.3.1. Opmeting Voor het opmeten van de gegevens beschikken we over twee verschillende soorten meetmodules. Enerzijds hebben we de meetmodules die in staat zijn de gegevens op te meten en reeds te verwerken tot een beter bruikbaar formaat zoals bijvoorbeeld de in dit eindwerk gebruikte temperatuur/vochtigheidsmodule van de firma Hygrosens. Deze module is in staat om de analoge output van de temperatuursonde en vochtigheidssonde in de module reeds om te zetten naar een digitale waarde. Deze digitale waarde wordt dan verspreid via een seriële aansluiting die RS232-compatibel is. Daarna is enkel een filtering van de gegevensstroom van de module nodig. Anderzijds kunnen we onverwerkte analoge signalen binnenkrijgen, en dienen we deze te verwerken tot een specifieke waarde. Onder deze categorie valt bijvoorbeeld de stralingsmeter, gebruikt in dit eindwerk. Deze meter zal afhankelijk van de opgemeten hoeveelheid straling, een zeer kleine spanning uitsturen. Om een voldoende sterk signaal te verkrijgen is versterking van dit signaal noodzakelijk. Voor de digitalisatie van dit signaal, en dus de verdere verwerking, blijkt een Analoog-naar-Digitaal-convertor nodig. Vanaf het moment dat de data digitaal beschikbaar zijn, kunnen we deze verwerken.
9
Ontwerp van een weerstation
Inleiding
1.3.2. Verwerking Om de gegevens te verwerken moet er een programma geschreven te worden. Dit zal steeds gebeuren in de programmeertaal C of C++. Voor elk van de gebruikte verwerkingssystemen bestaat een bijbehorende toolchain. Dit is een verzameling van applicaties waaronder de compiler en de linker. Deze zetten de geschreven broncode om naar een programma dat uitgevoerd kan worden op een bepaalde pc of single board computer. De installatie van deze toolchain gebeurt op een pc met Linux als besturingssysteem. De distributie is Slackware, versie 12.0 . De verwerking zal in stappen gebeuren, met het commando 'printf' als hulplijn. Dit geeft de programmeur de mogelijkheid om op elk moment de huidige stand van zaken van het programma tekstueel weer te geven in de console. Wanneer het programma zou stilvallen midden in de verwerking, is het aan de hand van 'printf' mogelijk om op te sporen op welk moment de verwerking is opgehouden. Wanneer een stukje code werkt, kan er een ander stukje toegevoegd worden, om zo op te bouwen naar een volledig functioneel programma. 1.3.3. Dataverspreiding- en opslag. Wanneer de verwerking vlot verloopt, kan er een extra stukje software toegevoegd worden aan het geheel om de verwerkte gegevens via een socket verbinding te versturen naar een centrale unit. Deze centrale unit, de weerserver, zal de opslag en visualisatie van de data verzorgen. Aangezien het streefdoel een universele toepassing is, wordt voor de verschillende SBC‟s gebruik gemaakt van dynamische IP adressen. Wat meteen ook tot gevolg heeft dat de data niet steeds naar hetzelfde IP adres moet gestuurd worden. Om de weerserver steeds terug te vinden op het netwerk, draait deze een extra applicatie, een zogenaamde broadcast server, welke continu zijn IP adres verstuurd via het netwerk. Zo zullen de meetgegevens nog steeds correct verzonden en opgeslagen worden na bijvoorbeeld een stroomuitval. Bij de ontvangst van nieuwe meetgegevens, zal de weerserver meteen in een logboek de huidige datum en tijd wegschrijven, samen met de ontvangen meetwaarde. 1.3.4. Visualisatie van de meetgegevens De weerserver doet meer dan enkel zorgen voor een correcte ontvangst en opslag van de meetgegevens. De meetgegevens worden ook grafisch weergegeven op het LCD display dat onderdeel is van de weerserver. Dit gebeurt met hulp van het nano-X window system. En tenslotte is er op de weerserver ook een http deamon actief, welke een website online houdt met zowel de huidige, als verlopen meetgegevens.
10
Ontwerp van een weerstation
Sensoren
2. Sensoren Dit deel gaat wat dieper in op de verschillende grootheden die dit weerstation dient op te meten.
2.1. Temperatuur en relatieve vochtigheid 2.1.1. Algemeen De relatieve luchtvochtigheid, uitgedrukt in %, is de verhouding tussen de daadwerkelijke hoeveelheid vocht in de lucht en de maximale hoeveelheid vocht die de lucht bij een bepaalde temperatuur kan bevatten. Omdat de temperatuur dus nodig is om de relatieve vochtigheid te berekenen, zijn sensoren voor de berekening van de relatieve vochtigheid vaak uitgerust met een temperatuursensor. Een relatieve luchtvochtigheid van 0% betekent dat de lucht geen vocht bevat. Terwijl een relatieve luchtvochtigheid van 100% dan betekent dat de lucht verzadigd is en niet meer water kan bevatten zonder dat condensatie optreedt. Dit laatste is belangrijk, aangezien we hieruit kunnen afleiden of er al dan niet mistvorming kan ontstaan. Andere mogelijke uitingen van condensatie zijn bijvoorbeeld dauw of rijp. Een waarde die afgeleid kan worden uit de temperatuur en de relatieve vochtigheid is het dauwpunt. Dit is de temperatuur tot waarop de lucht moet afgekoeld worden om verzadigd te raken (bij gelijke hoeveelheid waterdamp en druk). De berekening van het dauwpunt zal gebeuren aan de hand van onderstaande formule [1]: met met
waarbij: en
De nauwkeurigheid van bovenstaande formule is ±0,4 °C en ze is geldig voor:
11
Ontwerp van een weerstation
Sensoren
2.1.2. Plaatsing Meting van de luchttemperatuur
Om de luchttemperatuur op te meten, dient de sensor zich op 150 cm boven het aardoppervlak te bevinden. Vanzelfsprekend hoort de plaatsing ook te gebeuren buiten de nabijheid van mogelijke verstorende warmtebronnen, en op een open terrein omdat de wind best zo goed mogelijk aan de sensor kan. Voor de bepaling van de maximum en minimum temperatuur gebruiken we de desbetreffende temperatuur binnen een vast interval, namelijk 12 uur (van 6 uur tot 18 uur) . Om de sensor te beschermen tegen storende invloeden zoals bijvoorbeeld neerslag of directe zonne-inval, plaatsen we de sensor in een zogenaamde schotelhut zoals in Figuur 1 [2]. Figuur 1: Een schotelhut Meting van de relatieve vochtigheid
Algemeen wordt voor de opmeting van de relatieve vochtigheid hetzelfde principe gehanteerd als voor de meting van de luchttemperatuur, namelijk 150 cm boven het aardoppervlak, en beschermd tegen storende invloeden door een schotelhut. Ook hier is het belangrijk dat de wind zeker goed aan de sensor kan.
12
Ontwerp van een weerstation
Sensoren
2.1.3. De Hygrosens module Als sensor voor dit onderdeel heb ik gekozen voor de „Humidity-Temperature Sensor module with serial interface‟ van de Duitse firma Hygrosens (zie Figuur 2). De reden voor deze keuze is gebaseerd op volgende eigenschappen: Ten eerste is er, zoals de naam van de sensor al doet vermoeden, een seriële interface beschikbaar om de meetwaarden uit te lezen. Deze is compatibel met de RS-232 – standaard. Aangezien een van onze single board computers, namelijk de Picotux, opgebouwd is rond onder andere een seriële interface welke eveneens RS-232 – compatibel is, leek Figuur 2: De Hygrosens module het me verstandig om minstens een sensor te zoeken die een seriële interface had. Verder is ook het formaat van de data overdracht zeer nauwkeurig beschreven in de datasheet van de module. Wat natuurlijk noodzakelijk is, we willen de datastroom namelijk in een C++-programma verwerken. Voor het berekenen van de relatieve vochtigheid is zoals reeds aangehaald, nood aan de temperatuur op dat ogenblik. Doordat de Hygrosens module in staat is om beide grootheden door te sturen naar de gebruiker, geeft dit ons nog een voordeel; nu moet er geen extra temperatuursensor gezocht en geïnterfaced worden. En tenslotte zijn de verkregen nauwkeurigheden (zie volgend puntje) voldoende voor onze toepassing.
0 .. 100 % rH 0.01 % ±3 % rH (bij 23°C) -40 .. 80 °C 0.01 °C ±0.5 °C (tussen 0 en 40°C) 6 – 8 V DC 20 mA gemiddeld RS 232 compatibe 2400 Baud, 8N1
2.1.5. Beperkingen Een nadeel van deze module zit in de connectie tussen de module en de pc. Hier is namelijk een spanningsbron nodig, zoals zichtbaar in Figuur 3 [4]. Standaard is er een aansluiting voorzien voor een 9V batterij, die in ons geval enkel gebruikt zal worden tijdens testen. Bij de uiteindelijke plaatsing van het geheel kan men best kiezen voor een aansluiting op de netspanning via een transformator. Zo hoeven we geen metingen te verliezen wanneer de batterij uitgeput is.
Figuur 3: Aansluitschema van de Hygrosens sensor
2.1.6. Bijkomende informatie Item: Prijs:
Serial humidity module test kit € 105,91
14
Ontwerp van een weerstation
2.2.
Sensoren
Windsnelheid en windrichting
2.2.1. Algemeen De snelheid van de wind wordt gemeten met een anemometer of windmeter. Dit instrument werd in 1846 geïntroduceerd door de Ierse astronoom Thomas Romney Robinson (1792-1882) [4]. De windrichting boven land wordt bepaald met een windvaan. Meestal wordt dit gedaan over over periodes van 10 minuten. Wanneer er bijvoorbeeld in een weerbericht gesproken wordt over wordt over windkracht 8, dan ligt de gemiddelde windsnelheid van de afgelopen 10 minuten binnen minuten binnen de 17,2 en 20,7 meter per seconde. De omrekening van windsnelheid in meter per seconde, of kilometer per uur, naar Beaufort en terug, Beaufort en terug, is mogelijk met behulp van
op de volgende pagina. 2.2.2. Plaatsing Op voorschrift van de Wereld Meteorologische Organisatie [5], of kortweg het WMO, worden windmeters op weerstations geplaatst in een open terrein op een mast van 10 m hoogte. Om storende invloeden van gebouwen of bomen te beperken worden de meters soms hoger geplaatst. Met formules wordt de meting omgerekend naar 10 meter hoogte, zodat de gegevens vergelijkbaar zijn. 2.2.3. De Mierij module Deze module bestaat uit zowel een anemometer (Mierij, type 555, zie Figuur 4) als een windvaan (Mierij, type 444, zie Figuur 5), samen gemonteerd op één voet.
Figuur 5: De windvaan Figuur 4: De anemometer
15
Ontwerp van een weerstation
Sensoren
Tabel 1: Omzetting van de windsnelheid naar Beaufort [19]
0 .. 30 m/s 0.07 m/s < 0.9 m/s Optisch; 12 pulsen per rotatie 0 .. 360 ° 22.5 ° (16 stappen) ±11.75 ° Optisch; 4bit Gray code output 12 V DC 30 mA gemiddeld 1 signaal met pulsen van de anemometer 4 signalen met Gray code van de windvaan
2.2.5. Beperkingen Helaas is het door de ligging van onze school niet mogelijk om deze sensor in een vlakte te zetten, op een hoogte van 10 meter, waardoor meetfouten zullen optreden. Verder is de anemometer „slechts‟ in staat windsnelheden te meten tot 30 meter per seconde. Hierdoor zal het verschil tussen een orkaan en een zeer zware storm niet gemaakt kunnen worden. Maar aangezien deze onder normale omstandigheden toch nooit voorkomen in onze gebieden, is dit niet zozeer een probleem. En tenslotte dienen we ook nog op te merken dat de windrichting tot 16 mogelijke posities herleid wordt. Doch omdat dit reeds mogelijkheid geeft tot richtingsbepalingen van het type „NNO‟ is dit voldoende voor onze toepassing. 2.2.6. Bijkomende informatie Item: Prijs:
Wind vane, Economy class € 212,00
Item: Prijs:
Anemometer, Economy class € 171,00
17
Ontwerp van een weerstation
Sensoren
2.3. Zonnestraling 2.3.1. Algemeen Wanneer we even teruggaan in de tijd, en kijken naar hoe het aantal uren zonneschijn vroeger gemeten werd, komen we al snel terecht bij de methode van Campbell-Stokes. Deze methode was gebaseerd op een glazen bol, die de invallende zonnestralen concentreerde op een stukje wit papier aan de achterzijde van de bol. Als de zonnestraling hoger was dan een bepaalde waarde, brandde er een zwart streepje op het papier. Op het einde van de dag kon men dan de totale „brandafstand‟ opmeten en samentellen om zo het aantal uren zonneschijn van die dag te bekomen. Groot nadeel was dat de opmeting manueel diende te gebeuren, en elke dag een ander strookje nodig was. Omdat het doel van dit eindwerk een automatisch weerstation is, zullen we een andere methode moeten zoeken om het aantal uren zonneschijn te berekenen. Een optie is het gebruik van een pyranometer. Dit is een toestel dat de inkomende (globale) zonnestraling meet. De waarde wordt uitgedrukt in Watt per vierkante meter. Met globale straling bedoelen we de som van de directe straling en de indirecte, oftewel diffuse straling. 2.3.2. Directe straling De directe straling is het deel van de globale straling dat rechtstreeks van de zon afkomstig is. Dit deel van de straling kan gebruikt worden om het aantal uren zonneschijn te berekenen. Want in overeenstemming met de WMO-definitie is er sprake van zonneschijn indien de flux van de directe straling meer dan 120 W/m² bedraagt. Onderstaande afbeelding brengt extra duidelijkheid. De rode lijn is de gemeten directe straling; de blauwe lijn is de minimum directe straling nodig om te kunnen spreken van zonneschijn. De groene band toont het moment dat er zonneschijn was. Op een wolkloze zonnige dag kunnen we zoals zichtbaar in Figuur 6 een heuvelachtig verloop zien in de opgemeten hoeveelheid straling.
Figuur 6: Stralingsverloop op dagbasis [6]
18
Ontwerp van een weerstation
Sensoren
2.3.3. Indirecte straling De indirecte straling is het deel van de globale straling dat niet rechtstreeks van de zon afkomstig is. Hiermee bedoelen we dan de zonnestralen die via weerkaatsing invallen op de pyranometer. 2.3.4. Plaatsing Sensoren voor de meting van de globale straling dienen gemonteerd te worden op een verticaal statief, op een hoogte van 150 cm boven het aardoppervlak. In de omgeving mogen geen obstakels aanwezig zijn die 5 graden of meer uitsteken boven de horizon, bekeken vanuit de positie van de sensor. Verder mogen in de directe omgeving van de meetlocatie, oftewel binnen een straal van 200 meter van de sensor, geen obstakels staan die door uitstraling de metingen kunnen beïnvloeden. Tenslotte dient de sensor waterpas te staan, en blijft de glazen bol van de sensor (de dome) ook best vrij van stof, rijpaanslag, of andere onregelmatigheden. 2.3.5. Meetmodule De pyranometer voor het meten van de directe zonnestraling in dit eindwerk is het model CMP11 van de firma „Kipp en Zonen‟. De reden voor het gebruik van dit specifiek apparaat is dat het reeds aanwezig en beschikbaar was op school. De specificaties voldoen aan de gestelde eisen voor ons weerstation. 2.3.6. Technische Data Reactietijd: 5 seconden Niet-lineariteit: ±0.2% tussen (0 en 1000 W/m²) Onstabiliteit: ±0.5% verrandering per jaar Temperatuursafhankelijkheid:±1% (tussen -10 en +40°C ) Gevoeligheid: 7 tot 14 µV/W/m² Spectraal bereik: 310 .. 2800 nm Werkingstemperatuur: -40 .. 80°C Typische output: 0 .. 15 mV Dagelijkse nauwkeurigheid: ±2% 2.3.7. Bijkomende informatie Item: Prijs:
CMP11 stralingsmeter € 79.99
19
Figuur 7: De stralingsmeter
Ontwerp van een weerstation
Sensoren
2.4. Hoeveelheid neerslag 2.4.1. Algemeen De hoeveelheid neerslag kan worden opgemeten met behulp van een regenmeter, ook wel pluviometer of udometer genoemd. De standaard pluviometer bestaat uit een trechtervorm met een gekend oppervlak, en iets om de opgevangen neerslag in te verzamelen. Dit kan bijvoorbeeld een meetcilinder zijn. Door het meten van de opgevangen hoeveelheid neerslag, en deze waarde te delen door de oppervlakte van de trechter, kan men de neerslaghoeveelheid per vierkante meter in millimeter bekomen. Er bestaan meerdere soorten regenmeters, maar aangezien we een zo goed mogelijk autonoom systeem willen maken, dienen we ons in de keuze van regenmeters te beperken tot de automatische regenmeters. Dit kan bijvoorbeeld een regenmeter van het type 'tipping bucket' zijn, waarover in volgend puntje meer. Zodra we de hoeveelheid neerslag kennen, kunnen we afhankelijk van de bekeken periode ook iets zeggen over de intensiteit van de neerslag. Deze intensiteit kan onderverdeeld worden in verschillende gradaties: Vooreerst bestaat er de zachte, aanhoudende regen die 1 tot 2 mm water per uur geeft (frontale neerslag). Een dag in de kempen met lichte motregen geeft 2 tot 4 mm in 24 uur. Een sterke neerslagvlaag geeft 1 tot 2 mm per minuut en een zéér hevige neerslagvlaag 3 tot 4 mm per minuut. De maximale intensiteit ligt nooit boven 5 mm per minuut gedurende enkele minuten. Een zwaar onweer geeft 30 tot 80 mm neerslag, terwijl de hoeveelheid soms boven 100 mm in 2 of 3 uur ligt voor zeer hevig onweer. 2.4.2. Plaatsing De opstelling van de neerslagmeter moet zodanig zijn dat de neerslag vanuit alle richtingen onbeperkt in de opvangopening kan vallen. Harde ondergronden zijn ongewenst, aangezien opspattend water dan eventueel ook terug in de regenmeter kan vallen. De bovenrand van de neerslagmeter moet horizontaal zijn en de standaardhoogte van de rand is 40cm boven het aardoppervlak. De afstand van de meetlocatie neerslag tot nabije obstakels (bomen, muren, huizen, e.d.) dient tenminste twee maal, liefst zelfs vier maal de obstakelhoogte boven het vlak van de bovenzijde van de neerslagmeter te zijn. Voorbeeld: de obstakelhoogte van een 3 meter hoge haag is 3,0 – 0,4 = 2,6 m. De afstand van de meetlocatie tot deze haag dient tenminste (2 x 2,6 =) 5,2 m, doch bij voorkeur (4 x 2,6 =) 10,4 m te zijn.
20
Ontwerp van een weerstation
Sensoren
2.4.3. De Mierij neerslagsensor De aangeschafte sensor is de Mierij Rain Gauge model 200. Deze werkt volgens het principe van een 'tipping bucket' waarbij de regen via een trechter steeds in een klein opvangemmertje terecht komt. (Stap 1) Wanneer dit vol raakt, zal het omkantelen, waardoor het emmertje terug leeg gemaakt wordt, en een nieuw emmertje aan de andere kant het opvangen van neerslag overneemt. (Stap 2) Om zo wanneer deze vol is (Stap 3), terug te kantelen (Stap 4), zodat we terug in de beginsituatie komen. (Stap 5 oftewel terug Stap 1)
Figuur 8: De pluviometer
Figuur 9: Stappenoverzicht van de pluviometer
Hieronder volgen als verduidelijking de verschillende stappen nog eens getekend. Telkens als het geheel kantelt, zal er door een rietschakelaar een contact gesloten worden. Dit geeft een puls op de uitgang. Deze pulsen kunnen opgemeten en gesommeerd worden, zodat we weten hoeveel keer die specifieke hoeveelheid neerslag gevallen is. Bij het ontwerpen van software om de pulsen van de pluviometer te verwerken, zullen we rekening moeten houden met het denderend karakter van rietschakelaars.
21
Ontwerp van een weerstation
Sensoren
2.4.4. Technische Data Performantie: Resolutie: 0.2mm neerslag per kanteling Nauwkeurigheid: ± 4% Meetprincipe: Tipping Bucket Fysisch Oppervlakte opening: 210 cm² Hoogte: 24 cm Diameter: 20.5 cm Gewicht: 1 kg Werkingstemperatuur:0..+60° Connectie: RJ-9 waarvan 2 aansluitingen gebruikt. Output: Rietschakelaar
2.4.5. Beperkingen Natuurlijk heeft een dergelijke regenmeter ook zijn beperkingen. Dit is bijvoorbeeld een fout die optreedt bij sneeuwval en negatieve temperaturen. Deze zorgen er namelijk voor dat de kleine opening in de trechter geblokkeerd wordt, waardoor de trechter vol sneeuwt zonder enige detectie van neerslag. Wanneer de temperatuur terug boven het vriespunt stijgt, zal dan de sneeuw smelten en een neerslagwaarde geven, hoewel het op dat moment reeds terug droog kan zijn. We zullen dus voorzichtig moeten omspringen bij negatieve temperaturen. Er zal ook een goede locatie gekozen moeten worden om de regenmeter te plaatsen, aangezien bijvoorbeeld bladeren of andere vaste materialen voor verstopping kunnen zorgen, zodat de regenmeter zijn effect verliest. 2.4.6. Bijkomende informatie Item: Prijs:
Rain Gauge € 247,00
22
Single Board Computers (SBC’s)
Ontwerp van een weerstation
3. Single Board Computers (SBC’s) De verwerking van de data van de sensoren gebeurd niet vanzelf. Daarvoor moeten we gebruik maken van een of meerdere verwerkingseenheden. In ons geval is er gekozen voor enkele Single Board Computers met eigen besturingssysteem; namelijk Linux. In dit hoofdstuk gaan we even dieper in op de gebruikte SBC‟s. Maar eerst even een korte inleiding over embedded Linux.
3.1. Embedded Linux De term Embedded Linux staat voor Linux gebaseerde besturingssystemen die gebruikt worden in embedded toepassingen zoals bijvoorbeeld mobiele telefoons, media players, handsets, en andere consumenten elektronica. Maar Linux is ook zeer goed in staat om andere embedded applicaties uit te voeren, zoals in ons geval het uitlezen, verwerken, en verzenden van meetgegevens. Het verschil met de gewone „desktop‟ en „server‟ versies van Linux zit in de compactheid van het embedded systeem, of de „footprint‟. Want aangezien er slechts een bescheiden hoeveelheid resources voorzien zijn, zoals onder andere een kleinere hoeveelheid RAM geheugen en een beperkte schijfruimte, dient er geen volwaardige kernel geïnstalleerd te worden. Overigens zijn embedded systemen doorgaans minder krachtig en is het verbruik lager dan dat van volwaardige systemen. Het is een alternatief op de -vroeger veel gebruikte- assembly of C software voor embedded ontwikkelingen. De voordelen van onze systemen ten opzichte van laatstgenoemde zijn onder andere: Eenvoudigere toegang tot randapparatuur Grote help bij debugging dankzij printf(); Mogelijkheid om simultaan verschillende applicaties naast elkaar uit te voeren
De Picotux, gemaakt door het Duitse Kleinhenz, wordt gepromoot als zijnde de kleinste Linux computer ter wereld [7]. Met zijn afmetingen van 35mm×19mm×19mm is het toestel net groter dan de NetSilicon DigiConnect ME, waarop het toestel gebaseerd is. (zie op Figuur 10 het gedeelte waar Figuur 10: De Picotux de sticker met het MAC adres op plakt) Er is een Linux gebaseerd besturingssysteem, met 8 MB flash geheugen aanwezig. Bij het aansluiten van de 3.3V DC voeding start het toestel op, bestuurd door een ARM7 microprocessor van 55 Mhz. Gebruik
Op dit zeer compact bordje is zowel communicatie mogelijk via ethernet, als via de seriële aansluiting. In puntje 2.1.4 is terug te vinden dat de temperatuur/vochtigheidssensor van Hygrosens zijn informatie ter beschikking stelt via een seriële aansluiting. Het ligt dus voor de hand dat we dit bordje gaan gebruiken om de meetgegevens van de Hygrosens sensor te verwerken. Bijkomende informatie
Item: Prijs:
Kleinhenz Picotux € 99,00
24
Single Board Computers (SBC’s)
Ontwerp van een weerstation
3.2.2. Technologic Systems TS-7260 Algemene Beschrijving
De tweede gebruikte SBC is een TS-7260 zoals te zien is in Figuur 11. Deze compacte Single Board Computer is gebaseerd op de Cirrus EP9302 ARM9 CPU [8], wat al dadelijk doet vermoeden dat het om een krachtiger toestel gaat dan de Picotux. Dit is ook zo, de ARM9 processor heeft een processorsnelheid van 200 Mhz. De Figuur 11: TS-7260 belangrijke manier van connectiviteit die wij zullen gebruiken zijn de TS-XDIO aansluitingen. Deze extended input/output aansluitingen zijn reeds geïmplementeerd, en er zijn een heleboel handige functies beschikbaar die controleren of het signaal hoog of laag is, of er een stijgende flank gedetecteerd werd, een dalende flank, of helemaal geen signaalverandering,… Zelfs pulsbreedtemodulatie is beschikbaar. En tenslotte zijn er ook meerdere ingebouwde 12-bit ADC‟s beschikbaar, waarvan twee aan te sluiten zijn via de XDIO-aansluitingen. Gebruik
Omwille van de handige XDIO aansluitingen heb ik besloten om als eerste sensor voor dit bordje, de windsensor te implementeren. Hierdoor zullen reeds 5 pinnen gebruikt worden. Vier pinnen voor de vier bits die de windrichting voorstellen, en een pin, voor de pulsen om de windsnelheid te bepalen. In de algemene beschrijving is vermeld dat er een 12 bit ADC aanwezig is. Dit komt zeer goed van pas om de analoge data van de Pyranometer om te zetten naar een stralingswaarde. En ten slotte kunnen we ook de regensensor aan dit bordje koppelen, omdat er nog genoeg XDIO-pinnen vrij zijn. De zeer uitgebreide mogelijkheden van het bordje, laten toe om eventueel later nog extra sensoren toe te voegen. Bijkomende informatie
Tenslotte is er nog de Taskit Panel-Card. Deze is besteld in een Starter kit, wat betekend dat er extra IO direct beschikbaar is en het geheel overzichtelijk gemonteerd is op een relatief groot PCB (70 x 95,5 mm, zie Figuur 12). De rechtstreeks beschikbare aansluitingen Figuur 12: Taskit Panel-Card starter kit zijn onder andere: USB 2.0 een numeriek klavier een unidirectionele muis (draaiknop) 3.5 inch kleurendisplay (320 x 240 pixels @ 24 bit) een directe 100Mbit ethernet aansluiting aansluiting voor een SC / MMC kaart. Het geheel wordt bestuurd door een ARM9 processor van 200 Mhz. Gebruik
In tegenstelling tot de vorige SBC‟s werd deze starter kit niet aangeschaft om meetgegevens van weersensoren te verwerken. Het is namelijk zo dat de meetgegevens pas nuttig worden als het mogelijk is om ze visueel voor te stellen, hetzij in getallen, hetzij in een grafiekje, of op nog een andere manier. De aanwezigheid van een relatief groot LCD kleuren display komt goed van pas om alle opgemeten waarden in verband met het weer visueel in beeld te brengen. De aanwezigheid van de unidirectionele muis zorgt voor een mogelijkheid om te kunnen scrollen in menu‟s, en het numeriek klavier is nuttig om bijvoorbeeld de gegevens van een bepaalde datum op te vragen. Indien het nodig is, kan dit numeriek klavier later zelfs uitgebreid worden tot een alfanumeriek klavier, zoals de toetsen van een gsm dat kunnen. Bijkomende informatie
Item: Prijs:
Taskit Panel-Card starter kit € 549,00
26
Ontwerp van een weerstation
Uitlezing en verwerking
4. Uitlezing en verwerking 4.1. Algemeen 4.1.1. Connectiviteit Omdat we werken met embedded systemen, zit de mogelijkheid om een muis, toetsenbord en beeldscherm aan te sluiten op het toestel er helaas niet in. Een mogelijkheid om in te loggen op een single board computer is via ethernet. Hiervoor dienen we het desbetreffende toestel bijvoorbeeld met een straight kabel te verbinden met een switch uit het netwerk. Eventueel kan er ook een cross-verbinding gelegd worden rechtstreeks met een pc. Nadat de fysische verbinding gelegd is, moeten we contact opnemen met het bordje. Hiervoor moeten we het IP adres kennen van de SBC. Een eenvoudige mogelijkheid om dit te doen is het uitvoeren van het „nmap‟ commando in bash. Het enige dat we hiervoor dienen te kennen is het IP adres van een andere pc uit het netwerk, en het netwerkmasker van deze laatste. Dit kan met behulp van ifconfig: root@mshome:~# ifconfig | grep inet inet addr:192.168.1.4 Bcast:192.168.1.255 Mask:255.255.255.0 inet addr:127.0.0.1 Mask:255.0.0.0
Dankzij het masker „255.255.255.0‟ wordt het aantal mogelijke adressen van de picotux beperkt tot 253. Aangezien nmap op alle poorten scant, kan dit nog steeds een hele tijd duren. We kunnen de scanduur merkbaar verkleinen door als extra argument bij nmap „–p23‟ te gebruiken. Hiermee scannen we alle ip adressen af of er reactie is op poort 23, de standaard telnet poort. Want we weten dat de SBC‟s allen de telnet service gebruiken om te kunnen inloggen. root@mshome:~# nmap -p23 192.168.1.* Starting nmap 3.93 ( http://www.insecure.org/nmap/ ) at 2007-09-21 17:21 CEST Interesting ports on RTA300U.lan (192.168.1.1): PORT STATE SERVICE 23/tcp open telnet MAC Address: 00:90:96:6E:C5:95 (Askey Computer) Interesting ports on 192.168.1.2: PORT STATE SERVICE 23/tcp open telnet MAC Address: 00:14:66:00:00:EA (Kleinhenz Elektronik GmbH) Nmap finished: 256 IP addresses (2 hosts up) scanned in 8.032 seconds
27
Ontwerp van een weerstation
Uitlezing en verwerking
We zien nu duidelijk op adres 192.168.1.2 dat er een toestel van Kleinhenz Elektronic GmbH gevonden werd. Dit is in dit geval de Picotux. Als extra controle kan gekeken worden of het MAC adres klopt. Op dezelfde manier kunnen we ook de andere SBC‟s uit dit eindwerk terugvinden op het lokale netwerk. Inloggen op het toestel kan nu eenvoudigweg gebeuren met behulp van telnet. root@pcg10201:~# telnet 10.1.202.31 Trying 10.1.202.31... Connected to 10.1.202.31. Escape character is '^]'. picotux login: root BusyBox v1.00 (2005.06.24-09:49+0000) Built-in shell (msh) Enter 'help' for a list of built-in commands. #
4.1.2. Cross Compileren In embedded systemen zit doorgaans geen gcc of g++ toolchain ingebouwd om geschreven programma‟s te compileren. Dit zou teveel plaats in beslag nemen en is, eens de applicatie naar behoren werkt, helemaal niet meer nodig. Deze ruimte kan bespaard worden door het geschreven programma te compileren op een pc met genoeg ruimte en mogelijkheden. Achteraf kunnen we het bekomen bestand verzenden naar de single board computer die het moet uitvoeren. Aangezien we nu niet voor het platform waar we op werken compileren, maar een ander, noemen we dit kruislings compileren oftewel cross-compiling. Afhankelijk van het bordje waarvoor gecompileerd dient te worden, moeten we een ander commando gebruiken om een uitvoerbaar bestand te maken. In onderstaande tabel is een overzicht gemaakt van de compileer-commando‟s voor de verschillende SBC‟s.
Tabel 2: Commando's voor compilatie van C en C++ applicaties op de gebrukte SBC’s
28
Ontwerp van een weerstation
Uitlezing en verwerking
4.1.3. Doorsturen naar het systeem Na het cross compileren moet de bekomen applicatie nog verzonden worden naar het systeem dat het zal uitvoeren. Een veelgebruikte mogelijkheid hiervoor is TFTP, oftewel Trivial File Transfer Protocol. Dit is een vrij protocol voor bestandsoverdracht met de basisfuncties van FTP. Doordat het enkel de basisfuncties bevat, is het ook eenvoudig te implementeren met een zeer kleine hoeveelheid geheugen, wat zeer belangrijk is bij embedded systemen. Aan pc zijde starten we eveneens een (t)ftpserver. Deze bindt zich aan het huidige IP adres op de ftp-poort (23). Hiermee kunnen we dan via de SBC contact opnemen en pakketjes aanvragen met het bijbehorende commando, bijvoorbeeld: tftp –g 192.168.1.1 –r vb –l ./vb
-g staat voor GET en wordt gevolgd door het IP adres vanwaar we het bestand willen ophalen; -r voor REMOTE (vb is de naam van het op te halen bestand bij de remote host); en –l staat voor LOCAL (./vb betekent dat we het bestand op de huidige plaats in de directory willen zetten met als naam vb.) 4.1.4. Veranderen van rechten en uitvoeren. Vooraleer het programma uitvoerbaar is moeten we de rechten veranderen naar „uitvoerbaar‟. Dit gebeurd met het volgende commando. chmod a+x vb
Chmod staat voor „Change file modes‟. De a betekent dat de operatie geldig is voor iedereen (all) en de +x wilt zeggen dat we de parameter „x‟ (executable) voor iedereen willen toevoegen („+‟). Met andere woorden, iedereen mag nu de applicatie „vb‟ uitvoeren.
29
Ontwerp van een weerstation
Uitlezing en verwerking
4.2. De Hygrosens sensor 4.2.1. Connectie De Hygrosens sensor heeft een seriële aansluiting nodig. En omdat Picotux nagenoeg opgebouwd is rond een seriële aansluiting, zal dit toestel gebruikt worden om de Hygrosens sensor uit te lezen. Aangezien zowel de sensor als de SBC RS232compatibel zijn, hoeven we geen extra hardware bij te plaatsen en is de fysische connectie eenvoudig te maken. 4.2.2. Datatype In de datasheet van de Hygrosens module kunnen we terugvinden dat de datacommunicatie verloopt met een snelheid van 4800 Baud, en dat er steeds 8 databits verzonden worden, geen pariteitsbit, en wel een stopbit. Dit is nodig voor het initialiseren van de UART poort op de Picotux. 4.2.3. Structuur van een datablok Verder vinden we een standaard datablok die uitgestuurd kan worden door de sensor:
Figuur 13: Standaard datablok
Hier zien we duidelijk dat elke regel afgesloten wordt met een Carriage Return. Een datablok wordt gestart met een „@‟-teken, en afgesloten met een „$‟-teken. De vier tussenliggende regels zijn opgebouwd uit twee Identification regels en twee Value regels. De identificatieregels bevatten telkens informatie over welke grootheid het gaat, en wat het specifieke serienummer is van de sensor die deze grootheid opmeet. De hieropvolgende regel bevat nog eens een bevestiging dat het over eerder vermelde grootheid gaat, en geeft dan ook aan wat de waarde is van deze grootheid in HEX. Tot slot van zowel de identificatieregels als de waarderegels is er een CRC controle van 2 ASCII karakters.
30
Ontwerp van een weerstation
Uitlezing en verwerking
4.2.4. Structuur van een waarde regel De waarde regel bevat de huidige waarde van de corresponderende grootheid, gemeten door de corresponderende sensor op zijn specifiek kanaal. Het nummer van de sensor en zijn kanaal zijn in ons geval niet van belang, daar we maar één sensor in gebruik hebben. Als start van de regel wordt het karakter „V‟ (Value) verstuurd. Vervolgens komen terug twee ASCII karakters met het logische kanaal van de huidige sensor. Hier staat „01‟ weer voor temperatuur en „02‟ voor relatieve vochtigheid. Hierna komen de vier ASCII karakters met de opgemeten waarde. Deze waarde is feitelijk hexadecimaal, en dient omgezet te worden naar een decimale waarde voor de duidelijkheid. De resolutie voor de temperatuur bedraagt 0.01°C, maar aangezien de waarde niet met komma doorgestuurd wordt, dienen we de omgezette decimale waarde nog door 100 te delen om de correcte waarde te bekomen. Voor de vochtigheid is de resolutie 0.005%, wat dus betekent dat we na omzetting van hexadecimaal naar decimaal nog eens door 200 moeten delen om de correcte waarde te bekomen. Dan volgen nog twee ASCII karakters met een CRC waarde als controle op geldigheid van de regel. En als afsluiting krijgen we terug een oftwel Carriage Return. Als voorbeeld kunnen we even terugblikken op de standaard datablok.
Figuur 13: Standaard datablok
De waarde van de temperatuur bedraagd 0892 in HEX. Omgezet naar decimaal wordt dit 2194. Delen door 100 levert een temperatuur van 21.94°C. Voor de relatieve vochtigheid wordt 16B0 omgezet tot 29.04%
31
Ontwerp van een weerstation
Uitlezing en verwerking
4.2.5. Verwerking van de datablokken in een C++ programma Communicatie met de seriele poort
Aangezien de meetmodule verbonden is via een seriële connectie waar het RS232 communicatieprotocol standaard is, kunnen we best als eerste deze verbinding initialiseren. We werken met Linux, dus de aansluitingen kunnen we terugvinden in "/dev/" Alle mogelijke verbindingen zijn: # ls /dev console kmem mtd port pty tts zero cua mem mtdblock ptmx random tty full misc null pts root urandom In ons geval zit de nodige poort op tts, "/dev/tts/0" om precies te zijn. Unix programma's, die aan IO doen, doen dit steeds door te lezen van en te schrijven naar de corresponderende file descriptor. Deze laatste is niets meer dan een integer, een geheel getal, dat geassocieerd wordt met een open bestand. Dit kan in ons geval een seriële poort zijn, maar het kan evengoed een ethernet aansluiting, een echt bestand op de harde schijf, een FIFO, ... zijn. Het aanmaken van een file descriptor gebeurd met het commando "open()" Wanneer we nu de seriële poort van de Picotux willen openen, kan dit via volgende code: #define SERIALDEVICE "/dev/tts/0" int openfd() { struct termios options; int fd; // File descriptor voor de COM poort fd = open(SERIALDEVICE, O_RDWR | O_NOCTTY | O_NONBLOCK); if (fd == -1) { perror("open_port: openen van SERIALDEVICE mislukt! \n Foutmelding: "); } else { char *ttynaam = ttyname(fd); fcntl(fd, F_SETFL, 0); printf("serial device %d geopend! \n", ttynaam); }
// output instellen naar RAW options.c_oflag = 0; options.c_lflag = ICANON; //options.c_cflag &= ~(ICANON | ECHO | ECHOE | ISIG); // software flow control inschakelen options.c_iflag |= (IXON | IXOFF | IXANY); // input parity controleren + map CR naar NL options.c_iflag |= (INPCK | ISTRIP | ICRNL); // nieuwe opties voor de poort instellen + lijn proper maken tcflush(fd, TCIFLUSH); tcsetattr(fd, TCSANOW, &options); return fd; }
Alle gebruikte instellingen uitleggen zou ons hier te ver leiden. Mocht hier extra uitleg gewenst zijn, verwijs ik naar de “Serial Programming Guide for POSIX Operating Systems” van Michael R. Sweet [9]. Ophalen en effectieve verwerking van de data int leesin(int fd, int sensor) { printf("Poging tot inlezen\n"); int res = 0; char buf[50]; // We vragen alles op uit de seriele poort wat beschikbaar is // onvoldoende karakters ontvangen => blijven we inlezen res = read(fd,buf,50); // zoeken van de data in de buffer buf[res]= '\n'; // string afsluiten printf("Huidige ingave: %s \n", buf);
Extra gebruikte functie int hexToDec(char bin[]) { int value = 0; int sum = 0; int i = 0; for( i = 0; i < 4 ; i++) { switch(bin[i]) { case '0': value = 0; break; case '1': value = 1; break; case '2': value = 2; break; case '3': value = 3; break; case '4': value = 4; break; case '5': value = 5; break; case '6': value = 6; break; case '7': value = 7; break; case '8': value = 8; break; case '9': value = 9; break; case 'A': value = 10; break; case 'B': value = 11; break; case 'C': value = 12; break; case 'D': value = 13; break; case 'E': value = 14; break; case 'F': value = 15; break; default: printf("Input Error not 0-9 or A-F\n"); } switch(i) { case case case case } }
0: 1: 2: 3:
sum sum sum sum
= += += +=
value * 4096; break; value * 256; break; value * 16; break; value; break;
return sum; }
35
Ontwerp van een weerstation
Uitlezing en verwerking
Main programma int main() { int fd; while(1) { // openen van de file descriptor fd = openfd(); // Opvragen van de temperatuur while(leesin(fd, 1) == 0) {} // Opvragen van de vochtigheid while(leesin(fd, 2) == 0) {} // Terug sluiten van de file descriptor close(fd); // Eventjes pauzeren om de processor niet // onnodig te belasten sleep(10); } return 0; }
36
Ontwerp van een weerstation
Uitlezing en verwerking
4.3. De Kipp & Zonen stralingsmeter 4.3.1. Connectie De aansluiting van de stralingsmeter is vierdraads zoals aangegeven in Figuur 14. De rode aansluiting met het nummer 1 is de positieve uitgang van de gegenereerde spanning, en de blauwe draad met het nummer 2 is de negatieve uitgang. Het schild van de stralingsmeter is Figuur 14: Aansluiting van de de grond. Verder zijn er nog twee aansluitingen die niet stralingsmeter gebruikt worden. Deze dienen voor een mogelijke koppeling met een andere stralingsmeter die ondersteboven tegen de onderzijde van deze stralingsmeter gemonteerd kan worden, zodat we in alle richtingen de straling kunnen opvangen. 4.3.2. Datatype De stralingsmeter levert een lage spanning die in grootte evenredig is met de opgemeten straling. Deze spanning is erg laag, namelijk van de ordegrootte van enkele millivolt. Aangezien de analoog digitaal convertor van de gebruikte single board computer een bereik heeft van 0 tot 3.3 Volt, gaan we de uitgangsspanning van de stralingsmeter eerst versterken. Hiervoor gebruiken we een speciaal ic. De reden hiervoor is enerzijds de eenvoud, met een enkele weerstand is het mogelijk om vrij precies de uitgangsspanning te bepalen. En anderzijds is het ic dat ik gekozen heb reeds intern beveiligd tegen te hoge spanningen. De schematische opbouw van het ic, de INA114 van de firma Burr-Brown, is weergegeven in Figuur 15.
Figuur 15: Interne opbouw van de INA114 instrumentatieversterker
37
Ontwerp van een weerstation
Uitlezing en verwerking
4.3.3. Nauwkeurigheid Aangezien bij zeer zonnig weer de waardes kunnen oplopen tot 2000 W/m², tellen we uit hoeveel bits minimaal noodzakelijk zijn. 2*10(11) geeft 2048 mogelijkheden. Dus met de beschikbare 12 bits A/D convertor die de TS7260 aan boord heeft, kunnen we meer dan voldoende nauwkeurig uitlezen. Het is zelfs zo dat de uitlezing nauwkeuriger kan gebeuren dan het opmeten van de hoeveelheid straling zelf. 4.3.4. Verwerking van de spanning in een C++ programma Wegens tijdsgebrek heb ik de uitwerking van dit programma en de nodige testen niet kunnen voltooien. In bijlage E is het onafgewerkte programma terug te vinden. Momenteel is het enkel mogelijk de spanning van de ADC op te vragen, en er rekenkundige bewerkingen mee uit te voeren.
38
Ontwerp van een weerstation
Uitlezing en verwerking
4.4. De Mierij winddetecor 4.4.1. Interfacing van de meetmodule De uitgang van de meetmodule is een DB9 contact, dus met negen aansluitingen. Vier hiervan zijn voorzien voor de vier bits Gray code van de windvaan en eentje is de uitgang van de anemometer. Twee zijn er gebruikt voor enerzijds de voeding en anderszijds de massa, en de twee laatste contacten van de 9-polige stekker zijn niet gebruikt. Voor de interfacing van de meetmodule is er reeds een schakeling beschikbaar die het geheel omzet naar een TTL niveau. De oorspronkelijke bedoeling van deze bestaande schakeling was het uitlezen van de gegevens, en het versturen van de data via One Wire. Aangezien dit laatste uit testen van vorige jaren niet snel genoeg bleek voor het correct opnemen van alle pulsen gegenereerd door de anemometer, zullen we geen gebruik maken van One Wire. De rest van de schakeling lijkt echter wel nuttig, aangezien ze de uitgangsspanning van de windmeter omzet naar een digitaal signaal met TTL niveau. Er rest nog een laatste probleem voordat we de schakeling aan een Single Board Computer kunnen hangen voor dataverwerking; namelijk het feit dat de te gebruiken SBC, meerbepaald de TS-7260, slechts een maximum ingangsspanning van 3.3 volt aanvaardt. Hogere spanningen kunnen het systeem beschadigen. De omzetting van TTL naar 3.3V wordt gedaan met een 74LVX04 IC. Dit is in feite een gewone invertor, met als extra eigenschap dat de ingangsspanning 5V mag zijn, en de uitgang gestuurd wordt met de voedingsspanning, 3.3V. We gaan dus in feite over naar Low Voltage TTL. Nu kunnen we de signalen zonder problemen verbinden met de I/O pinnen van de SBC. De extra schakeling is zichtbaar in Figuur 16. Merk op dat we voor het tekenen van deze schakeling de 74LS04N gebruikt hebben in plaats van de 74LVX04. Echter qua pinout en schakelschema zijn ze overeenkomstig.
39
Ontwerp van een weerstation
Uitlezing en verwerking
Figuur 16: Schakelschema van de windsensor
4.4.2. Verwerking van de gegevens in een C++ programma Als verwerkingseenheid maken we gebruik van de TS-7260. De basis voor de verwerking was een sample code met als doel het verduidelijken van het gebruik van de XDIO poort. Er diende nog een uitbreiding bij te komen voor de extra databits, en een verwerking van de signalen tot nuttige en begrijpbare informatie. Initialisatie struct xdio xdio1,*xd1=0; if (open_xdio(&xdio1,0)) {xd1 = &xdio1;} assert(xd1); setPinDirection(xd1,0,INPUT); setPinDirection(xd1,1,INPUT); setPinDirection(xd1,2,INPUT); setPinDirection(xd1,3,INPUT); setPinDirection(xd1,4,INPUT); // Initialiseren van de nodige variabelen. int WD[4]; // initiatie van de bits voor de windrichting WindDirection int WS = 0;
// initiatie van de bit voor de windsnelheid WindSpeed en de vorige int WS_Old = 0; // waarde ervan, zodat we aan flankdetectie doen.
int array_Front = 0; int array_Current = 0; time_t Tarray[65000]; int checked = 0; int diff = 0; typedef unsigned char byte; byte b; // voor conversie van binair naar int. int geconverteerd[4]; // voor de windsnelheid in time_t start,end; // definïering van het start en het einde van de meting. time (&start); // het huidige moment als starttijd instellen. int dif = 0; // looptijd (verschil tussen starttijd en huidige tijd) Verwerking WD0 WD1 WD2 WD3
Omdat de windsnelheid continu varieert, zullen we een gemiddelde maken van de waardes van de afgelopen 60 seconden. Op deze manier verkrijgen we minder variërende waardes. De timing van 60 seconden kan eenvoudig gebeuren door het toevoegen van In volgend stukje code wordt de werking verder uitgelegd. // Bij het initialiseren van de variabelen hebben we mbv // ‘time(&start);’ het tijdstip waarop het progr. Begon, vastgelegd. time (&end); // Hiermee leggen we het huidige tijdstip vast. dif = difftime (end,start); // Dit levert in seconden het verschil tussen 2 tijdstippen. if(dif >= 60) // Indien we een minuut bezig zijn… { CurrentWindSpeed = WindSpeedCounter; // Huidige waarde doorgeven. WindSpeedCounter = 0; // pulsteller resetten time (&start); // opnieuw starten met tellen }
41
Ontwerp van een weerstation
Uitlezing en verwerking
Hiermee is echter nog niet alles gezegd. We mogen dan al wel beschikken over een leesbare uitvoer voor de windsnelheid, de windrichting is nog steeds alleen in Gray code beschikbaar. Om dit goed om te zetten gaan we eerst twee extra functies definiëren. De eerste functie dient voor het omzetten van de Gray Code naar binair. Dit gaat zoals ons in het labo meetsystemen werd aangeleerd, door middel van een exor bewerking. int exor(int p, int q) { if( p != q) {return 1;} else {return 0;} }
De tweede functie heeft een ander doel. Het is namelijk zo dat de windrichting kan variëren gedurende de meting, en dat er graag een „meest voorkomende‟ windrichting kan worden waargenomen. Hiervoor zullen we daarom gaan „turven‟; streepjes trekken bij elke windrichting om aan te geven hoe vaak deze in de afgelopen minuut is voorgekomen. Op deze manier kunnen we dan de meest voorkomende windrichting zoeken, en de overeenkomstige waarde tussen 0 en 15 omzetten naar een hoek in graden. void int_to_degrees(int n) { Dir[n]++; int biggest = 0; int i; for(i = 0; i<16; i++) { if(Dir[i]>biggest) { // Berekenen huidige windrichting. // Merk op dat we hier als 0° het noorden hebben, // En op het taskit bordje het Oosten. // Vandaar de -90 (of +270) // in de formule hieronder. current_Wind_Dir = (int)((double)i * 22.5 + 270); biggest = Dir[i]; } } }
42
Ontwerp van een weerstation
Uitlezing en verwerking
Nu kunnen we gebruik maken van deze functies in het hoofdprogramma. Eerst gaan we de windrichting omzetten met de exor‟s van Gray Code naar binaire code. geconverteerd[0] geconverteerd[1] geconverteerd[2] geconverteerd[3]
Dan kunnen we deze array in een byte steken, die we dan casten (opwaarderen) tot integer, en toevoegen aan onze turffunctie, welke ineens ook de meest voorkomende windrichting berekend. b = (geconverteerd[0] << 3) + (geconverteerd[1] << 2); b = b + (geconverteerd[2] << 1) + (geconverteerd[3] << 0); int_to_degrees((int)(b));
Eens per minuut zal de meest voorkomende windrichting via een socket verbinding verstuurd worden naar de server, alsook het aantal geregistreerde pulsen van de anemometer. Vervolgens wordt de array voor het turven terug geledigd, het aantal pulsen op nul gezet, en begint alles van vooraf aan opnieuw.
43
Ontwerp van een weerstation
Uitlezing en verwerking
4.5. De Mierij neerslagmeter 4.5.1. Interfacing van de meetmodule Voor de regensensor beschikken we over een 4draads aansluiting van het type RJ-9. Hiervan worden slechts twee aansluitingen gebruikt voor de reed schakelaar in de regensensor. Met behulp van een multimeter kon de bepaling van deze twee aanslutingen vlot gebeuren. De aansluiting hiervan met de Single Board Computer gebeurt eenvoudigweg via een verbinding tussen een XDIO-pin en de massa. De massa, omdat de XDIO-pin standaard hoog is, en we deze bij een puls laag willen maken. Op deze manier is het mogelijk om een continue controle te doen op stijgende flanken van de ingang XDIO. De functie “int getPin(xdio *x,int pin)” is reeds in staat om de waarde van een pin weer te geven. 4.5.2. Verwerking van de pulsen in een C++ programma Initialisatie
Aangezien we niet gewoon willen weten hoeveel regen er gevallen is, maar ook binnen welke periodie die gevallen is, zullen we een timer nodig hebben. Verder zullen we het aantal regenpulsen per uur verzenden naar de server. Om pulsen, ouder dan een uur te wissen, zullen we een array bijhouden van tijdstippen waarop er pulsen geregistreerd zijn. Deze array zal dan eens per uur doorlopen worden, en waardes die te oud zijn, zullen buiten de actieve selectie van de array vallen. time_t end,raintime; time (&raintime); int Rain = 1; int Rain_Old = 1;
// default hoog. // Oude waarde voor flankdetectie.
int array_Front = 0; int array_Current = 0; time_t Tarray[65000]; int checked = 0;
// // // //
Begin van de array Huidige plaats in de array Array van regenregistraties Voor de controle van Tarray
44
Ontwerp van een weerstation
Uitlezing en verwerking
Verwerking
Wanneer we een puls detecteren, en het is al langer dan een seconde geleden dat we een vorige puls gehad hebben, gaan we de waarde in de array zetten. De tijdsvoorwaarde is doorgevoerd omwille van het denderend gedrag van een rietschakelaar. Rain_Old = Rain; Rain = getPin(xd1, 7); diff = (int)(difftime (end,raintime)); if(Rain_Old == 1 && Rain == 0 && diff > 1) // Op ‾‾↓__ { printf("Rain Puls waargenomen op: %s" ,asctime(localtime(&end))); Tarray[array_Current] = end; array_Current++; time (&raintime); }
Eens per minuut gaat er dan een controle lopen of alle punten nog steeds binnen het afgelopen interval (hier bijvoorbeeld een uur) gebeurd zijn. Zoniet, vallen ze buiten de actieve array. Indien er binnen het interval geen pulsen vallen, wordt de array terug leeg gemaakt, en de verwijzing naar het begin van de array op nul ingesteld. while(checked) { diff = (int)(difftime(end, Tarray[array_Front])); if(diff > 3600.0) { // tijd hoort niet meer in het kwartier array_Front++; } else { checked = 1; } } checked = 0; if(array_Front == array_Current) { // array leeg. Terug vanvoor beginnen. array_Front = 0; array_Current = 0; }
Via een socket connectie worden het aantal pulsen, geregistreerd binnen het afgelopen interval, verstuurd. current_Rain = array_Current - array_Front; SendThroughSocket();
45
Ontwerp van een weerstation
Dataverspreiding
5. Dataverspreiding In het vorig hoofdstuk is enkele malen de melding gegeven “nu kunnen we de gegevens verzenden via een socket verbinding.” In een eerste puntje van dit hoofdstuk zal er dieper op ingegaan worden hoe dit juist in elkaar zit. Hierna volgt de bespreking van de gebruikte socket server en client. En tenslotte komt er nog een uitleg over de nood aan een broadcast server (en client), en de bespreking ervan.
5.1. Inleiding Sockets worden gebruikt om data uit te wisselen tussen verschillende processen. Deze kunnen zowel binnen eenzelfde pc (of in ons geval SBC) draaien, of tussen verschillende machines via een netwerk. Eens een socket connectie is opgebouwd, kan er data verzonden en ontvangen worden door de betrokken partijen, totdat de connectie door server of client gesloten wordt. Figuur 17 geeft een schematische weergave hiervan.
Figuur 17: Socket Communicatie
Voor dit project is een socket verbinding nodig om geregistreerde waardes van de gebruikte sensoren te verzenden naar de server. Die zal ze dan verder opslaan in een logboek.
46
Ontwerp van een weerstation
Dataverspreiding
5.2. Socket Programming 5.2.1. De server Het doel van de server is enerzijds het ontvangen van meetgegevens, verstuurd door diverse clients, en anderzijds het opslaan van deze gegevens. Eerst zullen we de socket server zelf opbouwen. #define SIZE sizeof(struct sockaddr_in) // nodig voor bind-functie void catcher(int sig); // Voor opvangen van fouten int newsockfd; // File descriptor voor de socket (gekend buiten main) main(int argc, char *argv[]) { char buffer [20]; // hierin krijgen we de data binnen in ASCII float value; // de omgezette waarde van ASCII tot float. int error = 0; // wordt ‘1’ indien fout in opbouw socket server. char c = 'k'; // bevestigingskarakter als reply bij ontvangst data /* Nog enkele variabelen voor de socket connectie*/ int port = 6767; int sockfd; struct sockaddr_in server; static struct sigaction act; printf("in server...\n"); server.sin_family = AF_INET; // niet geldig voor IPV6 server.sin_addr.s_addr = INADDR_ANY; // ook niet geldig voor IPV6 server.sin_port = htons(port); // poortnr. omzetten nr. TCP/IP network byte order en toekennen /* signal handling */ act.sa_handler = catcher; sigfillset(&(act.sa_mask)); sigaction(SIGPIPE, &act, NULL); /* Aanmaken van de socket */ if ( ( sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ) { perror("socket call failed"); error = 1; } /* Verbinden van de socketserver met zijn socket */ if ( bind(sockfd, (struct sockaddr *)&server, SIZE) == -1 ) { perror("bind call failed"); error = 1; } /* Beginnen met luisteren naar inkomende connecties */ if ( listen(sockfd, 5) == -1 ) { perror("listen call failed"); error = 1; }
47
Ontwerp van een weerstation
Dataverspreiding
Nu de socketserver opgebouwd is, kunnen we beginnen met connecties te aanvaarden en af te handelen. Hiervoor dienen we echter rekening te houden met een niet onbelangrijke zaak: Aangezien we data willen verzenden tussen verschillende SBC‟s, met elk hun eigen processor architectuur is het niet vanzelfsprekend dat getallen (waaronder float‟s) steeds op dezelfde manier opgeslagen worden. Zo bestaan er bijvoorbeeld al „Big Endian‟ en „Little Endian‟, welke respectievelijk eerst de meest beduidende bytes en daarna de minst beduidende bytes opslaan. De meest eenvoudige oplossing om toch waardes te kunnen versturen zonder rekening te houden met de architectuur van elke SBC, is het omzetten van de waarde naar ASCII formaat bij het verzenden, en het terug omzetten naar het float formaat bij het ontvangen. Dit zal gebeuren met de functies sprintf() en sscanf(). if(error == 0) { for (;;) { /* We aanvaarden een nieuwe connectie */ if ( (newsockfd = accept(sockfd, NULL, NULL)) == -1) { perror("accept call failed"); continue; } // We maken een kindprocess om de connectie verder af te handelen if ( fork() == 0 ) { /* zolang we data binnekrijgen gaan we een bevestiging terugsturen */ /* en de binnengekomen data terug omzetten naar float */ while (recv(newsockfd, &buffer , 20, 0) > 0) { send(newsockfd, &c , 1, 0); //printf("%s\n",buffer); sscanf (buffer,"%f",&value); // zoeken naar een float in ontvangsbuffer /*huidige tijd ophalen */ time_t rawtime; time ( &rawtime ); /* openen van logging file */ FILE *fp; if((fp = fopen("/usr/Steven/Log", "a")) != NULL) { fprintf(fp, "%s",ctime (&rawtime)); fprintf(fp, "%.2f\n",value); fclose(fp); } } } /* Als een client geen informatie meer zend kan de socket gesloten worden. */ close(newsockfd); } /* De parent heeft geen nood aan de newsockfd */ close(newsockfd); }
48
Ontwerp van een weerstation
Dataverspreiding
5.2.2. De client Als client gebruiken we bijvoorbeeld het client gedeelte uit de verwerking van de Hygrosens sensor. Het enige verschil met de overige sensoren is de data die verstuurd wordt. In de while(1)-lus voegen we de functie SendThroughSocket toe. Deze zal ongeveer elke tien seconden (er staat een sleep van 10 sec in de lus) de data via een socket verbinding versturen. We bekijken deze laatstgenoemde functie eens van dichterbij: void SendThroughSocket() { char buffer [20]; int n; // berekening van de vochtigheid en temperatuur, met komma op de // correcte plaats, en toevoeging van de voorafgesproken constante. value1 = ((float)temperatuur/(float)100 + 1000); value2 = ((float)vochtigheid/(float)200 + 2000); int sockfd; char rc; int port = 6767; struct sockaddr_in server; /*converteren en opslaan van server informatie */ server.sin_family = AF_INET; server.sin_port = htons(port); server.sin_addr.s_addr = inet_addr("10.1.202.19"); /* de client socket aanmaken */ if( (sockfd = socket(AF_INET, SOCK_STREAM, 0 )) == -1 ) { perror("socket call failed"); //exit(1); } /* de client socket verbinden met de server socket */ if ( connect(sockfd, (struct sockaddr *)&server, SIZE) == -1 ) { perror("connect call failed"); //exit(1); } /* zenden en ontvangen van informatie met de server */ n=sprintf (buffer, "%2.4f",value1); send(sockfd, &buffer, 20, 0); // verzenden van de temperatuur recv(sockfd, &rc, 1, 0); //wachten op ontvangstkarakter while(rc != 'k') {} rc == '\n'; n=sprintf (buffer, "%2.4f",value2); send(sockfd, &buffer, 20, 0); //verzenden van de vochtigheid recv(sockfd, &rc, 1, 0); //wachten op ontvangst karakter while(rc != 'k') {} rc == '\n'; }
Op deze manier kunnen we op relatief eenvoudige wijze de datacommunicatie tussen verschillende sensoren verzorgen. 49
Ontwerp van een weerstation
Dataverspreiding
5.3. Broadcasting Het bovenstaande deel van de socket connectie is na het schrijven volledig getest en functioneel bevonden. Maar dit blijft slechts zo tot het moment dat de server even uitgeschakeld wordt, reboot, of de netspanning even uitvalt. Want elke SBC is zo ingesteld dat zijn IP adres verkregen wordt via DHCP, en dus van keer tot keer verschillend kan zijn. In puntje 5.2 werd uitgegaan van een statisch IP adres, wat dus na bijvoorbeeld een tijdelijke spanningsuitval, verschillend kan zijn. En waardoor de server geen informatie meer kan ontvangen van de clients die desalniettemin waardes blijven registreren en proberen te verzenden. Een mogelijkheid om dit op te lossen is gebruik te maken van een statisch IP adres voor onze weerserver. Maar dit levert enerzijds extra administratie en werk op voor de informatica-afdeling en anderzijds een nog steeds minder algemeen toepasbaar ontwerp. Zo is het idee gekomen om een tweede server applicatie te laten draaien op de weerserver, die een broadcasting verzorgd van zijn IP adres. Door op de socket clients voor het instellen van de socket connectie even gaan luisteren naar de andere server en dit IP adres gebruiken, zullen we de gegevens steeds naar het juiste IP adres verzenden. In code vertaalt zich dit als volgt:
50
Ontwerp van een weerstation
Dataverspreiding
5.3.1. De server //#define BUFFSIZE 255 void Die(char *mess) { perror(mess); exit(1); } int main(int argc, char *argv[]) { char *ip = "NOT FOUND"; int sfd; struct ifreq ifr; struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr; memset(&ifr,0,sizeof ifr); sfd=socket(AF_INET,SOCK_STREAM,0); strcpy(ifr.ifr_name, "eth0"); sin->sin_family = AF_INET; if(0 == ioctl(sfd,SIOCGIFADDR, &ifr)) { ip=inet_ntoa(sin->sin_addr); } int sock; struct sockaddr_in echoserver; struct sockaddr_in echoclient; //char buffer[BUFFSIZE]; unsigned int echolen, clientlen; int received = 0; /* Create the UDP socket */ if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { Die("Failed to create socket"); } /* Construct the server sockaddr_in structure */ memset(&echoserver, 0, sizeof(echoserver)); /* Clear struct */ echoserver.sin_family = AF_INET; /* Internet/IP */ echoserver.sin_addr.s_addr = htonl(INADDR_BROADCAST); echoserver.sin_port = htons(6768); /* server port */ /*Set socket option to broadcast*/ int opt = 1; setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &opt, sizeof(int)); /* Send the word to the server */ echolen = strlen(ip); while(1) { { if (sendto(sock, ip, echolen, 0, (struct sockaddr *) &echoserver, sizeof(echoserver)) != echolen) { Die("Mismatch in number of sent bytes"); } sleep(5); } } close(sock); exit(0); }
51
Ontwerp van een weerstation
Dataverspreiding
Merk op dat we in de code een sleep(5) uitvoeren voordat we een nieuwe broadcasting uitvoeren. Dit is gedaan om enerzijds een overbelasting van het netwerk met broadcast berichten te voorkomen, en anderzijds de processorbelasting te verlagen. Zonder de sleep(5) zou de CPU namelijk op 100% van zijn capaciteiten broadcast berichten blijven verzenden, wat tot onnodig stroomverbruik en netwerkbelasting zou leiden. 5.3.2. De client int sock; struct sockaddr_in echoserver; struct sockaddr_in echoclient; char buffer[16] = " "; unsigned int echolen, clientlen, serverlen; int received = 0; /* Create the UDP socket */ if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { Die("Failed to create socket"); } /* Construct the server sockaddr_in structure */ memset(&echoserver, 0, sizeof(echoserver)); /* Clear struct */ echoserver.sin_family = AF_INET; /* Internet/IP */ echoserver.sin_addr.s_addr = htonl(INADDR_ANY); /* Any IP */ echoserver.sin_port = htons(atoi("6768")); /* server port */ /* Bind the socket */ serverlen = sizeof(echoserver); if (bind(sock, (struct sockaddr *) &echoserver, serverlen) < 0) { Die("Failed to bind server socket"); } /* Receive a message from the client */ clientlen = sizeof(echoclient); if ((received = recvfrom(sock, buffer, 16, 0, (struct sockaddr *) &echoclient, &clientlen)) < 0) { Die("Failed to receive message"); printf("Ontvangen buffer = %s\n",buffer); } close(sock);
Zo kunnen we nu de regel: server.sin_addr.s_addr = inet_addr("10.1.202.19");
in de socket client vervangen door de meer algemene versie: server.sin_addr.s_addr = inet_addr(buffer);
52
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
6. Visuele weergave van het eindresultaat 6.1. De KHLim meteo website De basis van de KHLim meteo website bestaat uit zuivere html code met een grafische opmaak via css. Zo kan het uiterlijk snel aangepast worden, zonder veel code te moeten wijzigen. Maar aangezien deze zuivere html code een statisch gegeven is, kunnen we ze niet op deze manier gebruiken om de gegevens van de verschillende weersensoren weer te geven. Als oplossing hiervoor zal er gebruik gemaakt worden van zelfgeschreven CGIscripts. Hier zullen we dieper op ingaan in een eerste en tweede puntje. Vervolgens zal er een voorstelling komen van het eindresultaat. 6.1.1. Common Gateway Interface Common Gateway Interface of kortweg CGI is een technologie die het mogelijk maakt om dynamisch gegevens uit te wisselen met een webbrowser. In ons geval zullen we het hoofdzakelijk gebruiken om gegevens te versturen naar de webbrowser. CGI programma‟s kunnen enerzijds geschreven worden in een scriptingtaal (waarvan de programmacode de broncode is) zoals bijvoorbeeld Perl of Python. Anderzijds kunnen ze ook bestaan uit een gecompileerd programma. De CGI scripts voor dit eindwerk vallen allen terug tot de laatste categorie, en zijn geschreven in C++. Tenslotte nog even twee opmerkingen voordat we overgaan tot de effectieve CGI applicaties. De CGI scripts hebben speciale rechten nodig om hun taak te volbrengen. Ze moeten namelijk uitvoerbaar zijn voor iedereen, zodat het script steeds kan lopen bij het opvragen van een pagina, en niet enkel wanneer de rootgebruiker is ingelogd en het script uitvoert. Dit kan voor bijvoorbeeld een applicatie „Cdata.cgi‟ eenvoudig gebeuren met het commando: chmod a+x Cdata.cgi Elke keer wanneer een CGI programma wordt opgestart zal er een nieuw proces starten. Bij een te groot aantal requests kan dit problemen geven, zeker omdat het Taskit bordje niet de krachten heeft van een volwaardige webserver. Meer recente technologieën zoals PHP of ASP lossen dit probleem op [9].
53
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
6.1.2. De programma’s Cdata.cgi
Deze applicatie zorgt voor het ophalen van de meest recente gegevens uit het logboek en geeft ze weer. Ook zal een vermelding gemaakt worden van het al dan niet online zijn van elke sensor. De basis van het programma is een html doorverwijspagina naar Cdata.html, welke gemaakt zal worden bij het verwerken van het Logboek. #include #include #include #include
<stdio.h> <stdlib.h>
int main() { printf("Content-type: text/html\n"); printf("\n"); printf("\n"); printf("\n"); printf("<meta http-equiv='REFRESH' content='0;URL=../Cdata.html'>\n"); printf("* KHLim Meteo - weerserver *\n"); printf("\n"); printf("\n"); // Verwerking van het logboek. printf("\n"); printf("\n"); return 0; }
Binnen de body zal zoals in de commentaar vermeld staat, een verwerking van het logboek gebeuren. Eerst en vooral wissen we een eventueel vroeger gemaakte pagina. system("rm -f /config/httpd/Cdata.html");
De optie „–f‟ zorgt ervoor dat we geen foutmeldingen teruggeven (bijvoorbeeld indien het bestand nog niet zou bestaan). De reden hiervoor is eenvoudigweg dat de foutmelding anders doorgestuurd zou worden met de standaard output, en dus onderdeel van de webpagina zou vormen. Dit is echter niet de bedoeling.
54
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
Vervolgens gaan we twee file pointers definiëren en twee bestanden openen. Een om uit het logboek te kunnen lezen, en een om de actuele gegevens weg te schrijven in Cdata.html. FILE *fp; FILE *fp2; if(((fp = fopen("/config/Steven/Log", "r")) != NULL)) { if(((fp2 = fopen("/config/httpd/Cdata.html", "a")) != NULL)) { } else {printf("HTML could not be opened. Please try again.\n");} fclose(fp2); } else {printf("Data is not available. Please try again later.\n");} fclose(fp);
Vervolgens gaan we het logboek doorlopen, op zoek naar de laatste waarde van elke sensor. Afhankelijk van de regel van het logboek gaan we een verschillende verwerking doorvoeren. Als het eerste teken van de regel geen getal is, hebben we te maken met een datum en tijd. We gaan dan deze omzetten van een karakter array, naar een time_t structuur waarmee we verder kunnen rekenen. Indien het verschil van de huidige tijd en de tijd uit de karakter array kleiner is dan een bepaalde toegelaten periode van inactiviteit (in ons geval vijf minuten) dan zetten we een boolean „online‟ op „true‟. Want door de opbouw van het logboek weten we dat na deze regel de sensor (met zijn waarde) volgt die opgemeten is op dit tijdstip. Wanneer het eerste teken van een regel van het logboek wel een getal is, weten we dat het gaat om een opgemeten waarde van een bepaalde sensor. Dan gaat er eerst gekeken worden om welke sensor het in feite gaat, en kan vervolgens de meetwaarde uit het getal gehaald worden. Ook kijken we of de boolean „online‟ op „true‟ staat. Indien dit het geval is, kunnen we melden dat deze sensor online is, en zetten we de boolean „online‟ terug op „false‟ om verder te lopen in de verwerking van het logboek. Indien dit voltooid is, gaan we verder met het opbouwen van de uiteindelijke webpagina, Cdata.html. Dit gebeurd als volgt: fprintf(fp2, "\n"); fprintf(fp2, "\n"); fprintf(fp2, "* KHLim Meteo - weerserver *\n"); fprintf(fp2, "\n"); fprintf(fp2, "\n"); fprintf(fp2, "\n"); fprintf(fp2, "
Voor de volledige uitwerking van Cdata.html verwijs ik naar bijlage G. Rdata.cgi
Rdata zorgt voor een onverwerkte (ruwe) weergave van het logboek in html. Om het geheel niet onnoodzakelijk lang te maken, en Rdata.cgi grotendeels hetzelfde is als Cdata.cgi ga ik enkel het grote verschil in de code met het bovenstaande bespreken. Eerst en vooral zal er geen verwerking van de datum en tijd meer gebeuren. Ook de meetgegevens worden niet meer verwerkt. Meer zelfs, er wordt niet eens meer gekeken van welke sensor de meetgegevens afkomstig zijn. Het enige wat feitelijk gebeurt is het doorlopen van het logboek, en het wegschrijven van elke regel in een webpagina. Of in code: while(! feof(fp)) { fgets(str,199,fp); fprintf(fp2, "%s ",str); }
De volledige uitwerking is terug te vinden in bijlage H. 56
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
Pdata
Om de gegevens uit het logboek beter leesbaar te maken, is Pdata.cgi ingevoerd. Deze verwerkt de gegevens zodat er duidelijk vermeld wordt welke sensor de waarde heeft opgemeten, wanneer dit precies gebeurd is, en natuurlijk wat de waarde effectief is. Eveneens wordt de eenheid vermeld. Het geheel wordt gepresenteerd in tabelvorm. Als basis vertrekken we weer van Cdata.cgi. Maar ook nu weer gaan we niet kijken of de sensor online is of niet. In plaats hiervan gaan we, indien de regel van het logboek niet met een getal begint, een stukje van de tabel maken met de inhoud van de regel. Indien de regel wel met een getal begint, gaan we net zoals in Cdata.cgi kijken om welke sensor het gaat, de opgemeten waarde uit het respectievelijke getal ophalen, en afhankelijk van de sensor drie gepaste kolommen produceren. Bijvoorbeeld voor de temperatuursensor zal de output richting Pdata.html als volgt zijn: fprintf fprintf fprintf fprintf
(fp2, (fp2, (fp2, (fp2,
" " " "
%2.2f
\n",value);
°C
\n",value);
Hygrosens module
\n",value); \n");
Voor de volledige uitwekring verwijs ik naar bijlage I. Opmerking
De controle of een regel al dan niet begint met een getal, zoals geregeld gebruikt in bovenstaande uitleg, is eenvoudig mogelijk met de functie ”isdigit()”. Deze levert nul indien het beschouwde karakter geen getal is, en is dus eenvoudig te gebruiken in een if() conditie. Ook gebruiken we de functies printf() en fprintf() door elkaar in de CGI applicaties. Dit is niet zonder reden. De standaard output van een CGI applicatie wordt doorgestuurd naar de webrowser bij het uitvoeren van het script. Dus de volledige opbouw van de redirectpagina zal gebeuren met de functie printf(). De pagina waarnaar de redirect pagina verwijst, bijvoorbeeld Cdata.html, is een bestand. Hier kunnen we met de functie fprintf() naar wegschrijven.
57
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
6.1.3. Het eindresultaat Figuur 19 geeft de hoofdpagina van de KHLim meteo website weer. Er is een kort informatief overzicht over de reden van bestaan van de website en de opbouw. Via tabs aan de bovenzijde van de pagina kan er overgegaan worden naar de eigenlijke meetgegevens van het weerstation en eventueel een pagina waar later de specificaties toegevoegd kunnen worden.
Figuur 18: KHLim meteo website
58
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
Wanneer we gaan kijken naar de huidige waarnemingen kunnen we enerzijds de huidige meetgegevens (zie Figuur 22) en anderzijds de online sensoren (zie Figuur 20) terugvinden. Tenslotte kunnen we onder „geschiedenis‟ ook alle geregistreerde gegevens opvragen. De data is beschikbaar in ruwe en verwerkte vorm. Fout! Verwijzingsbron niet gevonden. geeft een voorbeeld van de verwerkte vorm.
Figuur 19: Online Sensoren
Figuur 21: Huidige meetgegevens
Figuur 20: Geschiedenis
59
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
6.2. Een GUI mbv het Taskit display 6.2.1. Het X Window System. Bij de meeste Unix machines kunnen we standaard het X Window System terug vinden. Deze bevat de standaard toolkit en het protocol waarmee op vrij eenvoudige wijze grafische gebruikers interfaces (GUI‟s) gebouwd kunnen worden. Er zijn mogelijkheden om te bewegen met vensters, verscheidene vormen te tekenen, en interactief om te gaan met randapparatuur zoals de muis of het toetsenbord. Het is niet zo dat X als het ware „volmacht‟ heeft over de gebruikersinterface; het zijn verschillende client programma‟s die de gebruikersinterface uiteindelijk afhandelen. Ook kunnen we nog vermelden dat X geen integraal deel is van een besturingssysteem. Het is zelfs zo dat het als een aparte applicatie laag draait bovenop de kernel van het besturingssysteem. In tegenstelling tot vroegere display protocols, was X oorspronkelijk ontworpen om eerder te gebruiken via het netwerk, dan op een rechtstreeks aangesloten beeldscherm. Het is dus vanzelfsprekend ook mogelijk dat de machine waar een applicatie draait, verschilt van Figuur 22: X Window System de machine waar het display op aangesloten is. Enkele bekende GUI‟s, gebaseerd op het X Window System, zijn bijvoorbeeld KDE, Gnome 2.20 of Xfce 4.4. In Figuur 23 [11] wordt het design van X nog even grafisch weergegeven. 6.2.2. Nano-X De basis
We gaan geen gebruik maken van het X Window System op het Taskit bordje, maar wel van een variant ervan; Nano-X. Zoals de naam het al aangeeft is het een afgeslankte versie van X, wat wel te verwachten is voor een embedded systeem. Niettemin blijft het basisprincipe hetzelfde; er dient een X server gestart te worden, waarna een client programma het scherm kan aansturen zoals gewenst. Voor het schrijven van dit client programma heb ik mijn inspiratie gehaald uit een Nano-X Programming Tutorial, gebaseerde op een mini-X tutorial van David I. Bell [12]. Als basis ben ik vertrokken van volgende code:
De werking van deze code loopt als volgt: Eerst wordt er een zogenaamde window id aangemaakt, een unieke identificatie voor een venster. Dan volgt de definitie van een graphics context id. Dit is als het ware een lijst met parameters waarmee er getekend kan worden, bijvoorbeeld een bepaalde kleur en/of lettertype. In de parameter „event‟ zullen opgevangen events steken, om dan afhankelijk van het type event een verschillende handeling uit te voeren. En tenslotte hebben we nog de „screen information‟, die informatie bevat over het huidige scherm, zoals bijvoorbeeld het aantal pixels in de lengte en breedte. Na het definiëren van deze parameters gaan we proberen een connectie te maken met de window server. Dit gebeurt mbv de functie GrOpen(). Indien dit lukt, zal er niets kunnen weergegeven worden en mag het programma al meteen afsluiten. Als het lukt worden de parameters van het scherm opgehaald. We maken ook een nieuw venster aan, en geven het een parent, grootte, achtergronden kaderkleur. De toekenning van alle mogelijke gebeurtenissen waarbij reactie nodig is wordt gedaan en we maken het venster (en eventuele kinderen ervan) zichtbaar op het display. Als graphic context houden we de default parameters, zijnde witte tekst op een zwarte achtergrond, met als font „font 0‟. Indien de code zo zou worden afgesloten zou het een kadertje weergeven. Maar, dit zou een statische zaak zijn. Daarom voeren we een while(1) lus in, waarbinnen we continu controleren of er een nieuwe event gebeurd is. Met behulp van een switch kunnen we dan, afhankelijk van de geregistreerde event een specifieke afhandeling uitvoeren. Vanzelfsprekend is het tijdens de afhandeling van de event ook mogelijk om nieuwe vensters te tekenen, tekst toe te voegen aan een venster, of figuren te tekenen. Indien er geen event is, komen we in de if-voorwaarde terecht. Een volledige uitwerking van de grafische gebruikersinterface zou onnodig veel plaats in beslag nemen. Daarom zullen enkel de grote lijnen aan bod komen, en verwijs ik voor de volledige uitwerking van de GUI naar bijlage A. Het opstarten
Bij het opstarten zal er, zoals in het basisprogramma,een nieuw venster gemaakt en getoond worden. In het venster dat wij gebruiken, zijn verschillende afzonderlijke delen terug te vinden. Eerst en vooral hebben we een titelbalk, met de huidige datum en tijd. En vervolgens hebben we voor elke sensor van het meteostation een kadertje om de specifieke meetgegevens in weer te geven. Alles behalve de meetgegevens zelf (dus de titels, eenheden, …) zijn reeds ingevuld. Continue werking
Net zoals in bovenstaande applicatie wordt er continu gekeken of er al dan niet een event gebeurd is. Indien er een event gebeurd is, zal deze afgehandeld worden. Events
62
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
zijn in ons geval bijvoorbeeld het draaien aan de unidirectionele muis. Maar nagenoeg steeds zal er geen event gebeuren en zullen we in onderstaand deel terechtkomen: if(event.type == GR_EVENT_TYPE_NONE) { //printf("Geen Event\n"); if(oldsec != sec) { oldsec = sec; if(wid_focus) { UpdateVars(); WriteVars(); } CorrectTime(); GrText(wid, gc_Text, GrText(wid, gc_Text, GrText(wid, gc_Text, GrText(wid, gc_Text, GrText(wid, gc_Text, }
Eerst gaan we kijken of er een seconde verlopen is. Als dit het geval is, is het tijd om de datum en tijd te vernieuwen. De functie CorrectTime() zal de actuele tijd ophalen, en verwerken van time_t formaat tot een aantal arrays van karakters, om zo te kunnen wegschrijven op het LCD display. Indien het hoofdvenster actief is (wid_focus is een integer die gelijk is aan 1, enkel en alleen wanneer het hoofdvenster actief is) gaan we nog twee functies extra uitvoeren. Een eerste is UpdateVars(), welke de meest recente gegevens uit het logboek gaat ophalen, en in de interne variabelen gaat steken. Vervolgens zullen met behulp van de functie WriteVars() deze waarden worden weergegeven op het LCD display. Testresultaten
Zoals zichtbaar in Figuur 24 worden de meetgegevens op een overzichtelijke manier weergegeven op het display. Momenteel is de kader met informatie over de regenval geselecteerd. Dit is te zien aan de lichtblauwe kleur van het kader. Scrollen naar andere kaders kan met behulp van de rotatieknop (oftewel unidirectionele muis). Bij het klikken op een kader zal een nieuw venster openen waar later meer informatie kan volgen over de specifieke meetsensor. De bovenste kader met de datum en de tijd blijft steeds weergegeven.
63
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
Figuur 23: De GUI van het Taskit paneel
6.2.3. Bijzonderheden Compilatie
Als eerste bijzonderheid zou ik hier even willen wijzen op de compilatie van applicaties voor het taskit bordje. Het geschreven programma kan namelijk niet gecompileerd worden met behulp van enkel en alleen het standaard compilatie commando. Want het programma maakt gebruik van de bibliotheek libnano-X, en bij het toevoegen van een #include “nano-X.h” wordt niet meer gedaan dan de definities van de gebruikte functies herkenbaar maken. Het is ook nodig om de bibliotheek met de eigenlijke code achter de functies toe te voegen. Verder maken we ook gebruik van wiskundige functies welke vereist zijn om het dauwpunt te berekenen. Daarom zal de parameter „–lm‟ ook bijkomen in de compileeropdracht. Als we dan bijvoorbeeld „nano-x.c‟ willen compileren kan dit door het intypen van volgend commando: arm-linux-3.4.2-gcc nano-x.c -o Gui libnano-X.so -lm
64
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
Plaatsing van de bestanden
Wanneer er een bestand werd aangemaakt in de map /usr/local op het Taskit bordje, bleek dit na een reboot verdwenen te zijn. Met behulp van het commando „df‟ kon dit verklaard worden: root@Panel-Card:# df Filesystem 1k-blocks /dev/ram0 7931 /dev/mtdblock3 10240
Used Available Use% Mounted on 5503 2428 69% / 536 9704 5% /config
Hier is duidelijk zichtbaar dat de overgrote meerderheid van bestanden op het taskit bordje in het ram geheugen zitten. Waardoor ze logischerwijs niet kunnen blijven bestaan na herstarten van de SBC. Indien we in de directory /config een nieuwe map maken, en hier alle bestanden in zetten, zullen ze niet gewist worden bij spanningsverlies. Toevoeging van drivers van de unidirectionele muis
Standaard is het niet mogelijk om gebruik te maken van de unidirectionele muis, aanwezig op de SBC. Om dit in te schakelen moeten de drivers ervan geladen worden bij het opstarten van het bordje. Dit kan gedaan worden door volgende regel aan het opstartbestand toe te voegen: insmod /config/panelcard-knob.ko
Hier kan nog aan toegevoegd worden dat „insmod‟ staat voor „insert module‟, en de berwerking kan ongedaan gemaakt worden door het commando rmmod (remove module).
65
Ontwerp van een weerstation
Visuele weergave van het eindresultaat
Automatische start
Na het inschakelen van de spanning van het Taskit bordje wordt automatisch een opstartbestand doorlopen, namelijk rc.local; terug te vinden in de map /config. Hierin zijn enkele aanpassingen gemaakt, zodat na stroomuitval het hele weerstation gewoon terug zijn normale gangetje kan gaan zonder menselijke interactie. Na aanpassing ziet het opstartbestand eruit als volgt: root@Panel-Card:# cat /config/rc.local /bin/hostname Panel-Card # dynamic ip-address /sbin/udhcpc -n -q # static ip-address (momenteel niet van toepassing) #/sbin/ifconfig eth0 192.168.4.240 #/sbin/route add -net 0.0.0.0 netmask 0.0.0.0 gw 192.168.4.14 #netwok services /usr/sbin/telnetd /usr/sbin/httpd -c /config/httpd/httpd.conf -h /config/httpd /usr/bin/vsftpd # getting time from ntp-server (aangepast naar server uit Duitsland) netdate -i 37 ptbtime2.ptb.de -s -l 100000000000000000 /bin/ln -s /usr/share/zoneinfo/Europe/Berlin /etc/localtime ln -s /dev/rtc0 /dev/rtc #samknob driver insmod /config/panelcard-knob.ko # Opstarten nano-X server /bin/nano-X & # Opstarten van zelfgeschreven applicaties: /config/Steven/BroadcastServer& /config/Steven/socketserver& /config/Steven/Gui&
66
Extra’s
Ontwerp van een weerstation
7. Extra’s 7.1. Onderhoud Ondanks het feit dat het doel van dit eindwerk een geautomatiseerd weerstation was, zal er toch nog steeds een (weliswaar zeer kleine) menselijke interactie noodzakelijk zijn. De regelmaat van deze interactie is afhankelijk van sensor tot sensor. De neerslagmeter
Een grote bedreiging voor de neerslagmeter is het inwaaien van bladeren, die kunnen zorgen voor een verstopping van de trechter. Vooral in de herfst kan dit problemen leveren. Een oplossing voor het inwaaien van bladeren kan zijn het toevoegen van een rooster bovenop de trechter, maar aangezien deze de inval van regen bemoeilijkt, zeker wanneer er bladeren op het rooster zouden belanden, ben ik hier geen voorstaander van. De stralingsmeter
Voor de stralingsmeter zijn er twee zaken waarop gelet dient te worden. Een eerste aandachtspunt is het vuil worden van de dome waarlangs de zonneschijn invalt. Dit kan bijvoorbeeld gebeuren wanneer opspattende modder bij zeer hevige regenval op de dome beland. Maar aangezien bij de plaatsing vermeld is dat de stralingsmeter best 150 cm boven het aardoppervlak dient te staan, zal dit normaliter nauwelijks voorkomen. Wat wel kan leiden tot een beperkte stralingsinval is natuurlijk sneeuwval. Vandaar dat de aflezing bij sneeuwval niet accuraat is zolang de dome volledig of deels bedekt is door een laagje sneeuw. Verder moet de stralingsmeter intern een minimale staat van droogheid hebben. Hiertoe is een vocht absorberende stof aanwezig binnen het systeem. Maar deze kan slechts een beperkte hoeveelheid vocht absorberen, en dient indien opgebruikt (doorschijnend van kleur) vervangen te worden. Dit is noodzakelijk voor een goede werking, maar zal niet frequent noodzakelijk zijn. De Hygrosens sensor
Bij het voeren van testen met de sensor is opgevallen dat een goede luchtstroom door de sensor noodzakelijk is. Daarom zou ik graag nog even vermelden dat er best ook periodiek gecontroleerd wordt of dit nog steeds in orde is. De Mierij windsensor
Deze heeft geen noemenswaardig onderhoud nodig.
67
Extra’s
Ontwerp van een weerstation
7.2. Mogelijke problemen Stroomuitval
Indien de netspanning om een of andere reden zou uitvallen, is de weerserver zo ingesteld dat hij meteen opnieuw zal opstarten wanneer de netspanning terug opkomt. Hij zal dan ook meteen zoeken naar de timeserver die gebruikt wordt om de interne klok van het Taskit bordje. Indien er op dat moment nog geen internet beschikbaar is, zal dit niet lukken, en zal het bordje een default uur en datum instellen, en hiervan verder tellen.
7.3. Verdere evolutie 7.3.1. Debugging van uart.cpp Om tot een blijvend werkend systeem te komen is het noodzakelijk dat de bug in uart.cpp, het programma dat de verwerking van de gegevens van de Hygrosens sensor verzorgd, nog opgespoord en opgelost wordt. 7.3.2. Extra sensoren Om in de toekomst een basisvorm van weersvoorspelling uit te voeren is het invoeren van een barometer aan het geheel sterk aan te raden. Het is namelijk zo dat er een verband is tussen de luchtdruk en de kans op regen. Hoe lager de stand van een barometer, hoe groter de kans op neerslag is. [12] Tabel 3 geeft deze relatie weer. Luchtdruk in hPa
Regenkans
Weer
870 - 970
90%
Zware storm
970 - 980
90%
Storm
980 - 990
90%
Veel regen
990 - 1000
80%
Regen of wind
1000 - 1003.3
70%
Regen of wind
1003.3 - 1006.7
60%
Regen of wind
1006.7 - 1010
50%
Wisselvallig weer
1010 - 1015
40%
Wisselvallig weer
1015 - 1020
30%
Wisselvallig weer
1020 - 1030
20%
Goed weer
1030 - 1033.3
10%
Mooi weer
1033.3 - 1084
10%
Zeer mooi weer
Tabel 3: Verband tussen luchtdruk en neerslag
68
Extra’s
Ontwerp van een weerstation
7.3.3. Extra visualisatie mogelijkheden Via extra hardware
Een mooie mogelijkheid om grafisch de windrichting weer te geven is via een stappenmotor, welke de actuele windrichting opvolgt. De stappenmotor kan dan binnenhuis een windvaan of dergelijke aansturen. Bij de GUI van het taskit paneel
De grafische gebruikersinterface van het taskit paneel is zo opgebouwd dat elke sensor afzonderlijk geselecteerd kan worden. In een nieuw venster kunnen misschien gedetailleerde meetgegevens, trends en dergelijke, weergegeven worden. Ook kan een zoekfunctie zeer handig zijn om het weer van een bepaalde dag op te vragen. 7.3.4. Dataopslag Momenteel gebeurd de dataopslag in een tekstbestand. Dit is natuurlijk niet de meest functionele manier van werken. Het gebruik van een database zou een veel snellere en minder belastende vorm van werken zijn. Echter, het is niet vanzelfsprekend om een database te installeren op een embedded bordje met beperkte mogelijkheden. Een van de toepassingen die dit eventueel toch toelaten, is SQLite [13]. Dit is zoals de naam zelf al zegt een afgeslankte versie van het wijdverspreide SQL. Er is een mogelijkheid ingebouwd om in C++ applicaties met de database te communiceren, en het geheel ondersteunt cross-compiling. Ik ben er echter niet in geslaagd het geheel werkend te krijgen, maar het is een mogelijkheid die best verder onderzocht kan worden. Tenslotte zal er bij de uiteindelijke ingebruikname ook nood zijn aan een grotere opslagruimte. Het gebruik van een externe harddisk is een optie.
69
Algemene toepassing van SBC’s voor automatisatie
Ontwerp van een weerstation
8. Algemene toepassing van SBC’s voor automatisatie In dit eindwerk zijn Single Board Computers gebruikt voor de verwerking, opslag, en visualisatie van meetgegevens voor ons weerstation. Maar omwille van de meestal zeer uitgebreide aansluitmogelijkheden zijn dergelijke mini-computertjes evenzeer toepasbaar in een grote waaier van andere systemen. In dit puntje zal uitgelegd worden waarom, om dan tot enkele voorbeeldtoepassingen te komen.
8.1. Verwerkingseenheid op maat ? Afhankelijk van de toepassing zijn er verschillende mogelijkheden binnen de wereld van Single Board Computers. Een eerste selectie kan gemaakt worden op basis van de hoeveelheid te verwerken data, en de snelheid van de verwerking. Op basis hiervan kan er al een ruwe schatting volgen qua nodige processorkracht. Indien de keuze uitgaat naar embedded ARM processoren [14], zoals gebruikt in dit eindwerk, liggen de mogelijkheden tussen 25 en 500 Mhz. Ook de hoeveelheid I/O en het type ervan is een belangrijke keuzefactor. De meest voorkomende aansluitingen zijn: USB (1.0 / 2.0) DIO ADC COM (serieel) RJ-45 (ethernet) SD / MMC / … De modernere versies hebben ook reeds SATA poorten. Misschien lijken al deze aansluitingen op het eerste zicht soms overbodig, maar dergelijke zaken kunnen achteraf altijd handig van pas komen. Denk maar eens aan een externe harddisk welke via USB wel eens de basis kan vormen voor een massale opslag van bijvoorbeeld meetgegevens. Of een ander toestel vlakbij waarmee communicatie probleemloos kan lopen via de seriële poort. Verder is het ook zo dat de Single Board Computers een vrij laag verbruik hebben (typisch een halve tot een enkele Watt). Daarom zijn ze zelfs zonder toevoeging van extra koeling in een groot temperatuurbereik toepasbaar. De TS-7260 bijvoorbeeld kan zonder ventilator of koelvin gebruikt worden bij temperaturen tussen -40 en +70 graden Celsius. [15]
70
Algemene toepassing van SBC’s voor automatisatie
Ontwerp van een weerstation
8.2. Toepassingen Enkele van de talloze toepassingen waarvoor Single Board Computers zeer nuttig van pas komen zijn: Domotica: dankzij de digitale IO pinnen en de ethernet verbinding is het perfect mogelijk om via het internet bepaalde toestellen aan of uit te zetten, of hun status te controleren. Zo kan bijvoorbeeld in de winter de verwarming snel opgezet worden wanneer de werkdag om is, om thuis te komen in een gezellig warm huis. Of misschien kan een mailtje of SMS‟je nuttig van pas komen wanneer een inbraaksensor geactiveerd wordt. De mogelijkheden in deze sector alleen al zijn enorm talrijk. De nagenoeg „verplicht‟ geautomatiseerde systemen. Bijvoorbeeld meetstations op relatief moeilijk bereikbare plaatsen. Ook dan vormen SBC‟s een vrij compacte verwerkingseenheid die vaak tegen extreme weersomstandigheden bestendig zijn en dankzij hun laag energieverbruik vrij lang op batterijen kunnen werken. Het registreren van de gewerkte tijdsduur. Het is namelijk in veel bedrijven zo dat de werknemer door een kaart in een toestel te steken het begin of einde van de werkdag dient aan te kondigen. Dit systeem kan eveneens uitgevoerd worden met Single Board Computers. Geautomatiseerde winkels. Er bestaan bedrijven die puur online winkels uitbaten waar de klant via internet een bestelling kan doorgeven. De gevraagde artikelen worden dan door robots uit de rekken gehaald, ingepakt, en klaargemaakt voor verzending. Een voorbeeld waar de SBC‟s hier van pas kunnen komen is bijvoorbeeld het monitoren van de verschillende robots binnen het systeem. Zo kan de beheerder van het systeem op elk moment eenvoudig zien welke robot waar in het bedrijf aanwezig. En dit indien gewenst, zowel via een aangesloten scherm als via het internet. …
71
Ontwerp van een weerstation
Besluit
9. Besluit Dataverwerking
Verwerking van de meetgegevens afkomstig van de Hygrosensor is mogelijk, maar slechts voor een korte (variabele) duur. Na vijf minuten tot een kwartier lijkt het alsof de sensor geen gegevens meer verstuurd naar de Picotux die instaat voor verdere verwerking. Tot op het moment van schrijven heb ik geen oplossing gevonden voor dit probleem. Het programma dat instaat voor de windsensor, meerbepaald het ophalen en verwerken van de windrichting en de windsnelheid, levert geen problemen. De sensor is gedurende meerdere uren getest en blijft probleemloos een correcte waarde afleveren. Ook het opvangen van pulsen van de regenmeter gebeurt zoals het hoort. Wegens tijdsgebrek is de verwerking van de stralingsmeter niet volledig kunnen gebeuren. Voor de software is er een applicatie geschreven die de uitlezing van de ADC verzorgt. Deze zou nog via een wiskundige bewerking omgezet moeten worden tot een stralingswaarde, en verder verstuurd via de beschikbare socket verbinding. Op gebied van hardware is nog een instrumentatieversterker nodig om de output van de stralingsmeter te versterken om zo tot een zo nauwkeurig mogelijke waarde te komen. Verspreiding van meetgegevens
Aan de hand van testen is gebleken dat het broadcasten van het IP adres van de server probleemloos verloopt. Ook kunnen de verschillende „client‟ SBC‟s dit adres opvangen, en gebruiken in een socket verbinding. De data wordt zoals hoort opgeslagen in een logboekbestand. Visualisatie op het LCD display van de Taskit SBC
Op het hoofdscherm is voor elke sensor afzonderlijk een kadertje zichtbaar met een voorstelling van de meetgegevens van elke sensor. Elke seconde gebeurt een update, zodat steeds het correcte en de meest recente meetgegevens weergegeven worden. Het gebruik van de unidirectionele muis is ook mogelijk.
72
Ontwerp van een weerstation
Besluit
De KHLim meteo website
Bij het surfen naar de KHLim meteo website zal er de mogelijkheid zijn om de meest recente meetgegevens op te vragen. Ook worden de actieve sensoren weergegeven. Momenteel is de instelling zo dat de sensoren na vijf minuten inactiviteit als offline worden beschouwd totdat er nieuwe meetgegevens ontvangen worden. Op een andere pagina is de geschiedenis van meetgegevens op te vragen, zowel in ruwe vorm als in een verwerkte, eenvoudig leesbare, vorm. Het gebruik van SBC’s voor de automatisatie van systemen
Uit het eindwerk is duidelijk gebleken dat Single Board Computers zeer geschikt zijn om de automatisatie van de meest uiteenlopende systemen te verzorgen. Ze zijn relatief klein en temperatuurbestendig. Ook is het stroomverbruik is miniem. De processorkracht van de SBC‟s kan gekozen worden op basis van de hoeveelheid te verwerken data. En tenslotte hebben de meeste SBC‟s ook een groot aanbod aan aansluitmogelijkheden.
73
Ontwerp van een weerstation
10. Bibliografie [1] , Dauwpunt. Wikipedia. [Online] 13 Mei 2008. http://nl.wikipedia.org/wiki/Dauwpunt. [2] "Verklaard - schotelhutje." Meteo Zeeland. [Online] 1 April 2008. http://www.meteozeeland.nl/verklaardschotelhutje.php. [3] "Hygrosens Python library from Brian C. Lane." BrianLane.com: Linux Software Developer. [Online] 11 April 2008. www.brianlane.com/software/hygrosens/docs/183003_HYTELOG_SMD_dbe.pdf. [4] KNMI: Windmeter. De website van het KNMI. [Online] 25 Mei 2008. http://www.knmi.nl/VinkCMS/concept_detail.jsp?id=2421. [5] World Meteorological Organization (WMO). World Meteorological Organization (WMO). [Online] 25 Mei 2008. http://www.wmo.ch/pages/index_en.html. [6] Pyranometer main page. ZHQ hobby page. [Online] 13 April 2008. http://www.henkquast.nl/Zonneduurmeter/Zonneduurmeter_main.htm. [7] picotux - smallest Linux computer in the world. Picotux. [Online] 2007 November 2008. http://www.picotux.com/. [8] TS-7260 Ultra-low Power ARM9 Single Board Computer for Embedded Systems. Technologic Systems. [Online] 16 December 2007. http://www.embeddedarm.com/products/board-detail.php?product=TS-7260. [9] Sweet, Michael R., Serial Programming Guide for POSIX Operating Systems. Easy Software Products. [Online] 20 Mei 2008. http://www.easysw.com/~mike/serial/serial.html. [10] , Common Gateway Interface. Wikipedia. [Online] 6 Mei 2008. http://nl.wikipedia.org/wiki/Common_Gateway_Interface. [11] "Nano-X Programming Tutorial." The Nano-X Window System. [Online] 3 Maart 2008. http://www.microwindows.org/Nano-XTutorial.html. [12] Weersvoorspelling => Zelf voorspellen. MeteoLogic. [Online] 17 Mei 2008. http://proto4.thinkquest.nl/~lld011/?page=voorspelling/voorspellen. [13] SQLite Home Page. SQLite. [Online] 17 Mei 2008. http://www.sqlite.org/. [14] PC/104 Single Board Computers, Peripherals, Enclosures and Accessoires for Embedded Systems. Technologic Systems PC/104 Single Board Computesr and Peripherals. [Online] 12 April 2008. http://www.embeddedarm.com/products/index.php. [15] TS-7260 Ultra-low Power ARM9 Single Board Computer for Embedded Systems. Technologic Systems PC/104 Single Board Computers and Peripherals. [Online] 22 Mei 2008. http://www.embeddedarm.com/products/boarddetail.php?product=TS-7260. [16] Koninklijk Nederlands Meteorologisch Instituut., [boekaut.] H. Benschop. Handboek Waarnemingen. 2000.
74
Ontwerp van een weerstation
[17] , "Digital Humidity Module." Hygrosens Instruments. [Online] 1 April 2008. http://www.hygrosens.com/fileadmin/user_upload/Produkte/Sensormodule/FeuchteTemp.SensMod_DIGITAL/HYTEMOD_DIG_PLE.pdf.. [18] Weather. World Meteorological Organization (WMO). [Online] 5 Maart 2008. http://www.wmo.ch/pages/index_en.html. [19] Windsnelheid en schaal van Beaufort. Het weer in Beverwijk. [Online] 11 April 2008. http://www.meteobeverwijk.nl/Diashow/Modules/Weer/Wind.Htm. [20] Woordenlijst. Weerstation Roeselare. [Online] 13 Mei 2008. http://www.weerstationroeselare.be/woordenlijst.htm.
75
Ontwerp van een weerstation
Bijlages
11. Bijlages Voor de eenvoud heb ik besloten om de programmacode niet aan dit document toe te voegen. Er is een CD-Rom beschikbaar met hierop alle broncode. In de digitale versie van het eindwerk zullen onderstaande koppen hyperlinks vormen naar de respectievelijke bestanden op de CD-Rom.
A. Verwerking van de Hygrosens-sensor B. Broadcast server van het Taskit paneel C. Socket server van het Taskit paneel D. GUI van het Taskit paneel E. Verwerking van de Windsensor en de pluviometer F. Verwerking van de ADC G. Cdata.cgi H. Rdata.cgi I. Pdata.cgi
