Stație meteo IoT cu RPi și ESP8266: 10 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

La tutoriale anterioare, ne-am jucat cu NodeMCU, senzori și am învățat cum să captăm și să înregistrăm date pe ThingSpeak (o platformă Internet of Things (IoT) care vă permite să colectați și să stocați datele senzorilor în cloud și să dezvoltați aplicații IoT):

NU S-A FĂCUT UȘOR: CAPTURAREA DATELOR METEO DE LA DISTANȚĂ: TEMPERATURĂ ȘI UMIDITATE UV ȘI AERULUI

Cu acest nou tutorial, vom învăța cum să facem același lucru, dar în acest moment, folosind un Raspberry Pi pentru a captura date de la mai mulți senzori diferiți și, de asemenea, să explorăm diferite moduri de comunicare între dispozitive și web:

Senzori și tip de combinație:

• DHT22 (Temperatură și Umiditate) ==> Comunicare digitală
• BMP180 (Temperatură și presiune) ==> Protocol I2C
• DS18B20 (Temperatură) ==> Protocol cu 1 fir

Diagrama bloc arată ce vom obține la final cu acest proiect:

Pasul 1: BoM - Lista materialelor

1. Raspberry Pi V3 - 32,00 USD
2. Senzor de temperatură și umiditate relativă DHT22 - 9,95 USD
3. Rezistor 4K7 ohm
4. Senzor de temperatură impermeabil DS18B20 - 5,95 USD
5. Rezistor 4K7 ohm
6. BMP180 Senzor de presiune barometrică, temperatură și altitudine - 6,99 USD

Pasul 2: Instalarea senzorului de temperatură și umiditate

Primul senzor care va fi instalat va fi DHT22 pentru captarea datelor privind temperatura aerului și umiditatea relativă. Site-ul ADAFRUIT oferă informații excelente despre acei senzori. Mai jos, câteva informații preluate de acolo:

Prezentare generală

Senzorii de temperatură și umiditate DHT cu preț redus sunt foarte simpli și liniști, dar sunt minunați pentru pasionații care doresc să facă o înregistrare de date de bază. Senzorii DHT sunt compuși din două părți, un senzor capacitiv de umiditate și un termistor. Există, de asemenea, un cip foarte de bază în interior, care face o conversie analogică la digitală și scuipă un semnal digital cu temperatura și umiditatea. Semnalul digital este destul de ușor de citit folosind orice microcontroler.

DHT22 Caracteristici principale:

• Cost scăzut
• Putere de la 3 la 5V și I / O
• Utilizare curentă maximă de 2,5 mA în timpul conversiei (în timp ce solicitați date)
• Bun pentru citiri de umiditate 0-100% cu o precizie de 2-5%
• Bun pentru citiri de temperatură de -40 până la 125 ° C precizie ± 0,5 ° C
• Rată de eșantionare mai mare de 0,5 Hz (o dată la 2 secunde)
• Dimensiunea corpului 15,1 mm x 25 mm x 7,7 mm
• 4 pini cu spațiere de 0,1"

Odată ce, de obicei, veți utiliza senzorul pe distanțe mai mici de 20m, un rezistor 4K7 ohmi ar trebui să fie conectat între date și pinii VCC. Pinul de date de ieșire DHT22 va fi conectat la Raspberry GPIO 16. Verificați schema electrică de mai sus, conectând senzorul la pinii RPi după cum urmează:

1. Pinul 1 - Vcc ==> 3.3V
2. Pinul 2 - Date ==> GPIO 16
3. Pinul 3 - Nu se conectează
4. Pinul 4 - Gnd ==> Gnd

Nu uitați să instalați rezistorul 4K7 ohm între pinii Vcc și Data

Odată ce senzorul este conectat, trebuie să-i instalăm și biblioteca pe RPi.

Instalarea bibliotecii DHT:

Pe Raspberry, începând cu / acasă, accesați / Documente

cd Documente

Creați un director pentru a instala biblioteca și mutați acolo:

mkdir DHT22_Sensor

cd DHT22_Sensor

Pe browser, accesați Adafruit GitHub:

github.com/adafruit/Adafruit_Python_DHT

Descărcați biblioteca făcând clic pe linkul de descărcare zip din dreapta și dezarhivați arhiva din folderul Raspberry Pi creat recent. Apoi accesați directorul bibliotecii (subfolderul care este creat automat atunci când ați dezarhivat fișierul) și executați comanda:

sudo python3 setup.py instalare

Deschideți un program de testare (DHT22_test.py) din GITHUB

import Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 umiditate, temperatură = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin) dacă umiditatea nu este Niciuna și temperatura nu este Niciuna: imprimați ('Temp = {0: 0.1f} * C Umiditate = {1: 0.1 f}% '. format (temperatură, umiditate)) else: print (' Nu s-a putut citi. Încercați din nou! ')

Executați programul cu comanda:

python3 DHT22_test.py

Ecranul de imprimare terminal de mai jos arată rezultatul.

Pasul 3: Instalarea DS18B20 - senzor de temperatură

Prezentare generală a senzorului:

Vom folosi în acest tutorial o versiune impermeabilizată a senzorului DS18B20. Este foarte util pentru temperaturi îndepărtate în condiții umede, de exemplu pe un sol umed. Senzorul este izolat și poate lua măsurători până la 125oC (Adafrut nu recomandă utilizarea acestuia peste 100oC datorită căptușelii din PVC din cablu).

DS18B20 este un senzor digital, ceea ce îl face bine să fie folosit chiar și pe distanțe mari! Acești senzori de temperatură digitale cu 1 fir sunt destul de preciși (± 0,5 ° C în mare parte) și pot oferi până la 12 biți de precizie de la convertorul digital-analog la bord. Funcționează excelent cu NodeMCU folosind un singur pin digital și puteți chiar conecta mai multe pe același pin, fiecare are un ID unic pe 64 de biți ars din fabrică pentru a le diferenția.

Senzorul funcționează de la 3,0 la 5,0 V, ceea ce înseamnă că poate fi alimentat direct de la 3,3 V furnizat de unul dintre pinii Raspberry (1 sau 17).

Senzorul are 3 fire:

• Negru: GND
• Roșu: VCC
• Galben: date cu 1 fir

Aici, puteți găsi datele complete: Foaie de date DS18B20

Instalarea senzorului:

Urmați diagrama de mai sus și faceți conexiunile:

• Vcc ==> 3.3V
• Gnd ==> Gnd
• Date ==> GPIO 4 (implicit pentru bibliotecă)

Instalarea bibliotecii Python:

Apoi, să instalăm biblioteca Python care se va ocupa de senzor:

sudo pip3 instalează w1thermsensor

Înainte de a rula scriptul pentru a testa senzorul, verificați dacă interfața „1-Wire” este activată în RPi (a se vedea ecranul de imprimare de mai sus)

Nu uitați să reporniți RPi, după ce ați modificat configurația

Testarea senzorului:

Pentru testarea senzorului se poate folosi un script Python simplu:

timpul de import

din importul w1thermsensor W1ThermSensor ds18b20Sensor = W1ThermSensor () în timp ce True: temperature = ds18b20Sensor.get_temperature () print ("Temperatura este% s celsius"% temperatura) time.sleep (1)

Pasul 4: Instalarea BMP180

Prezentare generală a senzorului:

BMP180 este succesorul BMP085, o nouă generație de senzori de presiune digitală de înaltă precizie pentru aplicații pentru consumatori. Electronica de înaltă tensiune și joasă tensiune a BMP180 este optimizată pentru utilizare în telefoane mobile, PDA-uri, dispozitive de navigație GPS și echipamente de exterior. Cu un zgomot de altitudine mică de doar 0,25 m la un timp de conversie rapid, BMP180 oferă performanțe superioare. Interfața I2C permite integrarea ușoară a sistemului cu un microcontroler. BMP180 se bazează pe tehnologia piezo-rezistivă pentru robustețe EMC, precizie ridicată și liniaritate, precum și stabilitate pe termen lung.

Fișa tehnică completă BMP poate fi găsită aici: BMP180 - Senzor digital de presiune

Instalarea senzorului: urmați schema de mai sus și efectuați conexiunile:

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

Activarea interfeței I2C

Mergeți la Configurare RPi și confirmați că interfața I2C este activată. Dacă nu, activați-l și reporniți RPi.

Utilizarea BMP180

Dacă totul a fost instalat bine și totul a fost conectat bine, acum sunteți gata să porniți Pi-ul și să începeți să vedeți ce vă spune BMP180 despre lumea din jur.

Primul lucru de făcut este să verificați dacă Pi vă vede BMP180. Încercați următoarele într-o fereastră de terminal:

sudo i2cdetect -y 1

Dacă comanda a funcționat, ar trebui să vedeți ceva similar cu Terminal Printscreen de mai sus, care arată că BMP180 este pe canalul '77'.

Instalarea bibliotecii BMP180:

Creați un director pentru a instala biblioteca:

mkdir BMP180_Sensorcd BMP180_Sensor

Pe browserul dvs., accesați Adafruit GITHub:

github.com/adafruit/Adafruit_Python_BMP

Descărcați biblioteca făcând clic pe linkul zip de descărcare din dreapta și dezarhivați arhiva din folderul creat de Raspberry Pi. Apoi accesați subfolderul creat și executați următoarea comandă în directorul bibliotecii:

sudo python3 setup.py instalare

Deschideți IDE-ul Python și creați un program de testare și denumiți-l, de exemplu BMP180Test.py

importați Adafruit_BMP. BMP085 ca BMP085sensor = BMP085. BMP085 () print ('Temp = {0: 0.2f} * C'.format (sensor.read_temperature ())) print (' Pressure = {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 (senzor.read_sealevel_pressure ()))

Executați programul de testare:

python3 BMP180Test.py

Ecranul de imprimare terminal de mai sus arată rezultatul.

Rețineți că această presiune este prezentată în Pa (Pascals). Consultați pasul următor pentru a înțelege mai bine despre această unitate.

Pasul 5: Măsurarea vremii și a altitudinii cu BMP180

Să luăm un timp să înțelegem un pic mai mult despre ceea ce vom obține, cu citirile BMP. Puteți sări peste această parte a tutorialului sau să reveniți mai târziu.

Dacă doriți să aflați mai multe despre citirile senzorilor, accesați acest tutorial extraordinar:

BMP180 a fost conceput pentru a măsura cu precizie presiunea atmosferică. Presiunea atmosferică variază atât în funcție de vreme, cât și de altitudine.

Ce este presiunea atmosferică?

Definiția presiunii atmosferice este o forță pe care aerul din jur o exercită asupra tuturor. Greutatea gazelor din atmosferă creează presiune atmosferică. O unitate comună de presiune este „lire sterline pe inch pătrat” sau psi. Vom folosi aici notația internațională, adică newtoni pe metru pătrat, care se numesc pascali (Pa).

Dacă ați lua o coloană de aer de 1 cm lățime, ar cântări aproximativ 1 kg

Această greutate, apăsând pe amprenta acelei coloane, creează presiunea atmosferică pe care o putem măsura cu senzori precum BMP180. Deoarece acea coloană de aer lată de cm cântărește aproximativ 1 kg, rezultă că presiunea medie a nivelului mării este de aproximativ 101325 pascali, sau mai bine, 1013,25 hPa (1 hPa este, de asemenea, cunoscut sub numele de milibar - mbar). Aceasta va scădea cu aproximativ 4% pentru fiecare 300 de metri pe care urcați. Cu cât creșteți, cu atât veți vedea mai puțină presiune, deoarece coloana din partea de sus a atmosferei este mult mai scurtă și, prin urmare, cântărește mai puțin. Este util să știți, deoarece măsurând presiunea și făcând câteva calcule, vă puteți determina altitudinea.

Presiunea aerului la 3, 810 metri este doar jumătate din cea de la nivelul mării.

BMP180 generează presiune absolută în pascale (Pa). Un pascal este o cantitate foarte mică de presiune, aproximativ cantitatea pe care o va exercita o foaie de hârtie sprijinită pe o masă. Veți vedea mai des măsurători în hectopascali (1 hPa = 100 Pa). Biblioteca utilizată aici oferă valori în virgulă mobilă în hPa, ceea ce se întâmplă, de asemenea, să fie egal cu un milibar (mbar).

Iată câteva conversii la alte unități de presiune:

• 1 hPa = 100 Pa = 1 mbar = 0,001 bar
• 1 hPa = 0,75006168 Torr
• 1 hPa = 0,01450377 psi (lire pe inch pătrat)
• 1 hPa = 0,02953337 inHg (inci de mercur)
• 1 hpa = 0,00098692 atm (atmosfere standard)

Efecte de temperatură

Deoarece temperatura afectează densitatea unui gaz, iar densitatea afectează masa unui gaz, iar masa afectează presiunea (roata), presiunea atmosferică se va schimba dramatic odată cu temperatura. Piloții știu acest lucru ca „altitudine de densitate”, ceea ce face mai ușoară decolarea într-o zi rece decât una fierbinte, deoarece aerul este mai dens și are un efect aerodinamic mai mare. Pentru a compensa temperatura, BMP180 include un senzor de temperatură destul de bun, precum și un senzor de presiune.

Pentru a efectua o citire a presiunii, faceți mai întâi o citire a temperaturii, apoi combinați aceasta cu o citire brută a presiunii pentru a veni cu o măsurare finală a presiunii compensate de temperatură. (Biblioteca face toate acestea foarte ușoare.)

Măsurarea presiunii absolute

Dacă aplicația dvs. necesită măsurarea presiunii absolute, tot ce trebuie să faceți este să obțineți o citire a temperaturii, apoi efectuați o citire a presiunii (a se vedea schița de exemplu pentru detalii). Citirea presiunii finale va fi în hPa = mbar. Dacă doriți, puteți converti aceasta într-o unitate diferită utilizând factorii de conversie de mai sus.

Rețineți că presiunea absolută a atmosferei va varia atât în funcție de altitudine, cât și de modelele meteorologice actuale, ambele fiind lucruri utile de măsurat.

Observații meteo

Presiunea atmosferică în orice locație dată de pe pământ (sau oriunde cu atmosferă) nu este constantă. Interacțiunea complexă dintre rotirea pământului, înclinarea axei și mulți alți factori au ca rezultat zone în mișcare cu presiune mai mare și mai mică, care la rândul lor provoacă variații ale vremii pe care le vedem în fiecare zi. Urmărind schimbările de presiune, puteți prevedea schimbările pe termen scurt ale vremii. De exemplu, scăderea presiunii înseamnă de obicei vreme umedă sau se apropie o furtună (se instalează un sistem de joasă presiune). Creșterea presiunii înseamnă de obicei că se apropie vremea liberă (un sistem de înaltă presiune se deplasează prin). Amintiți-vă însă că presiunea atmosferică variază și în funcție de altitudine. Presiunea absolută în casa mea, Lo Barnechea din Chile (altitudine 950m) va fi întotdeauna mai mică decât presiunea absolută din San Francisco, de exemplu (mai puțin de 2 metri, aproape nivelul mării). Dacă stațiile meteo tocmai și-ar raporta presiunea absolută, ar fi dificil să se compare direct măsurătorile de presiune dintr-o locație în alta (iar predicțiile meteo pe scară largă depind de măsurătorile din cât mai multe stații posibil).

Pentru a rezolva această problemă, stațiile meteo elimină întotdeauna efectele altitudinii din citirile de presiune raportate prin adăugarea matematică a presiunii fixe echivalente pentru a face să apară ca și cum citirea ar fi luată la nivelul mării. Când faceți acest lucru, o lectură mai mare în San Francisco decât Lo Barnechea va fi întotdeauna din cauza tiparelor meteo, și nu din cauza altitudinii.

Pentru a face acest lucru, există o funcție în bibliotecă numită nivelul mării (P, A). Aceasta ia presiunea absolută (P) în hPa și altitudinea curentă a stației (A) în metri și elimină efectele altitudinii din presiune. Puteți utiliza ieșirea acestei funcții pentru a compara în mod direct valorile meteorologice cu alte stații din întreaga lume.

Determinarea altitudinii

Deoarece presiunea variază în funcție de altitudine, puteți utiliza un senzor de presiune pentru a măsura altitudinea (cu câteva avertismente). Presiunea medie a atmosferei la nivelul mării este de 1013,25 hPa (sau mbar). Acest lucru scade la zero pe măsură ce urci spre vidul spațiului. Deoarece curba acestei scăderi este bine înțeleasă, puteți calcula diferența de altitudine între două măsurători de presiune (p și p0) utilizând o ecuație specifică.

Dacă utilizați presiunea la nivelul mării (1013,25 hPa) ca presiune de bază (p0), ieșirea ecuației va fi altitudinea dvs. actuală deasupra nivelului mării. În bibliotecă există o funcție numită altitudine (P, P0) care vă permite să obțineți „altitudinea calculată”.

Explicația de mai sus a fost extrasă din tutorialul BMP 180 Sparkfun.

Pasul 6: HW-ul complet

Pasul 7: Trimiterea datelor către ThingSpeak

În acest moment, am învățat cum să pregătim RPi pentru a captura date de la toți cei 3 senzori, imprimându-i pe terminal. Acum, este timpul să vedem cum să trimiteți aceste date către platforma IoT, ThingSpeak.

Sa incepem!

În primul rând, trebuie să aveți un cont la ThinkSpeak.com

Urmați instrucțiunile pentru a crea un canal și luați notă de ID-ul dvs. de canal și de scriere a cheii API

Descărcați scriptul Python din GitHub: localData ToTS_v1_EXT.py

Să comentăm cele mai importante părți ale codului:

Mai întâi, să importăm biblioteca ThingSpeak, să definim clientul WiFi și să definim acreditările dvs. locale de router și Thinkspeak:

import lucruri

Există mai multe moduri de a comunica cu ThingSpeak, cea mai simplă modalitate ar fi utilizarea bibliotecii client pentru API-ul thingspeak.com dezvoltat de Mikolaj Chwaliz și Keith Ellis.

Biblioteca poate fi descărcată de pe https://github.com/mchwalisz/thingspeak sau poate fi utilizată PIP pe terminal:

sudo pip3 instalează thingspeak

Apoi, în interiorul scriptului, actualizați acreditările canalului ThingSpeak

chId = 9999999 # Introduceți cu ID-ul canalului

tsKey = 'INTRODUȚI CU CHEIA DE SCRIERE A CANALULUI' tsUrl = 'https://api.thingspeak.com/update' ts = thingspeak. Channel (chId, tsUrl, tsKey)

Acum, să inițializăm cei 3 senzori:

# DS18B20 Biblioteca cu 1 fir

din importul w1thermsensor W1ThermSensor ds18b20Sensor = W1ThermSensor () # În mod implicit GPIO 4 este utilizat de bibliotecă # DHT22 Import bibliotecă Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 biblioteca import Adafruit_BMP0B85. BMP0B85 Ar trebui să definiți altitudinea reală în care se află stația meteo, actualizând variabila globală "altReal". În cazul meu, stația mea este situată la 950m deasupra nivelului mării

altReal global

altReal = 950

Odată introdus cu stația de altitudine reală ca intrare, putem obține presiunea absolută, presiunea nivelului mării, temperatura și altitudinea folosind funcția bmp180GetData (altitudine):

def bmp180GetData (altitudine):

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) # presiune absolută în hPa (sau mbar) alt=rotund (alt) presSeaLevel = rotund (presSeaLevel / 100, 2) # presiune absolută în hPa (sau mbar) revenire temp, pres, alt, presSeaLevel

Funcția getLocalData (), va returna toate datele locale capturate de stația noastră:

def getLocalData ():

global timeString global humLab global tempExt global tempLab global presSL global altLab global presAbs # Get time of reading now = datetime.datetime.now () timeString = now.strftime ("% Y-% m-% d% H:% M") # Citește temperatura exterioară (1 metru distanță) tempExt = round (ds18b20Sensor.get_temperature (), 1) tempLab, presAbs, altLab, presSL = bmp180GetData (altReal) humDHT, tempDHT = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin not iar tempDHT nu este Nici unul: humLab = rotund (humDHT

Odată ce aveți toate datele capturate de funcțiile de mai sus, trebuie să le trimiteți la ThingSpeak. O veți face folosind funcția sendDataTs ():

def sendDataTs ():

data = {"field1": tempLab, "field2": tempExt, "field3": humLab, "field4": presSL, "field5": altLab} ts.update (data) print ("[INFO] Date trimise pentru 5 câmpuri: ", tempLab, tempExt, humLab, presSL, altLab)

Cu datele canalului dvs. actualizate, salvați scriptul și executați-l pe terminal:

sudo Python3 localData_ToTs_v1_EXT.py

Despre protocoale de comunicare

Rețineți că folosind „biblioteca de lucruri”, este importată „biblioteca de cereri”, adică o bibliotecă HTTP licențiată Apache2, scrisă în Python. Documentația oficială de solicitare a instalării poate fi găsită aici:

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

Dacă este necesar, înainte de a rula scriptul, puteți verifica dacă biblioteca de solicitări este instalată:

sudo pip3 solicitări de instalare

Opțional, puteți utiliza MTTQ ca metodă pentru a trimite date către ThingSpeak. MQTT este diferit de HTTP, odată ce este special conceput pentru a fi ușor și destinat dispozitivelor încorporate cu RAM scăzută și performanță CPU. De asemenea, în majoritatea cazurilor, MQTT utilizează o lățime de bandă mai mică.

Consultați acest tutorial: Actualizați un canal ThingSpeak folosind MQTT pe un Raspberry Pi pentru mai multe detalii.

Pasul 8: Trimiterea datelor la distanță către ThingSpeak utilizând ESP8266

Pentru acest pas, vom folosi același HW care a fost explicat în foarte tutorial:

NU S-A FĂCUT UȘOR: CAPTURAREA DATELOR METEO DE LA DISTANȚĂ: TEMPERATURĂ ȘI UMIDITATE UV ȘI AERULUI

Codul pe care îl vom folosi aici este practic același folosit în acel tutorial. Să comentăm cele mai importante părți ale codului:

În primul rând, să apelăm biblioteca ESP8266, să definim clientul WiFi și să definim acreditările dvs. locale de router și Thinkspeak:

/ * NodeMCU ESP12-E * /

#includeți clientul WiFiClient; const char * MY_SSID = "INTRAȚI CU SSDIDUL DUMNEAVOASTRĂ"; const char * MY_PWD = "INTRODUȚI CU PAROLA DUMNEAVOASTRĂ"; / * Thinkspeak * / const char * TS_SERVER = "api.thingspeak.com"; String TS_API_KEY = "INTRODUȚI CU CHEIA DE SCRIERE";

În al doilea rând, să includem o bibliotecă foarte importantă pentru proiectele IoT: SimpleTimer.h:

/* TEMPORIZATOR */

#includeți cronometrul SimpleTimer;

În al treilea rând, în timpul configurării (), vom iniția comunicarea serială, vom apela funcția connectWiFi () și vom defini cronometrele. Rețineți că linia de cod: timer.setInterval (60000L, sendDataTS); va apela funcția sendDataTS () la fiecare 60 de secunde, pentru a încărca date pe canalul ThinkSpeak.

configurare nulă ()

{… Serial.begin (115200); întârziere (10); … ConnectWifi (); timer.setInterval (60000L, sendDataTS); …}

În cele din urmă, dar nu în ultimul rând, în timpul buclei (), singura comandă necesară este inițierea cronometrului și atât!

bucla nulă ()

{… timer.run (); // inițiază SimpleTimer}

Mai jos, puteți vedea cele două funcții importante utilizate pentru gestionarea comunicării Thinkspeak:

Conexiune ESP12-E cu rețeaua WiFi:

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

* Conectarea WiFi *********************************************** *** / void connectWifi () {Serial.print ("Conectarea la" + * MY_SSID); WiFi.begin (MY_SSID, MY_PWD); while (WiFi.status ()! = WL_CONNECTED) {întârziere (1000); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi conectat"); Serial.println (""); }

ESP12-E trimiterea datelor către ThinkSpeak:

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

* Trimiterea datelor către canalul Thinkspeak ******************************************** ****** / 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 / actualizare HTTP / 1.1 / n"); client.print ("Gazdă: api.thingspeak.com / n"); client.print ("Conexiune: închidere / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("Content-Type: application / x-www-form-urlencoded / n"); client.print („Lungime conținut:”); client.print (postStr.length ()); client.print ("\ n / n"); client.print (postStr); întârziere (1000); } trimis ++; client.stop (); }

Codul complet poate fi găsit pe GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

După ce ați încărcat codul pe NodeMCU. Să conectăm o baterie externă și să facem o măsurare sub soare. Am pus stația la distanță pe acoperiș și încep să captez date pe ThingSpeak.com așa cum se arată în fotografiile de mai sus.

Pasul 9: Note finale

Scopul principal al acestui tutorial a fost de a arăta cum să conectați Raspberry Pi la ThingSpeak. Acest lucru este minunat pentru a captura date și a le conecta pe o platformă IoT.

Folosind oportunitatea, am trimis și date către acel canal specific, capturându-le de la o stație la distanță folosind un ESP8266. Această abordare este OK, dar nu cea mai bună. Deoarece avem o operațiune „asincronă”, uneori, ambele, RPi și ESP8266 încearcă să înregistreze în același timp (sau cu un interval mic) ceea ce este respins de ThingSpeak. Idealul ar fi ca ESP8266 să trimită date local la Raspberry Pi, iar ultimul să fie responsabil pentru gestionarea tuturor datelor. Făcând asta, „Stația principală” (Raspberry Pi), ar putea face 3 lucruri:

• Înregistrați toate datele într-o bază de date locală
• Prezentați toate datele pe o pagină Web locală (utilizând Flask așa cum se arată în fotografia de mai sus)
• Trimiterea tuturor datelor către ThingSpeak în același timp.

Într-un viitor tutorial, vom explora aceste opțiuni.

Pasul 10: Concluzie

Ca întotdeauna, sper că acest proiect îi poate ajuta pe ceilalți să își găsească drumul în lumea interesantă a electronicii!

Pentru detalii și cod final, vă rugăm să vizitați depozitarul GitHub: RPi-NodeMCU-Weather-Station

Pentru mai multe proiecte, vă rugăm să vizitați blogul meu: MJRoBot.org

Rămâneți aproape! Următorul tutorial vom trimite date de la o stație meteo la distanță către una centrală, pe baza unui server web Raspberry Pi:

Salude din sudul lumii!

Ne vedem în următorul meu instructabil!

Mulțumesc, Marcelo