Weerstation Bram E bben e n J asper v an H aastere | 6 va Profielvak Bram: Natuurkunde Profielvak Jasper: Natuurkunde Begeleider: Norbert van Veen
19-‐12-‐2014
10
Inhoud Voorwoord Hoofdstuk I: Inleiding Hoofdstuk II: Onderzoek 2.1: Hoe maak je van een aantal sensoren een geheel? 2.1.1 Sensoren 2.1.2 Temperatuursensor 2.1.3 Luchtdruksensor 2.1.4 Luchtvochtigheidssensor 2.1.5 Alle sensoren 2.1.6 Het solderen 2.2: Hoe schrijf je de code voor metingen in Arduino? 2.3: Hoe laten we Arduino data wireless verzenden? 2.4: Hoe beschermen we ons station tegen verschillende weersomstandigheden? Hoofdstuk III: Het uiteindelijke product Hoofdstuk IV: Conclusie en discussie Hoofdstuk V: Reflectie Literatuurlijst Logboek
2 3 4 t/m 7 4 5 5 6 7 7 8 10 12 14 17 15 18 19
1
Voorwoord Voordat we beginnen met ons PWS willen we graag onze begeleider Norbert van Veen bedanken. Hij heeft ons veel geholpen met het uitzoeken van de verschillende sensoren en het verhelpen van problemen die tijdens ons project zijn ontstaan. Ook willen we het Hisparc team van het Nikhef bedanken voor het sponseren van onze Arduino onderdelen en voor hun gastvrijheid, zodat we in hun werkplaats aan ons weerstation konden werken. Bram Ebben en Jasper van Haastere
2
Inleiding Dit profielwerkstuk is geschreven door Bram Ebben en Jasper van Haastere. Wij zijn twee scholieren die op het Fons Vitae Lyceum, in de zesde klas van het vwo zitten. Wij hebben allebei een dubbelprofiel Natuur en Techniek + Natuur en Gezondheid en we hebben dan ook veel interesse in de exacte vakken. Voor ons profielwerkstuk wilden we graag ons eigen weerstation gaan ontwerpen. In 5 vwo hebben we meegedaan aan het Hisparc project van de UvA(Nikhef). Daar hebben we met groepjes twee grote detectoren gemaakt, waarmee kosmische deeltjes gemeten kunnen worden. Deze twee detectoren staan op het dak van onze school en meten daar nu, ook op dit moment, kosmische deeltjes die vanuit de ruimte de aarde bereiken. Het leek ons leuk om bij deze detectoren ook een eigen weerstation te zetten, waarmee we de temperatuur, luchtdruk en luchtvochtigheid kunnen meten. Onze natuurkunde leraar, Norbert van Veen, die ons destijds ook geholpen heeft om aan het Hisparc project te mogen deelnemen, wilde ons graag begeleiden tijdens dit project. Onze hoofdvraag in dit project is: “Hoe maken we een wireless weerstation die data meet en verstuurt?”. De deelvragen die we hierbij gaan beantwoorden gaan over de problemen die we moesten overwinnen om tot ons eindproduct te komen. Onze deelvragen zijn: “ Hoe maak je van een aantal sensoren een geheel?” , “ Hoe schrijf je de code voor metingen?” , “Hoe laten we Arduino data wireless verzenden?” en “ Hoe beschermen we ons station tegen verschillende weersomstandigheden?”. Als profielvak hebben we natuurkunde gekozen, omdat we in 5 vwo hoofdstukken hebben behandeld die met ons onderwerp te maken hebben, namelijk: signaalverwerking, stroom, spanning en weerstand. De begrippen temperatuur, luchtdruk en luchtvochtigheid hebben ook allemaal met de natuurkunde te maken.
“ Experientia docet ” 3
Onderzoek We hebben gekozen voor een ontwerp project, omdat het ons leuker leek om iets te maken met je handen dan alleen een literatuuronderzoek te doen. Op deze manier gebruiken we de kennis die we zelf opgedaan hebben en de kennis van anderen om iets te maken dat echt in de praktijk zal werken. We hebben bijvoorbeeld onze kennis van natuurkunde over spanning en stroom kunnen gebruiken toen we de bekabeling tussen de sensoren hebben aangelegd. Het is ook heel leuk dat ons project uiteindelijk echt op het dak van de school mag komen te staan.
| Hoe maak je van een aantal sensoren een geheel? De belangrijkste onderdelen van een weerstation zijn de sensoren die al het meetwerk doen. Je kan deze sensoren niet zomaar aan elkaar verbinden en hopen dat ze iets doen. De sensoren moeten op een computer-‐ of systeembord worden geplaatst, zodat de waarden kunnen worden verwerkt. Eerst moeten we de waarden van de sensoren uitlezen, dan verwerken en vervolgens uitschrijven. Voor de kern van ons station hebben we ervoor gekozen om een systeembord van Arduino te gebruiken. Arduino is een open bron platform met makkelijk te gebruiken hardware en software. Het wordt veel gebruikt door mensen die een interactief project willen maken. De Arduino Uno die wij gebruiken is een computerbord met verschillende digitale en analoge ingangen [1]. Het verschil tussen analoge en digitale ingang is dat digitale ingang alleen een 0 en een 1 kan geven, dus er zijn maar twee standen. Bij analoog zijn er veel meer verschillende hoeveelheden spanning (tussen 0 en 5 Volt), namelijk 256 (2! ), die aan het apparaat gegeven kunnen worden. In 5 vwo hebben we voor onze praktische opdracht van natuurkunde ook met dit systeembord gewerkt. We hebben profijt gehad van deze ervaring, omdat we al wisten hoe we met de Arduino omgeving om moesten gaan en dat we al een deel van de materialen voor ons project voor handen hadden.
Sensoren Wij wilden met ons weerstation de temperatuur, luchtdruk en luchtvochtigheid kunnen meten. De sensoren die we hiervoor gebruiken hebben we besteld op het internet. De door ons gekozen sensoren zijn de DHT22 (luchtvochtigheid), DS18B20 (temperatuur), bmp085 (luchtdruk). We hebben gekozen voor deze sensoren, omdat de nauwkeurigheid van de sensoren goed was, tegen een lage prijs.
4
Het proces begon met het uitproberen van de sensoren op een breadboard. Dit is een bord waarop je heel makkelijk schakelingen kan bouwen. De verschillende sensoren dienen allemaal op geheel verschillende wijze geschakeld te worden. Deze manieren zijn per sensor allemaal te vinden op het internet. Hieronder laten we zien welke sensoren we gebruikt hebben en hoe deze zijn geschakeld. Temperatuursensor Om de temperatuur te meten gebruiken wij vier DS18B20 sensoren. Het is de bedoeling dat de temperatuur van de omgeving wordt bepaald met twee sensoren die op het Arduino-‐shield zitten. De twee andere sensoren monteren wij aan de photomultiplier van de twee detectoren die al op het dak aanwezig zijn. Hiermee zouden mensen van het Hisparc project kunnen bepalen of de temperatuur invloed heeft op de hoeveelheid straling die wordt gemeten. De sensor heeft drie pinnen. De eerste twee dienen verbonden te worden met de ground en de derde, de data pin, is voor de verbinding met de andere sensor of als het de laatste betreft, de verbinding via een 4,7kΩ weerstand naar de 5 Volt. In figuur 2 is zichtbaar hoe dit geschakeld dient te worden. De Figuur 1: de DS18B20 voeding en het signaal gaan over één draad in deze schakeling. Deze draad gaat bij ons in de digitale ingang 3. Figuur 2: De schakeling van de temperatuursensoren
Luchtdruksensor De luchtdruk wordt bij ons bepaald met behulp van de bmp085. De luchtdruk is afhankelijk van hoogte en temperatuur. Deze sensor berekent de temperatuur. De hoogte moet door ons gegeven worden, waardoor de sensor de luchtdruk kan bepalen.
Figuur 3: de bmp085 [2]
5
De sensor heeft zes pinnen, waarvan er twee door ons niet worden gebruikt. De voeding die deze sensor nodig heeft is 3,3 Volt. Deze wijkt af van de standaard 5 Volt die de andere sensoren nodig hebben. De ground en de voeding moeten net als de vorige sensoren worden verbonden met Arduino. De SDA (datalijn) wordt verbonden met de analoge ingang A4 en SCL (seriële clock) met de analoge ingang A5 net zoals in figuur 4.
Figuur 4: de schakeling van de luchtdruksensor
Luchtvochtigheidssensor Wij gebruiken de DHT22 om de luchtvochtigheid te bepalen. Vorig jaar hebben wij al gewerkt met de DHT11. Deze was veel minder nauwkeurig dan de DHT22. De DHT22 heeft vier pinnen, waarvan er drie pinnen gebruikt worden. De eerste pin moet aangesloten worden op de 5 volt van Arduino. De tweede pin is de data pin en gaat via een weerstand van 10kΩ naar de digitale ingang 5 op Arduino. De derde pin wordt niet gebruikt en de vierde pin moet naar de ground. De luchtvochtigheid wordt uitgedrukt in de relatieve luchtvochtigheid. Dat is het aantal procent waterdamp in de lucht ten Figuur 5: de DHT22 [3] opzichte van de maximale hoeveelheid waterdamp in de lucht bij die temperatuur. Warme lucht kan meer waterdamp bevatten dan koude lucht. Koude lucht is dus eerder verzadigd. Als er een plotselinge temperatuur stijging plaatsvindt dan zal de relatieve luchtvochtigheid dus dalen. Figuur 6: De schakeling van de luchtvochtigheidsensor
6
Alle sensoren Nu werkt alles los, maar dat is niet de bedoeling. Het moet allemaal tegelijk gaan werken. Om dit voor elkaar te krijgen dienen wij alle sensoren tegelijk met Arduino te verbinden. Dit hebben wij gedaan zoals weergegeven in Figuur 7. Figuur 7: De schakeling waarbij alle sensoren tegelijk werken Het solderen We hebben nu nog een probleem. Het breadboard is veel te groot en onhandig om te gebruiken. Het zou veel handiger zijn als deze compacter zou zijn en dus in een compacte behuizing zou kunnen passen. Dit hebben wij opgelost door alles op een Arduino shield te solderen. Het shield komt vervolgens op het Arduino systeembord te staan. Alle verbindingen die we hebben aangebracht op het breadboard hebben we overgezet op het shield. Daar hebben wij met soldeer alle draadjes en sensoren vast gesoldeerd. Ook hebben we alle verbindingen tussen de verschillende draadjes met soldeer gelegd. Soldeer is een legering van tin, lood en koper. Het soldeer heeft een lage weerstand en dus Figuur 8: De opstelling die wij gebruikte om te solderen geleidt het stroom goed. Ook is soldeer eenvoudig aan te brengen met behulp van een soldeerbout.
Het solderen leer je vooral door het veel te doen. In het begin gaat het wat langzaam en misschien wat slordig, maar na verloop van tijd gaat het steeds sneller en beter. Een techniek die ons heel erg geholpen heeft, is het maken van vulkaantjes met het soldeer. Dit is mogelijk door eerst de pin te verhitten en vervolgens een stukje soldeer toe te voegen. Dit soldeer zakt voor een deel naar de bodem en vormt dus een vulkaantje. Vulkaantjes zijn heel stevig en maken het makkelijker om vervolgens een verbinding aan te leggen tussen twee pinnen en/of kabels. In het begin hadden wij deze techniek nog niet helemaal goed onder de knie en gebeurde het nog wel eens dat we eerder een bol hadden dan een vulkaan. Het wordt heel slordig op het moment dat je daartussen verbindingen gaat leggen. 7
| Hoe schrijf je de code voor de metingen in Arduino? We hebben niets aan een schakeling alleen. De sensoren moeten ook aangestuurd worden door het systeembord. Daarvoor hebben we een code in Arduino geschreven. Arduino biedt op hun site een gratis programmeeromgeving aan die gebruikt kan worden om een Arduino systeembord te programmeren [4]. De taal die in Arduino gebruikt wordt lijkt erg op de programmeertaal ’C’. Alle codes en functies die je kan gebruiken staan uitgelegd op de website van Arduino. Arduino biedt ook de mogelijkheid om ‘libraries’ te gebruiken. Dat zijn al voorgeschreven codes van Arduino of van de fabrikant van een sensor, waarmee je gemakkelijk een functie kan toevoegen aan je code zonder die helemaal te hoeven overschrijven. Er zijn bijvoorbeeld libraries die de ijking van een bepaalde sensor bevatten. Bij vrijwel elke sensor die we hebben gebruikt had de fabrikant of Arduino zelf al een voorbeeld programma gemaakt voor die specifieke sensor, om hem te kunnen testen.
Een ‘sketch’ (zo wordt een programma in Arduino genoemd) bestaat uit 3 hoofddelen. Bovenaan een sketch kan je libraries importeren, pinnen definiëren en variabelen aanmaken [*1]. Daaronder heb je Void Setup [*2] en Void Loop [*3]. De Void Setup wordt vooral gebruikt om de bitrate, dat is de communicatie snelheid waarmee Arduino informatie stuurt, vast te leggen. Ook wordt het veel gebruikt om libraries op te starten (of te definiëren). De Void Loop is het deel van het programma dat de hele tijd herhaald wordt. Voor ons is dat dus het uitlezen van de sensoren en het verwerken van de gegevens. Na de Void Loop kunnen er ook nog functies aangemaakt worden, maar die moeten dan wel in de Void Loop gebruikt worden. Wij hebben deze laatste optie uiteindelijk niet gebruikt, omdat het niet nodig bleek te zijn [5]. Onze code bestaat uit verschillende delen van de standaard programma’s die we hebben samengevoegd en aangepast aan onze wensen. Door het gebruik van libraries, aantekeningen en handige codes hebben wij de uiteindelijke code voor Arduino compact en overzichtelijk weten te houden. * Op de volgende pagina staat onze Arduino code [*1] regels 1 -‐ 15 [*2] regels 16-‐25 [*3] regels 26-‐57
Figuur 9: Arduino programmeeromgeving
8
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
#include <Wire.h> // Alle Libraries aanroepen #include
// " " #include // " " #include // " " #include // " " dht DHT; // " " #define DHT22_PIN 5 // Luchtdruksensor op Pin 5 (met 10K weerstand op 5V) #define ONE_WIRE_BUS 3 // 2x Temperatuursensoren op Pin 3 (met 4.7K weerstand op 5V) BMP085 dps = BMP085(); // Druksensor op Analoge Pin A4 en A5 (op 3,3V) OneWire oneWire(ONE_WIRE_BUS); // Lib: OneWire is nodig om contact maken met ingang D3. DallasTemperature sensors(&oneWire); // oneWire reference naar Lib: Dallas Temperature. long Temperature = 0, Pressure = 0, Altitude = 0; //-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ // De Setup //-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ void setup() { Serial.begin(9600); Wire.begin(); dps.init(MODE_ULTRA_HIGHRES, 550, true); // 550 hoogte in cm ten opzichte van NAP sensors.begin(); // Start de library } //-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ // De Loop //-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ void loop(void) { // Luchtdruk sensor dps.getPressure(&Pressure); dps.getAltitude(&Altitude); // Temperatuur sensoren sensors.requestTemperatures(); //Luchtvochtigheidssensor uint32_t start = micros(); int chk = DHT.read22(DHT22_PIN); uint32_t stop = micros(); //Print Serial.print(sensors.getTempCByIndex(0)); Serial.print(","); Serial.print(sensors.getTempCByIndex(1)); Serial.print(","); Serial.print(sensors.getTempCByIndex(2)); Serial.print(","); Serial.print(sensors.getTempCByIndex(3)); Serial.print(","); Serial.print(Pressure); Serial.print(","); Serial.print(DHT.humidity, 1); delay(298923); // 5 minuten wachten tot de volgende meting // per minuut is er ongeveer 1077 ms aan delay. }
Figuur 10: De Arduino code
9
| Hoe laten we Arduino data wireless verzenden? Het is niet handig om een kabel te moeten leggen tussen Arduino en de computer. Dit probleem kan heel gemakkelijk worden opgelost door een zender te gebruiken. Het is de bedoeling dat Arduino op het dak van de school komt te staan en vervolgens alle data naar de Hisparc computer van onze school verzendt. Wij hebben ervoor gekozen om de APC-‐220 module te gebruiken. De APC-‐220 module is een relatief makkelijk in te stellen zender. Het is mogelijk om de zender via een ander programma dan Arduino uit te lezen. In open lucht kan hij tot een afstand van 1,2 km data blijven verzenden. Deze zender heeft zeven pinnen, de meest rechtse in het plaatje moet verbonden worden met de ground op Arduino. De tweede pin moet naar de 5 volt. De andere pin die wij gebruiken is de RXD. Deze is voor het Figuur 11: De schakeling van de zender verzenden informatie. De RXD schakelen we naar de digitale ingang 1. Het meten van gegevens op afstand en die vervolgens versturen naar een andere locatie wordt telemetrie genoemd. Wij gebruiken dit principe om de temperatuur, luchtvochtigheid en luchtdruk op het dak van de school te meten en die vervolgens naar een computer op onze school te sturen. Dit wordt mogelijk gemaakt door middel van radiogolven. Deze radiogolven zorgen voor de overdracht van informatie. Alle informatie van een zender wordt overgebracht naar een ontvanger. Wij gebruiken radiogolven met een frequentie van 434700 MHz . Het is heel belangrijk dat de frequentie waarop de zender verstuurt en de ontvanger ontvangt hetzelfde zijn anders werkt het niet. Niet alle frequenties zijn toegestaan. Het is niet de bedoeling dat hobbyisten bijvoorbeeld het vliegverkeer verstoren. Om dit te voorkomen zijn er een aantal frequenties vrijgegeven voor amateurs, die informatie willen verzenden. Om aan deze eisen te voldoen hebben wij gebruik gemaakt van Arduino en de bijgeleverde code voor de zender. Daarmee hebben wij de frequentie van de zender ingesteld, waarna het mogelijk was om onze data wireless te verzenden. Ons weerstation werkt nu draadloos, maar alle waarden die wij nu meten worden nog weergegeven in een seriële monitor van Arduino. Hier kunnen wij eigenlijk niets mee, deze data kan niet goed verwerkt worden. Dit maakt Arduino heel beperkt, maar hier is een handige en zeer eenvoudige oplossing voor te vinden; Python. Python is een programmeertaal die data snel kan verwerken en veel mogelijkheden heeft. Dit komt goed uit bij het verwerken van onze data. Ook voor Python hebben wij een code moeten schrijven. Dit hebben wij gedaan in Cannopy, een handig medium om een Python code te schrijven en meteen te testen. Wij zijn gestart met een code van een andere Python gebruiker. Hiermee zijn wij verder aan de slag gegaan. We hebben deze code aan onze eisen aangepast. De data die we via de ontvanger binnen krijgen schrijven we via Python weg in een tekstbestand. Een lange tijd hadden we hier problemen mee, omdat in ons bestand af en toe gegevens niet goed weergegeven werden.
Dit hebben we opgelost door drie voorwaarden op te stellen waar de data die we binnenkrijgen aan moeten voldoen, voordat ze worden weggeschreven [*4]. De gegevens mogen niet dezelfde gegevens zijn als de laatste meting, er mag niet niks gemeten worden en ze moeten groter zijn dan een bepaalde lengte. * Op de volgende pagina staat onze Python code [*4] regel 43
10
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
import msvcrt import serial import datetime import time import collections today = datetime.date.today() def get_first_valid_port(): # Windows found = False port_number = 0 while not found and port_number < 256: try: s = serial.Serial(port_number) s.close() found = True except serial.SerialException: port_number += 1 if found: return 'COM' + str(port_number + 1) return None port_id = get_first_valid_port() if not port_id: print "Could not find any available serial port." exit(0) else: print "Connecting to port", port_id port = serial.Serial(port_id, baudrate=9600, parity=serial.PARITY_NONE, bytesize=serial.EIGHTBITS, stopbits=serial.STOPBITS_ONE, timeout=1.0) port.setRTS(0) prev_output = [] while True: output = port.read(500) a = len(output) print a if output != '' and prev_output != output and a > 30: # Check output not empty and if not equal to previous output and if output string is greater than 30 if output: file = open(".\Documents\Arduino\MetingenV2\Metingen.txt", "a") file.write(output + " {:%d, %b %Y} | ".format(today) + (time.strftime("%H:%M:%S")) + "\n") file.close() prev_output = output if msvcrt.kbhit() and msvcrt.getch() == 's': break
Figuur 12: De Python code
11
| Hoe beschermen we Arduino tegen verschillende weersomstandigheden? Theoretisch gezien zijn we nu klaar met ons weerstation. Via Arduino lezen we met de verschillende sensoren de temperatuur, luchtvochtigheid en luchtdruk uit. Die gegevens worden vervolgens via de zender doorgestuurd naar onze computer. In de praktijk zijn we echter nog niet klaar. Als we nu ons station buiten zouden zetten dan zal hij niet lang blijven werken. De moeilijkheid bij het bouwen van een werkend weerstation is niet alleen de sensoren werkend krijgen. We moeten er ook voor zorgen dat de apparatuur in staat is de milieuwaarden af te lezen en tegelijkertijd moeten we de apparatuur ook beschermen tegen diezelfde milieuomstandigheden. Figuur 13: Het onbewerkte houten kistje
Een van de belangrijkste zaken is om ons weerstation zo waterdicht mogelijk te maken. Als er water in het systeem komt, kan er kortsluiting ontstaan en zal alles kapot gaan. Bovendien kunnen we dan geen juiste waarden meer meten. Het proces met het kiezen van een ontwerp heeft bij ons een lange tijd geduurd. We hebben veel getwijfeld over de manier waarop en het materiaal waarvan we onze behuizing zouden maken. Op het internet waren niet veel zelfgemaakte weerstations te vinden, althans weerstations die beschermd waren tegen verschillende weersomstandigheden. We hebben wel ideeën opgedaan, maar we zijn uiteindelijk zelf tot ons ontwerp gekomen.
Figuur 14: Het maken van de behuizing
Uiteindelijk is onze keuze voor het materiaal van de behuizing gevallen op hout. Hout is makkelijk bewerkbaar, in tegenstelling tot plastic en metaal. Bovendien hadden we het meeste gereedschap al klaar liggen, evenals het materiaal. We zijn begonnen met een oud bierkrat dat we nog hadden liggen. Het bierkrat was aan alle kanten open. Dat was op zich goed voor de stroming van de lucht maar we moesten de openingen wel inperken vanwege neerslag. Aan alle kanten hebben we er houten plankjes opgetimmerd. We hielden ruimte over die groot genoeg was voor een goede luchttoevoer, maar klein genoeg om het meeste water vanaf de zijkant tegen te houden.
Figuur 15: De behuizing
12
Onze grootste uitdaging was de bovenkant ook helemaal waterdicht te maken. Tijdens ons ontwerpproces hebben we veel verschillende materialen en ontwerpen overwogen. Naast neerslag moesten we er ook voor zorgen dat de wind geen grip op het dak kon krijgen. We hadden drie mogelijkheden; een plat dak, een bol dak en een punt dak. Ons eerste idee was om een punt dak te maken. Een voordeel daarvan zou zijn dat er geen sneeuw of regen op zou kunnen blijven liggen. Maar een nadeel van dat plan zou zijn dat een punt dak niet uit een doorlopend stuk hout gemaakt kan worden. Er zou bovenaan dus een spleet ontstaan, waarlangs water naar binnen zou kunnen gaan druppelen. Bovendien vangt een punt dak meer wind van de zijkant en is een punt dak lastiger te monteren dan een plat dak. Een bol dak, van plastic of metaal, zou deze problemen oplossen omdat het weinig wind vangt en neerslag goed kan afvoeren. Helaas konden we geen grote ronde bak vinden die groot genoeg was om onze kist af te dekken. We hebben dus gekozen voor een plat dak. We hadden nog een grote badkamertegel, die we voor ons project konden gebruiken. Dit soort steen is perfect om water buiten te houden, aangezien dat precies is waar het voor gemaakt is (maar dan in een badkamer). Aan alle kanten van de kist hebben we een paar centimeter overhang aangebracht zodat er geen neerslag tussen de gleuven van de planken zal kunnen gaan. Aan de onderkant van de Figuur 16: Het moet er zo uit gaan zien tegel hebben we plankjes vastgezet zodat de tegel niet kan gaan schuiven. Om de tegel goed op zijn plaats te houden doen we een band of touw om de tegel en de kist heen, zodat die niet weg kan waaien. We hebben aan beide zijkanten hengsels gemaakt waar we het touw doorheen knopen. Nu we het dak op zijn plaats hebben zijn we bijna klaar. Voor Arduino hebben we een plastic bakje gemaakt als tweede bescherming, mocht er toch water gaan lekken. Ook willen we onze kist nog extra beschermen tegen houtrot wat na enige tijd problemen zou kunnen veroorzaken. Om ons hout daartegen te beschermen moeten we ervoor zorgen dat neerslag niet in de kiertjes zou kunnen blijven zitten en dus opgenomen zou kunnen worden door het hout. Wij hebben ervoor gekozen om het water weg te houden door middel van beitsen. Beitsen is het lakken van hout om het te beschermen tegen vocht, vuil en slijtage. Eerst hebben we het gladde oppervlak van onze behuizing geschuurd om het een beetje ruw te maken. Op ruw hout kan beits namelijk beter blijven zitten. Figuur 17: De gebeitste behuizing
13
Uiteindelijk product Ons uiteindelijk product is een werkend weerstation met behulp van Arduino en Python dat op het dak van de school komt te staan. Daar zal hij de temperatuur, luchtvochtigheid en luchtdruk gaan meten. Vervolgens wordt deze data verstuurt naar een computer op onze school. Op deze computer wordt alle data vervolgens weggeschreven in een tekst bestand. Het maken van een grafiekje met deze data is ook eenvoudig. Het is mogelijk om de data te importeren in een tabel in Excel. Hier kan vervolgens een grafiek mee worden gemaakt. Dit is zichtbaar in figuur 19 en 20. Deze grafieken kunnen vergeleken worden. Er kunnen verbanden worden gelegd tussen bijvoorbeeld de luchtvochtigheid en de temperatuur. In onze grafieken is duidelijk zichtbaar dat op het moment dat de temperatuur stijgt de relatieve luchtvochtigheid daalt.
Figuur 18: Voorbeeld van metingen in tekstbestand
14
3 Februari 2015 25 20 Temperatuur 15 in Celsius 10 5 0 0:00:00 2:24:00 4:48:00 7:12:00 9:36:00 12:00:00 14:24:00 16:48:00 19:12:00 21:36:00 0:00:00 Tijd in uur:min:sec
3 Februari 2015 102000 101500 Luchtdruk 101000 in Pascal 100500 100000 99500 0:00:00 2:24:00 4:48:00 7:12:00 9:36:00 12:00:00 14:24:00 16:48:00 19:12:00 21:36:00 0:00:00 Tijd in uur:min:sec
3 Februari 2015 100 80 60 RelaXeve LuchtvochXgheid 40 20 0 0:00:00 2:24:00 4:48:00 7:12:00 9:36:00 12:00:00 14:24:00 16:48:00 19:12:00 21:36:00 0:00:00 Tijd in uur:min:sec
Figuur 19: Voorbeeld van metingen in grafiek (3 februari 2015)
15
17 Oktober 2014 25 20 Temperatuur 15 in Celsius 10 5 0 0:00:00 2:24:00 4:48:00 7:12:00 9:36:00 12:00:00 14:24:00 16:48:00 19:12:00 21:36:00 0:00:00 Tijd in uur:min:sec
17 Oktober 2014 102000 101500 101000 Luchtdruk 100500 in Pascal 100000 99500 99000 0:00:00 2:24:00 4:48:00 7:12:00 9:36:00 12:00:00 14:24:00 16:48:00 19:12:00 21:36:00 0:00:00 Tijd in uur:min:sec
17 Oktober 2014 100 80 60 RelaXeve LuchtvochXgheid 40 20 0 0:00:00 2:24:00 4:48:00 7:12:00 9:36:00 12:00:00 14:24:00 16:48:00 19:12:00 21:36:00 0:00:00 Tijd in uur:min:sec
Figuur 20: Voorbeeld van metingen in grafiek (17 oktober 2015)
16
Conclusie Hoe maken we een wireless weerstation die data meet en verstuurt? Je kan een goed werkend weerstation maken als je netjes werkt, je ervoor inzet, er echt zin in hebt, aandacht besteedt aan de details en goed logisch nadenkt. Het is geen project dat je even tussendoor doet, maar als je weerstation eenmaal werkt geeft het je veel voldoening. Hoe maak je van een aantal sensoren een geheel? Onderzoek hoe andere mensen het voor jou hebben gedaan en bestel onderdelen waarvan je weet dat ze goed met elkaar samenwerken. Test je opstelling goed voordat je het vast gaat zetten en solderen. Hoe schrijf je de code voor de metingen in Arduino? Gebruik de meegeleverde codes van Arduino of van de fabrikant. Die verander je naar je eigen wensen en mocht je er niet uit komen, doorzoek dan de website van Arduino of vraag hulp aan andere mensen die met Arduino werken. Hoe laten we Arduino data wireless verzenden? Zoek een zender uit die aan je eisen voldoet en bekijk goed hoe hij werkt. Volg de instructies van de fabrikant op en als je er niet uitkomt, bekijk dan nog eens goed hun website of het werk van anderen. Check de frequentie die je gebruikt goed! Hoe beschermen we Arduino tegen de weersomstandigheden zoals regen? Het beste is om je systeem in een waterdichte kist/doos te doen, plastic is daar een goede optie voor. Mocht dat niet handig zijn dan kan je ook hout, steen of metaal gebruiken. Zorg bij metaal en hout dat je het materiaal goed beschermt tegen water, omdat water bij hout houtrot kan veroorzaken en bij metaal roest.
Discussie Omdat we vorig jaar al voor een deel met Arduino gewerkt hebben, hadden we al een goed beeld van hoe moeilijk dit project zou worden. Onze verwachtingen over dit project zijn dan ook wel redelijk uitgekomen.
17
Reflectie Eén van de sterke punten van ons werkstuk is dat we op tijd begonnen zijn met het praktische gedeelte. Daardoor hebben we alles werkend gekregen, zoals we in het begin wilden hebben. Ook is de samenwerking tussen ons tweeën erg goed gegaan en hebben we allebei een even grote bijdrage geleverd. Wat wellicht beter had gekund is dat we meer sensoren op ons weerstation zouden kunnen plaatsen. Een lichtsensor zou misschien wel interessant geweest zijn, omdat we dan de dag-‐ en nachtcyclus bij zouden kunnen houden. Ook zou een windkrachtmeter interessant geweest zijn. Hier hebben we wel naar gekeken maar dat zou rond de €60 extra kosten en dat wilden we er niet aan uitgeven. Wat we nu meten op ons schoolgebouw is natuurlijk leuk, maar het zou betere resultaten opleveren als meerdere van deze weerstations over heel Nederland geplaatst zouden worden. Dan zou je al kunnen beginnen met voorspellingen maken. Als je er een regensensor aan vastmaakt zou je bijvoorbeeld verschillende buien over Nederland zien verplaatsen en je zou dan kunnen berekenen hoe lang het duurt voordat die in Amsterdam zou aankomen. We vonden het een erg interessant profielwerkstuk, omdat we geleerd hebben dat dit soort projecten echt te doen zijn als je er maar voor inzet. Het is niet moeilijk en met wat onderzoek, doorzettingsvermogen en gezond verstand kan je echt ver komen. Er zijn vast andere mensen die dit voor ons hebben gedaan, maar het voelt toch bijzonderder dan een literatuuronderzoek. We hebben ook iets neergezet dat er waarschijnlijk meerdere jaren kan blijven staan en waar onze school en het Hisparc project nog profijt van kunnen hebben. En dat is toch wel het leukste van dit alles.
Literatuurlijst [1] en [5] http://arduino.cc [2]http://www.hobbyking.com/hobbyking/store/__26917__Arduino_Barometric_Pressure_Sensor_B MP085_Breakout.html [3] http://www.3bm.de/2013/09/15/batteriebetriebene-‐funk-‐temperatursensoren-‐fuer-‐arduino/ [4] http://arduino.cc/en/Main/Software
18
Logboek Datum 26-‐8-‐2014 28-‐8-‐2014 2-‐9-‐2014
Uren 4 0,25 1,25
5-‐9-‐2014
1,5
10-‐9-‐2014 19-‐9-‐2014
0,5 1,5
20-‐9-‐2014
3
24-‐9-‐2014 6-‐10-‐2014
0,5 6,5
8-‐10-‐2014
5
28-‐10-‐2014
1,75
16-‐11-‐2014
3,75
17-‐11-‐2014 25-‐11-‐14
2,5 3
3-‐12-‐2014
2,5
4-‐12-‐2014 8-‐12-‐2014
1,5 7
10-‐12-‐2014 13-‐12-‐2014 14-‐12-‐2014 15-‐12-‐2014 16-‐12-‐2015 17-‐12-‐2015 18-‐12-‐2014 23-‐1-‐2015 27-‐1-‐2015 28-‐1-‐2015 31-‐1-‐2015 1-‐2-‐2015 2-‐2-‐2015 4-‐2-‐2015 5-‐2-‐2015 Totaal
0,60 1,20 1,5 2,20 1 5 7,5 4 1 1 1,5 3 4 2 4 85,50
Activiteiten / Problemen Opstarten profielwerkstuk. Bedenken deelvragen en hoofdvraag. Bespreking met begeleider -‐ plan van aanpak Sensoren + Arduino ontvangen. Druksensor schakeling op het breadboard getest. Temperatuur sensor getest op breadboard. Arduino heeft problemen met herkennen van sensoren. Arduino code geschreven / uitgeprobeerd Luchtvochtigheid sensor getest op breadboard. We konden er geen waardes uit krijgen. Sensoren op breadboard controleren. Alles werkt behalve de luchtvochtigheidssensor. Bespreking met begeleider – problemen besproken, wat hebben we al Gewerkt op het Nikhef. Luchtvochtigheid werkend gemaakt op het breadboard. Zender ingesteld, uitgeprobeerd etc. Begin met Python. Arduino code samengevoegd en netter gemaakt. Python code geschreven voor het uitlezen van de seriële poort. Extra temperatuur sensoren toegevoegd aan de schakeling, alles getest en kleine problemen opgelost. Ideeën bedacht voor de behuizing. Materialen verzameld, planken gezaagd en begonnen met in elkaar zetten. Behuizing afgemaakt. Begin van het verslag gemaakt, solderen van de schakelingen van het breadboard op ons Arduino shield. Solderen, problemen met de Arduino code oplossen en slimme oplossingen bedenken om onze schakelingen tegen water te beschermen . Solderen, code veranderingen aanbrengen en test metingen. Op het Nikhef gewerkt, alle schakelingen vast gesoldeerd en aan problemen met de Python code gewerkt. Verder aan de behuizing gewerkt. Behuizing afgemaakt, tegel als dak met plankjes (gezaagd). Schrijven verslag. Schrijven verslag. Schrijven verslag. Schrijven verslag. Schrijven verslag, foto’s gemaakt, testmetingen en code verbeteren. Verslag verbeteren en een fout met het solderen verbeterd. Verslag verbeteren. Logboek schrijven. Gegevens verwerken. Een aantal kabeltjes vervangen. Probleem bespreking. Verslag verbeteren en meting opgezet. Grafiekjes maken. Laatste aanpassingen aan het verslag. 19
20
