IoT gemakkelijk gemaakt: externe weergegevens vastleggen: UV- en luchttemperatuur en -vochtigheid - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-02-01 14:41

In deze zelfstudie zullen we externe gegevens vastleggen zoals UV (ultraviolette straling), luchttemperatuur en vochtigheid. Die gegevens zullen erg belangrijk zijn en zullen worden gebruikt in een toekomstig compleet weerstation.

Het blokdiagram laat zien wat we aan het einde zullen krijgen.

Stap 1: Stuklijst - Stuklijst

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

Vochtigheids- en temperatuursensor (DHT22) - USD10.00

UV-sensor - USD 4,00

OLED USD 12,00

Breadboard - USD1.00

Stap 2: De analoge UV-sensor

Deze UV-sensor genereert een analoge output die evenredig is met de ultraviolette straling die wordt aangetroffen in het lichtgevoelige spectrum. Het maakt gebruik van een UV-fotodiode (gebaseerd op galliumnitride), die het lichtbereik van 240-370 nm kan detecteren (dat UVB en het grootste deel van het UVA-spectrum dekt). Het signaalniveau van de fotodiode is erg klein, in het nano-ampère-niveau, dus de module heeft een operationele versterker ingebouwd om het signaal te versterken tot een beter leesbaar volt-niveau (0 tot 1V).

De sensor en op-amp kunnen worden gevoed door VCC aan te sluiten op 3,3 VDC (of 5 VDC) en GND op de voedingsaarde. Het analoge signaal kan worden verkregen van de OUT-pin.

De uitvoer is in millivolt en wordt gelezen door de analoge invoer van onze NodeMCU. Eenmaal gelezen, moeten we het "converteren" (of "in kaart brengen") zodat waarden beter door de code kunnen worden verwerkt. We kunnen het doen met de functie readSensorUV():

/* Lees UV-sensor in mV en bel UV-indexberekening */

void readSensorUV() { byte numOfReadings = 5; dataSensorUV = 0; for (int i=0; i<numOfReadings; i++) { dataSensorUV += analogRead(sensorUVPin); vertraging (200); } dataSensorUV /= numOfReadings; dataSensorUV = (dataSensorUV * (3,3 / 1023,0))*1000; Serial.println(dataSensorUV); indexBerekenen(); }

Zodra we de UV-gegevens hebben, kunnen we eenvoudig de UV-index berekenen zoals gedefinieerd in de bovenstaande tabel. De functie indexCalculate() doet het voor ons:

/* UV-index berekening */

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

Stap 3: Een beeldscherm installeren: OLED

Voor testdoeleinden zullen we een OLED op onze UV-meter opnemen (deze stap is volledig optioneel).

Het is prima om tijdens tests de seriële monitor te gebruiken, maar wat gebeurt er als u uw prototypes ver van uw pc in een stand-alone modus gebruikt? Laten we daarvoor een OLED-scherm installeren, de SSD1306, met als belangrijkste kenmerken:

• Schermgrootte: 0,96"
• I2C IIC SPI serieel
• 128X64
• Witte OLED LCD-LED

Volg het elektrisch schema en sluit de 4 pinnen van onze OLED aan:

• VCC gaat naar 3.3V
• GND gaat naar de grond
• SCL gaat naar NodeMCU (GPIO 2) ==>D4
• SDA gaat naar NodeMCU (GPIO 0) ==>D3

Zodra we het display hebben aangesloten, gaan we de bibliotheek downloaden en installeren op onze Arduino IDE: de "ESP8266 OLED Driver for SSD1306 display" ontwikkeld door Daniel Eichhorn (zorg ervoor dat u versie 3.0.0 of groter gebruikt!).

Installeer de bibliotheek op je Arduino IDE, die te vinden is op SSD1306Wire.h

Nadat u de IDE opnieuw hebt opgestart, zou de bibliotheek al moeten zijn geïnstalleerd.

De bibliotheek ondersteunt het I2C-protocol om toegang te krijgen tot het OLED-scherm met behulp van de ingebouwde Wire.h-bibliotheek:

/* OLED */

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

Laten we een aantal belangrijke API's opsommen die met ons OLED-scherm zullen worden gebruikt. De volledige lijst is te vinden op de GITHub hierboven.

A. Displaybediening:

ongeldig init(); // Initialiseer het scherm

ongeldige weergaveAan (ongeldig); // Zet het display aan void displayOff (void); // Zet het display uit void clear (void); // Wis de lokale pixelbuffer leegte flipScreenVertical(); // Draai het scherm ondersteboven

B. Tekstbewerkingen:

void drawString (int16_t x, int16_t y, String-tekst); // (xpos, ypos, "Tekst")

void setFont(const char* fontData); // Stelt het huidige lettertype in.

Beschikbare standaardlettertypen:

• ArialMT_Plain_10,

• ArialMT_Plain_16,

• ArialMT_Plain_24

Zodra zowel de OLED zelf als de bibliotheek zijn geïnstalleerd, gaan we een eenvoudig programma schrijven om het te testen. Voer de onderstaande code in op uw IDE, het resultaat zou een weergave moeten zijn zoals weergegeven in de bovenstaande foto:

* OLED */

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306Draadweergave (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); void setup () { Serial.begin(115200); beeldschermopstelling(); } void loop() { } /* Start en toon instellingsgegevens op OLED */ void displaySetup() { display.init(); // initialiseer display display.clear(); // Duidelijke weergave display.flipScreenVertical(); // Draai het scherm ondersteboven display.display(); // Zet gegevens op het display Serial.println ("Initiating Display Test"); display.setFont(ArialMT_Plain_24); display.drawString (30, 0, "OLED"); // (xpos, ypos, "Text") display.setFont (ArialMT_Plain_16); display.drawString (18, 29, "Test gestart"); display.setFont(ArialMT_Plain_10); display.drawString(10, 52, "Seriële baudrate:"); display.drawString(90, 52, String (11500)); weergave.weergave(); // Zet gegevens op weergavevertraging (3000); }

Bovenstaand programma is te downloaden vanaf mijn GitHub:

KnooppuntMCU_OLED_Test

Stap 4: Een lokale UV-meter

Nu het OLED-scherm is geïnstalleerd, kunnen we een batterij aansluiten en enkele tests op afstand uitvoeren met onze "UV-meter"

#define SW_VERSION "UV_Sensor_V.1"

/* UV-sensor */ #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; SSD1306Draadweergave (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); void setup() { Serial.begin(115200); beeldschermopstelling(); } void loop() { readSensorUV(); displayUV(); vertraging (1000); } /* Start en toon instellingsgegevens op OLED */ void displaySetup() { display.init(); // initialiseer display display.clear(); // Duidelijke weergave display.flipScreenVertical(); // Draai het scherm ondersteboven display.display(); // Zet gegevens op het display Serial.println ("Initiating UV Sensor Test"); display.setFont(ArialMT_Plain_24); display.drawString (10, 0, "MJRoBot"); display.setFont(ArialMT_Plain_16); display.drawString (0, 29, "UV-sensortest"); display.setFont(ArialMT_Plain_10); display.drawString (0, 52, "SW Ver.:"); display.drawString(45, 52, SW_VERSION); weergave.weergave(); vertraging (3000); } /* Lees UV-sensor in mV en bel UV-indexberekening */ void readSensorUV() { byte numOfReadings = 5; dataSensorUV = 0; for (int i=0; i<numOfReadings; i++) { dataSensorUV += analogRead(sensorUVPin); vertraging (200); } dataSensorUV /= numOfReadings; dataSensorUV = (dataSensorUV * (3,3 / 1023,0))*1000; Serial.println(dataSensorUV); indexBerekenen(); } /* UV-indexberekening */ void indexCalculate() { if (dataSensorUV < 227) indexUV = 0; anders if (227 <= dataSensorUV && dataSensorUV < 318) indexUV = 1; anders if (318 <= dataSensorUV && dataSensorUV < 408) indexUV = 2; anders if (408 <= dataSensorUV && dataSensorUV < 503) indexUV = 3; anders if (503 <= dataSensorUV && dataSensorUV < 606) indexUV = 4; anders if (606 <= dataSensorUV && dataSensorUV < 696) indexUV = 5; anders if (696 <= dataSensorUV && dataSensorUV < 795) indexUV = 6; anders if (795 <= dataSensorUV && dataSensorUV < 881) indexUV = 7; anders if (881 <= dataSensorUV && dataSensorUV < 976) indexUV = 8; anders if (976 <= dataSensorUV && dataSensorUV < 1079) indexUV = 9; anders if (1079 <= dataSensorUV && dataSensorUV < 1170) indexUV = 10; anders indexUV = 11; } /* Geef UV-waarden weer op lokale OLED*/ void displayUV() { display.clear(); display.setFont(ArialMT_Plain_16); display.drawString (20, 0, "UV-sensor"); display.drawString (0, 23, "UV (mV):"); display.drawString(80, 23, String(dataSensorUV)); display.drawString (0, 48, "UV-index:"); display.setFont(ArialMT_Plain_24); display.drawString(82, 42, String(indexUV)); weergave.weergave(); }

De bovenstaande code kan worden gedownload van mijn GitHun: NodeMCU_UV_Sensor_OLED.ino

Stap 5: Een DHT22 installeren voor luchttemperatuur- en vochtigheidsmetingen

Een van de meest gebruikte sensoren voor het vastleggen van weergegevens is de DHT22 (of zijn broer DHT11), een digitale relatieve vochtigheids- en temperatuursensor. Het gebruikt een capacitieve vochtigheidssensor en een thermistor om de omringende lucht te meten en spuugt een digitaal signaal uit op de datapin (geen analoge ingangspinnen nodig).

De sensor moet worden gevoed tussen 3,3V en 5V en werkt van -40oC tot +80oC met een nauwkeurigheid van +/- 0,5oC voor temperatuur en +/-2% voor relatieve vochtigheid. Het is ook belangrijk om in gedachten te houden dat de detectieperiode gemiddeld 2 seconden is (minimale tijd tussen metingen). De site van Adafruit geeft veel informatie over zowel DHT22 als zijn broer DHT11. Ga voor meer informatie naar de DHT22/11-zelfstudiepagina.

De DHT22 heeft 4 pinnen (naar de sensor gericht, pin 1 is de meest linkse):

1. VCC (we zullen verbinding maken met 3.3V van NodeMCU);
2. Gegevens uit;
3. Niet aangesloten en
4. Grond.

Als u de sensor gewoonlijk gebruikt op afstanden van minder dan 20 m, moet een weerstand van 10K worden aangesloten tussen de data- en VCC-pinnen. De output-pin wordt verbonden met NodeMCU-pin D3 (zie het bovenstaande diagram). Zodra de sensor op onze module is geïnstalleerd, downloadt u de DHT-bibliotheek van de Adafruit GitHub-repository en installeert u deze in het bibliotheekbestand van uw Arduino. Nadat u uw Arduino IDE opnieuw hebt geladen, moet de "DHT-sensorbibliotheek" worden geïnstalleerd.

Aan het begin van de code moeten we de regels opnemen:

/* DHT22*/

#include "DHT.h" #define DHTPIN D2 #define DHTTYPE DHT22 DHT dht(DHTPIN, DHTTYPE); zwevende brom = 0; vlottertemperatuur = 0;

Er wordt een nieuwe functie gemaakt om de sensor te lezen:

/* DHT-gegevens ophalen */

void getDhtData (void) { float tempIni = temp; float humIni = brom; temp = dht.readTemperature(); brom = dht.readHumidity(); if (isnan(hum) || isnan(temp)) // Controleer of het lezen is mislukt en sluit vroeg af (om het opnieuw te proberen). { Serial.println("Kan niet lezen van DHT-sensor!"); temp = tempIni; brom = humIni; opbrengst; } }

De volledige code inclusief de UV- en DHT-sensoren kan worden gedownload van mijn GitHub: NodeMCU_UV_DHT_Sensor_OLED

Stap 6: Gegevens verzenden naar ThingSpeak.com

Tot nu toe hebben we de NodeMCU ESP12-E alleen gebruikt als een gewoon en gewoon Arduino-bord. Natuurlijk hebben we alleen het echte potentieel van deze spectaculaire kleine chip "gekrast" en nu is het tijd om naar de hemel te stijgen! Of beter naar de sterren! Euh…naar de wolk!;-)

Laten we beginnen!

1. Ten eerste moet u een account hebben op ThinkSpeak.com
2. Volg de instructies om een kanaal te maken en noteer uw kanaal-ID en schrijf-API-sleutel
3. Werk de onderstaande code bij met uw wifi-netwerk en Thinkspeak-inloggegevens
4. Voer het programma uit op IDE

Laten we de belangrijkste delen van de code becommentariëren:

Laten we eerst de ESP8266-bibliotheek bellen, de WiFi-client definiëren en uw lokale router- en Thinkspeak-referenties definiëren:

/* ESP12-E & Thinkspeak*/

#include WiFiClient-client; const char* MY_SSID = "UW SSD-ID HIER"; const char* MY_PWD = "UW PASWOORD HIER"; const char* TS_SERVER = "api.thingspeak.com"; String TS_API_KEY ="JE KANAAL SCHRIJF API-SLEUTEL";

Ten tweede, laten we een zeer belangrijke bibliotheek voor IoT-projecten toevoegen: SimpleTimer.h:

/* TIMER */

#include SimpleTimer-timer;

Ten derde zullen we tijdens setup() seriële communicatie starten, de functie connectWiFi() aanroepen en de timers definiëren. Merk op dat de regel code: timer.setInterval(60000L, sendDataTS); zal elke 60 seconden de functie sendDataTS() aanroepen om gegevens naar het ThinkSpeak-kanaal te uploaden.

ongeldige setup()

{ … Serieel.begin(115200); vertraging(10); … verbindenWifi(); timer.setInterval(60000L, sendDataTS); … }

Ten slotte, tijdens de loop(), is het enige commando dat nodig is om de timer te starten en dat is alles!

lege lus()

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

Hieronder ziet u de twee belangrijke functies die worden gebruikt om Thinkspeak-communicatie af te handelen:

ESP12-E verbinding met uw wifi-netwerk:

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

* Wifi aansluiten ********************************************** ***/ void connectWifi() { Serial.print("Verbinding maken met "+ *MY_SSID); WiFi.begin(MY_SSID, MY_PWD); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serieel.print("."); } Serieel.println(""); Serial.println("WiFi Verbonden"); Serieel.println(""); }

ESP12-E verzendt gegevens naar ThinkSpeak:

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

* Gegevens verzenden naar Thinkspeak Channel ******************************************** ******/ 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 (brom); postStr += "\r\n\r\n"; client.print("POST /update HTTP/1.1\n"); client.print("Host: api.thingspeak.com\n"); client.print("Verbinding: sluiten\n"); client.print("X-THINGSPEAKAPIKEY: " + TS_API_KEY + "\n"); client.print("Inhoudstype: applicatie/x-www-form-urlencoded\n"); client.print ("Inhoudslengte: "); client.print(postStr.length()); cliënt.print("\n\n"); cliënt.print(postStr); vertraging (1000); } verzonden++; klant.stop(); }

De volledige code is te vinden op mijn GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Zodra je de code hebt geüpload naar je NodeMCU. Laten we een externe batterij aansluiten en wat metingen doen onder de zon. Ik plaats het Remote Station op het dak en begin met het vastleggen van gegevens op ThingSpeak.com, zoals te zien is op bovenstaande foto's.

Stap 7: Conclusie

Zoals altijd hoop ik dat dit project anderen kan helpen hun weg te vinden in de opwindende wereld van elektronica!

Ga voor meer informatie en de definitieve code naar mijn GitHub-opslagplaats: RPi-NodeMCU-Weather-Station

Ga voor meer projecten naar mijn blog: MJRoBot.org

Blijf kijken! Volgende tutorial zullen we gegevens van een extern weerstation naar een centraal weerstation sturen, gebaseerd op een Raspberry Pi-webserver:

Saludos uit het zuiden van de wereld!

Tot ziens in mijn volgende instructable!

Bedankt, Marcelo