IoT -väderstation med RPi och ESP8266: 10 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:44

På tidigare självstudier har vi lekt med NodeMCU, sensorer och lärt oss att fånga och logga data på ThingSpeak (en Internet of Things (IoT) -plattform som låter dig samla in och lagra sensordata i molnet och utveckla IoT -applikationer):

IOT GJORDE LÄTT: Fånga fjärrväderdata: UV- och lufttemperatur och luftfuktighet

Med denna nya handledning kommer vi att lära oss hur man gör detsamma men på den här tiden, med en Raspberry Pi för att fånga data från flera olika sensorer och också utforska olika sätt att kommunicera mellan enheter och webben:

Sensorer och kominikeringstyp:

• DHT22 (Temperatur och luftfuktighet) ==> Digital kommunikation
• BMP180 (temperatur och tryck) ==> I2C -protokoll
• DS18B20 (temperatur) ==> 1-trådsprotokoll

Blockdiagrammet visar vad vi kommer att få i slutet med detta projekt:

Steg 1: BoM - Materiallista

1. Raspberry Pi V3 - 32,00 US $
2. DHT22 temperatur- och relativ fuktighetssensor - 9,95 USD
3. Motstånd 4K7 ohm
4. DS18B20 Vattentät temperatursensor - 5,95 USD
5. Motstånd 4K7 ohm
6. BMP180 barometertryck, temperatur- och höjdsensor - 6,99 USD

Steg 2: Installera temperatur- och fuktsensorn

Den första sensorn som installeras är DHT22 för att fånga lufttemperatur- och relativ luftfuktighetsdata. ADAFRUIT -webbplatsen ger bra information om dessa sensorer. Nedan, lite information hämtad därifrån:

Översikt

De billiga DHT-temperatur- och fuktighetssensorerna är mycket enkla och långsamma, men de är bra för amatörer som vill göra grundläggande dataloggning. DHT -sensorerna består av två delar, en kapacitiv fuktighetssensor och en termistor. Det finns också ett mycket grundläggande chip inuti som gör lite analog till digital konvertering och spottar ut en digital signal med temperatur och luftfuktighet. Den digitala signalen är ganska lätt att läsa med vilken mikrokontroller som helst.

DHT22 Huvudegenskaper:

• Låg kostnad
• 3 till 5V effekt och I/O
• 2,5 mA max aktuell användning under konvertering (medan du begär data)
• Bra för 0-100% luftfuktighetsavläsningar med 2-5% noggrannhet
• Bra för -40 till 125 ° C temperaturavläsningar ± 0,5 ° C noggrannhet
• Högst 0,5 Hz samplingsfrekvens (en gång varannan sekund)
• Kroppsstorlek 15,1 mm x 25 mm x 7,7 mm
• 4 stift med 0,1 "mellanrum

En gång brukar du använda sensorn på avstånd mindre än 20m, ett 4K7 ohm -motstånd bör anslutas mellan data- och VCC -stift. DHT22 -utgångsdatapinnen kommer att anslutas till Raspberry GPIO 16. Kontrollera ovanstående elektriska diagram, anslut sensorn till RPi -stiften enligt nedan:

1. Stift 1 - Vcc ==> 3.3V
2. Pin 2 - Data ==> GPIO 16
3. Pin 3 - Not Connect
4. Pin 4 - Gnd ==> Gnd

Glöm inte att installera 4K7 ohm -motståndet mellan Vcc- och datastiften

När sensorn är ansluten måste vi också installera dess bibliotek på vår RPi.

Installera DHT -bibliotek:

På ditt hallon, börja på /hem, gå till /Documents

cd Dokument

Skapa en katalog för att installera biblioteket och flytta dit:

mkdir DHT22_Sensor

cd DHT22_Sensor

Gå till Adafruit GitHub i din webbläsare:

github.com/adafruit/Adafruit_Python_DHT

Ladda ner biblioteket genom att klicka på zip -länken för nedladdning till höger och packa upp arkivet på din Raspberry Pi nyligen skapade mapp. Gå sedan till bibliotekets katalog (undermapp som skapas automatiskt när du packade upp filen) och kör kommandot:

sudo python3 setup.py installera

Öppna ett testprogram (DHT22_test.py) från min GITHUB

importera Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 fuktighet, temperatur = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin) om luftfuktigheten inte är Ingen och temperaturen inte Ingen: print ('Temp = {0: 0.1f}*C Luftfuktighet = {1: 0.1 f}%'. format (temperatur, luftfuktighet)) else: print (' Det gick inte att läsa. Försök igen! ')

Kör programmet med kommandot:

python3 DHT22_test.py

Nedanstående terminalutskriftsskärm visar resultatet.

Steg 3: Installera DS18B20 - temperatursensor

Sensoröversikt:

Vi kommer att använda i denna handledning en vattentät version av DS18B20 -sensorn. Det är mycket användbart för fjärrtemperatur i våta förhållanden, till exempel på fuktig mark. Sensorn är isolerad och kan ta mätningar fram till 125oC (Adafrut rekommenderar inte att använda den över 100oC på grund av dess kabel -PVC -mantel).

DS18B20 är en digital sensor som gör den bra att använda även över långa avstånd! Dessa 1-trådiga digitala temperatursensorer är ganska exakta (± 0,5 ° C över stora delar av intervallet) och kan ge upp till 12 bitar precision från den inbyggda digital-till-analoga omvandlaren. De fungerar utmärkt med NodeMCU med en enda digital stift, och du kan till och med ansluta flera till samma stift, var och en har ett unikt 64-bitars ID inbränt på fabriken för att skilja dem åt.

Sensorn fungerar från 3,0 till 5,0V, vilket innebär att den kan drivas direkt från den 3,3V som tillhandahålls av en av hallonpinnarna (1 eller 17).

Sensorn har 3 ledningar:

• Svart: GND
• Röd: VCC
• Gul: 1-tråds data

Här hittar du fullständig data: DS18B20 Datablad

Sensorinstallation:

Följ diagrammet ovan och gör anslutningarna:

• Vcc ==> 3,3V
• Gnd ==> Gnd
• Data ==> GPIO 4 (standard för bibliotek)

Installera Python -biblioteket:

Låt oss sedan installera Python -biblioteket som hanterar sensorn:

sudo pip3 installera w1thermsensor

Innan du kör skriptet för att testa sensorn, kontrollera om "1-Wire" -gränssnittet är aktiverat i din RPi (se ovanstående utskriftsskärm)

Glöm inte att starta om din RPi efter att du har ändrat konfigurationen

Testar sensorn:

För att testa sensorn kan ett enkelt python -skript användas:

importtid

från w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor () medan True: temperatur = ds18b20Sensor.get_temperature () print ("Temperaturen är % s celsius" % temperatur) time.sleep (1)

Steg 4: Installera BMP180

Sensoröversikt:

BMP180 är efterföljaren till BMP085, en ny generation digitala högtryckssensorer med hög precision för konsumentapplikationer. Ultralåg, lågspänningselektronik i BMP180 är optimerad för användning i mobiltelefoner, handdatorer, GPS-navigationsenheter och utomhusutrustning. Med ett lågt höjdbrus på bara 0,25 m vid snabb konverteringstid erbjuder BMP180 överlägsen prestanda. I2C -gränssnittet möjliggör enkel systemintegration med en mikrokontroller. BMP180 är baserad på piezo-resistiv teknik för EMC-robusthet, hög noggrannhet och linjäritet samt långsiktig stabilitet.

Hela BMP -databladet hittar du här: BMP180 - Digital trycksensor

Sensorinstallation: Följ diagrammet ovan och gör anslutningarna:

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

Aktiverar I2C -gränssnitt

Gå till RPi Configuration och bekräfta att I2C -gränssnittet är aktiverat. Om inte, aktivera det och starta om RPi.

Använda BMP180

Om allt har installerats okej, och allt har anslutits okej, är du nu redo att slå på din Pi och börja se vad BMP180 berättar om världen runt dig.

Det första du ska göra är att kontrollera om Pi ser din BMP180. Prova följande i ett terminalfönster:

sudo i2cdetect -y 1

Om kommandot fungerade bör du se något liknande ovanstående Terminal Printscreen, som visar att BMP180 är på kanal '77'.

Installera BMP180 -biblioteket:

Skapa en katalog för att installera biblioteket:

mkdir BMP180_Sensorcd BMP180_Sensor

Gå till Adafruit GITHub i din webbläsare:

github.com/adafruit/Adafruit_Python_BMP

Ladda ner biblioteket genom att klicka på nedladdningslänken till höger och packa upp arkivet i din Raspberry Pi -skapade mapp. Gå sedan till den undermapp som skapats och kör följande kommando i bibliotekets katalog:

sudo python3 setup.py installera

Öppna din Python IDE och skapa ett testprogram och namnge det, till exempel BMP180Test.py

importera Adafruit_BMP. BMP085 som 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 (sensor.read_sealevel_pressure ()))

Utför testprogrammet:

python3 BMP180Test.py

Ovanstående terminalutskriftsskärm visar resultatet.

Observera att trycket visas i Pa (Pascal). Se nästa steg för att bättre förstå om den här enheten.

Steg 5: Mätning av väder och höjd med BMP180

Låt oss ta en stund att förstå lite mer om vad vi kommer att få, med BMP -avläsningarna. Du kan hoppa över den här delen av självstudien eller återvända senare.

Om du vill veta mer om sensoravläsningar, gå till denna fantastiska handledning:

BMP180 konstruerades för att noggrant mäta atmosfärstryck. Atmosfärstrycket varierar med både väder och höjd.

Vad är atmosfärstryck?

Definitionen av atmosfärstryck är en kraft som luften omkring dig utövar på allt. Vikten av gaserna i atmosfären skapar atmosfärstryck. En vanlig tryckenhet är "pounds per square inch" eller psi. Vi använder här den internationella notationen, det vill säga newton per kvadratmeter, som kallas pascal (Pa).

Om du tog 1 cm bred luftkolonn skulle väga cirka 1 kg

Denna vikt, som trycker ner på kolumnens fotavtryck, skapar det atmosfäriska trycket som vi kan mäta med sensorer som BMP180. Eftersom den cm breda luftpelaren väger cirka 1 kg följer det att det genomsnittliga havsnivåstrycket är cirka 101325 pascal, eller bättre, 1013,25 hPa (1 hPa är också känt som milibar - mbar). Detta kommer att sjunka cirka 4% för varje 300 meter du stiger upp. Ju högre du kommer desto mindre tryck ser du, eftersom kolonnen till toppen av atmosfären är så mycket kortare och väger därför mindre. Detta är användbart att veta, för genom att mäta trycket och göra lite matte kan du bestämma din höjd.

Lufttrycket vid 3, 810 meter är bara hälften av det vid havsnivån.

BMP180 matar ut absolut tryck i pascal (Pa). En pascal är en mycket liten mängd tryck, ungefär den mängd som ett pappersark kommer att utöva vilar på ett bord. Du kommer oftare att se mätningar i hektopascal (1 hPa = 100 Pa). Biblioteket som används här ger utmatningar flytande punktvärden i hPa, vilket också råkar vara lika med en millibar (mbar).

Här är några konverteringar till andra tryckenheter:

• 1 hPa = 100 Pa = 1 mbar = 0,001 bar
• 1 hPa = 0,75006168 Torr
• 1 hPa = 0,01450377 psi (pund per kvadrattum)
• 1 hPa = 0,02953337 inHg (tum kvicksilver)
• 1 hpa = 0,00098692 atm (standardatmosfär)

Temperatureffekter

Eftersom temperaturen påverkar gasens densitet och densiteten påverkar gasens massa och massan påverkar trycket (whew), kommer atmosfärstrycket att förändras dramatiskt med temperaturen. Piloter känner till detta som "densitetshöjd", vilket gör det lättare att ta av en kall dag än en varm eftersom luften är tätare och har en större aerodynamisk effekt. För att kompensera för temperaturen innehåller BMP180 en ganska bra temperatursensor samt en trycksensor.

För att utföra en tryckavläsning tar du först en temperaturavläsning, sedan kombinerar du den med en rå tryckavläsning för att komma fram till en slutlig temperaturkompenserad tryckmätning. (Biblioteket gör allt detta väldigt enkelt.)

Mätning av absolut tryck

Om din applikation kräver mätning av absolut tryck är det bara att få en temperaturavläsning och sedan utföra en tryckavläsning (se exempelskissen för detaljer). Den sista tryckavläsningen kommer att vara i hPa = mbar. Om du vill kan du konvertera detta till en annan enhet med hjälp av ovanstående omvandlingsfaktorer.

Observera att atmosfärens absoluta tryck kommer att variera med både din höjd och det aktuella vädermönstret, som båda är användbara saker att mäta.

Väderobservationer

Atmosfärstrycket på en given plats på jorden (eller var som helst med en atmosfär) är inte konstant. Den komplexa interaktionen mellan jordens snurr, axellutning och många andra faktorer resulterar i rörliga områden med högre och lägre tryck, vilket i sin tur orsakar variationer i vädret vi ser varje dag. Genom att se efter förändringar i trycket kan du förutsäga kortsiktiga förändringar i vädret. Till exempel innebär dropptryck vanligtvis att vått väder eller en storm närmar sig (ett lågtryckssystem rör sig in). Stigande tryck innebär vanligtvis att det är klart väder (ett högtryckssystem går igenom). Men kom ihåg att atmosfärstrycket också varierar med höjd. Det absoluta trycket i mitt hus, Lo Barnechea i Chile (höjd 950m) kommer alltid att vara lägre än det absoluta trycket i San Francisco till exempel (mindre än 2 meter, nästan havsnivå). Om väderstationer bara rapporterade sitt absoluta tryck skulle det vara svårt att direkt jämföra tryckmätningar från en plats till en annan (och stora väderprognoser beror på mätningar från så många stationer som möjligt).

För att lösa detta problem tar väderstationer alltid bort effekterna av höjd från sina rapporterade tryckavläsningar genom att matematiskt lägga till det ekvivalenta fasta trycket för att få det att se ut som om avläsningen gjordes vid havsnivå. När du gör detta kommer en högre avläsning i San Francisco än Lo Barnechea alltid att bero på vädermönster och inte på grund av höjd.

För att göra detta finns det en funktion i biblioteket som kallas havsnivå (P, A). Detta tar det absoluta trycket (P) i hPa och stationens nuvarande höjd (A) i meter och tar bort effekterna av höjden från trycket. Du kan använda denna funktion för att direkt jämföra dina väderavläsningar med andra stationer runt om i världen.

Bestämning av höjd

Eftersom trycket varierar med höjden kan du använda en trycksensor för att mäta höjd (med några varningar). Medeltrycket i atmosfären vid havsnivå är 1013,25 hPa (eller mbar). Detta sjunker till noll när du klättrar mot rymdens vakuum. Eftersom kurvan för detta fall-off är väl förstådd kan du beräkna höjdskillnaden mellan två tryckmätningar (p och p0) med hjälp av en specifik ekvation.

Om du använder havsnivåstryck (1013,25 hPa) som baslinjetryck (p0), kommer ekvationen att vara din nuvarande höjd över havet. Det finns en funktion i biblioteket som kallas höjd (P, P0) som låter dig få den "beräknade höjden".

Ovanstående förklaring extraherades från BMP 180 Sparkfun -handledning.

Steg 6: Komplett HW

Steg 7: Skicka data till ThingSpeak

Vid denna tidpunkt lärde vi oss hur man förbereder RPi för att fånga data från alla 3 sensorerna och skriva ut dem på terminalen. Nu är det dags att se hur man skickar dessa data till en IoT -plattform, ThingSpeak.

Låt oss börja!

Först måste du ha ett konto på ThinkSpeak.com

Följ instruktionerna för att skapa en kanal och notera ditt kanal -ID och Skriv API -nyckel

Ladda ner Python -skriptet från mitt GitHub: localData ToTS_v1_EXT.py

Låt oss kommentera koden viktigaste delarna:

Låt oss först importera ThingSpeak -biblioteket, definiera WiFi -klienten och definiera din lokala router och Thinkspeak -referenser:

importera saker

Det finns flera sätt att kommunicera med ThingSpeak, det enklaste sättet är att använda klientbiblioteket för thingspeak.com API som utvecklats av Mikolaj Chwaliz och Keith Ellis.

Biblioteket kan laddas ner från https://github.com/mchwalisz/thingspeak eller använda PIP på terminal:

sudo pip3 installera thingspeak

Uppdatera sedan inloggningsuppgifterna för ThingSpeak -kanal inuti skriptet

chId = 9999999 # Ange med ditt kanal -id

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

Låt oss nu initiera de 3 sensorerna:

# DS18B20 1-tråds bibliotek

från w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor () # Som standard används GPIO 4 av biblioteket # DHT22 Biblioteksimport Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 bibliotek import Adafruit_BMP1B00. B85 Du bör definiera den verkliga höjden där din väderstation ligger och uppdatera den globala variabeln "altReal". I mitt fall ligger min station 950 meter över havet

global altReal

altReal = 950

När vi väl kommit in med stationens verkliga höjd som ingång kan vi få det absoluta trycket, havsnivåstrycket, temperaturen och höjden med funktionen bmp180GetData (höjd):

def bmp180GetData (höjd):

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 tryck i hPa (eller mbar) alt=rund (alt) presSeaLevel = rund (presSeaLevel/100, 2) # absolut tryck i hPa (eller mbar) returtemp, pres, alt, presSeaLevel

Funktionen getLocalData (), returnerar all lokal data som fångas av vår station:

def getLocalData ():

global timeString global humLab global tempExt global tempLab global presSL global altLab global presAbs # Få tid att läsa nu = datetime.datetime.now () timeString = now.strftime ("%Y-%m-%d%H:%M") # Läs utetemperatur (1 meters avstånd) tempExt = rund (ds18b20Sensor.get_temperature (), 1) tempLab, presAbs, altLab, presSL = bmp180GetData (altReal) humDHT, tempDHT = Adafruit_DHT.read_retry (DHT22Sensor NoneDHT) och tempDHT är inte Ingen: humLab = rund (humDHT

När du har fått all information från ovanstående funktioner måste du skicka dem till ThingSpeak. Du kommer att göra det med funktionen sendDataTs ():

def sendDataTs ():

data = {"field1": tempLab, "field2": tempExt, "field3": humLab, "field4": presSL, "field5": altLab} ts.update (data) print ("[INFO] Data skickas för fem fält: ", tempLab, tempExt, humLab, presSL, altLab)

Med din kanaldata uppdaterad, spara skriptet och kör det på din terminal:

sudo Python3 localData_ToTs_v1_EXT.py

Om kommunikationsprotokoll

Observera att med hjälp av "thingspeak -biblioteket" importeras "förfrågningsbiblioteket", det vill säga ett Apache2 -licenserat HTTP -bibliotek, skrivet i Python. Den officiella dokumentationen för begäran om installation hittar du här:

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

Om det behövs kan du verifiera om förfrågningsbiblioteket är installerat innan du kör skriptet:

sudo pip3 installationsförfrågningar

Alternativt kan du använda MTTQ som en metod för att skicka data till ThingSpeak. MQTT skiljer sig från HTTP, en gång Den är speciellt utformad för att vara lätt och avsedd för inbäddade enheter med lågt RAM -minne och CPU -prestanda. I de flesta fall använder MQTT också mindre bandbredd.

Se denna handledning: Uppdatera en ThingSpeak -kanal med MQTT på en Raspberry Pi för mer information.

Steg 8: Skicka fjärrdata till ThingSpeak med hjälp av ESP8266

För detta steg kommer vi att använda samma HW som förklarades i muy tutorial:

IOT GJORDE LÄTT: Fånga fjärrväderdata: UV- och lufttemperatur och luftfuktighet

Koden som vi kommer att använda här är i princip densamma som användes i den här handledningen. Låt oss kommentera koden viktigaste delarna:

Låt oss först ringa till ESP8266 -biblioteket, definiera WiFi -klienten och definiera din lokala router och Thinkspeak -referenser:

/ * NodeMCU ESP12-E */

#inkludera WiFiClient -klient; const char* MY_SSID = "ENTER MED DITT SSDID"; const char* MY_PWD = "ENTER MED DITT LÖSENORD"; /* Thinkspeak*/ const char* TS_SERVER = "api.thingspeak.com"; String TS_API_KEY = "RETUR MED DIN SKRIVKNAPP";

För det andra, låt oss inkludera ett mycket viktigt bibliotek för IoT -projekt: SimpleTimer.h:

/ * TIMER */

#inkludera SimpleTimer -timer;

För det tredje, under installationen () kommer vi att initiera seriell kommunikation, ringa funktionen connectWiFi () och definiera timern. Observera att kodraden: timer.setInterval (60000L, sendDataTS); kommer att ringa funktionen sendDataTS () var 60: e sekund för att ladda upp data till ThinkSpeak -kanalen.

void setup ()

{… Serial.begin (115200); fördröjning (10); … connectWifi (); timer.setInterval (60000L, sendDataTS); …}

Slutligen men inte minst, under loop (), är det enda kommandot som behövs att initiera timern och det är det!

void loop ()

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

Nedan kan du se de två viktiga funktionerna som används för att hantera Thinkspeak -kommunikation:

ESP12-E-anslutning med ditt WiFi-nätverk:

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

*Anslut WiFi* ***/ void connectWifi () {Serial.print ("Ansluter till"+*MY_SSID); WiFi. Börjar (MY_SSID, MY_PWD); medan (WiFi.status ()! = WL_CONNECTED) {fördröjning (1000); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi -ansluten"); Serial.println (""); }

ESP12-E skickar data till ThinkSpeak:

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

*Skicka data till 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 /uppdatera HTTP /1.1 / n"); client.print ("Värd: api.thingspeak.com / n"); client.print ("Anslutning: stäng / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("Content-Type: application/x-www-form-urlencoded / n"); client.print ("Content-Length:"); client.print (postStr.length ()); client.print ("\ n / n"); client.print (postStr); fördröjning (1000); } skickat ++; client.stop (); }

Den fullständiga koden finns på min GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

När du har laddat upp koden till din NodeMCU. Låt oss ansluta ett externt batteri och göra några mätningar under solen. Jag sätter fjärrstationen på taket och börjar fånga data på ThingSpeak.com enligt bilderna ovan.

Steg 9: Slutanteckningar

Huvudsyftet med denna handledning var att visa hur du ansluter Raspberry Pi till ThingSpeak. Det här är bra att fånga data och logga dem på en IoT -plattform.

Med tillfället skickade vi också data till den specifika kanalen och tog dem från en fjärrstation med hjälp av en ESP8266. Detta tillvägagångssätt är OK, men inte det bästa. Eftersom vi har en "asynkron" operation, försöker ibland både RPi och ESP8266 logga samtidigt (eller med ett litet intervall) vad som motbevisas av ThingSpeak. Idealet skulle få ESP8266 att skicka data lokalt till Raspberry Pi och den sista som ansvarar för att hantera all data. Om du gör det kan "Main Station" (Raspberry Pi) göra tre saker:

• Logga all data på en lokal databas
• Presentera all data på en lokal webbsida (med hjälp av kolv enligt bilden ovan)
• Skickar all data till ThingSpeak samtidigt.

På en framtida handledning kommer vi att utforska dessa alternativ.

Steg 10: Slutsats

Som alltid hoppas jag att detta projekt kan hjälpa andra att hitta in i den spännande världen av elektronik!

För detaljer och slutkod, besök min GitHub-förvaring: RPi-NodeMCU-Weather-Station

För fler projekt, besök min blogg: MJRoBot.org

Håll utkik! Nästa handledning skickar vi data från en fjärrväderstation till en central, baserad på en Raspberry Pi -webbserver:

Hälsningar från södra världen!

Vi ses i min nästa instruerbara!

Tack, Marcelo