Zisterne Füllstandsanzeige 2.0 mit Wemos Lolin32 + MySQL Datenbank

Zisterne 2.0 Wemos Lolin32

Wasserstand einer Zisterne mit einem Wemos Lolin32 überwachen und Daten in einer MySQL Datenbank speicher.

Es handelt sich hier um eine Abänderung von meiner 1. Zisternen Überwachung, den Beitrag dazu findet Ihr hier. In der 2. Version werden die Daten in einer MySQL Datenbank gespeichert und können von überall abgerufen werden, vorausgesetzt Ihr habt eine MySQL Datenbank im Internet. Ihr könnt euch auch eine Lokale Datenbank anlegen, dazu benötigt Ihr eine Apache Server Software. Ich haben anfangs mit diesem Programm getestet Xampp, könnt Ihr hier Herunterladen.

Warum habe ich das ganze jetzt mit einer MySQL Datenbank realisiert?

Der Grund ist ganz einfach, in der 1. Version läuft das Wemos D1 mini Board rund um die Uhr. Ich wollte aber den Stromverbrauch reduzieren, gut die Boards verbrauchen ja nicht soviel, trotzdem müssen da nicht permanent Daten gesendet werden. Daher wird in der 2. Version, je nachdem wie man es einstellt, 2 mal am Tag eine Messung durchgeführt. Anschließend geht der Wemos Lolin32 in den Schlafmodus und verbraucht dadurch sehr wenig Strom.

Warum nehme ich den Wemos Lolin32?

Der Wemos Lolin32 ist sehr gut geeignet, da er nach dem Schlafmodus von alleine wieder aufwacht, ohne das ein Knopf oder ähnliches betätigt werden muss. Bei den anderen Wemos Board ist es so das, dass Board noch dem Schlafmodus in einen Standby Modus geht und nur durch eine Aktion aufgeweckt werden kann.

Hier könnt Ihr sehr die wie das ganze dann Dargestellt aussieht. Link zur Webansicht, live Datenbank abfrage.
Hier könnt Ihr die Datein für das Schreiben in die Datenbank und das Lesen der Datenbank herunterladen.
webansicht

Beschaltung

beschaltung

Funktion

Der Wemos ruft eine Internetseite auf, in meinem Fall “https://arduino-projekte.info/zisterne/writemysql.php”, dann werden über eine Ergänzung in der URL, die gemessenen Daten + Datum an die MySQL Datenbank übergeben.

Der Programmcode

#include <WiFi.h>
const int sleepSeconds = 28,779;
const char* ssid = "WLAN NAME"; //WLAN Netzwerk
const char* password = "PASSWORT";    //WLAN Passwort

//Webserver, wo die Datei zum befüllen der Datenbank leigt, nur die Adresse (z.B. arduino-projekte.info)
const char* host = "HIER KOMMT DIE WEDADRESSE REIN";

WiFiClient client;

int trigger = 13;
int echo = 12;
long dauer = 0;
long entfernung = 0;

void setup() {
  pinMode(trigger, OUTPUT);
  pinMode(echo, INPUT);
  WiFi.begin(ssid, password);
}

void loop() {
  digitalWrite(trigger, LOW);
  delay(5);
  digitalWrite(trigger, HIGH);
  delay(10);
  digitalWrite(trigger, LOW);
  dauer = pulseIn(echo, HIGH);
  entfernung = (dauer / 2) / 29.1;

  if (entfernung >= 200 || entfernung <= 0)
  {
    entfernung = 0;
  }
  else
  {
  entfernung = 192 - entfernung;
  entfernung = entfernung * 84.7457;
  }
  Serial.println("\nStarting connection to server...");
  //URL wird erzeugt und gesendet
  WiFiClient client;
  if (client.connect(host, 80)) {
    String url = "/writemysql.php";
    url += "?liter=";
    url += entfernung;
    client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                 "Host: " + host + "\r\n" +
                 "Connection: close\r\n\r\n");
    client.println();  //Verbindungs mit Server aufbauen und HTTP Anfrage senden
  }
  client.stop();
  //Beenden der Verbindung
  delay(1000);

  ESP.deepSleep(sleepSeconds * 1000000); //Schalfmodus
}

UPDATE:


Ich habe einen Wasserdichten Sensor gefunden und getestet. Der JSN-SR04T, dieser Funktioniert ohne Probleme und kann in den bestehenden Sketch eingebunden werden ohne was zu verändern. Ich habe auch den DYP-ME007Y ausprobiert, diesen habe ich jedoch nicht zum laufen bekommen. Ich hatte zwei Stück und beide haben nicht funktioniert.

Solltet Ihr fragen haben schreibt sie doch einfach in die Kommentare, dann kann ich den Artikel anpassen.

Folgende Bauteile wurde verwendet:

1x Wemos Lolin32 https://amzn.to/2DAV8Mg *
1x Ultraschallsensor HC-SR04 http://amzn.to/2ndm5Pb *
1x Wasserdichter Ultraschallsensor JSN-SR04T https://amzn.to/2F4q31r *
1x ca. 2m 4 Adrige Leitung http://amzn.to/2nqOzWs *
1x Silikon http://amzn.to/2nHPqOn *
1x Abzweigdose klein
1x Abzweigdose groß http://amzn.to/2nHWFpA *
1x ein Stück Blech um den Sensor am Decker der Zisterne zu befestigen

19 Thoughts to “Zisterne Füllstandsanzeige 2.0 mit Wemos Lolin32 + MySQL Datenbank”

  1. Alex

    Hallo,
    ich würde das ganze gerne nachbauen.
    In deiner Einkaufsliste ist leider kein Netzteil vorhanden? Oder kann ich das Board direkt an 230V klemmen?
    Hast du jetzt den wasserdichten Sensor im Einsatz?
    Dannke
    Gruß
    Alex

    1. Arduino Projekte

      Hallo Alex,
      nein das Board kann nicht direkt am 230 Volt geklemmt werden. Als Netzteil kann ein einfaches Handyladegerät mit Micro USB genommen werden.
      Ja ich habe den Wasserdichten Sensor im Einsatz, funktioniert ohne Probleme.
      Gruß
      Tobias

  2. Martin Schmidt

    Hallo,
    hast du den JSN-SR04T direkt über den verlinkten Amazon-Händler bestellt? Wenn ja, handelt es sich dabei um die Version 1.0 oder 2.0? Letztere soll nicht ganz so stabil laufen, habe ich gelesen. Ich plane auch den Sensor für eine Zisterne zu verwenden, jedoch mit dem Wemos D1 Mini und der Tasmota Firmware, da ich das MQTT Protokoll für Homeassistant brauche.
    Schöne Grüße und danke für die Rückmeldung
    Martin

    1. Arduino Projekte

      Hallo Martin,
      nein ich habe den Sensor wo anders bestellt.
      Gruß
      Tobias

    2. Thomas

      Ich plane AS ganze auch mit dem wemos d1 mini und dem iobroker.Nutze auch MQTT. Werde mich mal dran geben und versuchen ,das ganze in ein Skript zu packen

  3. Martin Schmidt

    Hallo,
    welche Version des JSN-SR04T hast du im Einsatz? Falls 2.0, ist er beim WEMOS mit dem 3.3 V Pin oder dem 5 V Pin verbunden ?
    Gruß Martin

    1. Arduino Projekte

      Hallo Martin,
      ich habe Version 2 und Sie ist bei mir mit den 5 Volt verbunden, es läuft soweit ohne Probleme.
      Gruß
      Tobias

  4. Hab nur kurz eine Bemerkung:
    const int sleepSeconds = 28,779
    Sollte da nicht ein Punkt anstatt Komma stehen?

  5. Rai

    Hallo,
    ein Kommentar zum Wemos D1 und das Aufwachen nach dem deep-sleep:
    Das funktioniert problemlos, man muss nur den D0 Anschluss mit dem RST Anschluss verbinden. Dann weckt er sich nach dem Ablauf der Sleepzeit selber auf.
    Bei den original-WemosD1 v3 Modulen gibt es sogar an der Unterseite zwei Lötpunkte, die mit ein bisschen Lötzinn verbunden werden können.

  6. Echt eine Tolle Anleitung und eine Inspiration: Mein Projekt ist im Laborbetrieb aber fertig und muss noch einige Tage Test überwinden:
    https://github.com/schwoediauer/arduino_IoT

  7. Juergen

    Ich habe eine Frage, eventuell betreibt diese Lösung schon jemand am LoPi? Im USB Betrieb funktioniert alles super, nur im Batteriebetreib kann ich keine Werte messen, muss hier noch etwas beachtet werden?

    Ich verwende den JSN-SR04T

  8. Christian

    Ich möchte auch eine Frage stellen. Zunächst, KLASSE PROJEKT! Ist kopiert 🙂 !
    Allerdings frage ich mich wie hoch die DeepSleep Zeit beim Lolin sein darf? Ich habe den D1 mini pro hier und der erlaubt laut Datenblatt nur ~71 Minuten. Über den Lolin konnte ich nichts finden (unbegrenzt?). Weiß jemand Näheres?
    Vielen Dank schonmal!

  9. Christian

    … was mich etwas verwirrt ist, dass der obige Code einen Deepsleep von 479 Minuten setzen “will” . Der DeepSleep verlangt ein unsigned int was bei 32Bit = 4.294.967.295 ist was dann wiederum den 71Minuten entspricht. Wie funktioniert die Messung 1x am Tag?

  10. Thomas

    Hallo Zusammen,
    gibt es hier nicht die Möglichkeit, einen Wert lokal auf dem ESP32 abzuspeichern?
    Dann könnte man den Wlan nur bei Änderung des Wasserstandes zum Senden aktivieren. Das würde auch noch Strom sparen. Oder man könnte bei Änderungen im Gegenzug öfters senden…

  11. Thomas

    Hallo,

    Ich hab den Code jatzt auf meinem Lolin D32 so geändert, dass der Niveau-Wert auf dem Chip gespeichert wird.
    Bei einer Änderung wird der Wert über Wlan übertragen.
    Wenn sich nichts ändert, geht der Chip für x-Stunden nin den Standby. Wenn er sich ändert, wird die nächste Messung eher gemacht.
    D.h. bei Änderung wird öfters gesendet.
    Hab es jetzt auch soweit hinbekommen, dass der Stromverbrauch im Deep sleep nur noch 73,5µA (bei 3,6V) sind.
    Bei einer Messung ohne Wlan sind es ca. 42mA und bei einer Messung mit Wlan geht´s hoch bis auf 82mA.
    Die Daten sende ich per Http-Push in meine “Middleware vom Volkszähler”.
    Wenn ich alles komplett durchgetestet habe, will ich es in meine zwei Zisternen einbauen (natürlich auf AKKU-Betrieb).
    Vielen Dank für die Ursprüngliche Idee und den “Anfangscode”

  12. ralphi

    Hi,
    ich hab jetzt auch einen ‘DYP-ME007Y’, da mein Zisternen-Deckel jetzt aus Kunststoff ist und in der kälteren Zeit vor Wasser trieft 🙁
    Die Dinger haben UART ! der TX Ausgang reicht aus – messen kontinuierlich.
    TX -> 4 Byte:
    byte 0: 0xff
    byte 1: H-Byte
    byte 2: L-Byte
    byte 3: check-sum = byte0 + byte1 + byte2 (low byte only)

    Mein Problem mit dem ATTiny + Batterie + 433MHz Sender, ist der Sleep Mod.
    Jedes mal wenn er in aus dem Sleep kommt, Misst er Misst.
    // *************************************************
    // *** Zisterne die 6. 🙁 433MHz Wasserdichter Sensor UART RX ***
    // ******************************************

    const uint32_t id = 170; // ********** FESTE ID PRO SENSOR **

    // ATMEL ATTINY 25/45/85 / ARDUINO
    //
    // +-\/-+
    // Res Ain0 (D 5) PB5 1| |8 Vcc
    // 433 Ain3 (D 3) PB3 2| |7 PB2 (D 2) (TX)
    // VCC Ain2 (D 4) PB4 3| |6 PB1 (D 1) (RX)
    // GND 4| |5 PB0 (D 0) VCC sonar bei sleep aus
    // +—-+

    #include // 433 MHz
    #include // Sleep Modes
    #include // Power management
    #include // Watchdog timer
    #include

    RCSwitch mySwitch = RCSwitch();
    const byte TX = 2;
    const byte Pin433 = 3;
    const byte Pin_VCC_in = A2;
    const byte Pin_VCC_sonar = 0;
    const byte RX = 1; // ADC13V Bat

    //byte readByte = 0;
    byte read_buffer[4];
    uint32_t werte_sum;
    byte count = 0;
    byte anz_count = 8;

    SoftwareSerial DYP = SoftwareSerial(RX,TX);

    // ** SETUP **
    void setup() {
    resetWatchdog (); // do this first in case WDT fires
    pinMode(Pin_VCC_sonar, OUTPUT);
    mySwitch.enableTransmit(Pin433);
    DYP.begin (9600);
    // Lösche den Lesepuffer
    for (byte loopstep = 0; loopstep <= 3; loopstep++) { read_buffer[loopstep] = 0; }
    count = 0;
    delay(200);
    }

    // *** LOOP **
    void loop() {
    // +++++++ SONAR ++++++++++++++
    digitalWrite(Pin_VCC_sonar, HIGH); // Sonar **
    delay(500);
    if (DYP.available() < 1) return;
    byte readByte = DYP.read(); // Zum Puffer lesen
    for (byte loopstep = 0; loopstep anz_count) { // fertig 0000000000000000
    uint32_t data = werte_sum / (count * 10); // sonar fertig cm
    // baue senden *******************
    //uint32_t data = 0x00000000;
    //data |= avg_dist ;
    digitalWrite(Pin_VCC_sonar, LOW);
    uint32_t vcc = analogRead(Pin_VCC_in); // 10 bit -> 24 // Batt **
    data |= vcc << 12;
    data |= (id < 0) { readByte = DYP.read(); }
    } // ** LOOP ***

    // ****************************************************************
    // *********************** SLEEP ****************************
    // ****************************************************************

    void goToSleep (uint8_t i) {
    for(i=i; i>0; –i) {
    set_sleep_mode (SLEEP_MODE_PWR_DOWN);

    //ADCSRA = 0; // turn off ADC
    power_all_disable (); // power off ADC, Timer 0 and 1, serial interface
    noInterrupts (); // timed sequence coming up
    resetWatchdog (); // get watchdog ready
    sleep_enable (); // ready to sleep
    interrupts (); // interrupts are required now
    sleep_cpu (); // sleep
    // *************** SLEEP ************************
    sleep_disable (); // precaution
    power_all_enable (); // power everything back on
    } // i times
    //ADCSRA |= _BV(ADEN); // ADC on
    //power_adc_enable();

    } // end of goToSleep

    // watchdog interrupt *********************
    ISR (WDT_vect) {
    wdt_disable(); // disable watchdog
    } // end of WDT_vect

    void resetWatchdog () { // ++++++++++++++++++
    MCUSR = 0; // clear various “reset” flags
    WDTCR = bit (WDCE) | bit (WDE) | bit (WDIF); // allow changes, disable reset, clear existing interrupt
    // set interrupt mode and an interval (WDE must be changed from 1 to 0 here)
    WDTCR = bit (WDIE) | bit (WDP3) | bit (WDP0); // set WDIE, and 8 seconds delay
    wdt_reset(); // pat the dog
    } // end of resetWatchdog

    1. ralphi

      Der Blog hat mir den Quellcode (loop) zusammen gekürzt.
      Wenn Jemand den vollständige haben will – einfach melden ..

  13. Nico

    Eine Frage die Berechnung des Echos bezieht sich auf was gibts da ne Formel wie es mit jeder Zisterne oder wasser fass funktioniert.
    Wenn ja bitte mal hier posten:) Dein Projekt ist klasse plane das evtl bei mir nachzubauen aber würde gern die Formel dazu verwenden hat ja jeder ein anderes Volumen.
    Wie genau ist das deiner Einschätzung nach, also +- Liter?

    1. Arduino Projekte

      Hallo Nico,
      schau dir mal den Artikel an, hier ist es auch beschrieben.
      https://arduino-projekte.info/zisterne-fuellstandsanzeige/
      Bei mir schwangt es mal um ca. 100 Liter, was aber bei jedem auch anders ist. Der Sensor schwangt um ca. 1 cm herrum und das auf die Zisterne oder Fass umgerechnet, kommen da andere Werte raus.
      Gruß
      Tobias

Leave a Comment