Stazione meteorologica: ESP8266 con Deep Sleep, SQL, grafici di Flask&Plotly: 3 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:00

Sarebbe divertente conoscere la temperatura, l'umidità o l'intensità della luce sul tuo balcone? So che lo farei. Così ho realizzato una semplice stazione meteorologica per raccogliere tali dati. Le sezioni seguenti sono i passaggi che ho seguito per crearne uno.

Iniziamo!

Passaggio 1: stazione meteorologica con sensori di luce, temperatura e umidità

Quando ho pianificato di costruire una stazione meteorologica, sognavo di avere una stazione meteorologica a tutti gli effetti che avesse la velocità del vento, la misurazione della pioggia, un sensore solare a spettro completo, ma si è scoperto che non sarebbe stato economico e il costo di acquisto potrebbe finire almeno $100. Ho rinunciato a tutte le opzioni e ho iniziato a costruirne una con $ 10, più o meno. $ 10 è il costo dei componenti di base della stazione meteorologica come le parti di seguito.

Ecco le parti:

1. Il marchio ESP8266 Wemos costa $ 2,39 pezzi su Aliexpress. Consiglierei il marchio Wemos perché il suo EPS8266 è più facile da programmare, aggiornare e ha 4 MB di flash o più.

2. Wemos Charger-Boost Shield costa $ 1,39 pezzi. Questo è un altro vantaggio di utilizzare questo marchio. Ha una scheda boost-up per batteria al litio (tensione nominale = 3,7 V) a 5 V per ESP8266. La scheda è inoltre dotata di un'opzione di ricarica con una corrente di carica massima = 1M.

*Nota: esiste un'opzione più economica per la ricarica/ricarica della batteria al litio. Questo costa $ 1,77 per 5 pezzi. Tuttavia, quando ho usato questa scheda per ESP8266 (di Wemos o un ESP8266 nudo), la modalità deep-sleep di ESP8266 ha attivato un ripristino subito dopo aver attivato l'ESP8266 in un ciclo di sleep-reset-sleep, il che è molto fastidioso. Se sai cosa stava succedendo, per favore scrivimi.

3. Wemos ha anche diversi scudi per la temperatura e l'umidità, ma ho intenzione di costruire da singoli componenti. Fotoresistenza (o resistenza dipendente dalla luce -- ldr, economica), un sensore di luminosità come BH1780 o TSL2561 (circa 0,87-0,89 c pezzi), un sensore di temperatura come DS18B20 (75 c ciascuno) e una combinazione di umidità e temperatura come DHT22 ($ 2,35 qui) o SHT21 ($ 2,20 qui). Un costo totale per il sensore ~$4.

4. Batteria al litio. Ne ho recuperato uno da una batteria Canon da 7,4 V, ovvero due batterie da 3,7 V in serie o una batteria al litio 18650. Ogni 18650 costa circa $ 5 ciascuno. Ho una foto che mostra lo smontaggio del pacco batteria della fotocamera. Fai attenzione però, il cortocircuito durante il taglio della copertura di plastica potrebbe generare calore estremo e bruciare.

5. Scheda PCB, ponticello, filo, saldatura, il tuo tempo, forse alcune abilità di debug.

Lascia che i componenti del filo insieme seguano lo schema sopra.

Quindi, dai un'occhiata all'attività nel ciclo di installazione. È semplicemente un'esecuzione di attività e termina con un comando di sospensione.

void setup() { Serial.begin(115200); Serial.println("Nodo iniziale denominato " + String(SENSORNAME)); setup_wifi(); ritardo(100); Wire.begin(); pinMode(ldrPin, INPUT); SHT21.begin(); if(!tsl.begin()) { Serial.print("TSL2561 non trovato"); mentre(1); } ritardo(100); ldr = analogRead(ldrPin); tsl.enableAutoRange(true); tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS); ritardo(100); sensor_event_t evento; tsl.getEvent(&event); if (evento.luce) lux = evento.luce; else Serial.println("Sovraccarico sensore");

h = SHT21.getHumidity();

t = SHT21.getTemperature(); tempSensor.setWaitForConversion(false); tempSensor.begin(); ritardo(100); if (tempSensor.getDeviceCount() == 0) { Serial.printf("DS18x20 non trovato sul pin %d\n", ds18b20); Serial.flush(); ritardo(1000); } ritardo(100); tempSensor.requestTemperatures(); t18 = tempSensor.getTempCByIndex(0); Serial.printf("\nLuce: %d lux\t", lux); Serial.printf("LDR: %d /1024\t", ldr); Serial.printf("T: %0.2f *C\t", t); Serial.printf("H:%0.2f \t", h); Serial.printf("HIC: %0.2f \t", hic); ritardo(100); client.setServer(mqtt_server, mqtt_port); client.setCallback(richiamata); riconnettersi(); ritardo(100); ESP.deepSleep(3e8); // 300 milioni di microsecondi, 300 secondi, 5 minuti; }

Durante il debug o la configurazione, comandare ESP.deepsleep() per avere una lettura seriale continua. Come sempre, il codice completo da caricare su ESP8266 è ospitato qui (GitHub).

Ricorda di mettere il ponticello tra RST e D0/GPIO16 per attivare un risveglio dopo un periodo di sonno profondo.

Ora è il momento di caricare il codice utilizzando l'IDE Arduino su ESP8266.

Passaggio 2: MQTT: un mezzo flessibile per pubblicare e sottoscrivere dati

Innanzitutto, mi sto appassionando all'utilizzo di MQTT per inviare e ricevere dati attraverso diversi sensori e client nella mia casa. Questo perché la flessibilità di inviare dati illimitati classificati per argomento e client illimitati per iscriversi a un argomento da un broker MQTT. In secondo luogo, non sono qualificato per discutere approfonditamente di MQTT. Ho avuto modo di conoscere MQTT a volte l'anno scorso (2017) quando ho seguito tutorial per configurare una stazione meteorologica e sensori utilizzando Node-RED. Comunque, farò del mio meglio per presentarti alcune informazioni. Un altro buon punto di partenza è Wikipedia.

Se non hai tempo per leggere la teoria e vuoi creare un broker MQTT, ho pubblicato un altro tutorial solo per farlo. Cerca questo post e scorri verso il basso fino al passaggio 4.

Per spiegare cos'è Message Queuing Telemetry Transport (MQTT) nella mia comprensione, ho preparato un diagramma come sopra. In poche parole, MQTT è uno standard ISO e un prodotto come mosquitto e mosquitto-client, due pacchetti che ho usato per creare il broker MQTT su un Raspberry Pi, deve essere conforme a quello standard. Il broker MQTT diventa quindi un mezzo per gli editori per inviare un messaggio e per gli abbonati per ascoltare un argomento di destinazione.

La combinazione della libreria Arduino PubSubclient con ArduinoJson, grazie al suo creatore knolleary e bblanchon, rende più facile per i tinker e gli sviluppatori una serie di strumenti dai sensori a un'apparecchiatura target o a un client finale.

Andiamo avanti con creare Database e visualizzare alcuni dati.

Passaggio 3: salvare i dati in SQL e visualizzarli su un server Web

Ho usato sqlite3 per creare un database per il server web. Installa sqlite3 in Rapberry Pi:

sudo apt-get install sqlite3

creato un database e una tabella digitando nel terminale:

sqlite3 weatherstation.db

CREATE TABLE weatherdata (id INT PRIMARY KEY, thetime DATETIME, ldr INT, tls2561 INT, ds18b20 REAL, tsht21 REAL, hsht21 REAL);

.exit //per uscire dalla riga di comando sqlite e tornare al terminale Linux

Per ascoltare un argomento pubblicato dalla stazione meteo, ho utilizzato una libreria Paho con Python:

#! /usr/bin/python3# adottato da: > # binh nguyen, august 04, 2018, from time import localtime, strftime, sleep import paho.mqtt.client as mqtt import sqlite3, json

mqtt_topic = 'balcony/weatherstation'

mqtt_username = "johndoe" mqtt_password = "password" dbfile = "/path/to/databse/weatherstation.db" mqtt_broker_ip = '192.168.1.50'

# the callback for when the client receives a connack response from the server.

def on_connect(client, userdata, flags, rc): print("connected with result code "+str(rc)) client.subscribe(mqtt_topic) # the callback for when a publish message is received from the server. def on_message(client, userdata, msg): thetime = strftime("%y-%m-%d %h:%m:%s", localtime())

topic = msg.topic

payload = json.dumps(msg.payload.decode('utf-8')) sql_cmd = sql_cmd = """insert into weatherdata values ({0}, '{1}', {2[ldr]}, {2[tsl2561]}, {2[ds18b20]}, {2[tsht21]}, {2[hsht21]})""".format(none, time_, payload) writetodb(sql_cmd) print(sql_cmd) return none

def writetodb(sql_cmd):

conn = sqlite3.connect(dbfile) cur = conn.cursor() cur.execute(sql_command) conn.commit()

client = mqtt.client()

client.on_connect = on_connect client.on_message = on_message client.username_pw_set(username=mqtt_username, password=mqtt_password) client.connect(mqtt_broker_ip, 1883, 60) sleep(1) client.loop_forever()

to display data from use another sql command to query data from the database such as:

sql_command = """ select * from weatherdata order by thetime desc limit 1000;"

this sql command is included in the app.py that uses flask framework and plotty to make a web server and plotting a graph.

the complete code is hosted on the github.

if the esp8266 cannot read the ds18b20, it assigned a value of -127 as the temperature which skews the relative range of other readable temperatures. i cleaned up those values by set a null value to those equals to -127:

sqlite3 weatherstation.db

sqlite3> update weatherdata set ds18b20 = null where ds18b20 = -127;

to set up an environment for this mini web server, i used the shared libraries on raspberry pi. a virtualenv is a better option if the web server is hosted on a powerful computer. start the web server by:

python3 app.py

press control + c to stop the server.

the web server is set to auto-refreshed for every 60 seconds. you can change the interval in index.html file:

battery performance:

i did not measure the current between the normal state or sleep state of esp8266. many others did so. the first google search turned to this page. the normal state of esp8266 consumes about 100ma depends on the rate of transmitting and wifi activity. the deep-sleep state needs in the range of micro a, which a thousand times less.

for 5-minute interval between sleeping and waking up, one single lithium 18650 (2000mah) could fuel my weather station for 12 days. the same battery only enough for esp 8266 ran less than a day with a normal working state. the one i took from the camera battery pack (did not know the capacity) was enough to run the weather station with deep sleep for 5-6 days.

thank you for spending time with me to this end.