In diesem Projekt geht es darum, zu zeigen, wie du unsere Produkte einsetzen kannst. Es gibt immer wieder Fragen wie man ein Gehäuse für den Aussenbereich wasserdicht bauen kann. Daher habe ich bei diesem Projekt etwas für den Aussenbereich gemacht, damit ihr auch seht, wie dicht unsere Gehäuse sind. Auf Thingspeak könnt ihr in Echtzeit sehen, wie die Temperatur und Luftfeuchtigkeit im Gehäuse ist. Das Gehäuse ist für diesen Härtetest auf meiner Terrasse allen Wetterbedingungen ausgesetzt. Die Stromversorgung des Mikrokontrollers und der Sensoren erfolgt über ein Kabel, dass ich nach aussen gezogen habe (9V Speisung). In einem späteren Projekt werde ich den ESP8266 noch autonomer mit einer Solarzelle laufen lassen. Aber bis dahin werde ich nun zuerst Erfahrung mit diesem Projekt sammeln. Falls du Fragen oder Anregungen hast nutze doch die Kommentarfunktion.
Im Zusammenhang mit dem wasserdichten Gehäuse werde ich euch diverse Sensoren vorstellen die ich eingebaut habe. Des Weiteren zeige ich dir, wie du die erfassten Daten einfach online mit der IoT (Internet of Things) Plattform Thingspeak visualisieren kannst.
Verbaute Sensoren im Wasserdichten Gehäuse
Si7021 Luftfeuchtigkeit Sensor
Der Si7021 ist ein genauer Luftfeuchtigkeit Sensor. Die Kommunikation erfolgt über den I2C Bus und es kann die Temperatur und die relative Luftfeuchtigkeit gelesen werden. Für die Ansteuerung des SI7021 Sensor gibt es auf GitHub bereits eine sehr gute Library die du unter Arduino mit dem ESP8266 nutzen kannst. Du kannst sie unter folgendem Link herunterladen:
https://github.com/LowPowerLab/SI7021
Hier noch ein Arduino Code Beispiel für den SI7021:
#include <Wire.h>
#include <SI7021.h>
SI7021 SI7021_Sensor;
void setup() {
SI7021_Sensor.begin();
}
void loop() {
//Die Temperatur muss noch mit 100 dividiert werden
float Temperatur = SI7021_Sensor.getCelsiusHundredths() / 100.0;
int Luftfeuchtigkeit = SI7021_Sensor.getHumidityPercent()
delay(2000);
}
BMP280 Luftdrucksensor
Der BMP280 ist ein Luftdrucksensor der neusten Generation von Bosch. Mit dem Sensor möchte ich sehen wie sich der Druck bei Wetteränderungen ändert und umso z.B. ein Gewitter oder Wetterwechsel zu sehen. Der Sensor wird auch über I2C angesprochen und ist auch adressierbar über zwei Adressen. Der Sensor liefert zusätzlich zum Luftdruck auch noch die Temperatur. Die Temperatur stimmt recht genau mit der vom Si7021 überein, der auch im Gehäuse verbaut ist. Für die Ansteuerung des BMP280 Sensor gibt es auf GitHub bereits eine sehr gute Library die du unter Arduino mit dem ESP8266 nutzen kannst. Du kannst sie unter folgendem Link herunterladen:
https://github.com/mahfuz195/BMP280-Arduino-Library
Hier noch ein Arduino Code Beispiel für den BMP280:
#include "BMP280.h"
#include "Wire.h"
BMP280 bmp;
void setup()
{
bmp.begin();
bmp.setOversampling(4);
}
void loop()
{
double T, P;
// In result steht die Zeit in ms die gewartet werden muss bis die Messwerte verfügbar sind.
// Ist der rückgabewert = 0 handelt es sich um einen Fehler
char result = bmp.startMeasurment();
//Wird ausgeführt wenn kein Fehler vorhanden ist
if (result != 0) {
delay(result); //Warten auf Messwerte
//Messwerte in Variablen Speichern
bmp.getTemperatureAndPressure(T, P);
delay(5000);
}
}
BH1750 Lichtsensor
Der BH1750 ist ein digitaler Lichtsensor der die Beleuchtungsstärke in Lux misst. Die Kommunikation mit dem Sensor ist über den I2C Bus. Der Sensor verfügt über zwei Adressen. Somit kannst du also maximal zwei Sensoren an einem I2C Bus betreiben. Standardmässig wird der Sensor über die Hex Adresse 0x23 angesprochen. Ich habe den Sensor in diesem Projekt eingesetzt um zu sehen, wie das Wetter ist, ob bewölkt oder sehr nebelig. Da ich aus einer Region mit viel Nebel komme sind meistens tiefe Werte zu erwarten. :-)
Für die Ansteuerung des BH1750 Sensor gibt es auf GitHub bereits eine sehr gute Library die du unter Arduino mit dem ESP8266 nutzen kannst. Du kannst sie unter folgendem Link herunterladen:
https://github.com/claws/BH1750
Hier noch ein Arduino Code Beispiel für den BH1750:
#include <Wire.h>
#include <BH1750.h>
BH1750 lightMeter;
void setup() {
lightMeter.begin();
}
void loop() {
// In der Variable BH1750Lux wird der Lux Wert gespeichert
int BH1750Lux = lightMeter.readLightLevel();
}
DS18B20 Temperatursensor
Der DS18B20 ist ein genauer digitaler Temperatur Sensor. Die Sensoren werden in der Herstellung kalibriert, daher ist eine absolute Genauigkeit von +-0.5°C und eine Auflösung von 0.0625°C möglich. Der Sensor wird über eine One-Wire Library angesprochen. Das heisst der Sensor hat nur drei Anschlüsse. Zwei für die Speisung und einen für die Kommunikation. Jeder Sensor hat eine eindeutige Identifikations-Nummer die es immer nur einmal gibt. Sind also zehn Sensoren an einem Pin angeschlossen, werden die Sensoren über diese Identifikations-Nummer einzeln angesprochen. In unserem Beispiel nutze ich nur einen. Daher ist es sehr einfach diesen auszuwerten. Die Libraries findest du in der Arduino IDE unter Bibliotheken Verwalten. Suche nach folgenden Libraries und installiere sie:
OneWire Library:

DallasTemperature Library:
Auflösung und Messzeiten des DS18B20
Die Auflösung vom DS18B20 kann eingestellt werden. Es ist zu beachten, je höher die Auflösung, desto länger ist die Messzeit des Sensores. Deshalb hier noch eine kleine Übersicht:
DS18B20 Auflösung | Auflösung Temperatur | Messzeit vom DS18B20 |
9 Bit | 0.5°C | 94 ms |
10 Bit | 0.25°C | 188 ms |
11 Bit | 0.125°C | 375 ms |
12 Bit | 0.0625°C | 750 ms |
Hier noch ein Arduino Code Beispiel zum Auslesen eines einzelnen DS18B20:
#include <Wire.h>
#include <DallasTemperature.h>
float DS18B20T;
#define ONE_WIRE_BUS 2 //OneWire Pin wo der DS18b20 angeschlossen wird
#define TEMPERATURE_PRECISION 12 //Höchste Auflösung von 12Bit einstellen
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature SensorDS18B20(&oneWire);
void setup() {
SensorDS18B20.begin();
}
void loop() {
SensorDS18B20.requestTemperatures(); // Messung der Temperatur Starten
delay(3000);
DS18B20T = SensorDS18B20.getTempCByIndex(0); //Messwert in Variable Speichern
}
Wasserdichtes Gehäuse für Arduino Controller
Für dieses Projekt habe ich ein etwas grösseres Gehäuse genommen, damit ich es auch noch besser erweitern kann und nicht von Anfang an mit dem Platz begrenzt bin. Das Gehäuse dichtet sehr gut ab und wird über Edelstahlschrauben zugeschraubt. Ist also perfekt für den Aussenbereich geeignet. Das Gehäuse ist jedoch auch starken Temperaturschwankungen ausgesetzt und da gibt es bei einem dichten Gehäuse das Problem, dass sich die Luft bei Erwärmung ausdehnt und wenn sie abkühlt zusammenzieht. Beim Abkühlen wird so Feuchtigkeit und Wasser in ein Gehäuse gelangen. Damit das nicht geschieht, habe ich ein Druckausgleichs Ventil im Gehäuse eingebaut. Das Ventil hat eine spezielle Membrane die den Druck mit dem Aussenbereich gleich hält und kein Wasser durch die Membrane lässt. Für die Kabel habe ich wasserdichte Kabelverschraubungen eingesetzt. Zum Bohren der Löcher empfehle ich dir einen Stufenbohrer zu nutzen.
Arduino Daten in Thingspeak Loggen mit einem ESP8266
Zum Thema Thingspeak und Arduino haben wir noch ein Youtube Video erstellt in dem du siehst wie einfach du Daten in Thingspeak loggen kannst.
Hier das komplette Arduino Code Beispiel von diesem Projekt
/******************************************************************************************* ******************************************************************************************* ** www.bastelgarage.ch ** ** Der Onlineshop mit Videoanleitungen und kompletten Bausätzen für Anfänger und Profis! ** ******************************************************************************************* ******************************************************************************************* ** In diesem Beispiel zeigen ich dir wie du verschiedene Sensoren mit dem ESP8266 ** ** auslesen kannst. Da der ESP8266 auch einfach mit dem Internet verbunden werden kann ** ** werden wir die gemessenen Daten auf einer IOT (Internet of Things) Plattform ** ** speichern. Als Plattform in diesem Beispiel nutze ich Thingspeak dies ist mit ** ** gewissen Einschränkungen kostenlos nutzbar. ** ** ** ** Verwendete Libraries: ** ** Si7021: https://github.com/LowPowerLab/SI7021 ** ** BMP280: https://github.com/mahfuz195/BMP280-Arduino-Library ** ** BH1750: https://github.com/claws/BH1750 ** ** DS18B20: Arduino Library DallasTemperature und OneWire ** ** ** ** Autor: Philippe Keller ** ** Datum: Januar 2017 ** ** Version: 1.0 ** ******************************************************************************************* */ /************************( Importieren der genutzten Bibliotheken )************************/ #include <Wire.h> // Wird für die Sensoren mit I2C Bus benötigt #include <BH1750.h> // Helligkeit Sensor #include <BMP280.h> // Luftdruck und Temperatur Sensor #include <SI7021.h> // Luftfeuchtigkeit und Temperatur Sensor #include <RunningMedian.h> // Sehr gute Library für Mittelwertbildung von Messdaten #include "ThingSpeak.h" #include <ESP8266WiFi.h> // Wifi Funktionen um sich mit dem Wlan zu verbinden #include <OneWire.h> // Wird für die Kommunikation mit dem Temperatursensor- #include <DallasTemperature.h> // DS18B20 genutzt. BMP280 bmp; /********************( Definieren der Globale Variablen und Konstanten)********************/ float SI7021T; // Variable zum Speichern der Temperatur float SI7021H; // Variable zum Speichern der Luftfeuchtigkeit double BMP280P; // Variable zum Speichern des Luftdrucks double BMP280T; // Variable zum Speichern des Temperatur float BMP280P2; // Hilfsvariable für Umwandlung in float float BMP280T2; // Hilfsvariable für Umwandlung in float int BH1750Lux; // Variable zum Speichern der Helligkeit in Lux float DS18B20T; // Variable zum Speichern der Temperatur char resultBMP280; // Variable für Fehlerauswertung und Messzeit #define ONE_WIRE_BUS 2 // Anschluss Pin von DS18B20 hier GPIO02 #define TEMPERATURE_PRECISION 12 // Höchste Auflösung 12 Bit Messzeit ca 750ms unsigned long ThingspeakLastLogTime = 0; // Hilfs Variable letzte Log Zeit unsigned long SensorenLetzteAktualisierung; // Hilfsvariable für Zeitmessung int status = WL_IDLE_STATUS; // status Wifi /**********************************(Thingspeak Eistellungen)*******************************/ unsigned long myChannelNumber = 123456; // Deine ThingSpeak Kanal Nummer const char * myWriteAPIKey = "xxxxxxxxxxxxxxx"; // Dein ThingSpeak API Key /************************************(Wifi Einstellungen)**********************************/ char ssid[] = "xxxxx"; // Deine Wlan SSID (Name) char pass[] = "xxxxx"; // Dein Wlan Passwort /************************( Definieren von Zeitabhänigen Variablen )************************/ float SensorenSampelTime = 4000; // Zeit in ms für Aktualisierung der Sensoren- // und Mittelwertbildung // Zeit in ms für Aktualisierung zum schicken der Messdaten an Thingspeak in ms. Kleiner als // 15000ms (15s) geht mit dem kostenlosen Account nicht. // Empfehlung von mir 60000ms oder 300000ms! int ThingspeakSampelTime = 60000; /***********************( Definieren der Objekte und initialisieren )***********************/ OneWire oneWire(ONE_WIRE_BUS); DallasTemperature SensorDS18B20(&oneWire); // DS18B20 initialisieren BH1750 lightMeter(0x23); // BH1750 initialisieren SI7021 SI7021_Sensor; // Si7021 initialisieren RunningMedian MedianSI7021T = RunningMedian(10); // Mittelung aktivieren über 10 Messwerte RunningMedian MedianSI7021H = RunningMedian(10); // Mittelung aktivieren über 10 Messwerte RunningMedian MedianBMP280T2 = RunningMedian(10); // Mittelung aktivieren über 10 Messwerte RunningMedian MedianBMP280P2 = RunningMedian(10); // Mittelung aktivieren über 10 Messwerte RunningMedian MedianBH1750Lux = RunningMedian(10); // Mittelung aktivieren über 10 Messwerte RunningMedian MedianDS18B20T = RunningMedian(10); // Mittelung aktivieren über 10 Messwerte WiFiClient client; // Wifi /*****************************************( Setup )****************************************/ void setup() { SensorDS18B20.begin(); // DS18B20 Temperatur Sensor starten Wire.begin(D2, D1); // Festlegen der I2C Pins und initialisieren (4,5 oder D2,D1) WiFi.begin(ssid, pass); // Wlan Aktivieren und mit definiertem Netzwerk verbinden ThingSpeak.begin(client); // ThingSpeak Client starten lightMeter.begin(BH1750_CONTINUOUS_HIGH_RES_MODE); // BH1750 Lichtsensor starten bmp.begin(); // BMP280 Luftdruck Sensor starten bmp.setOversampling(4); // Sensor auf die Höchste Auflösung einstellen } /***************** **(Funktion um Daten an Thingspeak zu senden)**************************/ void MesswerteSenden() { // Wenn die Zeit der Letzen Messung zu der Nächsten durch ist, wird die Funktion durchgeführt if (millis() - ThingspeakLastLogTime > ThingspeakSampelTime) { // Abfüllen der Felder mit den Messdaten ThingSpeak.setField(1, SI7021T); ThingSpeak.setField(2, SI7021H); ThingSpeak.setField(3, BMP280T2); ThingSpeak.setField(4, BMP280P2); ThingSpeak.setField(5, BH1750Lux); ThingSpeak.setField(6, DS18B20T); // Alle Messdaten zusammen an Thingspeak schicken ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey); //Aktuelle Zeit Speichern ThingspeakLastLogTime = millis(); } } /*************************************(Hauptprogramm)**************************************/ void loop() { // Mit der Funktion millis() wird die vergangene Zeit in ms zurückgegeben. Wir vergleichen diesen // Wert mit der letzten Sensor Aktualisierung ist mehr Zeit vergangen als in der Variable // SensorenSampelTime steht wird die if Verzweigung ausgeführt und sonst nicht. Wir könnten das auch // mit einer delay() Funktion lösen jedoch möchten wir das der Mikrocontroller nicht einfach // stehen bleibt, sondern weiterarbeiten kann. if (millis() - SensorenLetzteAktualisierung > (SensorenSampelTime)) { // Si7021 Temperatur auslesen und Mittelwert in Variable Speichern MedianSI7021T.add ((SI7021_Sensor.getCelsiusHundredths() / 100.0)); SI7021T = MedianSI7021T.getAverage(); // Si7021 Relative Luftfeuchtigkeit auslesen und Mittelwert in Variable Speichern MedianSI7021H.add(SI7021_Sensor.getHumidityPercent()); SI7021H = MedianSI7021H.getAverage(); // BH1750 Lux auslesen und Mittelwert in Variable Speichern MedianBH1750Lux.add(lightMeter.readLightLevel()); BH1750Lux = MedianBH1750Lux.getAverage(); // DS18B20 auslesen und Mittelwert in Variable Speichern MedianDS18B20T.add(SensorDS18B20.getTempCByIndex(0)); DS18B20T = MedianDS18B20T.getAverage(); // BMP280 Messung Starten resultBMP280 = bmp.startMeasurment(); // Zuerst überprüfen ob kein Fehler vorliegt, wenn der Wert gleich 0 ist, // liegt ein Fehler an. Ich hatte das Problem das sich nach 3 Tagen die Messwerte nicht // mehr Aktualisiert haben. Haben wir eine 0 führe ich ein Reset des Kontroller durch. // Der Retour Wert gibt die Messzeit in ms an deshalb anschliessend das delay(resultBMP280) if (resultBMP280 != 0) { delay(resultBMP280); bmp.getTemperatureAndPressure(BMP280T, BMP280P); // Messwerte abholen und Speichern // Messwerte in Float umwandeln und Mittelwert neu in Variable Speichern MedianBMP280T2.add(BMP280T * 1.0); // Messwerte in Float umwandeln MedianBMP280P2.add(BMP280P * 1.0); // Messwerte in Float umwandeln BMP280T2 = MedianBMP280T2.getAverage(); BMP280P2 = MedianBMP280P2.getAverage(); } else { // Falls ein Fehler festgestellt wurde führt der ESP8266 einen restart durch. // Achtung!!! Sobald der BMP280 nicht erreichbar ist Startet der ESP8266 ununterbrochen ESP.restart(); } SensorDS18B20.requestTemperatures(); // Neue Temperatur Messung starten SensorenLetzteAktualisierung = millis(); // Letzte Aktualisierung speichern } // Wenn minmimal 10 mal gemessen wurde Funktion messwerteSenden() aufrufen if (MedianDS18B20T.getCount() >= MedianDS18B20T.getSize())MesswerteSenden(); }

Ich frage mich allerdings, wie die Luftfeuchte gemessen wird. Denn eigentlich wird ja nur die Feuchte /in/ dem Kasten und nicht die wirkliche Außenfeuchte gemessen, oder? :-)

Hallo Peter,
Die Luftfeuchtigkeit wird nur im Innern des Gehäuse gemessen und gibt mir eine Aussage ob das Gehäuse noch dicht ist und kein Wasser eingedrungen ist. In diesem Blog Eintrag ging es darum um zu zeigen wie ein Gehäuse Wasserdicht gemacht werden kann.
Gruess Philippe

Hallo, ich bin nach wie vor auf der Suche nach einer Lösung wie ich trotz Posting über WLAN im 30 Minutentakt eine Batterielaufzeit von 1 Jahr schaffe. Hast du da zufällig ein Code-Beispiel ? Ich arbeite mit Wemos D1 mini und komme trotzdem Deep-Sleep nur auf 2-3 Monate. lG Frank

Ich habe das mit dem Wemos auch bereits mal versucht und bin da auch nicht auf ein Jahr Laufzeit gekommen. Wo wird der ESP den platziert? Falls er Sonnenlicht ausgesetzt ist hätte ich eine günstige Solar Lösung die ich gerade am Erproben bin. Ansonsten musst du schauen das du ein ESP32 mit Lipo einsetzen kannst der hat bei mir 1 Jahr gehalten mit DeepSleep und alle 30 min Daten schicken über Wlan (3000mA Lipo). Wir haben aktuell auch ein neues Board „SX1276 ESP32 868MHz LoRa Modul mit OLED“ im Shop wo du die Daten auch über Lora schicken kannst somit sind noch längere Laufzeiten möglich. Gruess Philippe

Ich habe hier mal eine eine Lösung, ähnlich dem Beispiel - wasserdicht, mit Druckausgleich (unten links) und atark, weil solarbetrieben
ohne deepsleep bei völliger Dunkelheit 4 Tage Laufzeit.

Nachtrag zu dem Kommentar



Hallo Alex,
Leider funktioniert das mit den Bildern nicht richtig. Wie hast du es den gelöst? Was für eine Solarzelle hast du verwendet mit welchem Regler und Akku?
Gruess Philippe