Ik vond op Marktplaats een anemometer of windsnelheidsmeter voor een bedrag van 5 euro. Ik had de indruk dat de verkoper niet wist wat 'ie ermee moest. Dus direct de vraagprijs geboden en hup, twee dagen later had ik het pakket op de stoep. Eigenlijk wist ik niet goed wat ik gekocht had...
Het eerste dat ik deed na het ontvangen van de windmeter is het internet op gaan om te kijken wat ik gekocht had. Er blijken nogal verschillende modellen en types te zijn. De prijs van een redelijk goede anemometer begint rond de 40-50 euro. Ik blijk de aller goedkoopste te hebben, van kunststof en het signaal komt van een reedcontact dat gesloten wordt als het magneet, dat aan de draai-as bevestigd is, er langs komt. Eigenlijk is het dus een ‘domme’ schakelaar die in één omwenteling twee keer schakelt.
De uitdaging
Het probleem was een goed python script te bouwen waarmee je binnen een vastgestelde tijd het aantal pulsen telt en dit omrekent naar windsnelheid (m/sec). Op een forum vond ik een basisscript. Deze heb ik verbouwd tot wat het nu is.
Daar gaan we!
Aansluitschema
De anemometer aansluiten is eenvoudig. Je sluit ‘m aan als een drukknop. Een van beide draden wordt op de 3,3V aangesloten, de andere draad loopt naar GPIO21 (= pin 40). Tussen pin 40 en een willekeurige ground (GND) wordt een pull-down weerstand (10kOhm) geplaatst.
Doet ‘ie het wel?
Omdat de windmeter zo goedkoop was twijfelde ik of de windmeter het wel zou doen. Om ‘m te testen heb ik een pulsteller gebouwd. Als je zeker wil zijn dat je windmeter het doet, open je nano en plak onderstaand script er in.
nano windmeter_test.py
Het script doet niets anders dan op GPIO21 luisteren of er pulsen binnen komen. Je moet de windmeter wel even in beweging zetten om resultaat te hebben.
#!/usr/bin/python
import RPi.GPIO as GPIO
import subprocess as sp
import time
# GPIO21 = pin 40
wind=21
GPIO.setmode(GPIO.BCM)
GPIO.setup(wind, GPIO.IN, pull_up_down=GPIO.PUD_UP)
# Wis scherm
tmp = sp.call('clear',shell=True)
print ("\033[1;32m")
print ("Windsnelheidsmeter test")
print ("=======================")
print ("\nDraai de windmeter\n")
print ("Stop dit programma met CTRL-c\n\033[1;m")
while True:
input_state = GPIO.input(wind)
if input_state == False:
print('De windmeter draait!')
time.sleep(0.2)Je start het script met:
python windmeter_test.py
Nu we weten dat de windmeter het doet, kunnen we verder.
Kern van de code
Het belangrijkste doel van de software is dat binnen een vastgestelde tijd het aantal pulsen gemeten wordt dat de anemometer afgeeft. Ik hanteer in deze tutorial een tijdsduur van 10 seconden. Later wordt dit naar 10 minuten omgezet omdat de gemiddelde windsnelheid per 10 minuten wordt bepaald door alle pulsen over tien minuten te tellen en die snelheid te berekenen.
Omrekenen naar moderne waarden
Uiteindelijk wil ik dat het script de afgegeven pulsen omrekent naar km/uur, Beaufort, knopen, enz. Daarna zou je er een grafiek van kunnen maken.
Windsnelheid berekenen
De anemometer produceert 2 pulsen per omwenteling, dus je kunt het aantal volledige rotaties van de sensor tellen door het aantal gedetecteerde inputs (pulsen) te delen door 2. Dit getal kan vervolgens worden gebruikt om de windsnelheid te berekenen:
snelheid = afstand / tijd
Om snelheid te berekenen, moet je de afgelegde afstand in een bepaalde tijd weten. Het meten van tijd is vrij eenvoudig en je kunt het aantal signalen tellen gedurende een vaste tijdsperiode, bijvoorbeeld tien seconden.
De afstand die een van de bekers (= die halve pingpongbal op de windmeter) aflegt, is gelijk aan het aantal rotaties vermenigvuldigd met de afstand rond de rand van de cirkel (omtrek):
snelheid = (rotaties * omtrek) / tijd
De omtrek kan worden berekend als je de straal of de diameter van de cirkel kent.
Je kunt de straal van de cirkel die de anemometer maakt, ontdekken door de afstand van het as-midden tot de rand van een van de cups te meten. Zodra je de straal weet, kan je de omtrek vinden met de formule 2 x pi x straal . Vergeet niet dat een hele rotatie twee signalen genereert, dus u moet het aantal gedetecteerde signalen halveren:
snelheid = ( (pulsen/2) * (2 * pi * straal) ) / tijd
De straal voor de anemometer die in dit project gebruikt wordt is 9,0 cm en dat is de waarde die in de volgende rekencode wordt gebruikt. Vergeet niet deze waarde te wijzigen als jouw anemometer andere afmetingen heeft!
Op basis van deze waarden kun je een script (windsnelheid.py) maken om de windsnelheid te berekenen.
import math # Om pi (π) te gebruiken in de berekening
diameter_cm = 9.0
interval = 5
pulsen = 17
print ("De straal van de anemometer is",diameter_cm,"cm")
print ("Aantal gemeten pulsen",pulsen)
print ("Meettijd",interval,"seconden")
omtrek_cm = (2 * math.pi) * diameter_cm
rotaties = pulsen / 2.0
afstand_cm = omtrek_cm * rotaties
speed = afstand_cm / interval
print ("De windsnelheid is",round(speed,2),"cm/sec")
Het resultaat
Op basis van de ingevoerde waarden heeft het script berekend dat de windsnelheid 96,13 cm/sec is.
Omrekenen naar eenheden
Voor degene die het uiteindelijke script wil voorzien van de standaard waarden die in de meteorologie gebruikt worden, heb ik hieronder de berekeningen voor de variabelen geplaatst. Ik merk dat ik er nog een keer naar moet kijken, want ze lijken niet helemaal nauwkeurig te zijn.
- Pulsen per seconde = Totaal gemeten pulsen / meettijd (sec)
- Omwenteling per seconde = pulsen per sec / 2
- Meters per seconde = (2 * 3.142) * (0.09 * pulsen per seconde)
- kmh = meters per seconde * 3.6
- mph = kmh / 1.609344
- beaufort = (mph + 6) / 6
- knopen (knots) = mph * 0.86897624190816
In de definitieve code hieronder heb ik de betreffende eenheden verwerkt.
De code (N24FR_v1.py)
'''
De gemiddelde windsnelheid per 10 minuten wordt bepaald door alle pulsen over tien minuten te tellen en die snelheid te rapporteren.
Windmeter, type N24FR
---------------------
Windmeter heeft een straal van 9 cm
De omtrek is dan: 9cm x PI = 28,27 cm
'''
import RPi.GPIO as GPIO
import datetime
import time
WindCount = 0
Wind_PIN = 21 # GPIO21 = pin40
GPIO.setmode(GPIO.BCM)
GPIO.setup(Wind_PIN, GPIO.IN)
##################################################################################
def main():
global WindCount
interval = 600 # meettijd in seconden
try:
GPIO.add_event_detect(Wind_PIN, GPIO.RISING, callback=MOTION, bouncetime=1)
time.sleep(interval)
print ("\033c")
print ("\033[1;37;40m") # helderwitte kleur
print ("Windsnelheidsmeting")
print ("===================")
print ("\033[1;373;33m") # helderwitte kleur
# omrekenen naar eenheden
pulsen = WindCount/interval
omwentelingenperseconde = pulsen/2
metersperseconde = (2 * 3.142) * (0.09 * pulsen)
kmh = metersperseconde * 3.6
mph = kmh / 1.609344
beaufort = (mph + 6) / 6
knots = mph * 0.86897624190816
print ("Aantal pulsen in",interval,"seconden : ",WindCount)
print ("Pulsen per seconde : ",round(pulsen,2))
print ("Omwentelingen per seconde : ",round(omwentelingenperseconde,2))
print ("Meter per seconde : ",round(metersperseconde,2))
print ("Kilometer per uur : ",round(kmh,2))
print ("Miles per uur : ",round(mph,2))
print ("Beaufort : ",round(beaufort,2))
print ("Knopen (knots) : ",round(knots,2))
print ("\n")
GPIO.cleanup()
except KeyboardInterrupt:
print("Gestopt!")
GPIO.cleanup()
##################################################################################
def MOTION(Rain_PIN):
global WindCount
WindCount = WindCount + 1
if __name__ == "__main__":
main()
Het resultaat
Het resultaat is een strakke weergave van de berekeningen van de pulsen die de anemometer heeft afgegeven. In de praktijd wordt er over een periode van zo’n 10 minuten gemeten om de gemiddelde windsnelheid te verkrijgen. Mocht je een andere meetperiode willen instellen, de interval is in het script eenvoudig aan te passen.
Mocht je nog vragen hebben, laat dan een reactie hieronder achter. Veel plezier ermee!
Have A Nice Day!
Laat een reactie achter