IoT ilmajaam RPi ja ESP8266 abil: 10 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:48

Varasematel õpetustel oleme mänginud NodeMCU -ga, anduritega ja õppinud andmete kogumist ja logimist ThingSpeak'is (asjade Interneti (IoT) platvorm, mis võimaldab teil koguda ja salvestada andurite andmeid pilves ja arendada IoT -rakendusi):

IOT MADE LIHTNE: KAUGSE ILMA ANDMETE VÕTMINE: UV- JA ÕHUTEMPERATUUR JA NIISKUS

Selle uue õpetuse abil õpime, kuidas seda teha, kuid seekord, kasutades Raspberry Pi -d andmete kogumiseks mitmelt erinevalt andurilt ning uurides erinevaid võimalusi seadmete ja veebi vaheliseks suhtlemiseks:

Andurid ja kombineerimise tüüp:

• DHT22 (temperatuur ja niiskus) ==> digitaalne side
• BMP180 (temperatuur ja rõhk) ==> I2C protokoll
• DS18B20 (temperatuur) ==> 1-juhtmeline protokoll

Plokkskeem näitab, mida me selle projekti lõpus saame:

1. samm: BoM - materjalide arve

1. Raspberry Pi V3 - 32,00 USA dollarit
2. DHT22 temperatuuri ja suhtelise niiskuse andur - 9,95 USD
3. Takisti 4K7 oomi
4. Veekindel temperatuuriandur DS18B20 - 5,95 USD
5. Takisti 4K7 oomi
6. BMP180 õhurõhu, temperatuuri ja kõrguse andur - 6,99 USD

2. samm: temperatuuri ja niiskuse anduri paigaldamine

Esimene paigaldatav andur on DHT22 õhutemperatuuri ja suhtelise niiskuse andmete salvestamiseks. ADAFRUITi sait pakub nende andurite kohta suurepärast teavet. Allpool, sealt saadi mõned andmed:

Ülevaade

Odavad DHT temperatuuri ja niiskuse andurid on väga lihtsad ja aeglased, kuid sobivad suurepäraselt harrastajatele, kes soovivad teha põhiandmete logimist. DHT -andurid koosnevad kahest osast, mahtuvuslikust niiskusandurist ja termistorist. Sees on ka väga lihtne kiip, mis muudab mõningaid analooge digitaalseks ja sülitab digitaalse signaali koos temperatuuri ja niiskusega. Digitaalsignaali on üsna lihtne lugeda mis tahes mikrokontrolleri abil.

DHT22 Peamised omadused:

• Odav
• 3 kuni 5 V toide ja I/O
• 2,5 mA maksimaalne praegune kasutus konversiooni ajal (andmeid küsides)
• Sobib 0–100% niiskusnäitudele 2–5% täpsusega
• Sobib temperatuurinäitudele -40 kuni 125 ° C ± 0,5 ° C täpsusega
• Proovivõtu sagedus ei ületa 0,5 Hz (üks kord 2 sekundi jooksul)
• Korpuse suurus 15,1 mm x 25 mm x 7,7 mm
• 4 tihvti 0,1 -tollise vahega

Kui tavaliselt kasutate andurit vähem kui 20 m kaugusel, tuleks andmete ja VCC kontaktide vahele ühendada 4K7 oomi takisti. DHT22 väljundandmete tihvt ühendatakse Raspberry GPIO 16 -ga. Kontrollige ülaltoodud elektriskeemi, ühendades anduri RPi kontaktidega järgmiselt.

1. Pin 1 - Vcc ==> 3.3V
2. Pin 2 - Andmed ==> GPIO 16
3. Tihvt 3 - ei ühenda
4. Tihvt 4 - Gnd ==> Gnd

Ärge unustage paigaldada 4K7 oomi takisti Vcc ja andmeklemmide vahele

Kui andur on ühendatud, peame installima ka selle raamatukogu meie RPi -sse.

DHT raamatukogu installimine:

Avage oma Vaarika seadmest alates /kodu jaotis /Dokumendid

cd dokumendid

Teegi installimiseks looge kataloog ja liikuge sinna:

mkdir DHT22_Sensor

cd DHT22_andur

Avage oma brauseris Adafruit GitHub:

github.com/adafruit/Adafruit_Python_DHT

Laadige raamatukogu alla, klõpsates paremal asuvat allalaadimise zip -linki ja pakkige oma Raspberry Pi hiljuti loodud kausta arhiiv lahti. Seejärel minge teegi kataloogi (alamkaust, mis luuakse automaatselt faili lahtipakkimisel) ja täitke käsk:

sudo python3 setup.py install

Avage minu GITHUBist testprogramm (DHT22_test.py)

import Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 niiskus, temperatuur = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin), kui niiskus ei ole Puudub ja temperatuur ei ole olemas: print ('Temp = {0: 0,1f}*C Niiskus = {1: 0,1 f}%'. formaat (temperatuur, niiskus)) else: print (' Lugemine ebaõnnestus. Proovige uuesti! ')

Käivitage programm käsuga:

python3 DHT22_test.py

Allpool olev terminali prindiekraan näitab tulemust.

Samm: paigaldage DS18B20 - temperatuuriandur

Anduri ülevaade:

Selles õpetuses kasutame DS18B20 anduri veekindlat versiooni. See on väga kasulik kaugtemperatuuri korral märgades tingimustes, näiteks niiskel pinnasel. Andur on isoleeritud ja seda saab mõõta kuni 125 oC (Adafrut ei soovita seda kasutada üle 100 oC kaabli PVC ümbrise tõttu).

DS18B20 on digitaalne andur, mis teeb selle kasutamiseks hea isegi pikkade vahemaade tagant! Need 1-juhtmelised digitaalsed temperatuuriandurid on üsna täpsed (± 0,5 ° C suurel osal vahemikust) ja võivad pardal oleva digitaalse-analoogmuunduri abil anda kuni 12 bitti täpsust. Nad töötavad suurepäraselt koos NodeMCU-ga, kasutades ühte digitaalset tihvti, ja saate isegi ühendada mitu sama nööpnõelaga, igal neist on nende eristamiseks tehases põletatud unikaalne 64-bitine ID.

Andur töötab vahemikus 3,0 kuni 5,0 V, mis tähendab, et seda saab toita otse 3,3 V toiteallikast, mida pakub üks Raspberry tihvt (1 või 17).

Anduril on 3 juhet:

• Must: GND
• Punane: VCC
• Kollane: 1-juhtmelised andmed

Siit leiate täielikud andmed: DS18B20 andmeleht

Anduri paigaldamine:

Järgige ülaltoodud diagrammi ja tehke ühendused:

• Vcc ==> 3.3V
• Gnd ==> Gnd
• Andmed ==> GPIO 4 (vaikimisi kogu jaoks)

Pythoni kogu installimine:

Järgmisena installime anduri haldava Pythoni teegi:

sudo pip3 installige w1thermsensor

Enne skripti käivitamist anduri testimiseks kontrollige, kas 1-juhtmeline liides on teie RPi-s lubatud (vt ülaltoodud prindiekraani)

Ärge unustage pärast konfiguratsiooni muutmist RPi taaskäivitada

Anduri testimine:

Anduri testimiseks saab kasutada lihtsat pythoni skripti:

impordi aeg

w1thermsensorilt import W1ThermSensor ds18b20Sensor = W1ThermSensor (), samas kui tõsi: temperatuur = ds18b20Sensor.get_temperature () print ("Temperatuur on % s celsius" % temperatuur) time.sleep (1)

Samm: paigaldage BMP180

Anduri ülevaade:

BMP180 on uue põlvkonna suure täpsusega digitaalsete rõhuandurite tarbijatele mõeldud rakenduste BMP085 järglane. BMP180 üliväikese võimsusega madalpinge elektroonika on optimeeritud kasutamiseks mobiiltelefonides, pihuarvutites, GPS-navigatsiooniseadmetes ja väliseadmetes. Madala kõrgusega, vaid 0,25 m kõrguse müraga kiire konversiooni ajal pakub BMP180 suurepärast jõudlust. I2C liides võimaldab lihtsat süsteemi integreerimist mikrokontrolleriga. BMP180 põhineb piesoresistentsel tehnoloogial, mis tagab EMC töökindluse, suure täpsuse ja lineaarsuse ning pikaajalise stabiilsuse.

Kogu BMP andmelehe leiate siit: BMP180 - digitaalne rõhuandur

Anduri paigaldamine: järgige ülaltoodud skeemi ja tehke ühendused:

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

I2C liidese lubamine

Minge jaotisse RPi Configuration ja veenduge, et I2C liides on lubatud. Kui ei, siis lubage see ja taaskäivitage RPi.

Kasutades BMP180

Kui kõik on õigesti installitud ja kõik on ühendatud, siis olete nüüd valmis oma Pi sisse lülitama ja nägema, mida BMP180 teile ümbritseva maailma kohta räägib.

Esimene asi, mida teha, on kontrollida, kas Pi näeb teie BMP180. Proovige terminaliaknas järgmist.

sudo i2cdetect -y 1

Kui käsk töötas, peaksite ülaltoodud terminali prindiekraanil nägema midagi sarnast, mis näitab, et BMP180 on kanalil 77.

Raamatukogu BMP180 installimine:

Teegi installimiseks looge kataloog:

mkdir BMP180_Sensorcd BMP180_Sensor

Avage oma brauseris Adafruit GITHub:

github.com/adafruit/Adafruit_Python_BMP

Laadige raamatukogu alla, klõpsates paremal asuvat allalaadimislipi linki ja pakkige oma Raspberry Pi loodud kausta arhiiv lahti. Seejärel minge loodud alamkausta ja täitke teegi kataloogis järgmine käsk:

sudo python3 setup.py install

Avage oma Pythoni IDE ja looge testprogramm ning pange sellele nimi, näiteks BMP180Test.py

import Adafruit_BMP. BMP085 kui 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 (' Seasevel Pressure = {0: 0.2f} Pa'.format (sensor.read_sealevel_pressure ()))

Käivitage testprogramm:

python3 BMP180Test.py

Ülaltoodud terminali printimise ekraan näitab tulemust.

Pange tähele, et see rõhk on esitatud Pa (Pascals). Selle üksuse paremaks mõistmiseks vaadake järgmist sammu.

Samm: ilma ja kõrguse mõõtmine BMP180 abil

Võtame aega, et BMP näitude abil natuke rohkem aru saada, mida me saame. Saate selle õpetuse osa vahele jätta või hiljem tagasi pöörduda.

Kui soovite sensori näitude kohta rohkem teada saada, minge selle suurepärase õpetuse juurde:

BMP180 oli ette nähtud õhurõhu täpseks mõõtmiseks. Atmosfäärirõhk varieerub sõltuvalt ilmastikust ja kõrgusest.

Mis on atmosfäärirõhk?

Atmosfäärirõhu määratlus on jõud, mida teie ümbritsev õhk avaldab kõigele. Gaaside kaal atmosfääris tekitab atmosfäärirõhu. Tavaline rõhuühik on "naela ruut tolli kohta" või psi. Kasutame siin rahvusvahelist märget, st njuutonit ruutmeetri kohta, mida nimetatakse paskaliteks (Pa).

Kui võtaksite 1 cm laiuse õhusamba, kaaluks see umbes 1 kg

See kaal, vajutades selle veeru jalajälge, loob atmosfäärirõhu, mida saame mõõta selliste anduritega nagu BMP180. Kuna tolli cm laiune õhusammas kaalub umbes 1 kg, järeldub, et keskmine merepinna rõhk on umbes 101325 paskalit või parem, 1013,25 hPa (1 hPa on tuntud ka kui milibaar - mbar). See langeb umbes 4% iga 300 meetri kohta, kui te tõusete. Mida kõrgemale jõuate, seda vähem rõhku näete, sest atmosfääri ülaosas asuv veerg on palju lühem ja kaalub seetõttu vähem. See on kasulik teada, sest rõhku mõõtes ja matemaatikat tehes saate määrata oma kõrguse.

Õhurõhk 3 810 meetri kõrgusel on vaid pool sellest, mis merepinnal on.

BMP180 väljastab absoluutse rõhu paskalites (Pa). Üks paskal on väga väike rõhk, umbes selline kogus, mida paberileht lauale toetub. Sagedamini näete mõõtmisi hektopaskalites (1 hPa = 100 Pa). Siin kasutatud raamatukogu pakub väljundeid ujukoma väärtusega hPa, mis on samuti võrdne ühe millibaariga (mbar).

Siin on mõned teisendused teistele rõhuühikutele:

• 1 hPa = 100 Pa = 1 mbar = 0,001 baari
• 1 hPa = 0,75006168 Torr
• 1 hPa = 0,01450377 psi (naela ruut tolli kohta)
• 1 hPa = 0,02953337 inHg (elavhõbeda tolli)
• 1 hpa = 0,00098692 atm (standardne atmosfäär)

Temperatuuri mõjud

Kuna temperatuur mõjutab gaasi tihedust ja tihedus mõjutab gaasi massi ning mass mõjutab rõhku (Whew), muutub õhurõhk temperatuuri muutudes dramaatiliselt. Piloodid teavad seda kui "tiheduskõrgust", mis teeb jahedal päeval kergemaks õhkutõusmise kui kuum, sest õhk on tihedam ja sellel on suurem aerodünaamiline efekt. Temperatuuri kompenseerimiseks sisaldab BMP180 üsna head temperatuuriandurit ja rõhuandurit.

Rõhunäidu tegemiseks peate esmalt mõõtma temperatuuri, seejärel kombineerima selle toorerõhu näiduga, et saada lõplik temperatuurikompenseeritud rõhumõõtmine. (Raamatukogu teeb selle kõik väga lihtsaks.)

Absoluutse rõhu mõõtmine

Kui teie rakendus nõuab absoluutse rõhu mõõtmist, peate tegema ainult temperatuuri näidu ja seejärel rõhunäidu (vt üksikasjade visandit). Lõplik rõhunäit on hPa = mbar. Soovi korral saate selle teisendada ühikuks, kasutades ülaltoodud teisendustegureid.

Pange tähele, et atmosfääri absoluutne rõhk varieerub nii teie kõrguse kui ka praeguste ilmastikutingimuste korral, mis mõlemad on kasulikud mõõtmiseks.

Ilmavaatlused

Atmosfäärirõhk maa peal (või kõikjal, kus on atmosfäär) ei ole konstantne. Keeruline koostoime Maa pöörlemise, telje kallutamise ja paljude muude tegurite vahel põhjustab kõrgema ja madalama rõhuga alade liikumist, mis omakorda põhjustab ilmastiku kõikumisi, mida me iga päev näeme. Rõhu muutusi jälgides saate ennustada ilmastiku lühiajalisi muutusi. Näiteks rõhu langus tähendab tavaliselt märga ilma või läheneb torm (madalrõhusüsteem liigub sisse). Rõhu tõus tähendab tavaliselt selge ilma lähenemist (kõrgsurvesüsteem liigub läbi). Kuid pidage meeles, et õhurõhk varieerub ka kõrguse järgi. Absoluutne rõhk minu majas, Lo Barnecheas Tšiilis (kõrgus 950 m) on alati madalam kui näiteks San Francisco absoluutne rõhk (alla 2 meetri, peaaegu merepind). Kui ilmajaamad teatasid just oma absoluutsest rõhust, oleks raske rõhumõõtmisi ühest kohast teise võrrelda (ja suuremahulised ilmaennustused sõltuvad võimalikult paljude jaamade mõõtmistest).

Selle probleemi lahendamiseks eemaldavad ilmajaamad alati kõrguse mõjud oma teatatud rõhunäitudest, lisades matemaatiliselt samaväärse fikseeritud rõhu, et see näeks välja nii, nagu oleks näidud võetud merepinnast. Kui te seda teete, on San Franciscos Lo Barnecheast kõrgem näit alati ilmastikuolude, mitte kõrguse tõttu.

Selleks on raamatukogus funktsioon nimega merepind (P, A). See võtab absoluutse rõhu (P) hPa -s ja jaama praeguse kõrguse (A) meetrites ning eemaldab rõhust kõrguse mõjud. Selle funktsiooni väljundi abil saate oma ilmastikunäiteid otse võrrelda teiste jaamadega üle maailma.

Kõrguse määramine

Kuna rõhk varieerub sõltuvalt kõrgusest, saate kõrguse mõõtmiseks kasutada rõhuandurit (mõne hoiatusega). Atmosfääri keskmine rõhk merepinnal on 1013,25 hPa (või mbar). See langeb nulli, kui ronite ruumi vaakumi poole. Kuna selle languse kõver on hästi arusaadav, saate kahe rõhumõõtmise (p ja p0) kõrguse erinevuse arvutada konkreetse võrrandi abil.

Kui kasutate baasrõhuna (p0) merepinna rõhku (1013,25 hPa), on võrrandi väljundiks teie praegune kõrgus merepinnast. Raamatukogus on funktsioon nimega kõrgus (P, P0), mis võimaldab teil saada "arvutatud kõrguse".

Ülaltoodud selgitus on välja võetud BMP 180 Sparkfuni õpetusest.

6. samm: täielik HW

Samm: andmete saatmine ThingSpeakile

Siinkohal õppisime, kuidas valmistada RPi ette kõigi kolme anduri andmete hõivamiseks, printides need terminalile. Nüüd on aeg näha, kuidas need andmed IoT platvormile ThingSpeak saata.

Alustagem!

Esiteks peab teil olema konto aadressil ThinkSpeak.com

Järgige juhiseid kanali loomiseks ning pange tähele oma kanali ID ja Write API võti

Laadige Pythoni skript alla minu GitHubist: localData ToTS_v1_EXT.py

Kommenteerime koodi kõige olulisemaid osi:

Esiteks impordime ThingSpeak raamatukogu, määratleme WiFi kliendi ja määratleme teie kohaliku ruuteri ja Thinkspeaki mandaadi:

import asju rääkima

ThingSpeakiga suhtlemiseks on mitmeid viise, lihtsaim viis oleks kasutada Mikolaj Chwalizi ja Keith Ellise välja töötatud thingspeak.com API klienditeeki.

Raamatukogu saab alla laadida aadressilt https://github.com/mchwalisz/thingspeak või kasutada terminalis PIP -i:

sudo pip3 installeeri thingspeak

Seejärel värskendage skripti sees ThingSpeak kanali mandaati

chId = 9999999 # Sisestage oma kanali ID -ga

tsKey = 'SISENE KANALI KIRJUTAMISVÕTMEGA' tsUrl = 'https://api.thingspeak.com/update' ts = thingspeak. Channel (chId, tsUrl, tsKey)

Nüüd lähtestame 3 andurit:

# DS18B20 1-juhtmeline raamatukogu

w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor () # Vaikimisi kasutab raamatukogu GPIO 4 # DHT22 Raamatukogu import Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 raamatukogu importimine Adafruit_B0P0 (BMP) Peaksite määratlema reaalse kõrguse, kus teie ilmajaam asub, värskendades globaalset muutujat „altReal”. Minu puhul asub minu jaam 950 m kõrgusel merepinnast

globaalne altReal

altReal = 950

Kui sisestate jaama tegeliku kõrguse sisendina, saame funktsiooni bmp180GetData (kõrgus) abil saada absoluutse rõhu, merepinna rõhu, temperatuuri ja kõrguse:

def bmp180GetData (kõrgus):

temp = bmp180Sensor.read_temperature () pres = bmp180Sensor.read_pressure () alt=bmp180Sensor.read_altitude () presSeaLevel = pres/pow (1.0 - kõrgus/44330.0, 5.255) temp = ümmargune (temp, 1) pres = ümmargune (pres/100, 2) # absoluutrõhk hPa (või mbar) alt=ümmargune (alt) presSeaLevel = ümmargune (presSeaLevel/100, 2) # absoluutne rõhk hPa (või mbar) tagasivoolutemperatuur, pres, alt, presSeaLevel

Funktsioon getLocalData () tagastab kõik meie jaama jäädvustatud kohalikud andmed:

def getLocalData ():

globaalne timeString globaalne humLab globaalne tempExt globaalne tempLab globaalne presSL globaalne altLab globaalsed presAbs # Lugemise aeg kohe = datetime.datetime.now () timeString = now.strftime ("%Y-%m-%d%H:%M") # Välistemperatuuri lugemine (1 meetri kaugus) tempExt = ümmargune (ds18b20Sensor.get_temperature (), 1) tempLab, presAbs, altLab, presSL = bmp180GetData (altReal) humDHT, tempDHT = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin ja tempDHT ei ole Puudub: humLab = ümmargune (humDHT

Kui olete ülaltoodud funktsioonidega kõik andmed hõivanud, peate need saatma ThingSpeakile. Seda saate teha funktsiooni sendDataTs () abil:

def sendDataTs ():

data = {"field1": tempLab, "field2": tempExt, "field3": humLab, "field4": presSL, "field5": altLab} ts.update (data) print ("[INFO] 5 välja andmed saadeti: ", tempLab, tempExt, humLab, presSL, altLab)

Kui teie kanali andmed on värskendatud, salvestage skript ja käivitage see oma terminalis:

sudo Python3 localData_ToTs_v1_EXT.py

Teave suhtlusprotokollide kohta

Pange tähele, et "thingspeak" -teeki kasutades imporditakse "taotluste kogu", see tähendab Apache2 litsentsitud HTTP -teek, mis on kirjutatud Pythonis. Ametliku taotluse installimise dokumentatsiooni leiate siit:

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

Vajadusel saate enne skripti käivitamist kontrollida, kas taotluste kogu on installitud.

sudo pip3 installitaotlused

Soovi korral saate MTTQ -d kasutada ThingSpeaki andmete saatmise meetodina. MQTT erineb HTTP -st, kui see on spetsiaalselt loodud kergeks ja mõeldud manustatud seadmetele, millel on madal RAM ja protsessori jõudlus. Samuti kasutab MQTT enamikul juhtudel vähem ribalaiust.

Vaadake seda õpetust: lisateabe saamiseks värskendage ThingSpeak kanalit, kasutades Raspberry Pi MQTT -d.

Samm: kaugandmete saatmine ThingSpeakile, kasutades ESP8266

Selle sammu jaoks kasutame sama HW -d, mida selgitati muy õpetuses:

IOT MADE LIHTNE: KAUGSE ILMA ANDMETE VÕTMINE: UV- JA ÕHUTEMPERATUUR JA NIISKUS

Kood, mida me siin kasutame, on põhimõtteliselt sama, mida selles õpetuses kasutati. Kommenteerime koodi kõige olulisemaid osi:

Esiteks helistame ESP8266 teeki, määratleme WiFi -kliendi ja määratleme teie kohaliku ruuteri ja Thinkspeaki mandaadi:

/ * SõlmMCU ESP12-E */

#kaasake WiFi -kliendi klient; const char* MY_SSID = "SISESTA OMA SSDID -ga"; const char* MY_PWD = "SISESTA PAROOLIGA"; /* Thinkspeak*/ const char* TS_SERVER = "api.thingspeak.com"; String TS_API_KEY = "SISESTA KIRJUTADA";

Teiseks lisagem asjade Interneti projektide jaoks väga oluline raamatukogu: SimpleTimer.h:

/ * TIMER */

#kaasa SimpleTimer taimer;

Kolmandaks, seadistamise () ajal alustame jadaühendust, kutsume funktsiooni connectWiFi () ja määrame taimerid. Pange tähele, et koodirida: timer.setInterval (60000L, sendDataTS); helistab funktsiooni sendDataTS () iga 60 sekundi järel, et andmed ThinkSpeaki kanalile üles laadida.

tühine seadistus ()

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

Lõpetuseks, kuid mitte vähemtähtis, tsükli () ajal on ainus vajalik käsk käivitada taimer ja ongi kõik!

tühine tsükkel ()

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

Allpool näete kahte olulist funktsiooni, mida kasutatakse Thinkspeaki suhtluse haldamiseks:

ESP12-E ühendus teie WiFi-võrguga:

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

*WiFi ühendamine *********************************************** ***/ void connectWifi () {Serial.print ("Ühendamine"+*MY_SSID); WiFi.binin (MY_SSID, MY_PWD); while (WiFi.status ()! = WL_CONNECTED) {delay (1000); Seeria.print ("."); } Serial.println (""); Serial.println ("WiFi ühendatud"); Serial.println (""); }

ESP12-E saadab andmeid ThinkSpeaki:

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

*Andmete saatmine Thinkspeak kanalile ******************************************* ******/ 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 /uuenda HTTP /1.1 / n"); client.print ("Host: api.thingspeak.com / n"); client.print ("Ühendus: sulge / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("Content-Type: application/x-www-form-urlencoded / n"); client.print ("Sisu-pikkus:"); klient.print (postStr.length ()); klient.print ("\ n / n"); klient.print (postStr); viivitus (1000); } saadetud ++; client.stop (); }

Kogu koodi leiate minu GitHubist: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Kui olete koodi oma NodeMCU -sse üles laadinud. Ühendame välise aku ja teeme mõningaid mõõtmisi päikese all. Panen kaugjaama katusele ja hakkan ThingSpeak.com -is andmeid jäädvustama, nagu ülaltoodud fotodel näidatud.

9. samm: viimased märkmed

Selle õpetuse peamine eesmärk oli näidata, kuidas Raspberry Pi ühendada ThingSpeakiga. See on suurepärane andmete jäädvustamiseks ja IoT platvormil logimiseks.

Kasutades võimalust, saatsime andmed ka sellele konkreetsele kanalile, jäädvustades need kaugjaamast ESP8266 abil. See lähenemine on OK, kuid mitte parim. Kuna meil on toiming "asünkroonne", proovivad mõnikord nii RPi kui ka ESP8266 korraga (või väikese intervalliga) logida seda, mida ThingSpeak ümber lükkab. Ideaalne oleks, kui ESP8266 saadaks andmed kohapeal Raspberry Pi -le ja viimane vastutaks kõigi andmete töötlemise eest. Seda tehes saaks "peajaam" (Raspberry Pi) teha kolme asja:

• Logige kõik andmed sisse kohalikku andmebaasi
• Esitage kõik andmed kohalikul veebilehel (kasutades kolbi, nagu on näidatud ülaltoodud fotol)
• Kõikide andmete saatmine ThingSpeakile korraga.

Tulevases õpetuses uurime neid võimalusi.

10. samm: järeldus

Nagu alati, loodan, et see projekt aitab teistel leida tee põnevasse elektroonikamaailma!

Üksikasjade ja lõpliku koodi saamiseks külastage minu GitHubi hoidlat: RPi-NodeMCU-Weather-Station

Rohkemate projektide jaoks külastage palun minu ajaveebi: MJRoBot.org

Püsige lainel! Järgmine õpetus saadame Raspberry Pi veebiserveril põhinevad andmed kaugest ilmajaamast kesksesse:

Tervitused maailma lõunaosast!

Kohtumiseni minu järgmises juhendis!

Aitäh, Marcelo