L’IoT és fàcil: captura de dades meteorològiques remotes: temperatura i humitat de l’aire i dels raigs ultraviolats: 7 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-02-01 14:39

En aquest tutorial, capturarem dades remotes com UV (radiació ultraviolada), temperatura i humitat de l’aire. Aquestes dades seran molt importants i s’utilitzaran en una futura estació meteorològica completa.

El diagrama de blocs mostra què aconseguirem al final.

Pas 1: BoM: llista de materials

NodeMCU (ESP8266-12E): 9,00 USD

Sensor d'humitat i temperatura (DHT22): 10,00 USD

Sensor UV: 4,00 USD

OLED 12,00 USD

Taula de pa: 1,00 USD

Pas 2: el sensor UV analògic

Aquest sensor UV genera una sortida analògica proporcional a la radiació ultraviolada que es troba a l’espectre de detecció de llum. Utilitza un fotodiode UV (basat en nitrur de gal·li), que pot detectar el rang de llum de 240-370 nm (que cobreix UVB i la major part de l’espectre UVA). El nivell de senyal del fotodiode és molt petit, a nivell de nanoamperes, de manera que el mòdul ha incorporat un amplificador operacional per amplificar el senyal a un nivell de volt més llegible (0 a 1V).

El sensor i l’ampli operatiu es poden alimentar connectant VCC a 3,3 V CC (o 5 V CC) i GND a terra. El senyal analògic es pot obtenir des del pin OUT.

La seva sortida serà en milivolts i la llegirà l’entrada analògica del nostre NodeMCU. Un cop llegit, hauríem de "convertir-lo" (o "mapear-lo") perquè els valors siguin millor gestionats pel codi. Ho podem fer amb la funció readSensorUV ():

/ * Llegiu el sensor UV en mV i truqueu el càlcul de l’índex UV * /

void readSensorUV () {byte numOfReadings = 5; dataSensorUV = 0; for (int i = 0; i <numOfReadings; i ++) {dataSensorUV + = analogRead (sensorUVPin); retard (200); } dataSensorUV / = numOfLectures; dataSensorUV = (dataSensorUV * (3.3 / 1023.0)) * 1000; Serial.println (dataSensorUV); indexCalculate (); }

Un cop tenim les dades UV, podem calcular fàcilment l’índex UV tal com es defineix a la taula anterior. La funció indexCalculate () ho farà per nosaltres:

/ * Càlcul de l’índex UV * /

void indexCalculate () {if (dataSensorUV <227) indexUV = 0; else if (227 <= dataSensorUV && dataSensorUV <318) indexUV = 1; else if (318 <= dataSensorUV && dataSensorUV <408) indexUV = 2; else if (408 <= dataSensorUV && dataSensorUV <503) indexUV = 3; else if (503 <= dataSensorUV && dataSensorUV <606) indexUV = 4; else if (606 <= dataSensorUV && dataSensorUV <696) indexUV = 5; else if (696 <= dataSensorUV && dataSensorUV <795) indexUV = 6; else if (795 <= dataSensorUV && dataSensorUV <881) indexUV = 7; else if (881 <= dataSensorUV && dataSensorUV <976) indexUV = 8; else if (976 <= dataSensorUV && dataSensorUV <1079) indexUV = 9; else if (1079 <= dataSensorUV && dataSensorUV <1170) indexUV = 10; else indexUV = 11; }

Pas 3: Instal·lació d'una pantalla: OLED

A efectes de prova, inclourem un OLED al nostre mesurador UV (aquest pas és completament opcional).

Està bé durant les proves per utilitzar el monitor sèrie, però, què passa quan utilitzeu els vostres prototips lluny del vostre PC en mode autònom? Per a això, instal·larem una pantalla OLED, la SSD1306, que presenta les principals característiques:

• Mida de la pantalla: 0,96"
• Sèrie I2C IIC SPI
• 128X64
• LED LCD OLED blanc

Seguiu l’esquema elèctric i connecteu els 4 pins del nostre OLED:

• VCC va a 3,3V
• GND va a terra
• SCL va a NodeMCU (GPIO 2) ==> D4
• SDA va a NodeMCU (GPIO 0) ==> D3

Un cop hàgim connectat la pantalla, descarreguem i instal·lem la seva biblioteca al nostre IDE Arduino: el "Controlador OLED ESP8266 per a pantalla SSD1306" desenvolupat per Daniel Eichhorn (Assegureu-vos que utilitzeu la versió 3.0.0 o superior).

Instal·leu la biblioteca al vostre IDE Arduino, que es pot trobar a SSD1306Wire.h

Un cop reiniciat l'IDE, la biblioteca ja hauria d'estar instal·lada.

La biblioteca admet el protocol I2C per accedir a la pantalla OLED mitjançant la biblioteca Wire.h integrada:

/ * OLED * /

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306Wire display (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN);

Enumerem algunes API importants que s’utilitzaran amb la nostra pantalla OLED. La llista completa es pot trobar al GITHub proporcionat més amunt.

A. Control de pantalla:

void init (); // Inicialitzar la pantalla

void displayOn (buit); // Activa la pantalla void displayOff (void); // Apagueu la pantalla buida buida (buida); // Esborreu el buffer de píxels local void flipScreenVertically (); // Capgireu la pantalla

B. Operacions de text:

void drawString (int16_t x, int16_t y, text de la cadena); // (xpos, ypos, "Text")

void setFont (const char * fontData); // Estableix el tipus de lletra actual.

Tipus de lletra predeterminats disponibles:

• ArialMT_Plain_10,

• ArialMT_Plain_16,

• ArialMT_Plain_24

Un cop instal·lats el propi OLED i la seva biblioteca, escrivim un programa senzill per provar-lo. Introduïu amb el codi següent al vostre IDE; el resultat hauria de ser una pantalla com es mostra a la foto anterior:

* OLED * /

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306Wire display (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); configuració nul·la () {Serial.begin (115200); displaySetup (); } void loop () {} / * Inicieu i mostreu les dades de configuració a OLED * / void displaySetup () {display.init (); // inicialitzar display display.clear (); // Esborra la pantalla display.flipScreenVertically (); // Capgirar la pantalla display.display (); // Posar dades a la pantalla Serial.println ("Iniciar la prova de visualització"); display.setFont (ArialMT_Plain_24); display.drawString (30, 0, "OLED"); // (xpos, ypos, "Text") display.setFont (ArialMT_Plain_16); display.drawString (18, 29, "Prova iniciada"); display.setFont (ArialMT_Plain_10); display.drawString (10, 52, "Serial BaudRate:"); display.drawString (90, 52, String (11500)); display.display (); // Posar les dades en el retard de visualització (3000); }

El programa anterior es pot descarregar del meu GitHub:

NodeMCU_OLED_Test

Pas 4: un mesurador UV local

Ara, amb la pantalla OLED instal·lada, podem connectar una bateria i fer algunes proves remotes mitjançant el nostre "UV Meter".

#define SW_VERSION "UV_Sensor_V.1"

/ * Sensor UV * / #define sensorUVPin A0 int dataSensorUV = 0; int indexUV = 0; / * OLED * / #include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306Wire display (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); configuració nul·la () {Serial.begin (115200); displaySetup (); } void loop () {readSensorUV (); displayUV (); retard (1000); } / * Inicieu i mostreu les dades de configuració a OLED * / void displaySetup () {display.init (); // inicialitzar display display.clear (); // Esborra la pantalla display.flipScreenVertically (); // Capgirar la pantalla display.display (); // Posar dades a la pantalla Serial.println ("Iniciar la prova del sensor UV"); display.setFont (ArialMT_Plain_24); display.drawString (10, 0, "MJRoBot"); display.setFont (ArialMT_Plain_16); display.drawString (0, 29, "Prova del sensor UV"); display.setFont (ArialMT_Plain_10); display.drawString (0, 52, "SW Ver.:"); display.drawString (45, 52, SW_VERSION); display.display (); retard (3000); } / * Llegiu el sensor UV en mV i truqueu el càlcul de l'índex UV * / void readSensorUV () {byte numOfReadings = 5; dataSensorUV = 0; for (int i = 0; i <numOfReadings; i ++) {dataSensorUV + = analogRead (sensorUVPin); retard (200); } dataSensorUV / = numOfLectures; dataSensorUV = (dataSensorUV * (3.3 / 1023.0)) * 1000; Serial.println (dataSensorUV); indexCalculate (); } / * Càlcul de l’índex UV * / void indexCalculate () {if (dataSensorUV <227) indexUV = 0; else if (227 <= dataSensorUV && dataSensorUV <318) indexUV = 1; else if (318 <= dataSensorUV && dataSensorUV <408) indexUV = 2; else if (408 <= dataSensorUV && dataSensorUV <503) indexUV = 3; else if (503 <= dataSensorUV && dataSensorUV <606) indexUV = 4; else if (606 <= dataSensorUV && dataSensorUV <696) indexUV = 5; else if (696 <= dataSensorUV && dataSensorUV <795) indexUV = 6; else if (795 <= dataSensorUV && dataSensorUV <881) indexUV = 7; else if (881 <= dataSensorUV && dataSensorUV <976) indexUV = 8; else if (976 <= dataSensorUV && dataSensorUV <1079) indexUV = 9; else if (1079 <= dataSensorUV && dataSensorUV <1170) indexUV = 10; else indexUV = 11; } / * Mostra valors UV en OLED local * / void displayUV () {display.clear (); display.setFont (ArialMT_Plain_16); display.drawString (20, 0, "Sensor UV"); display.drawString (0, 23, "UV (mV):"); display.drawString (80, 23, String (dataSensorUV)); display.drawString (0, 48, "Índex UV:"); display.setFont (ArialMT_Plain_24); display.drawString (82, 42, String (indexUV)); display.display (); }

El codi anterior es pot descarregar del meu GitHun: NodeMCU_UV_Sensor_OLED.ino

Pas 5: Instal·lació d’un DHT22 per a mesures de temperatura i humitat de l’aire

Un dels sensors més utilitzats per captar dades meteorològiques és el DHT22 (o el seu germà DHT11), un sensor digital d’humitat relativa i temperatura. Utilitza un sensor d’humitat capacitiu i un termistor per mesurar l’aire circumdant i escup un senyal digital al pin de dades (no calen pins d’entrada analògics).

El sensor hauria d’estar alimentat entre 3,3 V i 5 V i funcionarà de -40 º C a + 80 º C amb una precisió de +/- 0,5 º C per a la temperatura i +/- 2% per a la humitat relativa. També és important tenir en compte que el seu període de detecció és de mitjana de 2 segons (temps mínim entre lectures). El lloc d'Adafruit proporciona molta informació sobre tots dos, DHT22 i el seu germà DHT11. Per obtenir més informació, visiteu la pàgina del tutorial DHT22 / 11.

El DHT22 té 4 pins (cap al sensor, el pin 1 és el més esquerre):

1. VCC (ens connectarem a 3,3V des de NodeMCU);
2. Sortida de dades;
3. No està connectat i
4. Terra.

Una vegada que normalment utilitzeu el sensor a distàncies inferiors a 20 m, s’hauria de connectar una resistència de 10 K entre les dades i els pins VCC. El pin de sortida es connectarà al pin D3 de NodeMCU (vegeu el diagrama anterior). Un cop instal·lat el sensor al nostre mòdul, descarregueu la biblioteca DHT des del dipòsit Adafruit GitHub i instal·leu-la al fitxer Biblioteca Arduino. Quan torneu a carregar el vostre IDE Arduino, s'hauria d'instal·lar la "biblioteca de sensors DHT".

Al principi del codi, hem d'incloure les línies:

/ * DHT22 * /

#include "DHT.h" #define DHTPIN D2 #define DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); flotador zumbat = 0; temperatura flotant = 0;

Es crearà una nova funció per llegir el sensor:

/ * Obteniu dades DHT * /

void getDhtData (void) {float tempIni = temp; float humIni = hum; temp = dht.readTemperature (); hum = dht.readHumidity (); if (isnan (hum) || isnan (temp)) // Comproveu si alguna lectura ha fallat i sortiu aviat (per tornar-ho a provar). {Serial.println ("No s'ha pogut llegir del sensor DHT!"); temp = tempIni; hum = humIni; tornar; }}

El codi complet, inclosos els sensors UV i DHT, es pot descarregar del meu GitHub: NodeMCU_UV_DHT_Sensor_OLED

Pas 6: enviament de dades a ThingSpeak.com

Fins ara, només hem utilitzat el NodeMCU ESP12-E com a placa Arduino normal i ordinària. Per descomptat, només hem "ratllat" el potencial real d'aquest espectacular xip i ara és el moment d'enlairar-se al cel. O millor a les estrelles! Ehr … al núvol!;-)

Anem a començar!

1. En primer lloc, heu de tenir un compte a ThinkSpeak.com
2. Seguiu les instruccions per crear un canal i preneu nota del vostre identificador de canal i de la clau API d'escriptura
3. Actualitzeu el codi següent amb la vostra xarxa WiFi i les credencials de Thinkspeak
4. Executeu el programa a IDE

Comentem les parts més importants del codi:

En primer lloc, truquem a la biblioteca ESP8266, definim el client WiFi i definim les vostres credencials de router i Thinkspeak locals:

/ * ESP12-E i Thinkspeak * /

#include client WiFiClient; const char * MY_SSID = "EL VOSTRE ID SSD AQUÍ"; const char * MY_PWD = "LA VOSTRA CONTRASENYA AQUÍ"; const char * TS_SERVER = "api.thingspeak.com"; String TS_API_KEY = "LA CLAU DE L'API D'ESCRIPTURA DEL CANAL";

En segon lloc, incloguem una biblioteca molt important per a projectes IoT: SimpleTimer.h:

/ * TEMPORITZADOR * /

#include temporitzador SimpleTimer;

En tercer lloc, durant la configuració (), iniciarem la comunicació en sèrie, trucarem a la funció connectWiFi () i definirem els temporitzadors. Tingueu en compte que la línia de codi: timer.setInterval (60000L, sendDataTS); trucarà a la funció sendDataTS () cada 60 segons per tal de pujar dades al canal ThinkSpeak.

configuració nul·la ()

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

Per últim, però no menys important, durant el bucle (), l’única ordre necessària és iniciar el temporitzador i ja està!

bucle buit ()

{… timer.run (); // Inicia SimpleTimer}

A continuació, podeu veure les dues funcions importants que s’utilitzen per gestionar la comunicació de Thinkspeak:

Connexió ESP12-E amb la vostra xarxa WiFi:

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

* Connexió WiFi ************************************************ *** / void connectWifi () {Serial.print ("Connexió a" + * MY_SSID); WiFi.begin (MY_SSID, MY_PWD); while (WiFi.status ()! = WL_CONNECTED) {delay (1000); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi connectat"); Serial.println (""); }

ESP12-E enviament de dades a ThinkSpeak:

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

* Enviament de dades al canal Thinkspeak ********************************************* ****** / void sendDataTS (void) {if (client.connect (TS_SERVER, 80)) {String postStr = TS_API_KEY; postStr + = "& field1 ="; postStr + = String (dataSensorUV); postStr + = "& field2 ="; postStr + = String (indexUV); postStr + = "& field3 ="; postStr + = String (temp); postStr + = "& field4 ="; postStr + = String (hum); postStr + = "\ r / n / r / n"; client.print ("POST / actualització HTTP / 1.1 / n"); client.print ("Amfitrió: api.thingspeak.com / n"); client.print ("Connexió: tancar / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("Tipus de contingut: application / x-www-form-urlencoded / n"); client.print ("Longitud del contingut:"); client.print (postStr.length ()); client.print ("\ n / n"); client.print (postStr); retard (1000); } enviat ++; client.stop (); }

El codi complet es pot trobar al meu GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Un cop tingueu el codi penjat al vostre NodeMCU. Connectem una bateria externa i fem algunes mesures sota el sol. Poso l'Estació Remota al terrat i començo a capturar dades a ThingSpeak.com tal com es mostra a les fotos anteriors.

Pas 7: Conclusió

Com sempre, espero que aquest projecte pugui ajudar els altres a endinsar-se en l’apassionant món de l’electrònica.

Per obtenir més informació i el codi final, visiteu el dipòsit de GitHub: RPi-NodeMCU-Weather-Station

Per obtenir més projectes, visiteu el meu bloc: MJRoBot.org

Estigueu atents! El següent tutorial enviarem dades d'una estació meteorològica remota a una central, basada en un servidor web Raspberry Pi:

Saluts del sud del món!

Ens veiem a la meva propera instrucció!

Gràcies, Marcelo