IoT vejrstation med RPi og ESP8266: 10 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:28

På tidligere selvstudier har vi leget med NodeMCU, sensorer og lært at fange og logge data på ThingSpeak (en Internet of Things (IoT) platform, der lader dig indsamle og gemme sensordata i skyen og udvikle IoT -applikationer):

IOT GET NEMT: FANGNING AF FJERNVÆRDEDATA: UV- OG LUFTTEMPERATUR & Fugtighed

Med denne nye vejledning lærer vi, hvordan man gør det samme, men på dette tidspunkt ved hjælp af en Raspberry Pi til at fange data fra flere forskellige sensorer og også undersøge forskellige måder at kommunikere mellem enheder og internettet:

Sensorer og kominikationstype:

• DHT22 (temperatur og luftfugtighed) ==> Digital kommunikation
• BMP180 (temperatur og tryk) ==> I2C -protokol
• DS18B20 (temperatur) ==> 1-tråds protokol

Blokdiagrammet viser, hvad vi får til sidst med dette projekt:

Trin 1: BoM - regning af materialer

1. Raspberry Pi V3 - 32,00 US $
2. DHT22 temperatur- og relativ luftfugtighedssensor - USD 9,95
3. Modstand 4K7 ohm
4. DS18B20 Vandtæt temperatursensor - USD 5,95
5. Modstand 4K7 ohm
6. BMP180 barometrisk tryk-, temperatur- og højdesensor - USD 6,99

Trin 2: Installation af temperatur- og fugtighedsføleren

Den første sensor, der skal installeres, er DHT22 til registrering af lufttemperatur- og relativ luftfugtighedsdata. ADAFRUIT -webstedet giver god information om disse sensorer. Herunder, nogle oplysninger hentet derfra:

Oversigt

De billige DHT-temperatur- og fugtighedssensorer er meget grundlæggende og langsomme, men er gode til hobbyfolk, der ønsker at lave nogle grundlæggende datalogninger. DHT -sensorerne er lavet af to dele, en kapacitiv fugtighedsføler og en termistor. Der er også en meget grundlæggende chip indeni, der laver noget analog til digital konvertering og spytter et digitalt signal ud med temperatur og fugtighed. Det digitale signal er ret let at læse ved hjælp af enhver mikrokontroller.

DHT22 Hovedkarakteristika:

• Lavpris
• 3 til 5V strøm og I/O
• 2,5mA maks. Nuværende brug under konvertering (mens der anmodes om data)
• God til 0-100% luftfugtighedsmålinger med 2-5% nøjagtighed
• God til -40 til 125 ° C temperaturmålinger ± 0,5 ° C nøjagtighed
• Ikke mere end 0,5 Hz samplingshastighed (en gang hvert 2. sekund)
• Kropsstørrelse 15,1 mm x 25 mm x 7,7 mm
• 4 ben med 0,1 "afstand

Når du normalt bruger sensoren på afstande mindre end 20 m, skal en 4K7 ohm modstand tilsluttes mellem data og VCC -ben. DHT22 -udgangsdatastiften tilsluttes Raspberry GPIO 16. Kontroller ovenstående elektriske diagram, der forbinder sensoren med RPi -benene som nedenfor:

1. Pin 1 - Vcc ==> 3,3V
2. Pin 2 - Data ==> GPIO 16
3. Pin 3 - Ikke tilsluttet
4. Pin 4 - Gnd ==> Gnd

Glem ikke at installere 4K7 ohm modstanden mellem Vcc og Data pins

Når sensoren er tilsluttet, skal vi også installere sit bibliotek på vores RPi.

Installation af DHT -bibliotek:

På din Hindbær, start på /hjem, gå til /Dokumenter

cd Dokumenter

Opret et bibliotek for at installere biblioteket og gå derhen:

mkdir DHT22_Sensor

cd DHT22_Sensor

Gå til Adafruit GitHub i din browser:

github.com/adafruit/Adafruit_Python_DHT

Download biblioteket ved at klikke på download -zip -linket til højre, og pak arkivet ud på din Raspberry Pi -nyligt oprettede mappe. Gå derefter til bibliotekets bibliotek (undermappe, der automatisk oprettes, når du pakker filen ud), og udfør kommandoen:

sudo python3 setup.py installation

Åbn et testprogram (DHT22_test.py) fra min GITHUB

importer Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 fugtighed, temperatur = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin) hvis luftfugtighed ikke er Ingen og temperaturen ikke Ingen: print ('Temp = {0: 0.1f}*C Fugtighed = {1: 0.1 f}%'. format (temperatur, luftfugtighed)) else: print (' Det lykkedes ikke at læse. Prøv igen! ')

Udfør programmet med kommandoen:

python3 DHT22_test.py

Nedenstående terminaludskrivningsskærm viser resultatet.

Trin 3: Installation af DS18B20 - Temperatursensor

Sensoroversigt:

Vi vil i denne vejledning bruge en vandtæt version af DS18B20 -sensoren. Det er meget nyttigt til fjern temperatur i våde forhold, for eksempel på en fugtig jord. Sensoren er isoleret og kan foretage målinger indtil 125oC (Adafrut anbefaler ikke at bruge den over 100oC på grund af dens kabel -PVC -kappe).

DS18B20 er en digital sensor, der gør det godt at bruge selv over lange afstande! Disse 1-tråds digitale temperatursensorer er ret præcise (± 0,5 ° C over meget af området) og kan give op til 12 bits præcision fra den indbyggede digital-til-analoge omformer. De fungerer godt med NodeMCU ved hjælp af en enkelt digital pin, og du kan endda slutte flere til den samme pin, hver har et unikt 64-bit ID, der er indbrændt på fabrikken for at differentiere dem.

Sensoren fungerer fra 3,0 til 5,0V, hvilket betyder, at den kan drives direkte fra den 3,3V, der leveres af en af Raspberry pins (1 eller 17).

Sensoren har 3 ledninger:

• Sort: GND
• Rød: VCC
• Gul: 1-tråds data

Her kan du finde de fulde data: DS18B20 Datablad

Sensorinstallation:

Følg ovenstående diagram og lav forbindelserne:

• Vcc ==> 3,3V
• Gnd ==> Gnd
• Data ==> GPIO 4 (standard for bibliotek)

Installation af Python -biblioteket:

Lad os derefter installere Python -biblioteket, der håndterer sensoren:

sudo pip3 installer w1thermsensor

Inden du kører scriptet for at teste sensoren, skal du kontrollere, om "1-Wire" -grænsefladen er aktiveret i din RPi (se ovenfor udskrivningsskærm)

Glem ikke at genstarte din RPi, efter at du har ændret dens konfiguration

Test af sensoren:

Til test af sensoren kan der bruges et simpelt python -script:

importtid

fra w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor () mens True: temperatur = ds18b20Sensor.get_temperature () print ("Temperaturen er % s celsius" % temperatur) time.sleep (1)

Trin 4: Installation af BMP180

Sensoroversigt:

BMP180 er efterfølgeren til BMP085, en ny generation af højpræcise digitale trykfølere til forbrugerapplikationer. BMP180's ultra-lave strøm, lavspændingselektronik er optimeret til brug i mobiltelefoner, PDA'er, GPS-navigationsenheder og udendørs udstyr. Med en lav støj på kun 0,25 m ved hurtig konverteringstid tilbyder BMP180 overlegen ydeevne. I2C -grænsefladen giver mulighed for let systemintegration med en mikrokontroller. BMP180 er baseret på piezo-resistiv teknologi til EMC-robusthed, høj nøjagtighed og linearitet samt langsigtet stabilitet.

Det komplette BMP -datablad kan findes her: BMP180 - Digital tryksensor

Sensorinstallation: Følg ovenstående diagram og foretag tilslutningerne:

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

Aktivering af I2C -interface

Gå til RPi -konfiguration, og bekræft, at I2C -grænsefladen er aktiveret. Hvis ikke, skal du aktivere det og genstarte RPi'en.

Brug af BMP180

Hvis alt er installeret okay, og alt er blevet forbundet ok, er du nu klar til at tænde din Pi og begynde at se, hvad BMP180 fortæller dig om verden omkring dig.

Den første ting at gøre er at kontrollere, om Pi ser din BMP180. Prøv følgende i et terminalvindue:

sudo i2cdetect -y 1

Hvis kommandoen fungerede, skulle du se noget lignende ovenstående Terminal Printscreen, der viser, at BMP180 er på kanal '77'.

Installation af BMP180 -biblioteket:

Opret et bibliotek for at installere biblioteket:

mkdir BMP180_Sensorcd BMP180_Sensor

Gå til Adafruit GITHub i din browser:

github.com/adafruit/Adafruit_Python_BMP

Download biblioteket ved at klikke på download -zip -linket til højre, og pak arkivet ud på din Raspberry Pi -oprettede mappe. Gå derefter til den oprettede undermappe og udfør følgende kommando i bibliotekets bibliotek:

sudo python3 setup.py installation

Åbn din Python IDE, og opret et testprogram og navngiv det, for eksempel BMP180Test.py

import Adafruit_BMP. BMP085 som BMP085sensor = BMP085. BMP085 () print ('Temp = {0: 0.2f} *C'.format (sensor.read_temperature ())) print (' Tryk = {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 ()))

Udfør testprogrammet:

python3 BMP180Test.py

Ovenstående terminaludskrivningsskærm viser resultatet.

Bemærk, at dette tryk er angivet i Pa (Pascal). Se næste trin for bedre at forstå denne enhed.

Trin 5: Måling af vejr og højde med BMP180

Lad os tage lidt tid til at forstå lidt mere om, hvad vi får med BMP -aflæsninger. Du kan springe denne del af selvstudiet over eller vende tilbage senere.

Hvis du vil vide mere om sensoraflæsninger, kan du gå til denne gode vejledning:

BMP180 blev designet til nøjagtigt at måle atmosfærisk tryk. Atmosfærisk tryk varierer med både vejr og højde.

Hvad er atmosfærisk tryk?

Definitionen af atmosfærisk tryk er en kraft, som luften omkring dig udøver på alt. Vægten af gasser i atmosfæren skaber atmosfærisk tryk. En fælles enhed for tryk er "pounds per square inch" eller psi. Vi vil her bruge den internationale notation, det vil sige newton pr. Kvadratmeter, som kaldes pascal (Pa).

Hvis du tog 1 cm bred luftsøjle, ville den veje ca. 1 kg

Denne vægt, der trykker ned på fodsporet af den søjle, skaber det atmosfæriske tryk, som vi kan måle med sensorer som BMP180. Fordi den cm brede luftsøjle vejer cirka 1 kg, følger det, at det gennemsnitlige havtryk er omkring 101325 pascal eller bedre, 1013,25 hPa (1 hPa er også kendt som milibar - mbar). Dette vil falde omkring 4% for hver 300 meter, du stiger op. Jo højere du kommer, jo mindre tryk ser du, fordi søjlen til toppen af atmosfæren er så meget kortere og vejer derfor mindre. Dette er nyttigt at vide, for ved at måle trykket og lave noget matematik kan du bestemme din højde.

Lufttrykket ved 3, 810 meter er kun halvdelen af det ved havets overflade.

BMP180 udsender absolut tryk i pascal (Pa). Én pascal er en meget lille mængde tryk, omtrent den mængde, som et ark papir vil udøve på et bord. Du vil oftere se målinger i hektopascal (1 hPa = 100 Pa). Biblioteket, der bruges her, giver output floating-point værdier i hPa, hvilket også tilfældigvis svarer til en millibar (mbar).

Her er nogle konverteringer til andre trykenheder:

• 1 hPa = 100 Pa = 1 mbar = 0,001 bar
• 1 hPa = 0,75006168 Torr
• 1 hPa = 0,01450377 psi (pounds per square inch)
• 1 hPa = 0,02953337 inHg (tommer kviksølv)
• 1 hpa = 0,00098692 atm (standardatmosfære)

Temperatureffekter

Fordi temperaturen påvirker densiteten af en gas, og densiteten påvirker massen af en gas, og massen påvirker trykket (whew), vil atmosfærisk tryk ændre sig dramatisk med temperaturen. Piloter kender dette som "densitetshøjde", hvilket gør det lettere at tage af på en kold dag end en varm, fordi luften er tættere og har en større aerodynamisk effekt. For at kompensere for temperaturen indeholder BMP180 en temmelig god temperatursensor samt en trykføler.

For at udføre en trykaflæsning tager du først en temperaturmåling og derefter kombinerer den med en rå trykaflæsning for at komme frem til en endelig temperaturkompenseret trykmåling. (Biblioteket gør alt dette meget let.)

Måling af absolut tryk

Hvis din applikation kræver måling af absolut tryk, er alt du skal gøre at få en temperaturmåling og derefter udføre en trykaflæsning (se eksempelskitsen for detaljer). Den sidste trykaflæsning vil være i hPa = mbar. Hvis du ønsker det, kan du konvertere dette til en anden enhed ved hjælp af ovenstående konverteringsfaktorer.

Bemærk, at atmosfærens absolutte tryk vil variere med både din højde og de aktuelle vejrmønstre, som begge er nyttige ting at måle.

Vejrobservationer

Atmosfærisk tryk på et givet sted på jorden (eller hvor som helst med en atmosfære) er ikke konstant. Det komplekse samspil mellem jordens spin, aksehældning og mange andre faktorer resulterer i bevægelige områder med højere og lavere tryk, hvilket igen forårsager de variationer i vejret, vi ser hver dag. Ved at se efter ændringer i trykket kan du forudsige kortsigtede ændringer i vejret. For eksempel betyder faldende tryk normalt, at vådt vejr eller en storm nærmer sig (et lavtrykssystem bevæger sig ind). Stigende tryk betyder normalt, at klart vejr nærmer sig (et højtrykssystem bevæger sig igennem). Men husk, at atmosfærisk tryk også varierer med højden. Det absolutte tryk i mit hus, Lo Barnechea i Chile (højde 950m) vil altid være lavere end det absolutte tryk i f.eks. San Francisco (mindre end 2 meter, næsten havniveau). Hvis vejrstationer bare rapporterede deres absolutte tryk, ville det være svært at direkte sammenligne trykmålinger fra et sted til et andet (og store vejrforudsigelser afhænger af målinger fra så mange stationer som muligt).

For at løse dette problem fjerner vejrstationer altid højdeeffekter fra deres rapporterede trykaflæsninger ved matematisk at tilføje det tilsvarende faste tryk for at få det til at se ud som om aflæsningen blev foretaget ved havets overflade. Når du gør dette, vil en højere læsning i San Francisco end Lo Barnechea altid være på grund af vejrmønstre og ikke på grund af højde.

For at gøre dette er der en funktion i biblioteket kaldet havniveau (P, A). Dette tager det absolutte tryk (P) i hPa og stationens nuværende højde (A) i meter og fjerner højdeeffekterne fra trykket. Du kan bruge output fra denne funktion til direkte at sammenligne dine vejrmålinger med andre stationer rundt om i verden.

Bestemmelse af højde

Da trykket varierer med højden, kan du bruge en trykføler til at måle højde (med et par forbehold). Det gennemsnitlige tryk af atmosfæren ved havets overflade er 1013,25 hPa (eller mbar). Dette falder til nul, når du klatrer mod rumets vakuum. Fordi kurven for dette drop-off er godt forstået, kan du beregne højdeforskellen mellem to trykmålinger (p og p0) ved hjælp af en specifik ligning.

Hvis du bruger havniveautryk (1013,25 hPa) som grundlinjetryk (p0), vil output fra ligningen være din nuværende højde over havets overflade. Der er en funktion i biblioteket kaldet højde (P, P0), der lader dig få den "beregnede højde".

Ovenstående forklaring blev ekstraheret fra BMP 180 Sparkfun tutorial.

Trin 6: Den komplette HW

Trin 7: Send data til ThingSpeak

På dette tidspunkt lærte vi, hvordan vi forbereder RPi'en til at fange data fra alle 3 sensorer og udskrive dem på terminalen. Nu er det tid til at se, hvordan man sender disse data til en IoT -platform, ThingSpeak.

Lad os begynde!

Først skal du have en konto på ThinkSpeak.com

Følg instruktionerne for at oprette en kanal og notere dit kanal -id og skrive API -nøgle

Download Python -scriptet fra mit GitHub: localData ToTS_v1_EXT.py

Lad os kommentere de vigtigste dele af koden:

Lad os først importere ThingSpeak -biblioteket, definere WiFi -klienten og definere din lokale router og Thinkspeak -legitimationsoplysninger:

importer tingene

Der er flere måder at kommunikere med ThingSpeak, den enkleste måde ville være at bruge klientbiblioteket til thingspeak.com API udviklet af Mikolaj Chwaliz og Keith Ellis.

Biblioteket kan downloades fra https://github.com/mchwalisz/thingspeak eller bruges PIP på terminal:

sudo pip3 installer thingspeak

Opdater derefter inde i scriptet ThingSpeak -kanaloplysninger

chId = 9999999 # Gå ind med dit kanal -id

tsKey = 'ENTER WITH DIN CHANNEL WRITE KEY' tsUrl = 'https://api.thingspeak.com/update' ts = thingspeak. Channel (chId, tsUrl, tsKey)

Lad os nu initialisere de 3 sensorer:

# DS18B20 1-Wire bibliotek

fra w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor () # Som standard bruges GPIO 4 af biblioteket # DHT22 Bibliotek import Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 bibliotek import Adafruit_BMP1B85. PMP0 Du bør definere den reelle højde, hvor din vejrstation er placeret, og opdatere den globale variabel "altReal". I mit tilfælde er min Station placeret 950m over havets overflade

global altReal

altReal = 950

Når vi er kommet ind med stationens reelle højde som input, kan vi opnå det absolutte tryk, havets tryk, temperatur og højde ved hjælp af funktionen bmp180GetData (altitude):

def bmp180GetData (højde):

temp = bmp180Sensor.read_temperature () pres = bmp180Sensor.read_pressure () alt=bmp180Sensor.read_altitude () presSeaLevel = pres/pow (1.0 - altitude/44330.0, 5.255) temp = round (temp, 1) pres = round (pres/100), 2) # absolut tryk i hPa (eller mbar) alt=rund (alt) presSeaLevel = rund (presSeaLevel/100, 2) # absolut tryk i hPa (eller mbar) returtemp, pres, alt, presSeaLevel

Funktionen getLocalData (), returnerer alle lokale data, der er fanget af vores station:

def getLocalData ():

global timeString global humLab global tempExt global tempLab global presSL global altLab global presAbs # Få tid til at læse nu = datetime.datetime.now () timeString = now.strftime ("%Y-%m-%d%H:%M") # Læs udetemperatur (1 meters afstand) tempExt = runde (ds18b20Sensor.get_temperature (), 1) tempLab, presAbs, altLab, presSL = bmp180GetData (altReal) humDHT, tempDHT = Adafruit_DHT.read_retry (DHT22Sensor Ingen DHTp) og tempDHT er ikke Ingen: humLab = rund (humDHT

Når alle data er fanget af ovenstående funktioner, skal du sende dem til ThingSpeak. Du gør det ved hjælp af funktionen sendDataTs ():

def sendDataTs ():

data = {"field1": tempLab, "field2": tempExt, "field3": humLab, "field4": presSL, "field5": altLab} ts.update (data) print ("[INFO] Data sendt til 5 felter: ", tempLab, tempExt, humLab, presSL, altLab)

Med dine kanaldata opdateret, gem scriptet og udfør det på din terminal:

sudo Python3 localData_ToTs_v1_EXT.py

Om kommunikationsprotokoller

Bemærk, at ved hjælp af "thingspeak -biblioteket" importeres "anmodningsbiblioteket", det vil sige et Apache2 -licenseret HTTP -bibliotek, skrevet i Python. Den officielle anmodningsinstallationsdokumentation findes her:

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

Hvis det er nødvendigt, før du kører dit script, kan du kontrollere, om anmodningsbiblioteket er installeret:

sudo pip3 installationsanmodninger

Eventuelt kan du bruge MTTQ som en metode til at sende data til ThingSpeak. MQTT adskiller sig fra HTTP, engang Den er specielt designet til at være let og beregnet til integrerede enheder med lav RAM og CPU -ydelse. I de fleste tilfælde bruger MQTT også mindre båndbredde.

Se denne vejledning: Opdater en ThingSpeak -kanal ved hjælp af MQTT på en Raspberry Pi for flere detaljer.

Trin 8: Afsendelse af eksterne data til ThingSpeak ved hjælp af ESP8266

Til dette trin vil vi bruge den samme HW, der blev forklaret i muy tutorial:

IOT GET NEMT: FANGNING AF FJERNVÆRDEDATA: UV- OG LUFTTEMPERATUR & Fugtighed

Koden, som vi vil bruge her, er stort set den samme, der blev brugt på denne vejledning. Lad os kommentere de vigtigste dele af koden:

Lad os først ringe til ESP8266 -biblioteket, definere WiFi -klienten og definere din lokale router og Thinkspeak -legitimationsoplysninger:

/ * NodeMCU ESP12-E */

#inklusiv WiFiClient -klient; const char* MY_SSID = "ENTER MED DIN SSDID"; const char* MY_PWD = "ENTER MED DIT KODEORD"; /* Thinkspeak*/ const char* TS_SERVER = "api.thingspeak.com"; String TS_API_KEY = "ENTER MED DIN SKRIFTNøgle";

For det andet, lad os inkludere et meget vigtigt bibliotek til IoT -projekter: SimpleTimer.h:

/ * TIMER */

#inkludere SimpleTimer timer;

For det tredje vil vi under opsætningen () starte seriel kommunikation, kalde funktionen connectWiFi () og definere timerne. Bemærk, at kodelinjen: timer.setInterval (60000L, sendDataTS); kalder funktionen sendDataTS () hvert 60. sekund for at uploade data til ThinkSpeak -kanalen.

ugyldig opsætning ()

{… Serial.begin (115200); forsinkelse (10); … connectWifi (); timer.setInterval (60000L, sendDataTS); …}

Til sidst men ikke mindst, under loop (), er den eneste kommando, der er nødvendig, at starte timeren og det er det!

hulrum ()

{… Timer.run (); // Starter SimpleTimer}

Nedenfor kan du se de to vigtige funktioner, der bruges til at håndtere Thinkspeak -kommunikation:

ESP12-E-forbindelse til dit WiFi-netværk:

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

*Tilslutning af WiFi *********************************************** ***/ void connectWifi () {Serial.print ("Opretter forbindelse til"+*MY_SSID); WiFi. Begyndt (MY_SSID, MY_PWD); mens (WiFi.status ()! = WL_CONNECTED) {forsinkelse (1000); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi -forbindelse"); Serial.println (""); }

ESP12-E sender data til ThinkSpeak:

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

*Sender data til 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 (hum); postStr += "& field8 ="; postStr += String (dataSensorUV); postStr += "\ r / n / r / n"; client.print ("POST /opdater HTTP /1.1 / n"); client.print ("Host: api.thingspeak.com / n"); client.print ("Forbindelse: tæt / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("Indholdstype: application/x-www-form-urlencoded / n"); client.print ("Indholdslængde:"); client.print (postStr.length ()); client.print ("\ n / n"); client.print (postStr); forsinkelse (1000); } sendt ++; client.stop (); }

Den komplette kode findes på min GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Når du har uploadet koden til din NodeMCU. Lad os tilslutte et eksternt batteri og foretage nogle målinger under solen. Jeg satte fjernstationen på taget og begyndte at fange data på ThingSpeak.com som vist på ovenstående fotos.

Trin 9: Endelige noter

Hovedformålet med denne vejledning var at vise, hvordan du forbinder Raspberry Pi til ThingSpeak. Det er fantastisk at fange data og logge dem på en IoT -platform.

Ved hjælp af lejligheden sendte vi også data til den specifikke kanal og hentede dem fra en fjernstation ved hjælp af en ESP8266. Denne tilgang er OK, men ikke den bedste. Fordi vi har en "asynkron" operation, forsøger nogle gange både RPi og ESP8266 at logge på samme tid (eller med et lille interval), hvad der tilbagevises af ThingSpeak. Det ideelle ville have, at ESP8266 sender data lokalt til Raspberry Pi, og den sidste er ansvarlig for at håndtere alle data. Hvis du gør det, kan "Main Station" (Raspberry Pi) gøre 3 ting:

• Log alle data på en lokal database
• Præsenter alle data på en lokal webside (ved hjælp af kolbe som vist på billedet ovenfor)
• Sender alle data til ThingSpeak på samme tid.

På en fremtidig vejledning vil vi undersøge disse muligheder.

Trin 10: Konklusion

Som altid håber jeg, at dette projekt kan hjælpe andre med at finde vej til den spændende elektronikverden!

For detaljer og endelig kode, besøg mit GitHub-depot: RPi-NodeMCU-Weather-Station

For flere projekter, besøg min blog: MJRoBot.org

Bliv hængende! Næste vejledning sender vi data fra en fjernvejrstation til en central, baseret på en Raspberry Pi webserver:

Saludos fra den sydlige del af verden!

Vi ses i min næste instruerbare!

Tak skal du have, Marcelo