THINGSPEAK TEMPERATUR- UND FEUCHTIGKEITS-APP MIT ESP8266 - Gunook

2025 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2025-01-13 06:56

Während ich an meinen elektronischen Sachen bastelte, kam mir die Idee, eine webbasierte Wetter-App zu machen. Diese Web-App verwendet den SHT31-Sensor, um die Echtzeit-Temperatur- und Luftfeuchtigkeitsdaten zu erhalten. Wir haben unser Projekt auf dem ESP8266 WiFi-Modul bereitgestellt. Online oder offline! Keine Sorge, egal ob Sie online oder offline sind, Sie erhalten die Wetter-Updates von überall und jederzeit. Diese Web-App sendet Daten sowohl an den lokalen Webserver als auch an die Cloud. Für Cloud-Operationen verwenden wir die ThingSpeak-API. SHT31 verwendet I2C, um die Daten vom Sensor zu erhalten.

SHT 31 ist ein Temperatur- und Feuchtigkeitssensor von Sensirion. Der SHT31 bietet eine hohe Genauigkeit von ±2 % RH. Sein Feuchtigkeitsbereich liegt zwischen 0 bis 100 % und der Temperaturbereich liegt zwischen -40 bis 125 °C. Es ist viel zuverlässiger und schneller mit 8 Sekunden Sensorreaktionszeit. Seine Funktionalität umfasst eine verbesserte Signalverarbeitung und I2C-Kompatibilität. Es hat verschiedene Betriebsmodi, die es energieeffizient machen.

In diesem Tutorial haben wir SHT 31 mit dem Adafruit Huzzah-Board verbunden. Zum Lesen von Temperatur- und Feuchtigkeitswerten haben wir ESP8266 I2C-Schild verwendet. Dieser Adapter macht alle Pins für den Benutzer zugänglich und bietet eine benutzerfreundliche I2C-Umgebung.

Schritt 1: Erforderliche Hardware

Für diese Aufgabe verwendete Hardware:

1. SHT 31
2. Adafruit Huzzah ESP8266
3. ESP8266 I2C-Adapter
4. I2C-Kabel

Schritt 2: Hardwareverbindungen

Dieser Schritt umfasst die Hardware-Anleitung. In diesem Abschnitt werden im Wesentlichen die erforderlichen Kabelverbindungen zwischen dem Sensor und dem ESP8266 erläutert. Die Anschlüsse sind wie folgt.

1. Der SHT31 arbeitet über I2C. Das obige Bild zeigt die Verbindung zwischen ESP8266 und SHT31-Modul. Wir verwenden dafür ein I2C-Kabel, entweder können wir 4 F-F-Jumperdrähte verwenden.
2. ein Draht wird für Vcc verwendet, der zweite Draht für GND und zwei andere für SDA bzw. SCL
3. Gemäß dem I2C-Adapter werden Pin2 und Pin 14 eines ESP8266-Boards als SDA bzw. SCL verwendet

Schritt 3: Code für die Aufgabenplanung

In diesem Tutorial führen wir drei Operationen durch

• Lesen Sie die Daten von SHT11 mit dem I2C-Protokoll
• Hosten Sie den Webserver und senden Sie den Sensormesswert an die Webseite
• Posten Sie die Sensorwerte an die ThingSpeak API

Um dies zu erreichen, verwenden wir die TaskScheduler-Bibliothek. Wir haben drei verschiedene Aufgaben geplant, die sich auf drei verschiedene Kontrollvorgänge beziehen. das geht wie folgt

• Aufgabe 1 dient zum Lesen des Sensorwerts. Diese Aufgabe wird 1 Sekunde lang ausgeführt, bis ein Timeout von 10 Sekunden erreicht ist.
• Wenn Task1 sein Timeout erreicht, wird Task 2 aktiviert und Task1 wird deaktiviert.
• Wir verbinden uns in diesem Callback mit dem AP. Zwei boolesche Variablen werden verwendet, um das Umschalten zwischen STA und AP zu gewährleisten
• In Aufgabe 2 hosten wir einen Webserver unter 192.168.1.4. Diese Aufgabe wird alle 5 Sek. ausgeführt, bis sie ihr Timeout von 50 Sek. erreicht

• Wenn Task 2 das Zeitlimit erreicht, wird Task 3 aktiviert und Task 2 wird deaktiviert.

• Wir verbinden uns in diesem Callback mit STA (lokale IP)In Aufgabe 3 veröffentlichen wir den Sensormesswert an die Cloud ThingSpeak API
• Aufgabe 3 wird alle fünf Sekunden ausgeführt, bis sie ihr Timeout erreicht hat, d. h. 50 Sekunden
• Wenn Task3 sein Timeout erreicht, wird Task 1 wieder aktiviert und Task 3 wird deaktiviert.
• Wenn kein Rückruf angerufen wird oder das Gerät im Ruhezustand ist, geht es in den Light Sleep und spart so Strom.

void taskI2Ccallback();

void taskI2CDisable(); void taskAPCallback(); void taskAPDisable(); void taskWiFiCallback(); void taskWiFiDisable(); //Aufgaben für i2c, Hosten des Webservers und Posten auf Thingspeak Task tI2C(1 * TASK_SECOND, TASK_FOREVER, &taskI2CCallback, &ts, false, NULL, &taskI2CDisable); Task tI2C(1 * TASK_SECOND, TASK_FOREVER, &taskI2CCallback, &ts, false, NULL, &taskI2CDisable); Task tAP(5*TASK_SECOND, TASK_FOREVER, &taskAPCallback, &ts, false, NULL, &taskAPDisable); Aufgabe tWiFi(5* TASK_SECOND, TASK_FOREVER, &taskWiFiCallback, &ts, false, NULL, &taskWiFiDisable); //Timeout für Tasks tI2C.setTimeout(10 * TASK_SECOND); tAP.setTimeout(50 * TASK_SECOND); tWiFi.setTimeout(50 * TASK_SECOND); // I2C-Task aktivieren tI2C.enable ();

Schritt 4: Code zum Lesen von Temperatur- und Feuchtigkeitswerten

Wir verwenden die Wire.h-Bibliothek, um die Temperatur- und Feuchtigkeitswerte auszulesen. Diese Bibliothek erleichtert die i2c-Kommunikation zwischen dem Sensor und dem Master-Gerät. 0x44 ist die I2C-Adresse für SHT31.

SHT31 arbeitet in einem anderen Betriebsmodus. Dazu können Sie das Datenblatt entnehmen. Wir verwenden 0x2C und 0x06 als MSB bzw. LSB für den Einzelschussbetrieb.

// I2C-Aufgabenrückruf Void taskI2CCallback () { Serial.println ("taskI2CStarted"); unsigned int root[6]; // Übertragung von 0x44 beginnen; Wire.beginTransmission(Addr); // für eine einmalige Übertragung mit hoher Wiederholgenauigkeit verwenden wir 0x2C (MSB) und 0x06 (LSB) Wire.write (0x2C); Wire.write (0x06); // Übertragung beenden Wire.endTransmission (); // Bytes von 0x44 anfordern Wire.beginTransmission (Addr); Wire.endTransmission(); Wire.requestFrom(Addr, 6); if(Wire.available() == 6){ //data[0] und data[1] enthält 16 Bit Temperatur. root[0] = Wire.read(); root[1] =Wire.read(); //data[2] enthält 8 Bit CRC root[2] = Wire.read(); //data[3] und data[4] enthält 16 Bit Feuchtigkeit root[3] = Wire.read(); root[4] = Wire.read(); //data[5] besteht aus 8-bit CRC root[5] = Wire.read(); } int temp = (root[0] * 256) + root[1]; // MSB um 8 Bit verschieben, LSB-Float hinzufügen cTemp = -45.0 + (175.0 * temp / 65535.0); Schwimmer fTemp = (cTemp * 1,8) + 32,0; // Verschiebe das MSB um 8 Bits füge LSB hinzu dividiere durch volle Auflösung und * 100 für prozentuale Float-Feuchtigkeit = (100.0 * ((root[3] * 256.0) + root[4])) / 65535.0; tempC = cTemp; tempF = fTemp; feucht = Luftfeuchtigkeit; Serial.print ("Temperatur in C: / t"); Serial.println (String (cTemp, 1)); Serial.print ("Temperatur in F: / t"); Serial.println (String (fTemp, 1)); Serial.print ("Feuchtigkeit: / t"); Serial.println (String (Luftfeuchtigkeit, 1)); }

Schritt 5: Code zum Hosten eines Webservers

Wir haben einen Webserver von unserem Gerät auf einer statischen IP gehostet.

Die ESP8266WebServer-Bibliothek wird zum Hosten des Webservers verwendet

• Zuerst müssen wir IP-Adresse, Gateway und Subnetzmaske deklarieren, um unsere statische IP zu erstellen
• Deklarieren Sie nun ssid und Passwort für Ihren Access Point. Verbinden Sie sich von jedem STA-Gerät mit dem Access Point
• Hosten Sie den Server auf Port 80, der ein Standardport für das Internetkommunikationsprotokoll ist

//statische IP für APIPAddress ap_local_IP(192, 168, 1, 4);IPAddress ap_gateway(192, 168, 1, 254); IPAdresse ap_subnet(255, 255, 255, 0); //ssid und AP für lokales WLAN im STA-Modus const char WiFissid = "*********"; const char WiFipass = "*********"; //ssid und übergeben für AP const char APssid = "********"; const char APpass = "********"; ESP8266WebServer-Server (80); void setup{server.on("/", onHandleDataRoot); server.on("/Wert", onHandleDataFeed); server.onNotFound (onHandleNotFound);} Void taskAPCallback () { Serial.println ("taskAP gestartet"); server.handleClient(); aufrechtzuerhalten. Void onHandleDataRoot () {server.send (200, "text/html", SEITE1); } void onHandleDataFeed(){server.send(200, "text/html", SEITE2); } void onHandleNotFound(){ String message = "Datei nicht gefunden\n\n"; Nachricht += "URI: "; Nachricht += server.uri(); Nachricht += "\nMethode: "; Nachricht += (server.method() == HTTP_GET)?"GET":"POST"; Nachricht += "\nArgumente: "; Nachricht += server.args(); Nachricht += "\n"; server.send(404, "text/plain", Nachricht); aufrechtzuerhalten. Void reconnectAPWiFi () { WiFi.mode (WIFI_AP_STA); Verzögerung (100); WiFi.disconnect(); boolescher Status = WiFi.softAPConfig(ap_local_IP, ap_gateway, ap_subnet); if(status ==true) {Serial.print("Soft-AP einstellen …"); boolesches ap = WiFi.softAP(APssid, APpass); if (ap = = true) {Serial.print ("verbunden mit: / t"); //IPAdresse myIP = WiFi.softAPIP(); Serial.println (WiFi.softAPIP()); } server.begin();

}

Schritt 6: Thingspeak-Setup

ThingSpeak ist eine IoT-Plattform. ThingSpeak ist ein kostenloser Webservice, mit dem Sie Sensordaten in der Cloud sammeln und speichern können.

In diesem Schritt werde ich Ihnen ein kurzes Verfahren zur Einrichtung Ihres Thing Speak-Kontos geben

• Registrieren Sie sich für ein neues Benutzerkonto in ThingSpeak
• Erstellen Sie einen neuen Kanal, indem Sie Kanäle, Meine Kanäle und dann Neuer Kanal auswählen
• Bearbeiten Sie Ihre Felder
• Diese Felder enthalten Ihre Sensordaten
• Notieren Sie sich den Write API Key und die Channel ID
• Auf Ihrer Arduino-Skizze können Sie die ThingSpeak-Bibliothek für Arduino verwenden oder die Daten direkt an die ThingSpeak-API senden
• Der nächste Schritt befasst sich mit dem Posten des Inhalts in der Thing Speak API

Schritt 7: Code zum Posten von Daten an Thing Speak

Hier veröffentlichen wir die Sensorwerte an Thing Speak. Die folgenden Schritte sind erforderlich, um diese Aufgabe abzuschließen:

• Erstellen Sie Ihr Konto in thing speakErstellen Sie Kanäle und Felder, um Ihre Sensordaten zu speichern
• Wir können die Daten von ESP zu ThingSpeak und umgekehrt abrufen und posten, indem wir GET- und POST-Anfragen an die API verwenden.
• wir können unsere Daten wie folgt an ThingSpeak übermitteln

id taskWiFiCallback () { WiFiClient wifiClient; if(wifiClient.connect(hostId, 80)){String postStr = apiKey; postStr +="&field1="; postStr += String(feucht); postStr +="&field2="; postStr += String(tempC); postStr +="&field3="; postStr += String(tempF); postStr += "\r\n\r\n"; wifiClient.print("POST /update HTTP/1.1\n"); wifiClient.print("Host: api.thingspeak.com\n"); wifiClient.print("Verbindung: schließen\n"); wifiClient.print("X-THINGSPEAKAPIKEY: "+apiKey+"\n"); wifiClient.print("Content-Type: application/x-www-form-urlencoded\n"); wifiClient.print("Inhaltslänge: "); wifiClient.print (postStr.length()); wifiClient.print("\n\n"); wifiClient.print(postStr); } wifiClient.stop(); }

Schritt 8: Gesamtcode

Der gesamte Code ist in meinem GitHub-Repository verfügbar

Schritt 9: Credits

• Arduino JSON
• ESP826WebServer
• Aufgabenplaner
• SHT 31
• I2C-Scan
• HIH6130 instructables Tutorial
• Kabel
• NCD.io