Wetter-Web-App mit ESP8266 - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:17

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. SHT31

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 die anderen beiden 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 mit STA (lokale IP) in diesem Rückruf
• In Aufgabe 3 veröffentlichen wir den Sensormesswert in der 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.

Scheduler-ts;

//Aufgaben für i2c, Hosting des Webservers und Post auf Thingspeak

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 Internet-Kommunikationsprotokoll Hypertext Transfer Protocol (HTTP) ist.
• Geben Sie 192.168.1.4 in Ihrem Webbrowser für die Intro-Webseite und 192.168.1.4/Value für die Sensormess-Webseite ein

// statische IP für AP

IPAdresse ap_local_IP(192, 168, 1, 4);

IP-Adresse ap_gateway(192, 168, 1, 254);

IPAddress ap_subnet(255, 255, 255, 0); //ssid und AP für lokales WLAN im STA-Modus

const char WiFissid = "*********";

const char WiFipass = "*********";

//ssid und pass für AP

const char APssid = "********";

const char APpass = "********";

ESP8266WebServer-Server (80);

Einrichtung ungültig{

server.on("/", onHandleDataRoot);

server.on("/Wert", onHandleDataFeed);

server.onNotFound(onHandleNotFound);

}

void taskAPCallback(){

Serial.println ("taskAP gestartet");

server.handleClient();

}

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() ==

Nachricht += "\nArgumente: ";

Nachricht += server.args();

Nachricht += "\n";

server.send(404, "Text/Plain", Nachricht);}

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 ==wahr){

Serial.print("Soft-AP einstellen …");

boolesches ap = WiFi.softAP(APssid, APpass);

if(ap==wahr){

Serial.print ("verbunden mit: / t");

//IPAdresse myIP = WiFi.softAPIP();

Serial.println (WiFi.softAPIP());

}

server.begin();

}

}

Schritt 6: 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 Ding-Speak
• Erstellen 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

void 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 7: Gesamtcode

Der Gesamtcode ist in meinem Github-Repository verfügbar

Credits:

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