IoT-weerstation met RPi en ESP8266 - Ajarnpa

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

In eerdere tutorials hebben we met NodeMCU, sensoren gespeeld en geleerd hoe we gegevens kunnen vastleggen en loggen op ThingSpeak (een Internet of Things (IoT)-platform waarmee u sensorgegevens in de cloud kunt verzamelen en opslaan en IoT-toepassingen kunt ontwikkelen):

IOT GEMAKKELIJK GEMAAKT: OP AFSTAND GEGEVENS VASTLEGGEN: UV- EN LUCHTEMPERATUUR & VOCHTIGHEID

Met deze nieuwe tutorial leren we hoe we hetzelfde kunnen doen, maar in deze tijd, met behulp van een Raspberry Pi om gegevens van verschillende sensoren vast te leggen en ook om verschillende manieren van communicatie tussen apparaten en internet te verkennen:

Sensoren en communicatietype:

• DHT22 (Temperatuur en Vochtigheid) ==> Digitale communicatie
• BMP180 (temperatuur en druk) ==> I2C-protocol
• DS18B20 (Temperatuur) ==> 1-draads protocol

Het blokdiagram laat zien wat we aan het einde van dit project zullen krijgen:

Stap 1: Stuklijst - Stuklijst

1. Raspberry Pi V3 - US$ 32,00
2. DHT22 Temperatuur- en relatieve vochtigheidssensor - USD 9,95
3. Weerstand 4K7 ohm
4. DS18B20 Waterdichte temperatuursensor - USD 5.95
5. Weerstand 4K7 ohm
6. BMP180 Luchtdruk-, temperatuur- en hoogtesensor - USD 6,99

Stap 2: De temperatuur- en vochtigheidssensor installeren

De eerste sensor die wordt geïnstalleerd, is de DHT22 voor het vastleggen van gegevens over luchttemperatuur en relatieve vochtigheid. De ADAFRUIT-site biedt geweldige informatie over die sensoren. Bellow, wat informatie die daar vandaan komt:

Overzicht

De goedkope DHT-temperatuur- en vochtigheidssensoren zijn erg eenvoudig en traag, maar zijn geweldig voor hobbyisten die wat basisgegevens willen loggen. De DHT-sensoren bestaan uit twee delen, een capacitieve vochtigheidssensor en een thermistor. Er zit ook een heel eenvoudige chip in die wat analoog naar digitaal omzet en een digitaal signaal uitspuugt met de temperatuur en vochtigheid. Het digitale signaal is vrij eenvoudig af te lezen met elke microcontroller.

DHT22 Belangrijkste kenmerken:

• Goedkoop
• 3 tot 5V voeding en I/O
• Maximaal 2,5 mA stroomverbruik tijdens conversie (tijdens het opvragen van gegevens)
• Goed voor 0-100% vochtigheidsmetingen met een nauwkeurigheid van 2-5%
• Goed voor temperatuurmetingen van -40 tot 125 °C ±0,5 °C nauwkeurigheid
• Niet meer dan 0,5 Hz bemonsteringsfrequentie (eenmaal per 2 seconden)
• Lichaamsgrootte 15,1 mm x 25 mm x 7,7 mm
• 4 pinnen met een tussenruimte van 0,1 inch

Als u de sensor gewoonlijk gebruikt op afstanden van minder dan 20 m, moet een weerstand van 4K7 ohm worden aangesloten tussen de data- en VCC-pinnen. De DHT22-uitgangsgegevenspin wordt verbonden met Raspberry GPIO 16. Controleer het bovenstaande elektrische schema en sluit de sensor aan op de RPi-pinnen zoals hieronder:

1. Pin 1 - Vcc ==> 3.3V
2. Pin 2 - Gegevens ==> GPIO 16
3. Pin 3 - Niet aansluiten
4. Pin 4 - Gnd ==> Gnd

Vergeet niet om de 4K7 ohm-weerstand tussen Vcc- en datapinnen te installeren

Nadat de sensor is aangesloten, moeten we ook de bibliotheek op onze RPi installeren.

DHT-bibliotheek installeren:

Ga op je Raspberry, beginnend op /home, naar /Documents

cd-documenten

Maak een map om de bibliotheek te installeren en ga daarheen:

mkdir DHT22_Sensor

cd DHT22_Sensor

Ga in je browser naar Adafruit GitHub:

github.com/adafruit/Adafruit_Python_DHT

Download de bibliotheek door op de download-zip-link aan de rechterkant te klikken en pak het archief uit in de recentelijk gemaakte map van uw Raspberry Pi. Ga dan naar de directory van de bibliotheek (submap die automatisch wordt aangemaakt als je het bestand uitpakt) en voer het commando uit:

sudo python3 setup.py installeren

Open een testprogramma (DHT22_test.py) vanuit mijn GITHUB

importeer Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 vochtigheid, temperatuur = Adafruit_DHT.read_retry(DHT22Sensor, DHTpin) als de vochtigheid niet Geen is en de temperatuur niet Geen: print('Temp={0:0.1f}*C Vochtigheid={1:0.1 f}%'.format(temperatuur, vochtigheid)) else: print('Lezen mislukt. Probeer het opnieuw!')

Voer het programma uit met het commando:

python3 DHT22_test.py

Het onderstaande Terminal-afdrukscherm toont het resultaat.

Stap 3: DS18B20 installeren - temperatuursensor

Sensoroverzicht:

We zullen in deze tutorial een waterdichte versie van de DS18B20-sensor gebruiken. Het is erg handig voor afgelegen temperaturen in natte omstandigheden, bijvoorbeeld op een vochtige grond. De sensor is geïsoleerd en kan metingen uitvoeren tot 125oC (Adafrut raadt niet aan om hem boven 100oC te gebruiken vanwege de PVC-kabelmantel).

De DS18B20 is een digitale sensor waardoor hij ook over lange afstanden goed te gebruiken is! Deze 1-draads digitale temperatuursensoren zijn redelijk nauwkeurig (±0,5°C over een groot deel van het bereik) en kunnen tot 12 bits precisie geven van de ingebouwde digitaal-naar-analoogomzetter. Ze werken prima met de NodeMCU met behulp van een enkele digitale pin, en je kunt zelfs meerdere op dezelfde pin aansluiten, elke heeft een unieke 64-bits ID die in de fabriek is ingebrand om ze te onderscheiden.

De sensor werkt van 3,0 tot 5,0V, wat betekent dat hij rechtstreeks kan worden gevoed door de 3,3V die wordt geleverd door een van de Raspberry-pinnen (1 of 17).

De sensor heeft 3 draden:

• Zwart: GND
• Rood: VCC
• Geel: 1-draads gegevens

Hier vindt u de volledige gegevens: DS18B20 Datasheet

Sensorinstallatie:

Volg het bovenstaande schema en maak de aansluitingen:

• Vcc ==> 3.3V
• Gnd ==> Gnd
• Data ==> GPIO 4 (standaard voor bibliotheek)

De Python-bibliotheek installeren:

Laten we vervolgens de Python-bibliotheek installeren die de sensor zal verwerken:

sudo pip3 installeer w1thermsensor

Controleer voordat u het script uitvoert om de sensor te testen of de "1-Wire"-interface is ingeschakeld in uw RPi (zie bovenstaande printscreen)

Vergeet niet uw RPi opnieuw op te starten nadat u de configuratie hebt gewijzigd

Testen van de sensor:

Voor het testen van de sensor kan een eenvoudig pythonscript worden gebruikt:

import tijd

van w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor() while True: temperature = ds18b20Sensor.get_temperature() print("De temperatuur is %s Celsius" % temperatuur) time.sleep(1)

Stap 4: De BMP180. installeren

Sensoroverzicht:

De BMP180 is de opvolger van de BMP085, een nieuwe generatie zeer nauwkeurige digitale druksensoren voor consumententoepassingen. De elektronica met ultralaag vermogen en laagspanning van de BMP180 is geoptimaliseerd voor gebruik in mobiele telefoons, PDA's, GPS-navigatieapparatuur en buitenapparatuur. Met een laag geluidsniveau van slechts 0,25 m bij een snelle conversietijd, biedt de BMP180 superieure prestaties. De I2C-interface zorgt voor eenvoudige systeemintegratie met een microcontroller. De BMP180 is gebaseerd op piëzo-resistieve technologie voor EMC-robuustheid, hoge nauwkeurigheid en lineariteit, evenals stabiliteit op lange termijn.

Het volledige BMP-gegevensblad vindt u hier: BMP180 - Digitale druksensor

Sensorinstallatie:Volg het bovenstaande schema en maak de aansluitingen:

• Vin ==> 3.3V
• GND ==> GND
• SCL ==> GPIO 3
• SDA ==> GPIO 2

I2C-interface inschakelen

Ga naar RPi-configuratie en bevestig dat de I2C-interface is ingeschakeld. Als dit niet het geval is, schakelt u het in en start u de RPi opnieuw op.

De BMP180. gebruiken

Als alles goed is geïnstalleerd en alles goed is aangesloten, ben je nu klaar om je Pi aan te zetten en te zien wat de BMP180 je vertelt over de wereld om je heen.

Het eerste dat u moet doen, is controleren of de Pi uw BMP180 ziet. Probeer het volgende in een terminalvenster:

sudo i2cdetect -y 1

Als het commando werkte, zou je iets soortgelijks moeten zien als het bovenstaande Terminal Printscreen, waaruit blijkt dat de BMP180 op kanaal '77' staat.

De BMP180-bibliotheek installeren:

Maak een map om de bibliotheek te installeren:

mkdir BMP180_Sensorcd BMP180_Sensor

Ga in je browser naar Adafruit GIThub:

github.com/adafruit/Adafruit_Python_BMP

Download de bibliotheek door op de download-zip-link aan de rechterkant te klikken en pak het archief uit in de door Raspberry Pi gemaakte map. Ga dan naar de aangemaakte submap en voer het volgende commando uit in de directory van de bibliotheek:

sudo python3 setup.py installeren

Open je Python IDE en maak een testprogramma en noem het bijvoorbeeld BMP180Test.py

importeer Adafruit_BMP. BMP085 als BMP085sensor = BMP085. BMP085() print('Temp = {0:0.2f} *C'.format(sensor.read_temperature())) print('Druk = {0:0.2f} Pa'. format(sensor.read_pressure())) print('Altitude = {0:0.2f} m'.format(sensor.read_altitude())) print('Sealevel Pressure = {0:0.2f} Pa'.format(sensor.read_sealevel_pressure()))

Voer het testprogramma uit:

python3 BMP180Test.py

Het bovenstaande Terminal-afdrukscherm toont het resultaat.

Merk op dat die druk wordt weergegeven in Pa (Pascals). Zie de volgende stap om beter te begrijpen over dit apparaat.

Stap 5: Weer en hoogte meten met BMP180

Laten we de tijd nemen om wat meer te begrijpen over wat we zullen krijgen, met de BMP-metingen. Je kunt dit deel van de tutorial overslaan of later terugkomen.

Als je meer wilt weten over sensormetingen, ga dan naar deze geweldige tutorial:

De BMP180 is ontworpen om de atmosferische druk nauwkeurig te meten. De atmosferische druk varieert met zowel het weer als de hoogte.

Wat is atmosferische druk?

De definitie van atmosferische druk is een kracht die de lucht om je heen op alles uitoefent. Het gewicht van de gassen in de atmosfeer zorgt voor atmosferische druk. Een veelgebruikte drukeenheid is "pond per vierkante inch" of psi. We zullen hier de internationale notatie gebruiken, dat wil zeggen newton per vierkante meter, die pascal (Pa) worden genoemd.

Als je een luchtkolom van 1 cm breed zou nemen, zou je ongeveer 1 kg wegen

Dit gewicht, dat op de voetafdruk van die kolom drukt, creëert de atmosferische druk die we kunnen meten met sensoren zoals de BMP180. Omdat die cm brede luchtkolom ongeveer 1 kg weegt, volgt hieruit dat de gemiddelde druk op zeeniveau ongeveer 101325 pascal is, of beter, 1013,25 hPa (1 hPa is ook bekend als milibar - mbar). Dit zal ongeveer 4% dalen voor elke 300 meter die je stijgt. Hoe hoger je komt, hoe minder druk je zult zien, omdat de kolom naar de top van de atmosfeer veel korter is en dus minder weegt. Dit is handig om te weten, want door de druk te meten en wat rekenwerk te doen, kun je je hoogte bepalen.

De luchtdruk op 3.810 meter is slechts de helft van die op zeeniveau.

De BMP180 geeft de absolute druk weer in pascal (Pa). Eén pascal is een zeer kleine hoeveelheid druk, ongeveer de hoeveelheid die een vel papier zal uitoefenen als het op een tafel ligt. U zult vaker metingen in hectopascals zien (1 hPa = 100 Pa). De bibliotheek die hier wordt gebruikt, levert drijvende-kommawaarden in hPa, die toevallig ook gelijk zijn aan één millibar (mbar).

Hier zijn enkele conversies naar andere drukeenheden:

• 1 hPa = 100 Pa = 1 mbar = 0,001 bar
• 1 hPa = 0,75006168 Torr
• 1 hPa = 0,01450377 psi (pond per vierkante inch)
• 1 hPa = 0,02953337 inHg (inch kwik)
• 1 hpa = 0.00098692 atm (standaard atmosferen)

Temperatuureffecten

Omdat temperatuur de dichtheid van een gas beïnvloedt, en dichtheid de massa van een gas beïnvloedt, en massa de druk beïnvloedt (whew), zal de atmosferische druk dramatisch veranderen met de temperatuur. Piloten kennen dit als "dichtheidshoogte", waardoor het gemakkelijker is om op een koude dag op te stijgen dan op een warme dag, omdat de lucht dichter is en een groter aerodynamisch effect heeft. Om de temperatuur te compenseren, bevat de BMP180 een vrij goede temperatuursensor en een druksensor.

Om een drukmeting uit te voeren, voert u eerst een temperatuurmeting uit en combineert u die met een ruwe drukmeting om tot een uiteindelijke temperatuurgecompenseerde drukmeting te komen. (De bibliotheek maakt dit allemaal heel gemakkelijk.)

Absolute druk meten

Als uw toepassing het meten van absolute druk vereist, hoeft u alleen maar een temperatuurmeting te doen en vervolgens een drukmeting uit te voeren (zie de voorbeeldschets voor details). De uiteindelijke drukwaarde is in hPa = mbar. Als je wilt, kun je deze omrekenen naar een andere eenheid met behulp van bovenstaande omrekeningsfactoren.

Merk op dat de absolute druk van de atmosfeer zal variëren met zowel uw hoogte als de huidige weerpatronen, die beide nuttige dingen zijn om te meten.

Weerwaarnemingen

De atmosferische druk op een bepaalde locatie op aarde (of waar dan ook met een atmosfeer) is niet constant. De complexe interactie tussen de rotatie van de aarde, de kanteling van de as en vele andere factoren resulteert in bewegende gebieden met hogere en lagere druk, die op hun beurt de variaties in het weer veroorzaken die we elke dag zien. Door te letten op veranderingen in druk, kunt u veranderingen in het weer op korte termijn voorspellen. Drukverlaging betekent bijvoorbeeld meestal dat er nat weer is of dat er een storm op komst is (er komt een lagedrukgebied aan). Stijgende druk betekent meestal dat er helder weer nadert (er komt een hogedrukgebied doorheen). Maar onthoud dat de atmosferische druk ook varieert met de hoogte. De absolute druk in mijn huis, Lo Barnechea in Chili (hoogte 950m) zal altijd lager zijn dan de absolute druk in bijvoorbeeld San Francisco (minder dan 2 meter, bijna zeeniveau). Als weerstations alleen hun absolute druk zouden rapporteren, zou het moeilijk zijn om drukmetingen van de ene locatie naar de andere direct te vergelijken (en grootschalige weersvoorspellingen zijn afhankelijk van metingen van zoveel mogelijk stations).

Om dit probleem op te lossen, verwijderen weerstations altijd de effecten van hoogte uit hun gerapporteerde drukmetingen door wiskundig de equivalente vaste druk toe te voegen, zodat het lijkt alsof de meting op zeeniveau is gedaan. Wanneer u dit doet, zal een hogere waarde in San Francisco dan Lo Barnechea altijd het gevolg zijn van weerpatronen en niet van de hoogte.

Om dit te doen, is er een functie in de bibliotheek genaamd zeeniveau(P, A). Dit neemt de absolute druk (P) in hPa en de huidige hoogte van het station (A) in meters, en verwijdert de effecten van de hoogte uit de druk. U kunt de uitvoer van deze functie gebruiken om uw weermetingen direct te vergelijken met andere stations over de hele wereld.

Hoogte bepalen

Aangezien de druk varieert met de hoogte, kunt u een druksensor gebruiken om de hoogte te meten (met enkele kanttekeningen). De gemiddelde druk van de atmosfeer op zeeniveau is 1013,25 hPa (of mbar). Dit zakt naar nul als je naar het vacuüm van de ruimte klimt. Omdat de curve van deze daling goed wordt begrepen, kun je het hoogteverschil tussen twee drukmetingen (p en p0) berekenen met behulp van een specifieke vergelijking.

Als u druk op zeeniveau (1013,25 hPa) gebruikt als de basislijndruk (p0), is de uitvoer van de vergelijking uw huidige hoogte boven zeeniveau. Er is een functie in de bibliotheek met de naam hoogte (P, P0) waarmee u de "berekende hoogte" kunt krijgen.

De bovenstaande uitleg is geëxtraheerd uit de BMP 180 Sparkfun-tutorial.

Stap 6: De complete HW

Stap 7: Gegevens verzenden naar ThingSpeak

Op dit punt hebben we geleerd hoe we de RPi moeten voorbereiden om gegevens van alle 3 sensoren vast te leggen en deze op de terminal af te drukken. Nu is het tijd om te zien hoe die gegevens naar ons IoT-platform, de ThingSpeak, kunnen worden verzonden.

Laten we beginnen!

Ten eerste moet u een account hebben op ThinkSpeak.com

Volg de instructies om een kanaal te maken en noteer uw kanaal-ID en schrijf-API-sleutel

Download het Python-script van mijn GitHub: localData ToTS_v1_EXT.py

Laten we de belangrijkste delen van de code becommentariëren:

Laten we eerst de ThingSpeak-bibliotheek importeren, de WiFi-client definiëren en uw lokale router- en Thinkspeak-referenties definiëren:

import dingenpeak

Er zijn verschillende manieren om met ThingSpeak te communiceren, de eenvoudigste manier zou zijn om de clientbibliotheek te gebruiken voor de thingspeak.com API ontwikkeld door Mikolaj Chwaliz en Keith Ellis.

De bibliotheek kan worden gedownload van https://github.com/mchwalisz/thingspeak of PIP op terminal gebruiken:

sudo pip3 installeer thingspeak

Werk vervolgens in het script de inloggegevens van het ThingSpeak-kanaal bij

chId = 9999999 # Vul in met je kanaal-ID

tsKey='VOER IN MET JE KANAAL SCHRIJFSLEUTEL' tsUrl='https://api.thingspeak.com/update' ts = thingspeak. Channel(chId, tsUrl, tsKey)

Laten we nu de 3 sensoren initialiseren:

# DS18B20 1-draads bibliotheek

van w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor() # Standaard wordt GPIO 4 gebruikt door bibliotheek # DHT22 Bibliotheek import Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 bibliotheek import Adafruit_BMP. BMP085 als BMP085 Bmp0180S.) U moet de werkelijke hoogte bepalen waar uw weerstation zich bevindt, door de globale variabele "altReal" bij te werken. In mijn geval bevindt mijn station zich op 950 m boven de zeespiegel

globaal altReal

altReaal = 950

Eenmaal ingevoerd met de werkelijke hoogte van het station als invoer, kunnen we de absolute druk, druk op zeeniveau, temperatuur en hoogte verkrijgen met behulp van de functie bmp180GetData(hoogte):

def bmp180GetData(hoogte):

temp = bmp180Sensor.read_temperature() pres = bmp180Sensor.read_pressure() alt=bmp180Sensor.read_altitude() presSeaLevel = pres / pow(1.0 - hoogte/44330.0, 5.255) temp = rond (temp, 1) pres = rond (druk/100, 2) # absolute druk in hPa (of mbar) alt=rond (alt) presSeaLevel = rond (presSeaLevel/100, 2) # absolute druk in hPa (of mbar) retourtemp, pres, alt, presSeaLevel

De functie getLocalData(), retourneert alle lokale gegevens die door ons station zijn vastgelegd:

def getLocalData():

global timeString global humLab global tempExt global tempLab global presSL global altLab global presAbs # Tijd van lezen nu ophalen = datetime.datetime.now() timeString = now.strftime("%Y-%m-%d %H:%M") # Lees buitentemperatuur (1 meter afstand) tempExt = round(ds18b20Sensor.get_temperature(), 1) tempLab, presAbs, altLab, presSL = bmp180GetData(altReal) humDHT, tempDHT = Adafruit_DHT.read_retry(DHT22Sensor, DHTpin) als humDHT niet is Geen en tempDHT is niet Geen: humLab = rond (humDHT

Zodra u alle gegevens hebt vastgelegd door bovenstaande functies, moet u ze naar ThingSpeak sturen. Je doet het met de functie sendDataTs():

def sendDataTs():

data = { "field1": tempLab, "field2": tempExt, "field3": humLab, "field4": presSL, "field5": altLab } ts.update(data) print ("[INFO] Gegevens verzonden voor 5 velden: ", tempLab, tempExt, humLab, pressSL, altLab)

Nadat je kanaalgegevens zijn bijgewerkt, sla je het script op en voer je het uit op je terminal:

sudo Python3 localData_ToTs_v1_EXT.py

Over communicatieprotocollen

Merk op dat met behulp van de "thingspeak-bibliotheek", de "requests-bibliotheek" wordt geïmporteerd, dat wil zeggen een door Apache2 gelicentieerde HTTP-bibliotheek, geschreven in Python. De officiële Request Installation-documentatie is hier te vinden:

docs.python-requests.org/en/latest/user/install/

Indien nodig kunt u, voordat u uw script uitvoert, controleren of de aanvraagbibliotheek is geïnstalleerd:

sudo pip3 installatieverzoeken

Optioneel kunt u MTTQ gebruiken als een methode om gegevens naar ThingSpeak te verzenden. MQTT is ooit anders dan HTTP. Het is specifiek ontworpen om lichtgewicht te zijn en bedoeld voor embedded apparaten met weinig RAM en CPU-prestaties. Bovendien gebruikt MQTT in de meeste gevallen minder bandbreedte.

Raadpleeg deze tutorial: Update een ThingSpeak-kanaal met MQTT op een Raspberry Pi voor meer details.

Stap 8: Externe gegevens naar ThingSpeak verzenden met ESP8266

Voor deze stap gebruiken we dezelfde HW die werd uitgelegd in de tutorial:

IOT GEMAKKELIJK GEMAAKT: OP AFSTAND GEGEVENS VASTLEGGEN: UV- EN LUCHTEMPERATUUR & VOCHTIGHEID

De code die we hier zullen gebruiken, is in principe dezelfde als die in die tutorial. Laten we de belangrijkste delen van de code becommentariëren:

Laten we eerst de ESP8266-bibliotheek bellen, de WiFi-client definiëren en uw lokale router- en Thinkspeak-referenties definiëren:

/* NodeMCU ESP12-E */

#include WiFiClient-client; const char* MY_SSID = "VOER IN MET UW SSDID"; const char* MY_PWD = "VOER UW WACHTWOORD IN"; /* Thinkspeak */ const char* TS_SERVER = "api.thingspeak.com"; String TS_API_KEY ="VOER IN MET UW SCHRIJFSLEUTEL";

Ten tweede, laten we een zeer belangrijke bibliotheek voor IoT-projecten toevoegen: SimpleTimer.h:

/* TIMER */

#include SimpleTimer-timer;

Ten derde zullen we tijdens setup() seriële communicatie starten, de functie connectWiFi() aanroepen en de timers definiëren. Merk op dat de regel code: timer.setInterval(60000L, sendDataTS); zal elke 60 seconden de functie sendDataTS() aanroepen om gegevens naar het ThinkSpeak-kanaal te uploaden.

ongeldige setup()

{ … Serieel.begin(115200); vertraging(10); … verbindenWifi(); timer.setInterval(60000L, sendDataTS); … }

Ten slotte, tijdens de loop(), is het enige commando dat nodig is om de timer te starten en dat is alles!

lege lus()

{ … timer.run(); // Start SimpleTimer }

Hieronder ziet u de twee belangrijke functies die worden gebruikt om Thinkspeak-communicatie af te handelen:

ESP12-E verbinding met uw wifi-netwerk:

/***************************************************

* Wifi aansluiten ********************************************** ***/ void connectWifi() { Serial.print("Verbinding maken met "+ *MY_SSID); WiFi.begin(MY_SSID, MY_PWD); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serieel.print("."); } Serieel.println(""); Serial.println("WiFi Verbonden"); Serieel.println(""); }

ESP12-E verzendt gegevens naar ThinkSpeak:

***************************************************

* Gegevens verzenden naar Thinkspeak Channel ******************************************** ******/ void sendDataTS(void) {if (client.connect(TS_SERVER, 80)) { String postStr = TS_API_KEY; postStr += "&field6="; postStr += String (temp); postStr += "&field7="; postStr += String (brom); postStr += "&field8="; postStr += String (dataSensorUV); postStr += "\r\n\r\n"; client.print("POST /update HTTP/1.1\n"); client.print("Host: api.thingspeak.com\n"); client.print("Verbinding: sluiten\n"); client.print("X-THINGSPEAKAPIKEY: " + TS_API_KEY + "\n"); client.print("Inhoudstype: applicatie/x-www-form-urlencoded\n"); client.print ("Inhoudslengte: "); client.print(postStr.length()); cliënt.print("\n\n"); cliënt.print(postStr); vertraging (1000); } verzonden++; klant.stop(); }

De volledige code is te vinden op mijn GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Zodra je de code hebt geüpload naar je NodeMCU. Laten we een externe batterij aansluiten en wat metingen doen onder de zon. Ik plaats het Remote Station op het dak en begin met het vastleggen van gegevens op ThingSpeak.com, zoals te zien is op bovenstaande foto's.

Stap 9: Laatste opmerkingen

Het belangrijkste doel van deze tutorial was om te laten zien hoe je de Raspberry Pi op ThingSpeak kunt aansluiten. Dit is geweldig om gegevens vast te leggen en te loggen op een IoT-platform.

We hebben van de gelegenheid gebruik gemaakt om ook gegevens naar dat specifieke kanaal te sturen en ze vast te leggen vanaf een extern station met behulp van een ESP8266. Deze benadering is OK, maar niet de beste. Omdat we een "asynchrone" bewerking hebben, proberen zowel RPi als ESP8266 soms tegelijkertijd (of met een klein interval) te loggen wat wordt weerlegd door ThingSpeak. Het ideaal zou zijn dat de ESP8266 gegevens lokaal naar de Raspberry Pi verzendt en dat de laatste verantwoordelijk is voor het verwerken van alle gegevens. Door dat te doen, zou het "Hoofdstation" (Raspberry Pi) 3 dingen kunnen doen:

• Log alle gegevens in een lokale database
• Presenteer alle gegevens op een lokale webpagina (met Flask zoals weergegeven in de bovenstaande foto)
• Alle gegevens tegelijkertijd naar ThingSpeak verzenden.

In een toekomstige zelfstudie zullen we die opties onderzoeken.

Stap 10: Conclusie

Zoals altijd hoop ik dat dit project anderen kan helpen hun weg te vinden in de opwindende wereld van elektronica!

Ga voor meer informatie en de definitieve code naar mijn GitHub-opslagplaats: RPi-NodeMCU-Weather-Station

Ga voor meer projecten naar mijn blog: MJRoBot.org

Blijf kijken! Volgende tutorial zullen we gegevens van een extern weerstation naar een centraal weerstation sturen, gebaseerd op een Raspberry Pi-webserver:

Saludos uit het zuiden van de wereld!

Tot ziens in mijn volgende instructable!

Bedankt, Marcelo