IoT maklik gemaak: vaslegging van afgeleë weerdata: UV en lugtemperatuur en humiditeit: 7 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-02-01 14:39

In hierdie tutoriaal neem ons data op afstand vas, soos UV (ultravioletstraling), lugtemperatuur en humiditeit. Hierdie data sal baie belangrik wees en sal gebruik word in 'n toekomstige volledige weerstasie.

Die blokdiagram wys wat ons aan die einde sal kry.

Stap 1: BoM - Staatsbrief

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

Sensor vir humiditeit en temperatuur (DHT22) - USD10,00

UV -sensor - USD 4,00

OLED USD 12,00

Broodbord - USD1,00

Stap 2: Die analoog UV -sensor

Hierdie UV-sensor genereer 'n analoog uitset eweredig aan ultravioletstraling wat op die ligsensor spektrum voorkom. Dit gebruik 'n UV-fotodiode (gebaseer op Galliumnitrid), wat die 240-370nm ligreeks kan opspoor (wat UVB en die meeste UVA-spektrum dek). Die seinvlak van die fotodiode is baie klein, op die nano-ampere vlak, sodat die module 'n operasionele versterker ingebed het om die sein na 'n meer leesbare volt-vlak (0 tot 1V) te versterk.

Die sensor en op-amp kan aangedryf word deur VCC aan te sluit op 3.3VDC (of 5VDC) en GND op die grond. Die analoog sein kan verkry word uit die OUT -pen.

Die uitset daarvan is in millivolt en word gelees deur die analoog insette van ons NodeMCU. Sodra dit gelees is, moet ons dit 'omskakel' (of 'kaart') sodat waardes beter deur die kode hanteer kan word. Ons kan dit doen met die funksie readSensorUV ():

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

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); indexCalculate (); }

Sodra ons die UV -data het, kan ons die UV -indeks maklik bereken soos gedefinieer in die tabel hierbo. Die funksie indexCalculate () sal dit vir ons doen:

/ * UV -indeksberekening */

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

Stap 3: Installeer 'n skerm: OLED

Vir toetsdoeleindes sal ons 'n OLED op ons UV -meter insluit (hierdie stap is heeltemal opsioneel).

Dit is goed om tydens die toetse die seriële monitor te gebruik, maar wat gebeur as u u prototipes ver van u rekenaar in 'n losstaande modus gebruik? Laat ons daarvoor 'n OLED -skerm, die SSD1306, installeer, met die belangrikste kenmerke:

• Vertoon grootte: 0.96"
• I2C IIC SPI -reeks
• 128X64
• Wit OLED LCD LED

Volg die elektriese diagram en verbind die 4 penne van ons OLED:

• VCC gaan na 3.3V
• GND gaan grond toe
• SCL gaan na NodeMCU (GPIO 2) ==> D4
• SDA gaan na NodeMCU (GPIO 0) ==> D3

Sodra ons die skerm gekoppel het, kan ons die biblioteek aflaai en installeer op ons Arduino IDE: die "ESP8266 OLED -bestuurder vir SSD1306 -skerm" wat deur Daniel Eichhorn ontwikkel is (maak seker dat u weergawe 3.0.0 of groter gebruik!).

Installeer die biblioteek op u Arduino IDE, wat u op SSD1306Wire.h kan vind

Sodra u die IDE herbegin het, behoort die biblioteek reeds geïnstalleer te wees.

Die biblioteek ondersteun I2C-protokol om toegang tot die OLED-skerm te kry met behulp van die ingeboude Wire.h-biblioteek:

/ * OLED */

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

Kom ons noem 'n paar belangrike API's wat saam met ons OLED -skerm gebruik sal word. Die volledige lys kan gevind word op die GITHub hierbo.

A. Vertoonbeheer:

leegte init (); // Begin die skerm

leegte displayOn (leeg); // Skakel die skerm in op leeg displayOff (leeg); // Skakel die skerm uit; void clear (void); // Maak die leegte van die pixelbuffer leeg, flipScreenVertically (); // Draai die skerm om

B. Teksbewerkings:

void drawString (int16_t x, int16_t y, string text); // (xpos, ypos, "teks")

void setFont (const char* fontData); // Stel die huidige lettertipe in.

Beskikbare verstek lettertipes:

• ArialMT_Plain_10,

• ArialMT_Plain_16,

• ArialMT_Plain_24

Sodra die OLED self en sy biblioteek geïnstalleer is, skryf ons 'n eenvoudige program om dit te toets. Voer die onderstaande kode op u IDE in; die resultaat moet 'n vertoning wees soos op die foto hierbo getoon:

* OLED */

#include "SSD1306Wire.h" #include "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306Wire -skerm (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); ongeldige opstelling () {Serial.begin (115200); displaySetup (); } leemte -lus () {} / * Begin en stel opstellingdata op OLED * / ongeldig displaySetup () {display.init (); // initialiseer vertoning display.clear (); // Maak die display display.flipScreenVertically () skoon; // Draai die skerm onderstebo display.display (); // Plaas data op die skerm Serial.println ("Begin skermtoets"); display.setFont (ArialMT_Plain_24); display.drawString (30, 0, "OLED"); // (xpos, ypos, "Text") display.setFont (ArialMT_Plain_16); display.drawString (18, 29, "Toets begin"); display.setFont (ArialMT_Plain_10); display.drawString (10, 52, "Serial BaudRate:"); display.drawString (90, 52, String (11500)); vertoon.display (); // Sit data op vertoning vertoon (3000); }

Bogenoemde program kan afgelaai word vanaf my GitHub:

NodeMCU_OLED_Toets

Stap 4: 'n Plaaslike UV -meter

As die OLED -skerm geïnstalleer is, kan ons 'n battery aansluit en afstandstoetse doen met ons 'UV -meter'

#definieer SW_VERSIE "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; SSD1306Wire -skerm (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); ongeldige opstelling () {Serial.begin (115200); displaySetup (); } leemte -lus () {readSensorUV (); displayUV (); vertraging (1000); } / * Begin en stel opstellingdata op OLED * / ongeldig displaySetup () {display.init (); // inisialiseer display display.clear (); // Maak die display display.flipScreenVertically () skoon; // Draai die skerm onderstebo display.display (); // Sit data op die skerm Serial.println ("Inisieer UV -sensor toets"); display.setFont (ArialMT_Plain_24); display.drawString (10, 0, "MJRoBot"); display.setFont (ArialMT_Plain_16); display.drawString (0, 29, "UV Sensor Test"); display.setFont (ArialMT_Plain_10); display.drawString (0, 52, "SW Ver.:"); display.drawString (45, 52, SW_VERSION); vertoon.display (); vertraging (3000); } / * Lees UV -sensor in mV en bel UV -indeksberekening * / 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); indexCalculate (); } / * UV -indeksberekening * / leegte indexCalculate () {if (dataSensorUV <227) indexUV = 0; anders as (227 <= dataSensorUV && dataSensorUV <318) indexUV = 1; anders as (318 <= dataSensorUV && dataSensorUV <408) indexUV = 2; anders as (408 <= dataSensorUV && dataSensorUV <503) indexUV = 3; anders as (503 <= dataSensorUV && dataSensorUV <606) indexUV = 4; anders as (606 <= dataSensorUV && dataSensorUV <696) indexUV = 5; anders as (696 <= dataSensorUV && dataSensorUV <795) indexUV = 6; anders as (795 <= dataSensorUV && dataSensorUV <881) indexUV = 7; anders as (881 <= dataSensorUV && dataSensorUV <976) indexUV = 8; anders as (976 <= dataSensorUV && dataSensorUV <1079) indexUV = 9; anders as (1079 <= dataSensorUV && dataSensorUV <1170) indexUV = 10; anders indexUV = 11; } /* Wys UV -waardes op plaaslike OLED* / ongeldig 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 -indeks:"); display.setFont (ArialMT_Plain_24); display.drawString (82, 42, string (indexUV)); vertoon.display (); }

Bogenoemde kode kan afgelaai word vanaf my GitHun: NodeMCU_UV_Sensor_OLED.ino

Stap 5: Installeer 'n DHT22 vir lugtemperatuur- en humiditeitsmetings

Een van die mees gebruikte sensors vir die opsporing van weerdata is die DHT22 (of sy broer DHT11), 'n digitale relatiewe humiditeits- en temperatuursensor. Dit gebruik 'n kapasitiewe humiditeitsensor en 'n termistor om die omringende lug te meet en spoeg 'n digitale sein op die datapen uit (geen analoog invoerpenne nodig nie).

Die sensor moet tussen 3,3V en 5V aangedryf word en werk van -40oC tot +80oC met 'n akkuraatheid van +/- 0,5oC vir temperatuur en +/- 2% vir relatiewe humiditeit. Dit is ook belangrik om in gedagte te hou dat die waarnemingsperiode gemiddeld 2 sekondes is (minimum tyd tussen lesings). Die webwerf van Adafruit bied baie inligting oor beide, DHT22 en sy broer DHT11. Besoek die tutoriaalbladsy van DHT22/11 vir meer besonderhede.

Die DHT22 het 4 penne (na die sensor gerig, pen 1 is die linkerkant):

1. VCC (ons koppel aan 3.3V vanaf NodeMCU);
2. Data uit;
3. Nie gekoppel nie en
4. Grond.

As u die sensor gewoonlik op afstande van minder as 20 m gebruik, moet 'n 10K -weerstand tussen data- en VCC -penne verbind word. Die uitvoerpen sal aan NodeMCU -pen D3 gekoppel word (sien die diagram hierbo). Sodra die sensor by ons module geïnstalleer is, laai die DHT -biblioteek af van die Adafruit GitHub -bewaarplek en installeer dit in u Arduino's Library -lêer. Sodra u u Arduino IDE herlaai het, moet die "DHT -sensorbiblioteek" geïnstalleer word.

Aan die begin van die kode moet ons die lyne insluit:

/* DHT22*/

#sluit "DHT.h" in #definieer DHTPIN D2 #definieer DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); float hum = 0; vlot temp = 0;

'N Nuwe funksie sal geskep word om die sensor te lees:

/ * Kry DHT -data */

void getDhtData (void) {float tempIni = temp; float humIni = neurie; temp = dht.readTemperature (); hum = dht.readHumidity (); if (isnan (hum) || isnan (temp)) // Kontroleer of enige lees misluk het en verlaat vroeg (om weer te probeer). {Serial.println ("Kan nie lees van DHT -sensor nie!"); temp = tempIni; neurie = humIni; terugkeer; }}

Die volledige kode, insluitend die UV- en DHT -sensors, kan afgelaai word vanaf my GitHub: NodeMCU_UV_DHT_Sensor_OLED

Stap 6: Stuur data na ThingSpeak.com

Tot dusver het ons slegs die NodeMCU ESP12-E gebruik as 'n gewone en gewone Arduino-bord. Natuurlik het ons slegs die werklike potensiaal van hierdie skouspelagtige klein skyfie "gekrap" en is dit nou die tyd om op te styg hemel toe! Of beter vir die sterre! Ehr … na die wolk!;-)

Laat ons begin!

1. Eerstens moet u 'n rekening by ThinkSpeak.com hê
2. Volg die instruksies om 'n kanaal te skep en let op u kanaal -ID en skryf API -sleutel
3. Dateer die onderstaande kode op met u WiFi -netwerk en Thinkspeak -geloofsbriewe
4. Begin die program op IDE

Kom ons gee kommentaar op die belangrikste dele van die kode:

Kom ons skakel eers die ESP8266 -biblioteek, definieer die WiFi -kliënt en definieer u plaaslike router- en Thinkspeak -geloofsbriewe:

/* ESP12-E & Thinkspeak*/

#sluit WiFiClient -kliënt in; const char* MY_SSID = "U SSD ID HIER"; const char* MY_PWD = "U WAGwoord HIER"; const char* TS_SERVER = "api.thingspeak.com"; String TS_API_KEY = "U KANAAL SKRYWE API -SLEUTEL";

Tweedens, laat ons 'n baie belangrike biblioteek vir IoT -projekte insluit: SimpleTimer.h:

/ * TIMER */

#sluit SimpleTimer -timer in;

Derdens, tydens die opstelling (), begin ons met seriële kommunikasie, skakel die funksie connectWiFi () en definieer die tydtellers. Let daarop dat die kodereël: timer.setInterval (60000L, sendDataTS); sal elke 60 sekondes die funksie sendDataTS () noem om data na ThinkSpeak -kanaal op te laai.

leemte opstelling ()

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

Uiteindelik, maar tydens die lus (), is die enigste opdrag wat nodig is om die timer te begin en dit is dit!

leemte lus ()

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

Hieronder kan u die twee belangrike funksies sien wat gebruik word om Thinkspeak -kommunikasie te hanteer:

ESP12-E-verbinding met u WiFi-netwerk:

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

*Verbind WiFi ********************************************** ***/ void connectWifi () {Serial.print ("Koppel aan"+*MY_SSID); WiFi.begin (MY_SSID, MY_PWD); terwyl (WiFi.status ()! = WL_CONNECTED) {vertraging (1000); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi gekoppel"); Serial.println (""); }

ESP12-E stuur data na ThinkSpeak:

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

*Stuur data na 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 (hum); postStr += "\ r / n / r / n"; client.print ("POST /opdater HTTP /1.1 / n"); client.print ("Gasheer: api.thingspeak.com / n"); client.print ("verbinding: sluit / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("Inhoudstipe: toepassing/x-www-vorm-urlencoded / n"); client.print ("Inhoudlengte:"); client.print (postStr.length ()); client.print ("\ n / n"); client.print (postStr); vertraging (1000); } gestuur ++; client.stop (); }

Die volledige kode kan gevind word op my GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Sodra u die kode na u NodeMCU opgelaai het. Kom ons koppel 'n eksterne battery en meet onder die son. Ek sit die afstandstasie op die dak en begin met die opneem van data op ThingSpeak.com soos in die foto's hierbo getoon.

Stap 7: Gevolgtrekking

Soos altyd, hoop ek dat hierdie projek ander kan help om die opwindende wêreld van elektronika te vind!

Besoek my GitHub-bewaarplek: RPi-NodeMCU-Weather-Station vir besonderhede en finale kode.

Besoek my blog vir meer projekte: MJRoBot.org

Bly ingeskakel! Volgende tutoriaal stuur ons data van 'n afgeleë weerstasie na 'n sentrale, gebaseer op 'n Raspberry Pi -webbediener:

Groete uit die suide van die wêreld!

Sien jou in my volgende instruksies!

Dankie, Marcelo