Lokaal weerstation: 8 stappen (met afbeeldingen)

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Omdat ik op zoek was naar een geweldig project om te maken voor mijn eerstejaars schoolproject, had ik veel ideeën over wat ik moest maken, maar geen ervan vond ik een uitdaging.

Later bedacht ik me om een weerstation te maken met iets speciaals. Ik wilde al mijn gegevens kunnen opslaan en later kunnen gebruiken voor statistieken. Dit project zou speciaal gemaakt zijn voor personen die interesse hebben in meteorologie en een thuis gemaakt weerstation willen dat niet zo duur is als wat er op de markt verkrijgbaar is. Het project is ook gemaakt om de mogelijkheid te behouden om op elk moment sensoren toe te voegen of te verwijderen.

Ik was erg blij toen ik mijn eindresultaat zag dat beter was dan verwacht.

Het is gemaakt van een Raspberry Pi 4 met linux.

• Apache-website (html css js)
• Eventlet (backend-serverwebsite)
• MariaDB (databaseserver)

Benodigdheden

• Raspberry Pi 4:

  sd-kaart (min 16gb)

• Sensoren:

  1. QS-FS windsnelheidssensor
  2. Windsensor Tuinsignaaluitgang Aluminiumlegering Windrichtingsensor Windvaansnelheid Meetinstrument https://www.banggood.com/Wind-Sensor-Garden-Signal-Output-Aluminum-Alloy-Wind-Direction-Sensor-Wind-Vane-Speed -Measuring-Instrument-p-1624988.html?rmmds=mijnbestelling&cur_warehouse=CN
  3. DHT22 (vochtigheid)
  4. BMP280 (luchtdruk)
  5. DS18B20 (temperatuur)

• Voedingen

  • 5v voeding (RPi)
  • 9v voeding (op een externe breadboard voeding)

• Broodplank (x2)

  T-schoenmaker plus voor RPi 4

• jumperdraden

• IC's

  • MCP3008
  • PCF8574AN
• LCD-scherm 16x2
• LED (rood

• Behuizing (optioneel)

  • wijnkisten
  • houten paal (2m)
  • houten plank (1m)

Stap 1: Dingen Voorbereiden

Het is altijd van groot belang om alle items die je nodig hebt te hebben voordat je aan een stap gaat werken. Dit bespaart u veel tijd tijdens het doorwerken.

Dus eerst, Wat heb je nodig:

• Raspberry Pi 4:

  sd-kaart (min 16gb)

• Sensoren:

  1. QS-FS windsnelheidssensor
  2. Windsensor Tuin Signaaluitgang Aluminium Windrichting Sensor Windvaan Snelheid Meetinstrument:
  3. DHT22 (vochtigheid)
  4. BMP280 (luchtdruk)
  5. DS18B20 (temperatuur)

• Voedingen

  • 5v voeding (RPi)
  • 9v voeding (op een externe breadboard voeding)
• Broodplank (x2)
• T-schoenmaker plus voor RPi 4
• jumperdraden

• IC's

  • MCP3008
  • PCF8574AN
• LCD-scherm 16x2
• LED (rood)

• Behuizing (optioneel)

  • wijnkistenhouten
  • houten plank (1m)
  • paal (2m)

Je vindt alle links waar ik deze heb gekocht in het gedeelte benodigdheden onder de intro.

Stap 2: De RPi. instellen

Voor ons project hebben we een RPi nodig waarop de gegeven software is geïnstalleerd.

• Apache-website (html css js)
• Flask Socket-IO (backend-serverwebsite)
• MariaDB (databaseserver)

Voordat je gaat installeren is het altijd handig om ervoor te zorgen dat je de nieuwste software op je RPi hebt geïnstalleerd. Om dit te doen, voert u gewoon de volgende opdracht uit:

sudo apt update

Apache:

Laten we het eerst hebben over Apache. Apache is een webserver die over de hele wereld wordt gebruikt. Het laat uw website vlekkeloos draaien. Het enige wat je hoeft te doen is het te installeren en je website in de juiste map te zetten en daar is hij.

sudo apt installeer apache2 -y

Dat is het!

Om er zeker van te zijn dat alles correct is geïnstalleerd, surft u naar uw raspberry pi Ip-adres in uw browser en kijkt u of u de standaardwebsite krijgt. Als je problemen hebt met deze stap, kun je hier de RPi-website raadplegen.

Evenement:

Laten we nu Eventlet installeren. Het zal onze backend-server draaien en de verbinding maken van onze sensoren naar onze website. Daarvoor hebben we een aantal pakketten nodig.

Kolf-socketIO:

pip3 install flask-socketio

Evenement:

pip3 install eventlet

Gevent:

pip3 installeren gevent

Mariadb:

Mariadb is een op MySQL gebaseerde database die relationele databases maakt. Het wordt vaak gebruikt op de RPi en daarom is er veel hulp op internet te vinden. Voor meer info kan je naar deze link gaan.

apt installeer mariadb-server

Stap 3: Sensoren aansluiten en code toevoegen

Om de sensoren aan te sluiten op onze RPi kunnen we een T-Cobbler plus gebruiken. Dit is een handig tooltje waarmee je al je pinnen op je RPi op een breadboard kunt gebruiken.

In mijn project heb ik 5 sensoren:

1. QS-FS windsnelheidssensor
2. Windsensor Tuin Signaaluitgang Aluminium Windrichting Sensor Windvaan Snelheid Meetinstrument:
3. DHT22 (vochtigheid)
4. BMP280 (luchtdruk)
5. DS18B20 (temperatuur)

Windsnelheidssensor:

Allereerst ben ik begonnen met de windsnelheidssensor omdat ik vooral enthousiast was over deze sensor. Het is een sensor met een analoog signaal van 0-5v output en heeft een spanning van minimaal 7 volt nodig om te werken. Ik kies voor de 9 volt adapter om hem van stroom te voorzien.

Om deze sensor in te lezen heb ik een MCP3008 gebruikt wat een IC is om analoge signalen in te lezen. Het IC kan werken op 3.3V of 5V, maar ik kies 3.3V om het compatibel te maken met de RPi. Dit betekende dat ik de uitgangsspanning moest veranderen van 5V naar 3,3V. Ik deed dit door een spanningsdeler toe te voegen die werd gecreëerd door 2 weerstanden (2k en 1k ohm).

Windrichtingsensor:

Windrichting is net zo belangrijk als de windsnelheid, daarom zal ik dit hierna aansluiten.

Deze sensor heeft dezelfde specificatie als de windsnelheidssensor. Hij werkt ook op 9V en heeft een uitgangsspanning van 5 volt. Ook deze sensor zullen we via een spanningsdeler op de MCP3008 aansluiten.

DHT22 (vochtigheid):

De DHT22 leest de luchtvochtigheid af. Het geeft u een waarde in procenten en de waarde ervan kan worden afgelezen met behulp van het I2C-protocol op de RPi. Daarom moet u de I2C-poorten inschakelen in de Raspi-config. Meer info hier.

BMP280 (luchtdruk):

De BMP280 wordt gebruikt om de luchtdruk af te lezen. De waarde wordt uitgelezen via de SPI-bus op de RPi. Dit protocol moet ook ingeschakeld zijn in de Raspi-config. Voor mijn code heb ik de Adafruit-bibliotheek gebruikt.

DS18B20 (temperatuur):

De laatste sensor meet de temperatuur. deze sensor komt uit Dallas en als je een beetje ervaring hebt met Dallas, zou je waarschijnlijk al moeten weten dat ze de 1Wire-bus gebruiken. Wees niet verbaasd als ik zeg dat dit protocol ook moet worden ingeschakeld in de Raspi-config.

Hoe ik de sensoren heb aangesloten:

Als pdf heb ik een elektrisch en breadboard schema geüpload om het wat makkelijker te maken.

Nadat u de sensoren met succes hebt aangesloten en u de code hebt toegevoegd die nodig is om alle sensoren te lezen, kunt u doorgaan en naar de volgende stap gaan. Als u een sensor wilt achterlaten of meer wilt toevoegen, dan kan dat.

Stap 4: Een webinterface ontwerpen

Nu we de sensoren hebben aangesloten, hebben we een ontwerp nodig voor onze website.

We willen dat de website een eenvoudige uitstraling heeft en alle realtime-gegevens van de sensoren toont.

Ook willen we de historie van deze meetwaarden per tijdsinterval kunnen zien.

Dus begon ik eerst wat rond te kijken op het web voor wat inspiratie. Bovenal waren het gewoon weerinformatiesites zonder echt het ontwerp waar ik naar op zoek was. Weerstations die al op de markt waren, hadden hoogstwaarschijnlijk een display. En uit die vitrine kwam mijn inspiratie. De meeste displays hebben een design met een grid-look. Dit bracht me op het idee om de homepage te maken waar alle sensoren zouden worden weergegeven.

Maar ik zei ook dat ik een pagina wilde maken waar je de geschiedenis van elke sensor zijn waarden kunt zien.

Om die reden heb ik in mijn ontwerp ook een 2e pagina gemaakt waarin dit staat. Op deze pagina kon ik wat extra informatie over mijn sensor zien die niet op mijn voorpagina zou staan en natuurlijk het geschiedenisgedeelte.

Na een paar uur had ik mijn volledige ontwerp uitgewerkt!

Het ontwerp is gemaakt met Adobe XD.

Stap 5: Database maken

Om even bij te komen van het ontwerpgedeelte ben ik begonnen met mijn database.

Deze database zou alle sensoren (5) bevatten, alle actuatoren (2) en de waarden die die sensoren hadden.

De database is vrij eenvoudig en heeft een paar relaties.

Op de foto ziet u het databasemodel.

Stap 6: Coderen van de website: frontend (html css)

Terug naar de website!

Nu ik een ontwerp heb, kan ik het beginnen te coderen als html css om het echt te gebruiken.

Op de homepage:

Ik begon door elke sensor als een element op mijn website te beschouwen. Zodat ik later dit onderdeel kon laten genereren door mijn Javascript-code.

Ik heb ook willekeurige JS-houderklassen in de elementen ingevoegd. Deze zouden het mogelijk maken om de inhoud van dat element te veranderen

Dit kostte me veel tijd omdat ik niet zo goed ben in deze specifieke taal.

Na de startpagina te hebben gemaakt, was het tijd om te beginnen bij de geschiedenispagina.

Op de geschiedenis-pagina:

Deze pagina was wat makkelijker opnieuw te maken. Op deze pagina waren ook js-houders om de info over de sensor in te krijgen, een realtime waardeslot en om de tabel met alle gemeten waarden weer te geven.

Om een tab-optie op mijn website te maken om te kiezen tussen Tabel of Grafiek, moest ik een beetje Javascript toevoegen om de elementen niet of juist wel te laten weergeven.

Nu hebben we een prachtige website, maar kunnen we er niets op laten zien? Laten we dat oplossen.

Je kunt mijn code vinden in mijn github-repository:

Stap 7: Codering van de website: Backend (eventlet) + Codering Frontend (javascript)

Achterkant:

Hoewel de backend-server al is geïnstalleerd, moeten we dit nog in ons project implementeren. Eerst moeten we wat imports toevoegen om alles goed te laten werken.

from flask import Flask, request, jsonify from flask_socketio import SocketIO from flask_cors import CORS

Om de server te laten opstarten moeten we het volgende toevoegen:

socketio.run(app, debug=False, host='0.0.0.0')

De server is nu online, maar kan niet met de frontend praten.

Hij ontvangt of retourneert niets. Laten we dat veranderen.

Om alle sensoren in de database op te vragen, voegt u een route toe:

@app.route(endpoint + '/sensors', methods=['GET']) def get_sensors(): if request.method == 'GET': s = DataRepository.get_sensors() return jsonify(sensors=s), 200

Deze code gebruikt een klasse genaamd DataRepository en spreekt tot de database. Hier geeft het ons de sensoren terug waar we om vroegen.

We hebben ook een route nodig om de info over 1 specifieke sensor te vragen en een andere voor de waarden van een bepaalde sensor.

Dit zijn allemaal routes maar om de realtime data mogelijk te maken. We moeten elk interval de gegevens sturen die de sensoren zojuist hebben gelezen. Hiervoor gebruiken we de Socket-IO verbinding. Het is een verbinding die tot stand komt vanaf het moment dat iemand de website laadt met JS en deze verbinding open houdt. Dit is een full-duplex verbinding, wat betekent dat het een verbinding is die op beide manieren (verzenden en ontvangen) tegelijkertijd werkt. Om dit te gebruiken moeten we de volgende code toevoegen.

@socketio.on('connect') def initial_connection(): print('Een nieuwe client connect') socketio.send("U bent geconnecteerd") # # Stuur naar de client!

Dit stukje code wordt uitgevoerd wanneer een client verbinding maakt.

Om een bericht van de frontend te krijgen kun je deze code gebruiken.

@socketio.on('message') def message_recieved(): pass

Je kunt ook berichten sturen. Dit wordt gedaan door het volgende.

socketio.emit('Update_RTD', dict_results, broadcast=True)

Het eerste gegeven argument kan alles zijn wat je wilt, maar komt overeen met wat je in je JS plaatst en je kunt er ook objecten mee verzenden. Dit is optioneel.

Javascript:

Het is belangrijk om een beetje JS toe te voegen om de server verbonden te krijgen met de backend-server om de huidige gegevens weer te geven en informatie uit de database te krijgen.

We noemen de socketIO-functies die we hebben gemaakt om gegevens te ontvangen en te verzenden.

Wanneer we gegevens ontvangen als een Json-object, zullen we deze ontmantelen om de gewenste informatie te krijgen en deze vervolgens in de JS-houders plaatsen die we op onze website plaatsen.

Je kunt mijn code vinden in mijn github-repository:

Stap 8: Een behuizing maken

De behuizing heeft veel werk gekost en kan op elke gewenste manier worden gedaan. Dit is hoe ik het deed.

Ik heb wat wijnkratten meegenomen.

Een van hen gebruikte ik als de doos om mijn RPi en de meeste van mijn sensoren te bevatten.

De windsnelheidssensor en windrichtingsensor werden uiteraard niet binnen geplaatst maar bovenop een dwarsbalk die op een paal werd geplaatst. Aan deze paal heb ik die wijnkist gehangen waar ik ook een deur voor gemaakt heb.

U kunt zien hoe ik mijn project heb voltooid door naar de foto's te kijken.

Dit is natuurlijk een voorbeeld van hoe je het kunt doen. Je kunt ermee doen wat je wilt.