Wasserdichtes Gehäuse für IoT Thingspeak

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:

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

}