Füllstandsmessung per Pegelsonde.

[Beowolf]

So, jetzt habe mal wieder hier weiter gemacht. PVC Rohr aus dem Baumarkt geholt.

Leeres Rohr - linkes Poti auf Null. OK
Wasser rein - auf 140 cm (ist die max Füllhöhe vom Öltank). OK
Rechtes Poti gedreht und gemessen - mehr als 1.006 Volt bekomme ich dort nicht.

Ich habe jetzt in der Tabelle bei max Füllhöhe 500 eingegeben. ist ja auch richtig, oder? Mehr kann die Sonde nicht.
Wenn ich nun in der Tabelle bei einer Füllhöhe von "140,1367188cm" schaue, steht dort als Spannngswert "0,92490234 Volt".

Habe jetzt am rechten Poti gedreht, bis ich 0,925 Volt erreicht habe.

Soweit so gut.

ABER

Mit der Berechnung Liter zu Dichte stimmt etwas nicht.

Im Sketch steht:

    // read the analog value
    fuel = analogRead(analogPin);     // read the input pin
    percent = fuel * 0.132;
      if (percent > 100) {
         percent = 100;
      }
    float calc = max_liter / analog_value;    // calculate percent
          calc = calc * dichte;               // calculate dichte
    liter = fuel * calc;                      // calculate liter
        if (liter > max_liter) {
           liter = max_liter;
        }

In Zahlen in der "float" Zeil 289 (Meine Tankgrößen 8900 Liter und Analogwert voll 215):

calc = 8900 / 215 ist 41,39535

calc = 41,39535 * 1 (bei Wasser)

Bei vollem Tank:

liter = 215 * 41,39535

liter gleich 8900 Liter

So weit so richtig. Alles bei Wasser

Wenn ich jetzt die Dichte von Heizöl einsetze kommt eine falsche Literzahl heraus.

calc = 41,39535 * 0,86 (bei Heizöl)

calc = 35,6

liter = 215 * 35,6

liter gleich 7654 Liter

das ist bei gleichem Analogwert (ist ja Druck) zu wenig. Öl ist leichter als Wasser. Die Menge sollte mehr sein.

Ich habe jetzt mal 1 / 0,86 geteilt. Macht 1,1628

Wenn ich nun

calc = 41,39535 * 1,1628 (bei Heizöl)

calc = 48,1345

liter = 215 * 35,6

liter gleich 10349 Liter

Das passt schon besser.

Grüße
Manfred

[Beowolf]

Hallo Eisbaeeer,

ich hoffe, das Du nichts dagegen hast, wenn ich den geänderten Sketch hier einstelle.

Ich habe den Sketch für meinen Öltank jetzt wie folgt geändert.

Event. kann ja jemand die Änderung verwerten.

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------
  Program:      Füllstandsmessung mit Pegelsonde

  Description:  Dieses Programm misst die analolge Spannung an einem Port, welche von einem Drucksensor
                0-5m Meßhöhe und 4-20mA Stromschnittstelle erzeugt wird.
                Voraussetzung ist ein Meßwandler, welcher die 24V Versorgungsspannung an
                den Drucksensor liefert und 0-3,3V analoge Spannung ausgibt.
                Dienste:
                DHCP, wenn vorhanden, sonst wird eine feste IP mit 192.168.1.21 vergeben.
                  
  Hardware:     Arduino Nano ATmega 328P 
                W5100 Netzwerk shield
                LCD Display I2C HD44780
        
        Pin-Ports:
        A0 = Analog IN
        A4 = SDA
        A5 = SCL
        
  
  Date:         20191013
  Modified:     Initial Version 1.0
                - DHCP error routine

                20191017
                - Fixed uptime_d

                20191019
                Version 1.1
                - Dichte Berechnung hinzugefügt
                Version 1.2
                - LCD wechselt jetzt alle 30 Sek. zwischen Uptime und Analog Messwert

                20191024
                - Fixed MQTT uptime_d char array

                20191028
                Version 1.3
                - MQTT Port definierbar
                - MQTT User Password authentication

  Author:       Eisbaeeer, https://github.com/Eisbaeeer               
 
  Author:       Ethernet part: W.A. Smith, http://startingelectronics.com
                progress bar -  CC BY-SA 3.0 :  skywodd, https://www.carnetdumaker.net/articles/faire-une-barre-de-progression-avec-arduino-et-liquidcrystal/
        
  LICENSE:    MIT License
  
-------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
// Include some libraries
#include <Ethernet.h>
#include <SPI.h>

#include <Wire.h>
#include <hd44780.h>                       // main hd44780 header
#include <hd44780ioClass/hd44780_I2Cexp.h> // i2c expander i/o class header
hd44780_I2Cexp lcd; // declare lcd object: auto locate & auto config expander chip
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
const int LCD_COLS = 20;
const int LCD_ROWS = 4;
const int LCD_NB_COLUMNS = 20;

#include "progress.h"



// ##############################################################################################################################
// ---- HIER die Anpassungen vornehmen ----
// ##############################################################################################################################
// Hier die maximale Füllmenge des Behälters angeben. Dies gilt nur für symmetrische Behälter.
const float max_liter = 8900;                           

// Analoger Wert bei maximalem Füllstand (wird alle 30 Sekungen auf dem LCD angezeigt oder in der seriellen Konsole mit 9600 Baud.
const int analog_value = 880;                           

// Dichte der Flüssigkeit - Bei Heizöl bitte "1.1628" eintragen, aber nur wenn die Kalibrierung mit Wasser erfolgt ist! 
// Bei Kalibrierung mit Wasser bitte "1.0" eintragen
const float dichte = 1.1628;                              

// IP Adresse und Port des MQTT Servers
IPAddress mqttserver(192, 168, 49, 38);
const int mqttport = 1886;

// Wenn der MQTT Server eine Authentifizierung verlangt, bitte folgende Zeile aktivieren und Benutzer / Passwort eintragen
#define mqttauth
const char* mqttuser = "mqttuser";
const char* mqttpass = "Beowolf503588";                 

// IP Adresse, falls kein DHCP vorhanden ist. Diese Adresse wird nur verwendet, wenn der DHCP-Server nicht erreichbar ist.
IPAddress ip(192, 168, 49, 155);                          

// MAC-Addresse bitte anpassen! Sollte auf dem Netzwerkmodul stehen. Ansonsten eine generieren.
byte mac[] = { 0xD4, 0x3E, 0x07, 0xD5, 0x79, 0xED };    

// ##############################################################################################################################
// AB hier nichts mehr ändern!
// (Ausser ihr wisst, was ihr tut)
// ##############################################################################################################################

#define USE_SERIAL Serial

// No more delay
unsigned long startMillis;  // some global variables available anywhere in the program
unsigned long currentMillis;
const unsigned long periode = 1000;  // one seconds

byte one_minute = 60; // one minute
byte one_minute_count = 0;
byte one_hour = 60; // one hour
byte one_hour_count = 0;
byte one_day = 24; // one day
byte one_day_count = 0;

byte uptime_s = 0;
byte uptime_m = 0;
byte uptime_h = 0;
int uptime_d;

float percent;
float liter;
boolean LCD_Page;

// Analog IN
int analogPin = A0;
int fuel = analogRead(analogPin);  // variable to store the analog value read from sensor

// MQTT global vars
#include <PubSubClient.h>
unsigned int send_interval = 30; // the sending interval of indications to the server, by default 10 seconds
unsigned long last_time = 0; // the current time for the timer

boolean mqttReconnect = false;

// MQTT definitions
EthernetClient ethClient;
PubSubClient client(ethClient);
void callback(char * topic, byte * payload, unsigned int length);
// Declare subs
void Mqttpublish();



void defaultEthernet(void)
  {
    Ethernet.begin(mac, ip);  // initialize Ethernet device
  }


void setup()
{
  USE_SERIAL.begin(9600);       // for debugging
  
  analogReference(INTERNAL);  // für einen erweiterten Meßbereich
  

/*--------------------------------------------------------------
 * LCD init
--------------------------------------------------------------*/
  lcd.init();
  int status;
  status = lcd.begin(LCD_COLS, LCD_ROWS);
  if(status) // non zero status means it was unsuccesful
  {
    status = -status; // convert negative status value to positive number
    // begin() failed so blink error code using the onboard LED if possible
    hd44780::fatalError(status); // does not return
  }

  // initalization was successful, the backlight should be on now
  // Print a message to the LCD
  lcd.print("Oeltank");
  lcd.setCursor(0, 1);
  lcd.print("Version 1.3.1");
  lcd.setCursor(0, 3);
  lcd.print("github/Eisbaeeer");
  delay(1000);
  uptime_d = 0;

  setup_progressbar();

/*--------------------------------------------------------------  
 * Milliseconds start
--------------------------------------------------------------*/
  startMillis = millis();  //initial start time


// start MQTT client
  client.setServer(mqttserver, mqttport);

  Mqttpublish();

/*--------------------------------------------------------------  
 * Ethernet init
--------------------------------------------------------------*/  
    if (Ethernet.begin(mac) == 0) {
    // USE_SERIAL.println(F("Failed config using DHCP"));
    // DHCP not working, switch to static IP
    defaultEthernet();
    if (Ethernet.hardwareStatus() == EthernetNoHardware) {
      // USE_SERIAL.println(F("Eth shield not found"));
    } else if (Ethernet.linkStatus() == LinkOFF) {
      // USE_SERIAL.println(F("Eth cable not conn"));
      }
    }
 
    USE_SERIAL.print(F("IP: "));
    USE_SERIAL.println(Ethernet.localIP());       
}




void loop()
{
 
/*--------------------------------------------------------------  
 * check ehternet services
--------------------------------------------------------------*/
    switch (Ethernet.maintain()) {
      case 1:
       //renewed fail
       USE_SERIAL.println(F("Error: renewed fail"));
       break;

      case 2:
        //renewed success
       USE_SERIAL.println(F("Renewed success"));
       //print your local IP address:
       USE_SERIAL.print(F("My IP address: "));
       USE_SERIAL.println(Ethernet.localIP());
       break;

      case 3:
       //rebind fail
       USE_SERIAL.println(F("Error: rebind fail"));
       break;

      case 4:
       //rebind success
       USE_SERIAL.println(F("Rebind success"));
       //print your local IP address:
       USE_SERIAL.print(F("My IP address: "));
       USE_SERIAL.println(Ethernet.localIP());
       break;

      default:
       //nothing happened
       break;
  }
 
 
  
/*--------------------------------------------------------------  
 * remove delay (one second)
--------------------------------------------------------------*/
  currentMillis = millis();  //get the current "time" (actually the number of milliseconds since the program started)
  if (currentMillis - startMillis >= periode)  // Hier eine Sekunde (periode)
  { 
  startMillis = currentMillis;

    /******************************************************************************************
   *  1 Sekunden Takt 
   * *****************************************************************************************
   *  
   *  
   *******************************************************************************************/
    
    // Hier die Funktionen im Sekundentakt
    // ###################################    
                 
     uptime_s++;
     if (uptime_s >59)
        { uptime_s = 0; 
          uptime_m ++;
        }
     if (uptime_m >59)
        { uptime_m = 0; 
          uptime_h ++;
        }
     if (uptime_h >23)
        { uptime_h = 0; 
          uptime_d ++;
        }
     
       
   /******************************************************************************************
   *  30 Sekunden Takt 
   * *****************************************************************************************
   *  
   *  
   *******************************************************************************************/
   if ((millis()) >= (last_time + send_interval * 1000)) {
        last_time = millis(); 



        LCD_Page = !LCD_Page;
        MqttSub();
      }
  
  /******************************************************************************************
   *  1 Minuten Takt 
   * *****************************************************************************************
   *  
   *  
   *******************************************************************************************/
    if (one_minute_count <= one_minute) {
        one_minute_count++;
        } else {
        one_minute_count = 0; // reset counter
        one_hour_count++;

    // read the analog value
    fuel = (9.5 * fuel + 0.5 * analogRead(analogPin))/10.0;              // analogen eingang lesen und beruhigen
    percent = (fuel * 100.0) / analog_value;
          percent = percent * dichte;                                    // Prozentanzeige der Dichte anpassen
      if (percent > 100) {
         percent = 100;
      }
    float calc = max_liter / analog_value;    // calculate percent
          calc = calc * dichte;               // calculate dichte
    liter = fuel * calc;                      // calculate liter
        if (liter > max_liter) {
           liter = max_liter;
        }
    USE_SERIAL.print(F("Analog: "));
    USE_SERIAL.println(fuel);
    USE_SERIAL.print(F("Prozent: "));
    USE_SERIAL.println(percent);
    USE_SERIAL.print(F("Liter: "));
    USE_SERIAL.println(liter);

    // print out to LCD
    draw_progressbar(percent);
    write_lcd();
                
        USE_SERIAL.print(F("Uptime: "));
        USE_SERIAL.print(uptime_m);
        USE_SERIAL.println(F(" Minuten"));

        // MQTT reconnect timeout
        //Mqttpublish();
        mqttReconnect = false;     
        
     }

   /******************************************************************************************
   *  1 Stunden Takt 
   * *****************************************************************************************
   *  
   *  
   *******************************************************************************************/
     if (one_hour_count == one_hour) {
        one_hour_count = 0; // reset counter
                
    // Hier die Funktionen im Stundentakt
    // ###################################

      USE_SERIAL.println(F("ONE HOUR"));
      } 
      
  }

  
}
   /******************************************************************************************
   *  Ende Loop
   * ****************************************************************************************
   *  Beginn Unterprogramme
   ******************************************************************************************/


void MqttSub(void)
{
  // MQTT stuff
  // If the MQTT connection inactively, then we try to set it and to publish/subscribe
  if ( mqttReconnect == false )
  {
    if (!client.connected()) {
        USE_SERIAL.print(F("Conn MQTT"));
         // Connect and publish / subscribe
        #ifdef mqttauth
         if (client.connect("Oeltank", mqttuser, mqttpass)) {
        #else
         if (client.connect("Oeltank")) {
        #endif
            USE_SERIAL.println(F("succ"));
            // pulish values
            Mqttpublish();
          } else {
            // If weren't connected, we wait for 10 seconds and try again
            USE_SERIAL.print(F("Failed, rc="));
            USE_SERIAL.print(client.state());
            USE_SERIAL.println(F(" try again every min"));
            mqttReconnect = true;
         }
          // If connection is active, then sends the data to the server with the specified time interval 
          } else {
            Mqttpublish(); 
          }
    }
}

void write_lcd(void)
{
    char LCDbuff[20];
    // Zeile 1
    lcd.setCursor(6, 0); 
    dtostrf(liter, 4, 0, LCDbuff);
    lcd.print(LCDbuff); lcd.print(" Liter");
    
    if ( LCD_Page == false ) {
              // Zeile 3
              lcd.setCursor(0, 2); 
              lcd.print("Uptime");

              // Zeile 4
              lcd.setCursor(0, 3);
              String uptimesum;
              uptimesum = String(uptime_d);
              uptimesum = String(uptimesum + "d ");
              uptimesum = String(uptimesum + uptime_h);
              uptimesum = String(uptimesum + "h ");
              uptimesum = String(uptimesum + uptime_m);
              uptimesum = String(uptimesum + "m");
              lcd.print(uptimesum);    
    } else {
              // Zeile 3
              lcd.setCursor(0, 2); 
              lcd.print("Messwert Analog");

              // Zeile 4
              lcd.setCursor(0, 3);
             // lcd.print(analogRead(analogPin));    
              lcd.print(fuel); 
    }
 
 }

void Mqttpublish(void)
{  
      char buff[25];
      dtostrf(fuel, 5, 2, buff);
      client.publish("Oeltank/Analog", buff );

      dtostrf(liter, 5, 0, buff);
      client.publish("Oeltank/Liter", buff );

      dtostrf(percent, 5, 0, buff);
      client.publish("Oeltank/Prozent", buff );
    
      // System    
      String upsum;
      upsum = String(uptime_d);
      upsum = String(upsum + "d ");
      upsum = String(upsum + uptime_h);
      upsum = String(upsum + "h ");
      upsum = String(upsum + uptime_m);
      upsum = String(upsum + "m");
      upsum.toCharArray(buff, 25);
      client.publish("Oeltank/Uptime", buff); 
}

void draw_progressbar(byte percent) {
 
  lcd.clear(); 
  /* Affiche la nouvelle valeur sous forme numérique sur la première ligne */
  lcd.setCursor(0, 0);
  lcd.print(percent);
  lcd.print(F(" %  ")); 
  // N.B. Les deux espaces en fin de ligne permettent d'effacer les chiffres du pourcentage
  // précédent quand on passe d'une valeur à deux ou trois chiffres à une valeur à deux ou un chiffres.
 
  /* Déplace le curseur sur la seconde ligne */
  lcd.setCursor(0, 1);
 
  /* Map la plage (0 ~ 100) vers la plage (0 ~ LCD_NB_COLUMNS * 2 - 2) */
  byte nb_columns = map(percent, 0, 100, 0, LCD_NB_COLUMNS * 2 - 2);
  // Chaque caractère affiche 2 barres verticales, mais le premier et dernier caractère n'en affiche qu'une.

  /* Dessine chaque caractère de la ligne */
  for (byte i = 0; i < LCD_NB_COLUMNS; ++i) {

    if (i == 0) { // Premiére case

      /* Affiche le char de début en fonction du nombre de colonnes */
      if (nb_columns > 0) {
        lcd.write(1); // Char début 1 / 1
        nb_columns -= 1;

      } else {
        lcd.write((byte) 0); // Char début 0 / 1
      }

    } else if (i == LCD_NB_COLUMNS -1) { // Derniére case

      /* Affiche le char de fin en fonction du nombre de colonnes */
      if (nb_columns > 0) {
        lcd.write(6); // Char fin 1 / 1

      } else {
        lcd.write(5); // Char fin 0 / 1
      }

    } else { // Autres cases

      /* Affiche le char adéquat en fonction du nombre de colonnes */
      if (nb_columns >= 2) {
        lcd.write(4); // Char div 2 / 2
        nb_columns -= 2;

      } else if (nb_columns == 1) {
        lcd.write(3); // Char div 1 / 2
        nb_columns -= 1;

      } else {
        lcd.write(2); // Char div 0 / 2
      }
    }
  }
}

Grüße
Manfred

[Eisbaeeer]

@Beowolf Hi. Kein Problem. Besser wäre ein Pull-request gewesen. Dann wären deine Änderungen schon in Github
Ich mach das wenn ich dazu komme.
Gruß Eisbaeeer

[Beowolf]

Ich wollte Dir da nicht zwischen funken.

[BastelKlaus]

Hi und erst mal DANKE für diese tolle Arbeit!

Ich bin mit so Elektro selbstbauten totaler Anfänger, hab mich aber nach dem ich dass hier gelesen hab alles bestellt und bin jetzt am zusammenbauen.

Vielleicht eine Dumme Frage aber,
beim einschalten steigt der gemessene Spannung erst auf 24,6V und fällt dann schnell auf 23,9V ist das so ok oder soll ich lieber so einstellen das 24V das maximal gemessene ist?

Ich verwende ein ELRO Multimeter zum Messen.

[Beowolf]

Ich würde mal sagen, das das vollkommen ok ist. 23,9 oder 24 Volt.

Hau Dir da ein Ei drauf. Ist egal.

[BastelKlaus]

ich konnte es mal wieder nicht erwarten...

danke für die schnelle Antwort.

Ich hab das Ganze jetzt so eingestellt, dass ich beim anschalten keine Spitze über 24V bekommen.
-Bedeutet beim anschalten 24V nach 1-2 sec dann 23.3V
In der Zisterne abgeglichen
-außerhalb vom Wasser 0V
-am Grund liegend erst 0,98V mit dem 2 Jumpern erreiche ich jetzt 1,98V

ist das so ok?

[Eisbaeeer]

@BastelKlaus sagte in Füllstandsmessung per Pegelsonde.:

ich konnte es mal wieder nicht erwarten...

-außerhalb vom Wasser 0V
-am Grund liegend erst 0,98V mit dem 2 Jumpern erreiche ich jetzt 1,98V

ist das so ok?

Welche maximale Füllstandshöhe wirst du denn erreichen? Also wieviel cm hat dein Behälter maximale Höhe?
Grundsätzlich passt es, wenn die maximale Spannung die 3,3V 5V nicht übersteigt. Bei mir ist es auch so, dass ich bei meiner maximalen Füllstandshöhe auf 3,3V abgeglichen habe. Damit habe ich dann die höchst mögliche Range meines AD-Wandlers ausgereizt.
Gruß Eisbaeeer

[Beowolf]

@Eisbaeeer sagte in Füllstandsmessung per Pegelsonde.:

Grundsätzlich passt es, wenn die maximale Spannung die 3,3V nicht übersteigt. Bei mir ist es auch so, dass ich bei meiner maximalen Füllstandshöhe auf 3,3V

Mir ist nicht klar, wie Du auf 3,3 Volt kommst. Ich habe die Sonde in ein PVC Rohr für den Abgleich gesteckt. Passenden Wasserstand "simuliert" und dann gemessen.

Bei einer Füllhöhe von 1,40m bekam ich nur eine Spannung von ca. einem Volt hin. Mehr ging nicht.

[Eisbaeeer]

@Beowolf
Technische Daten meiner Sonde:
Messbereich 0 bis 5 Meter bei 4-20mA.
Das bedeutet, dass die Sonde pro Meter Füllhöhe einen Strom von 3,2mA erzeugt (16mA / 5 Meter = 3,2mA/M). Bei deinen 1,4 Meter maximale Füllhöhe wäre das dann 4mA + 4,48mA = 8,48mA Strom. Jetzt ist die Frage, wie dein Stromwandler das ganze verarbeiten kann. Meiner hat mehrer Möglichkeiten zur Einstellung. Ich wandle jetzt mit dem Modus 4-20mA zu 0-5V. Es gäbe aber auch noch eine Einstellung am Wandler mit 0-3,3V, was für den Nano eigentlich die richtige wäre . Aber ich nutze die 0-5V, weil ich ja schon weiß, dass mein Strom nie die 20mA, also den maximalen Strom erreichen wird, da meine Füllhöhe nie die 5 Meter erreicht. Somit gewinne ich ein wenig mehr "Auflösung" im AD-Wandler des Nano. Bei 1,4 Meter liegst du mit der Sonde (mit Meßbereich 0-5 Meter) sehr ungünstig. Da wäre eine Sonde mit 0-3 Meter die bessere Wahl gewesen. Aber die kosten eben auch ein bischen mehr.
Ich hoffe du konntest folgen?
Da die Wandlungen alle linear sind, spielt die Spannung eigentlich keine Rolle. Es ist eben nur wichtig, die maximale Spannung beim maximalen Füllstand zu bekommen. Und die muss natürlich noch zum AD-Wandler Eingang passen, damit der nicht kaputt geht. Beim Nano sind es am AD-Eingang eben 3,3V 5V. Meine maximale Füllhöhe und meine Wandlereinstellung erlaubt es mir nun, den eingeschränkten Sondenbereich etwas zu zerren. Da meine Füllhöhe 3,2 Meter sind, erreiche ich dann eben auch "fast" die 3,3V, die der Nano am Eingang verarbeitet.
Gruß Eisbaeeer

Edit: Ich korrigiere mich. Habe eben nochmals im Datenblatt nachgelesen. Der A0 vom Nano verträgt sogar 5V. Das ändert aber immer noch nichts daran, dass man die maximale Spannung beim maximalen Füllstand nach der Wandlung erreichen sollte. Das sind dann eben 5V im Idealfall, den aber die wenigsten erreichen werden, da dann eben ein Füllstand von 5 Meter vorliegen muss.

[BastelKlaus]

@Eisbaeeer
hi ich kann nur schätzen aber 2,5-3m tief maximal.
Ich komm halt nicht auf 3,3V oder mehr, hab an dem Poti schon maximal gedreht da wird nicht mehr als die knapp 2V (Zisterne ist am überlaufen).

Noch eins hätte ich da, ich wollte dass ganze mal mit Espeasy testen da ich schon 2-3 im Einsatz hab und in skripten nicht fit bin.
Ich bekomm am LCD nichts angezeigt obwohl ich im i2c scan das Display finde.
Kann ich dass hier mit rein posten oder soll ich da lieber was neues auf machen?

Edit: Den gestrichenen Teil hab ich nun hin bekommen, dachte erst es lag an dem 5V, aber in Wirklichkeit wars nur Unwissenheit --> böser Kontrast

Egal wieder was gelernt.

Morgen mach ich mich mal an die Verkabelung in die Zisterne, mal schaun was da dann noch so lauert

[BastelKlaus]

Hab heute alles man angeschlossen:
-NodeMCU 8266 E12 (kann mit 3,3V an A0)
-den Rest würde ich sagen Sonde und so alles wie ihr auch habt

Die Spannung die zu A0 geht ist eigentlich Konstant 1,98V, aber die Werte die ich im ESP auslese schwanken 0,685V-0,63V.
Ist das so Normal oder liegt es an meinem ESP?

[Eisbaeeer]

Die Schwankung ist normal. Um die zu beruhigen könnte man einen Mittelwert errechnen. Ich übertrage aber eh nur alle halbe Minute mit MQTT.
Mein System läuft jetzt schon 49 Tage ohne Probleme.

[BastelKlaus]

@Eisbaeeer schaut schick aus, echt ne tolle Arbeit.

Ich log die Daten jetzt mal mit history und schau es mir Morgen wieder an.
Wo würdet ihr die Berechnung des Volumens machen?

Bei mir greift Volumenberechnung eines liegenden Kreiszylinders (Tank-Problem)
Abbildung
https://de.wikipedia.org/wiki/Zylinder_(Geometrie)

In Excel kann ich das Volumen gut berechen, aber wo macht man das in Iobroker am besten?

[opossum]

Hallo, @BastelKlaus ,

hast Du den gleichen Node MCU wie bei mir abgebildet?
?
Bei mir sieht das so aus:

Ich habe ESPEasy geflasht, dort macht die Software die Berechnung.

Eingebaut sieht das so aus:
das Gerät klinkt sich in mein WLAN ein und sendet dann via MQTT an den MQTT-Adapter seine Werte.

[opossum]

Devices angelegt:

dann

hier die Werte eingestellt. Ich habe einmal den Inhalt meiner vollen Zisterne berechnet, das ergab die 5600 Liter.
Du hättest hier im Feld Formel auch die Möglichkeit, eine Berechnung anzustellen. War aber bei mir nicht notwendig. Ich sende den Wert alle 10 Sekunden an den Controller, den ich im ESP8266 erstellt habe.
Im ESP habe ich noch eine Rule gebaut, die eine Berechnung durchführt, das ist dann der Prozentwert des Füllstandes.

[opossum]

Hier der Eintrag des Controllers:

Im Controller dann folgende Einstellungen:

Im IOBroker den MQTT-Adapter installiert und hier User und Passwort eingetragen. Das ist dann auch im ESPEasy hinterlegt.

[opossum]

Ganz nebenbei fällt auch noch die Ansteuerung der Anzeige mit ab. Ist auch alles sehr gut im WiKi beschrieben.
Einstellungen für das LCD:

[BastelKlaus]

@opossum für so eine schöne detaillierte Anleitung sollte man die schon fast....

Ohne schmarn ich hab mir das die letzten Wochen nach und nach zusammen gesucht und dachte mir.
Wenns das dann mal funktioniert, kann ich auch mal was positives beisteuern zu spät

Bekommt man in die Rule auch die Berechnung meiner Zisterne rein?
Ich muss da mal noch aweng was lesen denk ich.

Und ja ich hab genau diese ESP Board und die restlichen Komponenten die du und Eisbaeeer vorgeschlagen habt.
Auch die Ama... Sonde die dann doch fast 1 Monat Lieferzeit hatte.

[opossum]

Hallo, @BastelKlaus ,

Du brauchst das Volumen im ESP nicht berechnen. Da Du das ja schon in Excel gemacht hast, weißt Du ja schon, wie viel Liter bei Dir den Zustand "Voll" bedeuten. Du brauchst ja nur den Wert für leer und voll. Der ESP setzt ja die Spannung am A0 intern in 1024 Schritte um, also 0-1023. Dabei entspricht 0 = leer und 0V am Eingang A0 bzw. 1023=Voll= 3,3V am Eingang A0. Der ESP wandelt also die Eingangsspannung in einen Wert um, der irgendwo zwischen 0 und 1023 liegt. Mit den Angaben für 0=0 und 1023=5600 Liter (bei mir) kann der ESP den Füllstand auf 5,4 Liter genau berechnen. Das ist mehr als ausreichend. Die Berechnung in der Rule mache ich nur, weil ich im ioBroker nicht noch ein Umrechnungsscript laufen lassen will. Da sollen nur noch die absoluten Werte ankommen für Füllstand und Prozent Füllstand, die ich dann in meiner VIS verwurste. Da es ja in letzter Zeit immer geregnet hat, ist meine Zisterne bis zum Überlauf gefüllt, so dass ich bei mir die Höhe der Wassersäule gut messen konnte, dann brauchte ich noch den Durchmesser auf Höhe des Wasserspiegels, damit konnte ich dann das Volumen eines Zylinders recht schnell berechnen. (Betonzisterne als Zylinder mit aufgesetztem Kegel, um das mal geometrisch zu beschreiben.) Herausgekommen ist dann das Ergebnis 5600 Liter.
Sorry, wenn ich jetzt schneller war. Ich bin aber auf Dein Ergebnis und vielleicht auch auf Deine VIS gespannt.