IoT u lehtësua: Regjistrimi i të dhënave të motit në distancë: UV dhe ajri Temperatura dhe lagështia: 7 hapa

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-02-01 14:42

Në këtë tutorial, ne do të kapim të dhëna të largëta si UV (rrezatimi ultraviolet), temperatura e ajrit dhe lagështia. Ato të dhëna do të jenë shumë të rëndësishme dhe do të përdoren në një Stacion të Moti të plotë në të ardhmen.

Diagrami i bllokut tregon se çfarë do të marrim në fund.

Hapi 1: BM - Fatura e Materialit

NodeMCU (ESP8266-12E) - 9.00 USD

Sensori i lagështisë dhe temperaturës (DHT22) - 10,00 USD

Sensori UV - 4.00 USD

OLED 12.00 USD

Breadboard - 1 USD

Hapi 2: Sensori Analog UV

Ky sensor UV gjeneron një dalje analoge proporcionale me rrezatimin Ultra-Violet që gjendet në spektrin e ndijimit të dritës. Ai përdor një fotodiodë UV (bazuar në nitridin e galiumit), i cili mund të zbulojë gamën e dritës 240-370nm (e cila mbulon UVB dhe shumicën e spektrit UVA). Niveli i sinjalit nga fotodioda është shumë i vogël, në nivelin nano-amper, kështu që moduli ka përfshirë një përforcues operacional për të amplifikuar sinjalin në një nivel volt më të lexueshëm (0 deri 1V).

Sensori dhe op-amp mund të fuqizohen, duke lidhur VCC me 3.3VDC (ose 5VDC) dhe GND me tokëzimin e energjisë. Sinjali analog mund të merret nga kunja OUT.

Dalja e tij do të jetë në milivolt dhe do të lexohet nga Anput Analog i NodeMCU -së sonë. Pasi të lexohet, ne duhet ta "konvertojmë" (ose "hartojmë") që vlerat të trajtohen më mirë nga kodi. Ne mund ta bëjmë atë me funksionin readSensorUV ():

/ * Lexoni sensorin UV në mV dhe thirrni llogaritjen e indeksit UV */

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

Pasi të kemi të dhënat UV mund të llogarisim lehtësisht indeksin UV siç përcaktohet në tabelën e mësipërme. Funksioni indexCalculate () do ta bëjë atë për ne:

/ * Llogaritja e indeksit UV */

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

Hapi 3: Instalimi i një ekrani: OLED

Për qëllime testimi, ne do të përfshijmë një OLED në matësin tonë UV (Ky hap është plotësisht opsional).

OKshtë në rregull gjatë testeve, të përdorni Serial Monitor, por çfarë po ndodh kur përdorni prototipet tuaj larg kompjuterit tuaj në mënyrë të pavarur? Për këtë, le të instalojmë një ekran OLED, SSD1306, të cilat karakteristikat kryesore janë:

• Madhësia e ekranit: 0.96"
• Seriali I2C IIC SPI
• 128X64
• LED i bardhë OLED LCD

Ndiqni diagramin elektrik dhe lidhni 4 kunjat e OLED -it tonë:

• VCC shkon në 3.3V
• GND shkon në tokë
• SCL shkon në NodeMCU (GPIO 2) ==> D4
• SDA shkon në NodeMCU (GPIO 0) ==> D3

Pasi të kemi lidhur ekranin, le të shkarkojmë dhe instalojmë bibliotekën e tij në Arduino IDE tonë: "ESP8266 OLED Driver for SSD1306 display" i zhvilluar nga Daniel Eichhorn (Sigurohuni që përdorni Versionin 3.0.0 ose më të madh!).

Instaloni bibliotekën në Arduino IDE tuaj, që mund të gjendet në SSD1306Wire.h

Pasi të keni rifilluar IDE, biblioteka duhet të jetë e instaluar tashmë.

Biblioteka mbështet protokollin I2C për të hyrë në ekranin OLED duke përdorur bibliotekën e integruar Wire.h:

/ * OLED */

#përfshi "SSD1306Wire.h" #përfshi "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306 Ekran me tela (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN);

Le të rendisim disa API të rëndësishëm që do të përdoren me ekranin tonë OLED. Lista e plotë mund të gjendet në GITHub të dhënë më lart.

A. Kontrolli i ekranit:

void init (); // Filloni ekranin

void displayOn (void); // Ndizni ekranin në void displayOff (void); // Fikni ekranin e fikur void qartë (të pavlefshëm); // Pastro vendndodhjen e pixel buffer void flipScreenVertical (); // Kthejeni ekranin përmbys

B. Operacionet e tekstit:

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

void setFont (const char* fontData); // Vendos fontin aktual.

Shkronjat e paracaktuara të disponueshme:

• ArialMT_Plain_10,

• ArialMT_Plain_16,

• ArialMT_Plain_24

Pasi të jetë instaluar vetë OLED dhe Biblioteka e tij, le të shkruajmë një program të thjeshtë për ta testuar atë. Shkruani me kodin e mëposhtëm në IDE tuaj, rezultati duhet të jetë një ekran siç tregohet në foton e mësipërme:

* OLED */

#përfshi "SSD1306Wire.h" #përfshi "Wire.h" const int I2C_DISPLAY_ADDRESS = 0x3c; const int SDA_PIN = 0; const int SCL_PIN = 2; SSD1306 Ekran me tela (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); void setup () {Serial.begin (115200); displaySetup (); } void loop () {} / * Iniconi dhe shfaqni të dhënat e konfigurimit në OLED * / void displaySetup () {display.init (); // inicializoni shfaqjen e ekranit.qartë (); // Pastro ekranin.flipScreenVertically (); // Kthejeni ekranin me kokë poshtë.display (); // Vendosni të dhënat në ekran Serial.println ("Fillimi i Testit të Shfaqjes"); display.setFont (ArialMT_Plain_24); display.drawString (30, 0, "OLED"); // (xpos, ypos, "Text") display.setFont (ArialMT_Plain_16); display.drawString (18, 29, "Testi filloi"); display.setFont (ArialMT_Plain_10); display.drawString (10, 52, "Serial BaudRate:"); display.drawString (90, 52, String (11500)); display.display (); // Vendosni të dhënat në vonesën e shfaqjes (3000); }

Programi i mësipërm mund të shkarkohet nga GitHub im:

NyjaMCU_OLED_Test

Hapi 4: Një matës UV lokal

Tani, me ekranin OLED të instaluar, ne mund të lidhim një bateri dhe të bëjmë disa teste në distancë duke përdorur "Matësin UV"

#përcakto SW_VERSION "Sensori_VV_.1"

/ * Sensori UV */ #përcakto sensorinUVPin 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; SSD1306 Ekran me tela (I2C_DISPLAY_ADDRESS, SDA_PIN, SCL_PIN); void setup () {Serial.begin (115200); displaySetup (); } void loop () {readSensorUV (); displayUV (); vonesa (1000); } / * Iniconi dhe shfaqni të dhënat e konfigurimit në OLED * / void displaySetup () {display.init (); // inicializoni shfaqjen e ekranit.qartë (); // Pastro ekranin.flipScreenVertically (); // Kthejeni ekranin me kokë poshtë.display (); // Vendosni të dhënat në ekran Serial.println ("Fillimi i Testit të Sensorit UV"); display.setFont (ArialMT_Plain_24); display.drawString (10, 0, "MJRoBot"); display.setFont (ArialMT_Plain_16); display.drawString (0, 29, "Testi i sensorit UV"); display.setFont (ArialMT_Plain_10); display.drawString (0, 52, "Veriperëndimor:.:"); display.drawString (45, 52, SW_VERSION); display.display (); vonesë (3000); } / * Lexoni Sensorin UV në mV dhe thirrni llogaritjen e indeksit UV * / void readSensorUV () {byte numOfReadings = 5; dataSensorUV = 0; për (int i = 0; i <numOfReadings; i ++) {dataSensorUV+= analogRead (sensorUVPin); vonesë (200); } dataSensorUV /= numOfReadings; dataSensorUV = (dataSensorUV * (3.3 / 1023.0)) * 1000; Serial.println (dataSensorUV); indexCalculate (); } / * Llogaritja e Indeksit UV * / void indexCalculate () {if (dataSensorUV <227) indexUV = 0; përndryshe nëse (227 <= dataSensorUV && dataSensorUV <318) indexUV = 1; përndryshe nëse (318 <= dataSensorUV && dataSensorUV <408) indexUV = 2; përndryshe nëse (408 <= dataSensorUV && dataSensorUV <503) indexUV = 3; përndryshe nëse (503 <= dataSensorUV && dataSensorUV <606) indexUV = 4; përndryshe nëse (606 <= dataSensorUV && dataSensorUV <696) indexUV = 5; përndryshe nëse (696 <= dataSensorUV && dataSensorUV <795) indexUV = 6; përndryshe nëse (795 <= dataSensorUV && dataSensorUV <881) indexUV = 7; përndryshe nëse (881 <= dataSensorUV && dataSensorUV <976) indexUV = 8; përndryshe nëse (976 <= dataSensorUV && dataSensorUV <1079) indexUV = 9; përndryshe nëse (1079 <= dataSensorUV && dataSensorUV <1170) indexUV = 10; tjetër indexUV = 11; } /* Shfaq vlerat UV në OLED lokale* / void displayUV () {display.clear (); display.setFont (ArialMT_Plain_16); display.drawString (20, 0, "Sensori UV"); display.drawString (0, 23, "UV (mV):"); display.drawString (80, 23, String (dataSensorUV)); display.drawString (0, 48, "Indeksi UV:"); display.setFont (ArialMT_Plain_24); display.drawString (82, 42, String (indexUV)); display.display (); }

Kodi i mësipërm mund të shkarkohet nga GitHun im: NodeMCU_UV_Sensor_OLED.ino

Hapi 5: Instalimi i një DHT22 për matjet e temperaturës dhe lagështisë së ajrit

Një nga sensorët më të përdorur për kapjen e të dhënave të motit është DHT22 (ose është vëllai DHT11), një sensor dixhital i lagështisë dhe temperaturës relative. Ai përdor një sensor kapacitiv të lagështisë dhe një termistor për të matur ajrin përreth dhe nxjerr një sinjal dixhital në kunjin e të dhënave (nuk nevojiten kunja hyrëse analoge).

Sensori duhet të fuqizohet midis 3.3V dhe 5V dhe do të punojë nga -40oC në +80oC me një saktësi +/- 0.5oC për temperaturën dhe +/- 2% për lagështinë relative. Alsoshtë gjithashtu e rëndësishme të kihet parasysh se periudha e ndijimit të tij është mesatarisht 2 sekonda (koha minimale midis leximeve). Faqja e Adafruit ofron shumë informacione për të dy, DHT22 dhe vëllain e tij DHT11. Për më shumë detaje, ju lutemi vizitoni faqen Tutorial DHT22/11.

DHT22 ka 4 kunja (përballë sensorit, kunja 1 është më e majta):

1. VCC (ne do të lidhemi me 3.3V nga NodeMCU);
2. Të dhënat jashtë;
3. Jo i lidhur dhe
4. Toke.

Pasi zakonisht do të përdorni sensorin në distanca më të vogla se 20m, një rezistencë 10K duhet të lidhet midis kunjave të të dhënave dhe VCC. Pina e daljes do të lidhet me kunjin NodeMCU D3 (shiko diagramin e mësipërm). Pasi të jetë instaluar sensori në modulin tonë, shkarkoni bibliotekën DHT nga depoja e Adafruit GitHub dhe instalojeni në skedarin tuaj të Bibliotekës Arduino. Pasi të ringarkoni ID -në tuaj Arduino, duhet të instalohet "biblioteka e sensorit DHT".

Në fillim të kodit, duhet të përfshijmë rreshtat:

/* DHT22*/

#përfshi "DHT.h" #përcakto DHTPIN D2 #përcakto DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); human notues = 0; float temp = 0;

Një funksion i ri do të krijohet për të lexuar sensorin:

/ * Merrni të dhëna DHT */

void getDhtData (void) {float tempIni = temp; noton humIni = gumëzhimë; temp = dht.readTemperature (); hum = dht.readHumidity (); nëse (isnan (hum) || isnan (temp)) // Kontrolloni nëse leximet dështuan dhe dilni herët (për të provuar përsëri). {Serial.println ("Leximi i leximit nga sensori DHT!"); temp = tempIni; hum = humIni; kthim; }}

Kodi i plotë përfshirë sensorët UV dhe DHT mund të shkarkohet nga GitHub im: NodeMCU_UV_DHT_Sensor_OLED

Hapi 6: Dërgimi i të dhënave në ThingSpeak.com

Deri më tani, ne kemi përdorur vetëm NodeMCU ESP12-E si një bord të rregullt dhe të zakonshëm Arduino. Sigurisht, ne kemi vetëm "gërvishtur" potencialin e vërtetë të këtij çipi të vogël spektakolar dhe tani është koha për të ngritur në parajsë! Ose më mirë për yjet! Ehr… në re!;-)

Le të fillojmë!

1. Së pari, duhet të keni një llogari në ThinkSpeak.com
2. Ndiqni udhëzimet për të krijuar një kanal dhe mbani shënim ID -në tuaj të kanalit dhe shkruani çelësin API
3. Përditësoni kodin e mëposhtëm me rrjetin tuaj WiFi dhe kredencialet Thinkspeak
4. Drejtoni programin në IDE

Le të komentojmë pjesët më të rëndësishme të kodit:

Së pari, le të thërrasim bibliotekën ESP8266, të përcaktojmë klientin WiFi dhe të përcaktojmë kredencialet tuaja lokale të Router -it dhe Thinkspeak:

/* ESP12-E & Thinkspeak*/

#përfshi klientin WiFiClient; const char* MY_SSID = "ID juaj SSD KERTU"; const char* MY_PWD = "FJALA JUAJ KASSTU KTU"; const char* TS_SERVER = "api.thingspeak.com"; Vargu TS_API_KEY = "KANALET TUAJ SHKRUAJ API";

Së dyti, le të përfshijmë një bibliotekë shumë të rëndësishme për projektet IoT: SimpleTimer.h:

/ * KOHA *

#përfshi kohëmatësin SimpleTimer;

Së treti, gjatë konfigurimit (), ne do të fillojmë komunikimin serik, do të thërrasim funksionin connectWiFi () dhe do të përcaktojmë kohëmatësit. Vini re se linja e kodit: timer.setInterval (60000L, sendDataTS); do të thërrasë funksionin sendDataTS () çdo 60 sekonda, në mënyrë që të ngarkojë të dhëna në kanalin ThinkSpeak.

void setup ()

{… Serial.fillo (115200); vonesa (10); … ConnectWifi (); timer.setInterval (60000L, sendDataTS); …}

Së fundi, por jo më pak e rëndësishme, gjatë lakut (), komanda e vetme e nevojshme është të filloni kohëmatësin dhe kjo është ajo!

lak void ()

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

Më poshtë, mund të shihni dy funksionet e rëndësishme të përdorura për të trajtuar komunikimin Thinkspeak:

Lidhja ESP12-E me rrjetin tuaj WiFi:

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

*Lidhja e WiFi ******************************************* ***/ void connectWifi () {Serial.print ("Lidhja me"+*MY_SSID); WiFi.filloj (MY_SSID, MY_PWD); ndërsa (WiFi.status ()! = WL_CONNECTED) {vonesë (1000); Serial.print ("."); } Serial.println (""); Serial.println ("WiFi i lidhur"); Serial.println (""); }

ESP12-E duke dërguar të dhëna në ThinkSpeak:

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

*Dërgimi i të dhënave në 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 /përditëso HTTP /1.1 / n"); client.print ("Pritësi: api.thingspeak.com / n"); client.print ("Lidhja: mbyll / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("Lloji i Përmbajtjes: aplikacioni/x-www-form-urlencoded / n"); client.print ("Përmbajtja-Gjatësia:"); klient.print (postStr.length ()); client.print ("\ n / n"); klient.print (postStr); vonesa (1000); } dërguar ++; client.stop (); }

Kodi i plotë mund të gjendet në GitHub tim: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Pasi të keni ngarkuar kodin në NodeMCU tuaj. Le të lidhim një bateri të jashtme dhe të bëjmë disa matje nën diell. E vendos Stacionin në distancë në çati dhe filloj të kap të dhëna në ThingSpeak.com siç tregohet në fotot e mësipërme.

Hapi 7: Përfundimi

Si gjithmonë, shpresoj se ky projekt mund të ndihmojë të tjerët të gjejnë rrugën e tyre në botën emocionuese të elektronikës!

Për detaje dhe kodin përfundimtar, ju lutemi vizitoni depozitimin tim GitHub: RPi-NodeMCU-Weather-Station

Për më shumë projekte, ju lutemi vizitoni blogun tim: MJRoBot.org

Qëndroni të sintonizuar! Udhëzimi tjetër ne do të dërgojmë të dhëna nga një stacion moti i largët në një qendror, bazuar në një server në internet Raspberry Pi:

Saludos nga jugu i botës!

Shihemi në udhëzimin tim të ardhshëm!

Faleminderit, Marcelo