Füllstandsmessung per Pegelsonde.

Beowolf

Noch einmal eine Frage zur Kalibrierung.

Ich muß bald Öl bestellen. Tank ist fast leer.

Es sollte doch auch funktionieren, wenn ich vorher einen "geschätzten" Restinhalt einstelle, und nach dem Betanken die erhaltene Ölmenge hinzuaddiere, oder? Per Einstellung am Poti.

Grüße

opossum

Du musst ja am Strom-Spannungswandler am Ausgang einmal auf 0V justieren (am Eingang fließen dann 4mA) und einmal auf 3,3V (am Eingang dann 20mA). Die maximale Füllmenge ist ja bekannt. Man könnte am Eingang über Widerstände diese 4mA und 20mA "simulieren". Allerdings kann ich nicht sagen, welche Spannung über der Sonde abfällt. Was ich genau sagen kann, meine Sonde hat bei "leer" wirklich 4mA, gemessen mit Multimeter 4,02mA. Du könntest vielleicht die Sonde anschließen. Sie wird ja mit 24V versorgt. Bei angeschlossener Sonde den Spannungsabfall messen, mit diesem Wert dann die Widerstände ausrechnen, die bei diesem Spannungsabfall einmal 4mA fließen lassen und einmal 20mA fließen lassen. Dann kannst Du mit den Potis auf 0V und 3,3V Ausgangsspannung justieren. Der Vorteil wäre, das Du danach genau weißt, wieviel tatsächlich noch im Tank ist.
Ob man an den Eingang einfach solch einen Widerstand anschließen kann und ob der Spannungsabfall konstant ist, kann ich nicht sagen.

Eisbaeeer

Heute hat es nicht geregnet. Zeit für den Umbau. HM Kapazitive Messung raus, Pegelsonde rein.
Jetzt noch warten, bis die Zisterne voll ist. Es kann also wieder regnen. 🤣
Beim Einbau stehen jetzt noch die Pfostenstecker vom ISP im Weg. Deshalb passt die Abdeckung rechts noch nicht drauf. Wird bei der nächsten Gelegenheit ausgelötet. Braucht eh keiner, dann passt die Abdeckung drauf.

Grüße Eisbaeeer

Beowolf

So, ich habe die Schaltung jetzt mal aufgebaut. Das Poti für die Nullspannung ist klar. Das andere Poti ist nicht wirklich klar.

Ich habe die Sonde so im Raum liegen. Null Volt eingestellt, 0 Liter im Tank. So weit, so gut.

Lege ich die sonde in einen Eimer Wasser (10 Liter voll), zeigt mir die Anzeige auch einen Wert an. Leider schwankt der immer zwische 341 und 260 Liter.

Das andere Poti macht nichts. Von Anschlag zu Anschlag (man hört ein ganz leises klicken) passiert nichts.

Ich benötige da wohl noch einmal Hilfe.

Grüße
Manfred

Beowolf

Habe mich mal ein wenig umgeschaut.

Das Schwanken der Werteausgabe ist wohl normal bei einen Nano usw.. Selbst bei einem angeschlossenem Poti schwanken die Ausgabewerte.

Ich habe mal im Sketch etwas verändert.

Zeile 126

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

Habe ich auf den Analgwert gesetzt, damit in der Rechnung schon mal ein Wert steht.

Zeile 285

fuel = (95 * fuel + 5 * analogRead(analogPin))/100; // read the input pin and smooth it

Hier wird der Wert beruhigt.

Ist das so ok?

Eisbaeeer

@Beowolf Man könnte auch eine Minute die Werte messen, in ein Array und den Mittelwert bilden. Mir reicht das so, wie es jetzt ist.
Zum Abgleich kann ich noch sagen, dass ich aufgrund meiner Zisterne (ich erreiche keine 5 Meter Wassersäule) doch beide Jumper wieder aufgesetzt habe und damit abgeglichen. Jetzt erreiche ich bei voller Zusterne die 3.3V

Beowolf

Das mit den Poti verstehe ich noch nicht.

Linker Poti stellt Nullpunkt ein. Dazu mit Multimeter an hellblau (mittlerer Pin vom Wandlermodul) auf 0V einstellen. Es kann auch ein negativer Wert angezeigt werden. Das Poti macht locker 20 Umdrehungen, bis es von min auf max geht.

Ok, das ist klar. Geht auch ohne Problem.

Rechter Poti stellt dann den Range ein. Minimum ist bei Tank leer, maximum bei Tank voll (maximum darf 3.3V nicht übersteigen!

Das ist mir nicht klar. Wo messe ich das?

opossum

@Beowolf , die 3,3V werden an genau dem gleichen Pin gemessen, wie die 0V. Aus meiner Sicht kann man nicht sauber justieren, wenn nur eine Teilmenge im Tank ist, es sei denn, man kennt die Größe dieser Teilmenge. Wenn der Tank voll ist, kann ich beide Werte sauber abgleichen. Sonde nicht im Tank, 0V einstellen (linkes Poti). Dann Sonde in den vollen Tank, egal, welcher Wert jetzt angezeigt wird, den Ausgang jetzt mit dem rechten Poti auf 3,3V abgleichen. Liegen die 3,3V an, muss die Füllstandsanzeige eigentlich den maximalen Inhalt anzeigen. In der Rechnung sind ja genau diese zwei Punkte hinterlegt. Analogwert 0 entspricht 0 Liter, Analogwert 1023 entspricht voller Füllstandsmenge. Oder man bringt den Strom-Spannungswandler zu diesen Werten von 0v und 3,3V. Das geht aber nur, wenn am Sondeneingang einmal 4mA und einmal 20mA fließen.
Vereinfacht gesagt:
Eingang Sonde 4mA = Ausgang 0V = Eingang Arduino = Analogwert 0 Arduino
Eingang Sonde 20mA = Ausgang 3,3V = Eingang Arduino = Analogwert 1023.
Wie gesagt, so würde ich das machen. Kann ich leider noch nicht, genau der Strom-Spannungswandler ist noch unterwegs.

opossum

Hallo,

habe das mal in einer Exceltabelle zusammengerechnet:
Werteliste Zisterne.xlsx
Habe zuerst ausgerechnet, wie viel Prozent der Spannung an A0 anliegen müssen (Spalte D), wenn der Analogwert x eintritt.
100% Spannung sind dann ja 3,3V, 0% sind 0V. Im Feld E2 die maximal Füllmenge. Ausgehend vom Prozentwert des Analogwertes dann auch die Füllmenge(Spalte C) sowie die Ausgangsspannung(Spalte B) ausgerechnet. Mit dieser Tabelle könnte man ausrechnen, wie hoch die Spannung bei einer bestimmten Füllmenge sein muss. Ist die maximal Füllmenge eine andere, das Feld E2 anpassen, alle anderen Werte ändern sich dann automatisch.
Beispiel: Ich habe 3861 Liter in der Zisterne, das entspricht dem Analogwert 706 und damit muss ich den oberen Wert der Ausgangsspannung mit dem rechten Poti auf 2.275V einstellen (dazu muss natürlich die Sonde im Tank sein). Alles unter der Annahme, dass die Spannungswerte linear verlaufen. Ich hoffe, ich habe keinen Denkfehler drin. Vielleicht hilft das ja. Ich kann also mit meinen Bedingungen auf ca. 5l anzeigen bzw. rechnen.

Eisbaeeer

In der Theorie JA, in der Praxis meist NEIN. Ganz so einfach ist es nicht, denn ihr habt einen entscheidenden Faktor vergessen.
Die meisten Pegelsonden erreichen 20mA bei 5 Meter Füllstand. Meine wird diesen Wert nie erreichen, da mein Behälter nur 3,2 Meter hoch ist.
Für mich (und jedem Mitstreiter, bei dem der Behälter ebenfalls 3,2 Meter hoch ist) gilt also, bei 10,24mA habe ich 3,3V am Poti 2 eingestellt, um dem AD-Wandler im Nano den maximalen Range zu geben. Ich hoffe das war verständlich !?
Also am einfachsten ist, wenn man den Abgleich tatsächlich im Behälter durchführt, dann sollte es stimmen.
@Beowolf , für dich heißt das ein wenig Rechenarbeit, wenn du außerhalb des Tanks kalibrieren willst. Du musst dann den maximalen Strom, welche die Pegelsonde liefert, berechnen und aufgrund von diesem dann Kalibrieren.

Ich gehe davon aus, dass die Sonde linear arbeitet.
Formel: (Strombereich : Pegelhöhe laut Datenblatt der Sonde)

16mA : 500cm = 0,032

Formel: (Behälterhöhe * Ergebnis von oben)

320cm * 0,032 = 10,24mA

Damit erreicht die Sonde bei mir maximal einen Strom von 10,24mA
Grüße Eisbaeeer

opossum

Hallo, @Eisbaeeer ,

das war Gedankenübertragung. Habe gerade meine Sonde in der Hand gehabt und nachgelesen. 0-5M, 4-20mA, also bei 5m Füllhöhe kommen erst 20mA. Hatte ich übersehen. Danke. Aber muss man zu den errechneten Werten nicht noch 4 mA addieren wegen des Nullpunkts von 4mA? Bin mir da nicht sicher.

Beowolf

Die 4 mA gehören dazu addiert.

Also:

320cm * 0,032 = 10,24mA + 4mA  =  14,24mA

für die volle Höhe wären das dann ja auch

500cm * 0,032 = 16mA + 4mA  =  20mA

opossum

@Beowolf ,
danke Dir, habe mein Excel mal dahingehend erweitert.

Werteliste Zisterne.xlsx

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. :grinning:

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.:sunglasses:

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?

Community Forum

NEWS

Füllstandsmessung per Pegelsonde.

Support us

757

32.4k

81.5k

1.3m