[Tutorial] analoge Strom- Gas- und Wasserzähler auslesen und Daten auswerten

  • Hallo Zusammen,

    ich habe mir vorgenommen, folgendes Thema mal ausführlich darzustellen:

    Wie lese ich Die analogen(!) Strom-, Wasser- und Gaszähler eines Hausanschlusses mit dem Raspberry-Pi (und nur ganz wenigen Zusatzbauteilen) aus und verarbeite die Daten.


    Es gibt schon ältere Einzelthreads zu diesem Thema, aber hier möchte ich das als Gesamtlösung zusammenfassen:


    Digitale (Strom-) Zähler werden ausdrücklich hier nicht behandelt.


    Es gibt noch alternative Herangehensweisen, die ich auch nicht behandeln will:


    Die Bauteile, die benötigt werden (zusätzlich zu einem Raspberry Pi), sind ggf. in der Bastelkiste vorhanden:

    • 1 Reed-Kontakt (für den Gaszähler),
    • eine möglichst helle grüne LED (für den Ferraris Stromzähler),
    • eine möglichst helle grüne oder gelbe LED (für den analogen Wasserzähler),
    • zwei Phototransistoren (fast egal, welcher Typ) jeweils einen für Strom und Wasser-Zähler,
    • 3x 1kOhm Widerstände (je einen für Strom- Wasser- und Gaszähler),
    • 2x 1kOhm Vorwiderstand (für die LEDs, für Strom und Wasserzähler),
    • 2 Kondensatoren (im nF bis µF Bereich, keine Elkos, 100nF sind 'ne gute Größe) jeweils einen für Strom und Wasser-Zähler,
    • 2 Widerstände im 100 kOhm Bereich. jeweils einen für Strom und Wasser-Zähler (evtl. nicht nötig),
    • Etwas Draht und Klebeband. Ggf. Pappe, um Umgebungslicht abzuschirmen,
    • Steckernetzteil 5V für den Raspberry Pi.

    Nice to have:

    • Ein Gehäuse für den Raspberry Pi

    Der Raspberry Pi kann headless betrieben werden, also werden nicht(!) benötigt:

    * Tastatur, Maus und Monitor


    Wir benötigen außerdem nicht(!):

    * Analog-Digital-Wandler oder dergleichen, Kamera, zusätzlichen Arduino oder dergleichen


    Keine Angst: Es werden dennoch Analogwerte erfasst und die Software schreiben wir uns selbst. Ein einziger Raspberry Pi kann alle drei Zähler geichzeitig auslesen. Es sind keinerlei Eingriffe in die Zähler erforderlich. Die Auslese der Daten erfolgt optisch und magnetisch von außerhalb des Gehäuses.


    Kurz zum Prinzip:

    • Der Gaszähler ist am einfachsten auszulesen. Mit der letzten Ziffer der Anzeige rotiert intern ein Magnet, der einen Reed-Kontakt, der außen angebracht wird, auslösen kann.
    • Der Wasserzähler hat einen rotierenden kleinen Spiegel. Hier kommt eine Reflex-Lichtschranke zum Einsatz.
    • Der Ferraris-Zähler ist am kniffeligsten: Hier rotiert eine rote Markierung auf der rotierenden Scheibe. Diese Markierung wollen wir auch per Reflex-Lichtschranke erkennen.

    Zur Realisierung:


    • Auf dem Raspberry Pi werden wir einen WEB-Server (apache) laufen lassen, der die Anzeige aller Werte und grafische Auswertung übernimmt.
    • Zusätzlich lassen wir einen MQTT-Broker (mosquitto) laufen, der die Echtzeitwerte für allerlei Anwendungen im Netz zur Verfügung stellt.

    Edited 3 times, last by wend ().

  • Gaszähler Hardware

    Fangen wir mit dem Einfachsten an. Ihr benötigt: 1kOhm Widerstand und einen Reed-Kontakt.

    Die Schaltung geht dann wie folgt:

    GPIO -- 1kOhm -- ReedKontakt -- GND

    Welchen GPIO wir verwenden werden, das sehen wir weiter unten. Es muss ja zur Software passen.


    Den Widerstand habe ich in die Zuleitung eingearbeitet und den Reed-Kontakt etwa so an den Gaszähler mit Klebeband befestigt.

    Auf dem Gaszähler sieht man auch, was ein impuls bedeutet: 1 imp =^ 0.01 m³. Bei jeder Umdrehung bekommen wir einen Impuls und das heisst: 10 Liter verbraucht.


    Und falls Ihr Euch fragt, was ist ein Reed-Kontakt? Dann schaut mal hier:

    https://de.wikipedia.org/wiki/Reedschalter

    Die Bauteile gibt es in jedem Elektronik-Fachgeschäft. Kosten etwa 10 Cent.


    Es gab noch die Frage, wozu der Widerstand gut sei: Nun, er verhindert, dass der Strom (bei durchgeschaltetem Reed-Schalter) zu groß wird (naemlich maximal 5 mA), falls der GPIO versehentlich auf Ausgang geschaltet ist. Der Ingangswiderstand der GPIOs ist aber 50 kOhm, wenn der also auf Eingang gestellt ist, dann mach der zusätzliche 1kOhm Widerstand nichts aus. Dasselbe gilt übrigens auch für die Schaltungen der anderen Zähler: Immer einen Sicherheits-Widerstand mit einbauen!


    Vorbereitung:

    Ihr könnt den Reed-Schalter samt Kabel und WIderstand schonmal verlöten und anbringen. Man muss ggf noch ein wenig bei der Einbauposition ausprobieren, aber eigentlich ist es sehr unkritisch. Die Gaszähler haben bereis einen dafür vorgesehenen Ort, wo der interne Magnet den Schalter gut auslöst. Überprüft das am besten mit einem Multimeter, ob es auch schaltet.

    Code
    #define PIN 27 /* GPIO 27 */

    Wenn Ihr es so machen wollt, wie ich, dann verwendet als GPIO den mit der Nummer 27. Aber dazu später.

    Edited once, last by wend ().

  • Reflex-Lichtschranke Hardware

    Für die beiden anderen Zählertypen benötigen wir jeweils eine Reflexlichtschranke. Die Hardware dazu ist jeweils praktisch gleich.

    Hierzu verwenden wir einen GPIO als Ausgang und beschalten damit eine LED, also in etwa:


    GPIO -- LED -- 1kOhm -- GND


    Die LED kann dann von der Software an- und ausgeschaltet werden. Diese LED beleuchtet die umlaufende Markierung beim Stromzähler (Zeiger oder Spiegel bei der Wasseruhr). Es werden dabei immer zwei Messungen gemacht. Eine bei eingeschalteter LED und eine bei ausgeschalteter LED, um das Umgebungslicht herauszurechnen.


    Zur Wahl der LED:


    Das mit der superhellen LED ist ein guter Tipp. Ich wollte eine grüne verwenden wegen der roten Zeiger. Dann ist der Kontrast am besten. Deshalb ist Infrarot auch nicht so gut, außerdem weiß ich nicht wegen der Transmission durch ein Plexiglasgehäuse, ob das Infrarot noch so gut durchkommt.


    Lichtsensor:

    An einem zweiten GPIO wird der Lichtsensor (Phototransistor) angeschlossen. Und zwar mit folgender Schaltung. Diese Schaltung ist das Herzstück des Sensors und ersetzt einen Analog-Digital-Wandler (in diesem Fall).



    Hier die Schaltung:


    Hierzu erstmal: Wir verwenden wieder die GPIO des Raspberrys und GND. Welche, das kommt weiter unten noch. Der Innenwiderstand ist wie schon beschrieben ca. 50 kOhm, und wir verwenden hier auf jeden Fall wieder den Sicherheits-Vorwiderstand 1kOhm.


    Weiterhin muss ein Kondensator dimensioniert werden. Ich habe hier mal einen typischen Wert von 67nF eingezeichnet. Es kann aber sein, dass je nach Fototransistor und LED-Helligkeit ein anderer verwendet werden muss. Das erkennt man daran, dass die Entladezeiten (siehe weiter unten) zu kurz oder zu lang werden.

    Außerdem habe ich noch die Zuleitung eingezeichnet, denn diese hat auch einen (kleinen) Beitrag zur Kapazität. (Der Beitrag zum Widerstand ist vernachlässigbar und eh irrelevant.)

    Damit die Zuleitung nicht stört bzw. dominiert, sollten die Kapazität schon im Bereich Nano-Farad bis Mikrofarad sein. Eventuell muss man beim Phototransistor noch einen zusätzlichen Widerstand von >100 kOhm in die Leitung einschleifen, aber so wie es hier gezeichnet ist, ist es schonmal ein guter Start, und bei mir hat das funktioniert.


    Wie funktioniert das nun:


    Eine Messung besteht aus mehreren Schritten:


    1. Zunächst wird der GPIO als Ausgang geschaltet und auf HIGH gesetzt. Damit wird der Kondensator geladen.
    2. Wir warten etwas (ca 1 Millisekunde), damit der Kondensator auch wirklich voll ist.
    3. Dann wird der GPIO als Eingang geschaltet (das macht die Software). Wir lesen dann erwartungsgemäß HIGH als Zustand, da ja der Kondensator noch von gerade vorhin geladen ist.
    4. Wir lesen nun immer wieder den Eingangszustand, der irgendwann von HIGH auf LOW geht, da sich der Kondensator mit der Zeit entläd. Und zwar einmal über den (50 + 1) kOhm Eingangswiderstand des Raspberry-Pis, aber außerdem über den Phototransistor. Je mehr Licht auf den Phototransistor fällt, desto schneller entläd sich der Kondensator.
    5. Wir messen so die Zeit, die es braucht, bis das Signal von HIGH auf LOW geht. Das können wir mit der Software etwa mit einer Auflösung von 1µs machen. Wir sollten also den Kondensator so dimensionieren, dass der Unterschied zwischen Hell und Dunkel etwa 1000 bis 5000 µs beträgt. Dann bekommen wir die Lichtintensität quasi mit einer Auflösung von 1/1000 bis 1/5000. Das entspricht etwa der Auflösung eines 10 bis 12 Bit ADCs.

    Und das ist völlig ausreichend, um die umlaufende Markierung der Zählerscheiben zu detektieren.


    Die idee ist nun, dass bei einer kontinuierlichen Messung der Helligkeit (sagen wir mal 3 bis 5 mal pro Sekunde), man einen Helligkeitsabfall merkt, wenn die Rote Markierung an der Reflexlichtschranke vorbeikommt, oder der Spiegel der Wasseruhr. Diesen kann man detektieren (siehe die Plots unten). Und dann hat man einen Zählimpuls, der ja einem gewissen Verbrauch entspricht.


    Beim Justieren der Reflexlichtschranke sollte man also darauf achten, dass dieser Helligkeitsunterschied möglichst groß ist, damit das gut detektiert werden kann. Außerdem muss der Sensor vor Umgebungslicht geschützt werden. Also wenn einer die Lampe im Keller an macht, sollte nicht versehentlich ein Puls detektiert werden. Hier haben wir zwar die Möglichkeit, das Untergrundlicht zu subtrahieren (wie messen einmal bei LED an und bei LED aus, und ziehen das Ergebnis voneinander ab), aber das funktioniert nicht so gut, wie ich dachte. Das liegt wohl daran, dass die Helligkeit-Pulslänge-Relation nicht linear ist (und auch nicht einfach 1/tau). Die "Subtraktion" ist also komplizierter. Aber bei guter Umgebungslichtabschirmung geht es auch so.)


    Ich hänge mal zwei Plots an, wo man die Helligkeits-Abfall-Pulse erkennen kann. Beim Wasserzähler (rechts) ist das SIgnal wegen des gut reflektierenden Spiegels am Zeiger sehr klar (tiefe Modulation). Beim Ferraris-Zahler aber nur wenige Prozent (links). Hier muss man die Detektionsschwelle dynamisch anpassen (macht die Software) aber dann geht es trotzdem sehr gut.

  • Montage der Reflex-Lichtschranken

    Ich habe jeweils eine dreiadrige Zuleitung verwendet (rot-gelb-grün auf den Bildern).

    GND, GPIO1 und GPIO2.

    Die 1kOhm Widerstände habe ich jeweils in die Leitungen mit eingearbeitet, GPIO1 versorgt dabei die LED und GPIO2 den Lichtsensor (also Phototransistor und Kondensator parallel). GND wird von beiden benutzt.


    Die Montage der Bauteile ist dennoch knifflig. Wenn man ausschliesslich Pappe und Klebeband verwenden will, dann sollte man die LED so ausrichten, dass der Lichtkegel die Markierung gut trifft. Den Phototransistor steckt man am besten in ein Röhrchen aus schwarzer Pappe (oder schwarzer Schrumpfschlauch tuts auch, also als Kolimator), so dass er nur einen kleinen Aussschnitt vorne sehen kann. In diesen Ausschnitt sollte genau die Stelle sichbar sein, wo die Markierung vorbeikommt. Wenn Ihr einen kleine Spiegel am Zeiger der Wasseruhr verwendet, dann ist auch noch wichtig, dass der Blickwinkel stimmt, damit (Reflexionsgesetzt) maximal viel vom LED-Licht in den Photosensor reflektiert wird. Man kann das alles berechnen, oder auch ausprobieren. Evtl. hilft etwas Knete. Wer einen 3D-Drucker hat, kann auch einen Halter ausdrucken: Z.B. sowas:

    https://www.thingiverse.com/thing:2829444

    oder sowas:

    https://www.thingiverse.com/thing:2827771


    Bei der Wasseruhr sieht es dann etwa so aus:


    Ich weiss, es ist etwas schwer zu erkennen, da ich alles mit schwarzem Isolierband abgeklebt habe. Aber ich denke, man bekommt einen Eindruck. An meiner Uhr ist sogar im Plexiglas extra eine runde Mulde für so einen Aufsatz.


    Beim Stromzähler etwa so:


    So, was fehlt noch? Ich habe folgende GPIOs verwendet:

    Beim Stromzähler:

    Code
    #define PIN 26  /* GPIO 26 */
    #define OPIN 19 /* GPIO 19 */

    Und beim Wasserzähler:

    Code
    #define PIN 12  /* GPIO 12 */
    #define OPIN 16 /* GPIO 16 */

    OPIN ist "OUTPUT" also jeweils die LED.

    Edited 2 times, last by wend ().

  • Software Setup

    Jetzt zur Software. Wir fangen mit einem einfachen raspian an. In meinem Fall ein altes jessie.


    Schliesst den Raspberry irgendwie ans lokale Netzwerk an und sorgt dafür, dass Ihr einen ssh-Zugriff habt. Wie das geht, wurde hier im Forum schon oft besprochen.


    Wir benötigen den WEB-Server apache sowie den MQTT-Broker mosquitto sowie den gcc C-Compiler und spaeter noch gnuplot und screen:

    Code
    sudo apt-get install apache2 mosquitto mosquitto-clients gcc gnuplot screen


    Hier muss ich nochmal alles nachvollziehen, da es schon lange her ist, seit ich den Raspberry Pi eingerichtet habe, also beschwert Euch, wenn was nicht geht oder ich ein Paket vergessen habe.


    Prüft bitte schon mal, ob der apache sich meldet, wenn ihr die URL des Raspberry Pis in einem Browser auf einem anderen Rechner im selben Netz eingebt.


    Wir benötigen noch einige spezial-Pakete. Und zwar einmal die paho-mqtt.c library, das have ich schonmal in einem anderen Tutorial beschrieben, wie man die selbst compiliert. Siehe: [Tutorial] Daten zwischen mehreren Raspis live austauschen und in einem Cockpit anzeigen


    Es gibt aber auch ein fertiges debian-Paket, was man sich runterladen und einfach installieren kann. Dieses findet ihr hier:

    https://codeberg.org/kollo/MQTT-Hyperdash/releases

    Und zwar die Datei: paho.mqtt.c_1.0-1_armhf_nonofficial.deb


    runterladen und installieren:


    Code
    sudo dpkg -i paho.mqtt.c_1.0-1_armhf_nonofficial.deb


    Weiterhin brauchen wir noch die bcm2835-1.50 library. Diese hatte ich schonmal hier verwendet:



    Die verwendetet library gibt es hier:

    http://www.airspayce.com/mikem/bcm2835/


    Und so kann man die installieren:

    Code
    # download the latest version of the library, say bcm2835-1.xx.tar.gz, then:
    tar zxvf bcm2835-1.xx.tar.gz
    cd bcm2835-1.xx
    ./configure
    make
    sudo make check
    sudo make install



    Derweil kümmern wir uns schonmal um die selbstgeschriebene Software:


    Unter /home/pi legt ihr bitte folgende Verzeichnisse an:

    Code
    drwxr-x---  data/
    drwxr-x---  gaszaehler/src/
    drwxr-x---  gnu/
    drwxr-x---  rawdata/
    drwxr-x---  stromzaehler/src/
    drwxr-x---  wasserzaehler/src/


    Es dauert noch ein wenig, bis ich das alles hier schön zusammengestellt habe. In der Zwischenzeit könnt Ihr vielleicht nochmal den folgenden Beitrag von vor drei Jahren lesen, wo alles entstanden ist:


    Edited 4 times, last by wend ().

  • Generelles zu Software

    Die Zähler werden jeweils von einem kleinen und schnellen C-Programm ausgelesen. Welches nichts anderes macht, als dauernd zu schauen, ob entweder der Reed-Schalter geschaltet ist, oder nicht, sowie die Lichtintensität der Refelxlichtschranke auswertet.

    Wenn ein Impuls oder die Messmarkierung detektiert wird, dann wird der exakte Zeitstempel dieses Ereignisses in eine (ASCII) Datei geschrieben und ein Zähler erhöht. Jeden Tag wird eine Neue Datei verwendet. Die landen dann im Verzeichnis /home/pi/rawdata.


    Die Messungen geschehen also unregelmässig. Nach jeder Umdrehung wird eine Messung verzeichnet. Dreht sich das Rädchen langsam, dann entsprechend selten. Dreht es sich schnell, dann häufiger.

    Der Verbauch errechnet sich dann aus der Zeit, die seit dem letzten Umlauf vergangen war. Ein Umlauf entspricht bei der Wasseruhr genu 1 Liter, bei der Gasuhr 10 Liter (oder 0.01 m³) und beim Ferraris-Stromzähler 1/75 kWh. Die 1/75 sind auch auf dem Zähler angegeben. In seltenen Fällen kann es eine andere Kalibrierung sein. Meist aber 1/75. Das heisst also, es braucht 75 Umdrehungen für eine Kilowattstunde.


    Aus den Rohdaten erzeugt ein Sript in regelmäßigen Abständen (also etwa jede halbe Stunde per cron-job) mit gnuplot Grafiken und ein Update der WEB-Seiten. Weterhin werden am Ende des Tages Tages-, Monats- und Jahresstatistiken zusammengestellt. So kann man nicht nur den Instantan-Verbrauch, wie auch Tagessummen, Wochensummen und Monatssummen in Balkenplots anzeigen. Weiterhin lasse ich mir auch alle Werte auf meinen Handy anzeigen, uns zwar dort nicht (nur) mit dem Browser, sondern vor allem mit der App "MQTT-Dash", dies geschieht per MQTT.

    (siehe die angehängten Plots).


    Nochetwas: der Instantan-Verbrauch wird so genau gemessen wie möglich. Das heißt aber auch, daß er nie Null wird. Denn bis zum nächsten Puls vergeht ja immer eine Zeit (und der nächste Puls kommt immer !), und in dieser Zeit ist der Verbrauch dann (im Mittel) klein aber nicht Null.

    Insbesondere beim Waserzähler fällt das auf, denn wenn kein Hahn aufgedreht ist, bleibt die Uhr ja stehen und läuft erst weiter, wenn der Hahn wieder aufgemacht wird. Natuerlich ist in der Zwischenzeit der Verbrauch 0, aber das naechste Meßinterval geht ja bis zur nächsten Umdehung, und da wurde dann genau 1 Liter verbrauch, nur halt über eine Lange Zeit.


    In diesem Bild sieht man einen Screenshot von meinem Android-Smartphone mit der App MQTT-Dash und den instantan-Verbrauchswerten, sowie den (hochgezählten) Zählerständen:

  • Gaszähler Software

    Ok, dann mal los.

    Hier kommt das Makefile in /home/pi/gaszaehler/src. Also legt entsprechende Verzeichnisse an, da kommt dann die Software ein. Wir werden alles selbst kompilieren.

    Code
    all: gaszaehler
    
    file.o : file.c
            gcc -c -O3 $<
    mqtt.o : mqtt.c
            gcc -c -O3 $<
    
    
    gaszaehler : gaszaehler.c timer.c file.o mqtt.o
            gcc gaszaehler.c timer.c file.o mqtt.o -o gaszaehler -lbcm2835 -lpaho-mqtt3c

    Es werden also folgende Quelltext-Dateien benötigt:

    Code
    file.c  file.h mqtt.c   timer.c

    Diese sind für alle drei Zähler gleich, sowie gaszähler.c:


    und

    Edited 3 times, last by wend ().

  • Gemeinsamer Code (für Gas Wasser- und Stromzähler)

    Code: file.h
    void get_countervalue(char *name, int *cnt);
    int appendfile(const char *name, char *adr, size_t len);
    double v_timer();
    char *date_time();





    Hinweis für timer.c:


    Hier noch eine kleine Ergänzung für zukünftige Anwender der Skripte: Die Adresse des Timers muss an den Prozessor angepasst werden. Sonst kommt es zu keiner Erkennung uns auch keiner Ausgabe.


    In der Datei timer.c

    Für RPi 1

    #define ST_BASE (0x20003000)

    Für RPi 2 oder 3

    #define ST_BASE (0x3f003000)


    Für den gerade veröffentlichten RPi 4, hab ich keine Ahnung.

    (danke an tonklon)



    Hinweis: Alle Programmcodes sind unter der GPLv2 lizensiert. Das, falls Ihr das weiterentwickeln wollt. Bitte gerne, lasst mich teilhaben. Ansonsten natuerlich keine Garantie.... usw...

    Edited 4 times, last by wend ().

  • Wasserzähler Software

    Das Ganze geht ganz ähnlich wie die Gaszähler-Software: (im Verzeichnis /home/pi/wasserzaehler/src) Bitte kopiert die gemeinsamen Dateien dort hin. Zusätzlich:


    Code: Makefile
    all: wasserzaehler
    
    file.o : file.c
            gcc -c -O3 $<
    mqtt.o : mqtt.c
            gcc -c -O3 $<
    
    wasserzaehler : wasserzaehler.c timer.c file.o mqtt.o
            gcc wasserzaehler.c timer.c file.o mqtt.o -o wasserzaehler -lbcm2835 -lpaho-mqtt3c

    Edited 2 times, last by wend ().

  • Stromzähler Software


    Das Ganze geht ganz ähnlich wie die Gaszähler-Software: (im Verzeichnis /home/pi/stromzaehler/src) Bitte kopiert die gemeinsamen Dateien dort hin. Zusätzlich:

    Code: Makefile
    all: stromzaehler
    
    file.o : file.c
            gcc -c -O3 $<
    mqtt.o : mqtt.c
            gcc -c -O3 $<
    
    stromzaehler : stromzaehler.c timer.c file.o mqtt.o
            gcc stromzaehler.c timer.c file.o mqtt.o -o stromzaehler -lbcm2835 -lpaho-mqtt3c

    Edited 2 times, last by wend ().

  • Ich gebe zu, das ganze ist schon etwas umfangreich geworden, deshalb machen wir hier mal eine Pause. Die Datennahme kann ja so schon gestartet werden (lasst die Programme gaszaehler wasserzaehler oder gaszaehler einfach mal laufen). Dann könnte Ihr die Datenfiles in /home/pi/rawdata untersuchen. Die Empfindlichkeiten und Anpassungen der Lichtschwellen muss noch gemacht werden, das ist etwas aufwendig. Ich warte erstmal auf etwas Feedback hier, vielleicht möchte das einer ja tatsächlich so nachbauen. Etwas Programmiererfahrung wäre von Vorteil. Es gibt noch tausend Sachen zu erläutern, aber vielleicht findet Ihr vieles auch durch experimentieren raus.


    Was jetzt noch käme wäre die Datenverarbeitung und -aufbereitung zur WEB-Seite. Auf dem MQTT-Broker sollten die Messwerte aber schon live auftauchen, sobald die Messprogramme laufen.


    Hier sind die TOPICs:


    Erklärt sich wahrscheinlich von selbst. Und mit MQTT kann man ja auch Zusätze wie node-red, grafna oder MQTT-Hyperdash verwenden....


    Wenn Ihr soweit seid, sagt mal bescheid, dann können wir weitermachen. Bis dahin, viel Erfolg und Spass!

    Edited once, last by wend ().

  • Hallo wend tolle Arbeit die du hier geleistet hast,es passt quasi wie Faust aufs Auge was ich hier vorhabe. Ich nutze seit geraumer Zeit den Home Assistant, ich habe mir eine Wasseruhr mit Impulsgeber bestellt: Spewa Wasserzähler, diese sollte eigentlich in mein Hunter Hydrawise System eingebunden werden. Leider sind dann die Daten nicht in Home assistant auslesbar (Schnittstelle geschlossen)


    Daher die Frage wie würde ich das einfach mit dem Zähler lösen können? Ich habe einen Raspberry noch rumliegen (ansonsten kommt morgen ein Probe Nodemcu) ich tu mich halt schwer mit den Widerständen etc, brauch ich was genau oder was nicht.... Wäre nett wenn jemand dazu etwas sagen kann. Habt einen schönen Abend

  • Hallo brot123, tja, tut mir leid. Ich kann zu dieser Hardware nix sagen. Ich wollte ja gerade keine teure, komplizierte Zusatzhardware verwenden, sondern möglichst billige, einfach Teile aus der Bastelkiste (plus natürlich einen RaspBerry Pi). Und ich kann sagen, jede Art Zusatz-Hardware oder kompliziertere Schaltungen sind nicht notwendig. Die Limitierungen der Hardware macht die Software wieder wett, und dafür ist es ja ein RaspBerry Pi, mit Betriebsystem und Entwicklungsumgebung. Das kann man ausnutzen. Allerdings ist es keine fertige Lösung, sondern eine Bastellösung, und die Hardware ist der kleinste Teil (Ich würde sagen, in einem Nachmittag fertig gebaut und installiert, auch für Laien). Mit der Software sollte man etwas Spass haben, denn da liegt die eigentliche Innovation. Und da kann man sich auch noch austoben, und hier empfehle ich etwas Vorwissen/Erfahrung mit dem raspBerry Pi. Wir sind hier halt ein RaspBerry Pi Forum, und nicht (so sehr) Arduino, Microcontroller, Elektronik allgemein. Und bei diesem Tutorial soll man was lernen. Über RaspBerry Pi Programmierung, diskrete Elektronische Bauteile, die basics halt: Kondensator, Widerstand, LED und Phototransistor. Die Schaltung kann man bis ins Detail gut verstehen (Lade- und Entladeverhalten eines Kondensators). Vorne analog rein, hinten digital raus, sozusagen.

  • Es würden jetzt noch folgende Kapitel zu diesem Tutorial folgen:

    • Datennahme automatisch starten (nach jedem Reboot des Raspberry Pis)
    • WEB-Seite mit Plots und Datenstatistik dynamisch erzeugen.
    • Visualisierung der Echtzeit-Daten per MQTT-Hyperdash


    Das Visualisieren kann man aber auch anders machen. Es trifft jedoch so genau meinen Geschmack. Konkret heißt das:

    • Wir verwenden keine Datenbanken, sondern einfache ASCII Files, um die Daten zu speichern,
    • Wir verwenden cron zum Triggern der verschiedenen Aufgaben/Skripte. Diese erzeugen nicht nur die WEBSeiten, sondern räumen auch noch das System auf, also archivieren alte Daten, aggregieren die Monatswerte etc... Alle Daten bleiben auf dem RaspBerry Pi.
    • Wir verwenden möglichst wenig Spezialsoftware, dafür möglichst viele Betriebsystemfunktionen, also was bereits mit dem Raspberry Pi mitgeliefert wird.
    • Aus persönlicher Abneigung (Whitespace Formatierungs-Blödsinn) verwende ich kein Python. Dafür X11-BASIC. Ob das wirklich besser ist, darüber kann man streiten, und ich ermuntere jeden, bei seinem Nachbau ruhig auch Python-Skripte zu schreiben, wenn das gefällt.
    • Aus mangelnder Erfahrung verwende ich weder Node-Red noch Grafna für die MQTT Datenvisualisierung. Aber ich finde beide Projekte interessant, und würde mit etwas Hilfe auch damit anbandeln. Bis dahin verwende ich das wesendlich simplere MQTT-Hyperdash.

    Wer jetzt mit mir diesen Weg beschreiten möchte, der kann sich schonmal X11-Basic und MQTT-Hyperdash installieren. Wie das geht, habe ich in den folgenden beiden Tutorials beschrieben:

    Für eilige: Installiert einfach folgende .deb Pakete und fertig:

    1. x11basic_1.27-58-unstable_armhf.deb von https://codeberg.org/kollo/X11Basic/releases
    2. mqtt-hyperdash_1.03-14_armhf.deb von https://codeberg.org/kollo/MQTT-Hyperdash/releases


    Der ganze Rest des Folgenden setzt dann nichts weiter voraus. Vielleicht noch Shell-Skript (sh/bash) und gnuplot. Das ist aber schon installiert, bzw. sollte oben schon per apt-get installiert worden sein. Es lohnt sich unbedingt, sich mit beiden ausführlicher zu beschäftigen, insbesondere mit gnuplot. Es handelt sich um sehr alte, und sehr flexible Software, die schon seit über 30 Jahren eingesetzt wird, und deshalb wahrscheinlich auch in weiteren Jahrzehnten noch benutzt werden kann. Aber wer das nicht möchte, kann auch einfach meine Skripte verwenden und gut ist.

  • H. Wie fangen wir jetzt an? Ich habe mir überlegt, dass das Herz der gazen Sache bei cron liegt. Deshalb hier mal meine crontab:

    Code
    @reboot /home/pi/bas/start_all.bas  2>&1 > /dev/null
    # minute  hour  monthday  month  weekday  command
    15 3 * * * /home/pi/gaszaehler/bas/Gas-Auswertung.bas 2>&1 > /dev/null
    17 3 * * * /home/pi/wasserzaehler/bas/Wasser-Auswertung.bas 2>&1 > /dev/null
    19 3 * * * /home/pi/stromzaehler/bas/Strom-Auswertung.bas 2>&1 > /dev/null
    33 3 * * * /home/pi/gaszaehler/bas/makeplots.bas 2>&1 > /dev/null
    5 7-23 * * * /usr/bin/gnuplot /home/pi/gaszaehler/gnu/gasverbrauch.gnu 2>&1 > /dev/null
    6 7-23 * * * /usr/bin/gnuplot /home/pi/wasserzaehler/gnu/wasserverbrauch.gnu 2>&1 > /dev/null
    */15 7-23 * * * /usr/bin/gnuplot /home/pi/stromzaehler/gnu/stromverbrauch.gnu 2>&1 > /dev/null


    (Zur Erläuterung der crontab und wie man die einrichtet, bitte sucht in diesem Forum. Es ist/war ein häufiges Thema).


    Wie man sieht, werden im wesentlichen .bas und .gnu scripte aufgerufen. Die .bas Dateien dind dabei X11-Basic programme und die .gnu Dateien Steueranweisungen für gnuplot.

    • Das Programm start_all.bas startet dabei die Programme gaszaehler, stromzaehler und wasserzaehler, die wir ganz oben schon kompiliert haben. Details folgen weiter unten.
    • Die Programme *-Auswertung.bas erstellen die Datenstatistiken für die WEB-Seite. Sie machen aus den Rohdaten aufbereitete Daten, die dann auf der WEB-Seite anzezeigt werden. (einmal am Tag, in der Nacht).
    • das Programm makeplots generiert die Plots (grafiken) für die WEB-Seite. (einmal am Tag, in der Nacht)
    • die anweisungen *verbrauch.gnu aktualisieren die Verbrauchs-Plots (mehrmals am Tag, in diesem Fall tagsüber jede Stunde bzw. alle 15 Minuten).

    Jetzt kommen wir zu den einzelnen Komponenten:



    Wie schon gesagt, sorgt das dafür, dass unsere drei Zählerstände auch kontinuierlich ausgelesen werden. Die 3 Programme, die gestartet werden, kennen wir ja schon von weiter oben. Ferner wird noch ein Log-Eintrag in /home/pi/zaehler.log erzeugt, damit man nachvollziehen kann, wann der Raspberry Pi neu gestartet wurde. (das tool screen habt Ihr oben schon mit apt-get install installiert, es ermöglicht es, sich in die Konsolen-Ausgabe der Programme inzuklinken, um zu sehen, was die so machen).


    Als nächstes würden wir uns die .gnu Steuerdatein mal ansehen, die die Plots generieren. Hier muss ich aber vorausschicken, dass die Dateien /home/pi/gaszaehler/gnu/gasverbrauch.gnu /home/pi/wasserzaehler/gnu/wasserverbrauch.gnu /home/pi/stromzaehler/gnu/stromverbrauch.gnu erst erzeugt werden (von einem der .bas Programme). Es gibt aber Vorlagen (zu erkennen an der Endung .proto,) die Ihr hier bitte in die entsprechenden Verzeichnisse /home/pi/gaszaehler/gnu/ bzw. /home/pi/wasserzaehler/gnu/ und /home/pi/stromzaehler/gnu/ kopiert.


    Aus den .proto dateien werden die .gnu dateien spaeter erzeugt, indem bestimmte texte darin durch aktualisierte Texte ersetzt werden, z.B. xx.xx.xxxx durch das aktuelle Datum, usw.


    Lange Rede, hier kommen jetzt die einzelnen Dateien. Seht selbst:






    Die Dateien sind alle recht ähnlich. Muss ich Details erläutern?


    Die anderen benötigten Dateien würde ich hier einfach erstmal so reinkopieren, damit ihr was zum Spielen habt. Ich würde die dann auf Zuruf näher erläutern. Waere das was?

    Edited 3 times, last by wend ().

  • Die *-Auswertung.bas Programme sind recht ähnlich für jeden Zählertyp. Das Programm makeplots.bas macht dabei noch die Hauptarbeit. Es erzeugt die WEB-Seite, also den Rahme in dem dann auch die stündlich aktualisierten Plots erscheinen.


    Eigentlich wäre es das schon: Eine rundum Datenauswertung für die Gas- Strom- und Wasserzähler. Ihr habe nun alle Files, um das zum Laufen zu bekommen. Wenn was nicht geht, bitte melden.


    Noch Fragen?


    (ggf. wäre es günstig, Eure Fragen in separaten Threads zu stellen, dann kann ich diesen hier noch für Ergänzungen nutzen. Fehler würde ich dann direkt in den Betreffenden Abschnitten korrigieren. Ihr könnt Euch ja auf diesen Thread bzw. dieses Tutorial beziehen in der Überschrift Eures Beitrags.).