Amazon Kindle als Statusdisplay – Update

Amazon Kindle als Statusdisplay – Update

Nachdem das Statusdisplay für Wetter- und Temperaturdaten sowie weitere Informationen auf dem Kindle nun ein paar Tage in Betrieb ist und soweit gut funktioniert, habe ich noch ein paar Veränderungen vorgenommen. Grundlage dafür sind die Arbeiten aus dem vorherigen Artikel.

Anpassungen am Kindle als Statusdisplay

WLAN aktivieren/deaktivieren

Um die Laufzeit der Batterie des Kindle zu verlängern, schalte ich das WLAN in dem Script zeige_daten.sh zum holen des Statusbild am Beginn des Scriptes ein und am Ende wieder aus. Nachteil an der Sache ist, das man sich per SSH nicht mehr mit dem Kindle verbinden kann, da das Kindle UI-Framework beim Booten mit dem Aufruf des Scriptes init_daten.sh deaktiviert wird und der Kindle nicht mehr auf irgendwelche Tastendrücke reagiert. D.h der automatische Aufruf dieses Scriptes beim Booten muss wieder deaktiviert werden (Stichwort „Kite -> onboot“). Nach einem Reboot des Kindle (~40 Sek. auf den Knopf an der Unterseite drücken) kann man dann wieder per SSH über WLAN zugreifen. Dann besteht die Verbindung solange der Cron nicht das Script zeige_daten.sh aufruft. Bei längeren Arbeiten muss daher der Cron auskommentiert, oder ifdown wlan0 im Script zeige_daten.sh auskommentiert werden. Das Script init_daten.sh rufe ich dann manuell auf bevor ich die SSH-Sitzung beende.

Hier mein aktuelles zeige_daten.sh Script. Die Änderungen gegenüber der vorherigen Version sind in Zeile 3, 4 und 18 zu finden:

#!/bin/sh

ifup wlan0
sleep 30

cd "$(dirname "$0")"

rm daten_output.png
eips -c
eips -c

if wget http://raspberry/kindle/daten_output.png; then
    eips -g daten_output.png
else
    eips -g daten_error.png
fi

ifdown wlan0

 

Uhrzeit stellen

Da der Kindle bei mir nicht am Internet hängt und auch kein Amazon-Konto konfiguriert ist, wurde die Uhrzeit nicht synchronisiert bzw. lief immer aus dem Ruder. Daher erstmal Uhrzeit kontrollieren und ggf. manuell einstellen:

date
date MMDDHHMMYYYY
date 250317572016

Anschliessend die neue Uhrzeit/Datum in die Hardware-Uhr schreiben:

hwclock -w

Dann noch in folgender Datei anstelle des NTP-Servers von Amazon den von meiner Fritzbox (in der Regel fritz.box) eintragen:

vi /etc/sysconfig/ntp

 

Batterieanzeige des Kindle

Während der Anzeige des Statusbild gibt es keine Möglichkeit mehr den Ladezustand der Batterie des Kindle zu sehen. Mittels SSH kann man den Ladezustand der Batterie (in %) mit dem Befehl:

gasgauge-info -s

abfragen. (Dieser Befehl kann übrigens noch verschiedene anderer Werte der Batterie des Kindle abfragen).

Um diese Information auch im Statusbild verfügbar zu machen, nutze ich das Tool eips welches im Kindle zum Löschen des Bildschirmes, dem Schreiben von Zeichen, dem Scrollen der Anzeige und der Anzeige von PNG-Bildern genutzt werden kann. Also einfach ein kleines Shell-Script mit folgendem Inhalt erstellt und per Cron (vi /etc/crontab/root) alle 5 Minuten ausgeführt.

#!/bin/sh
gasgauge-info -s | xargs /usr/sbin/eips 47 39 > /dev/null;

Der Ladezustand des Kindle-Akkus wird dann in der rechten unteren Ecke angezeigt. Beim aktualisieren des Statusbild wird die Information erstmal wieder überschrieben, dann nach 5 Minuten durch Starten des obigen Scriptes durch den Cron jedoch wieder angezeigt.

Mit eips kann das %-Zeichen der Ausgabe nicht geschrieben werden. Es erscheint eine entsprechende Fehlermeldung. Diese wird nach /dev/null geleitet. 47 und 39 sind die Zeilen- und Spaltennummer zur Ausgabe des Textes.

Im Ergebnis schaut es dann mit 42% Akkustand wie im folgendemn Bild aus. Das mit der 42 war Zufall 🙂

kindle_batteriestand

Anpassungen an der Serverkomponente

Neben den Änderungen am Kindle habe ich auch noch einige Anpassungen des Python-Scriptes bzgl. der Anzeige weiterer Daten vorgenommen. Dazu habe ich auch ein paar zusätzliche SVG erstellt. Im Python-Script werden auf Basis verschiedene IF-Abfragen unterschiedliche SVG-Templates geladen. Das aktualisierte Python-Script ist am Ende des Artikels zu finden.

Batterieanzeige der Fensterkontakte

kindle_batterie Der Batteriezustand der Homematic-Fensterkontakte kann über FHEM abgefragt werden.

Zum Thema Batteriestatus von Homematic-Geräten gibt es übrigens auch einen netten Artikel in meintechblog.de.

Jedenfalls werden im Python-Script die Statis der Batterien aller Homematic-Fensterkontakte abgefragt. Alle Namen der Fensterkontakte die den Status „low“ melden, werden aneinandergereiht in eine Variable geschrieben. Ist diese Variable ungleich „leer“, wird anstelle des Statusbild mit den Temperaturen etc. ein entsprechender Hinweis mit der Liste aller Batterie-schwächelnder Fensterkontakte angezeigt. Und das so lange, bis die Batterien gewechselt wurden. Im linken Bild ist der Hinweis über zwei leere Batterien zu sehen. Für diese Anzeige gibt es ein eigenes SVG.

Temperatur Warmwasserspeicher

kindle_puffertempDie Anzeige des Luftdruckes und der Windgeschwindigkeit ist nett, für mich aber nicht wirklich informativ. Wie schon im vorherigen Artikel angedeutet ist die Temperatur des Warmwasserspeicher wesentlich hilfreicher. Diese Daten lese ich schon seit längerem aus und schreibe sie in eine Snapshot-Tabelle. Übersteigt die untere Temperatur im Pufferspeicher die Marke von 28°C, wird anstelle des Luftdruck/Wind die oberer und untere Temperatur des Warmwasserspeicher angezeigt.
In der Praxis sehe ich so morgens den Luftdruck und nach Anfeuern des Kamins oder Aufheizen der Solarpanel irgendwann die Puffertemperatur. Auch für diese Anzeige gibt es ein eigenes SVG.

 

Status der Heizung

kindle_heizungZum guten Schluss noch eine weiteres SVG welches zur Anzeige kommt, sobald die Viessmann-Gastherme einen anderen Status als „kein Fehler“ meldet. Dies kann neben echten Fehlern in der Anlage z.B. auch eine anstehende Wartung sein. Auch diese Anzeige wird solange angezeigt bis der Status der Heizung wieder OK ist.
Während ich das hier schreibe kommt mir gerade der Gedanke, das die Anzeige der Wartung ggf. relativ lange angezeigt wird da der Heizungsbauer die nächsten 5 Monate keinen Termin frei hat. Hier muss noch ein Reset-Mechanismus her…

Da ich keinen echten Fehler der Heizung als Beispiel für das Bild provozieren konnte, habe ich im Python-Script die Abfragen nach „kein Fehler“ testweise so verändert, das die Gut-Meldung der Heizung angezeigt wird. Diese ist auch im Bild zu sehen.
 

Abgeändertes Python-Script

Hier noch das versprochene Python-Script in der neuen Version. Neben den oben besprochenen Punkten habe ich das Auslesen der Fensterkontakte (für „Offen/Geschlossen“- und den Batteriestatus) noch in eine While-Schleife gepackt die über eine Liste aller Fensterkontakte läuft. Diese Copy&Paste-Faulheit wie beim ersten Anlauf rächt sich irgendwann immer…

#!/usr/bin/python2
# -*- coding: utf-8 -*-

import codecs
import telnetlib
import MySQLdb
from datetime import datetime, time


################
# Hole FHEM data
################
tnet_host= "localhost"
tnet_port= 7072
def fhem_task(fcmd):
    tc= telnetlib.Telnet(tnet_host,tnet_port)
    tc.write(fcmd)
    erg= tc.read_until( "\n" )
    tc.close()
    return erg

# Abwesenheit pruefen
if "off" in fhem_task("list ABWESENHEIT STATE\r\n"):
    abwesenheit="nicht gesetzt"
if "on" in fhem_task("list ABWESENHEIT STATE\r\n"):
    abwesenheit="gesetzt"

# Liste Fensterkontakte
listFensterkontakte = ['FensterHeizung', 'FensterKeller', 'FensterGaestezimmer1', 'FensterGaestezimmer2', 'FensterBuero1', 'FensterBuero2', 'FensterWohnen1', 'FensterWohnen2', 'FensterWohnen3', 'FensterWohnen4', 'FensterGaestebad', 'FensterSpind', 'FensterBad1']

# Fensterkontakte
anz_fenster_offen=0;
for Fensterkontakt in listFensterkontakte:
    if "open" in fhem_task("get "+ Fensterkontakt +" param STATE\r\n"):
        anz_fenster_offen += 1

# Garagenkontakt
if "open" in fhem_task("get Garagentor param STATE\r\n"):
    stat_garage="offen"
else:
    stat_garage="geschlossen"

# Batteriestatus Fensterkontakte
kontakt_batterie_low=""
for Fensterkontakt in listFensterkontakte:
    if "low" in fhem_task("get "+ Fensterkontakt +" param battery\r\n"):
        kontakt_batterie_low += Fensterkontakt + ", "

# Wetter
try:
    condition=str.split(fhem_task("get MeinWetter condition\r\n"))
    if len(condition)==5:
        wetter_icon=condition[3] + " " + condition[4]
    else:
        wetter_icon=condition[3]
except:
    wetter_icon="Fehler"

luftdruck=str.split(fhem_task("get MeinWetter pressure\r\n"))
tendenz=str.split(fhem_task("get MeinWetter pressure_trend_txt\r\n"))
wind=str.split(fhem_task("get MeinWetter wind_speed\r\n"))

######################
# Datenbanken auslesen
######################
db = MySQLdb.connect(host="localhost", user="", passwd="", db="")
cur = db.cursor()
cur.execute("SELECT MIN(aussentemperatur), MAX(aussentemperatur) FROM temperaturen WHERE timestamp >= DATE(NOW()) ORDER BY timestamp")
for row in cur.fetchall():
    mintemp=round(row[0],2)
    maxtemp=round(row[1],2)

cur = db.cursor()
cur.execute("SELECT warmwasser, speicher_unten, error0 FROM snapshot")
for row in cur.fetchall():
    speicher_oben=round(row[0],2)
    speicher_unten=round(row[1],2)
    fehlerspeicher=row[2].replace(" ","\r",2)

db.close()


################
# Preprocess SVG
################
now = datetime.now()
now_time = now.time()
if time(5,50) <= now.time() <= time(22,50):
    # Wenn eine der Batterien der Fensterkontakte leer ist
    if kontakt_batterie_low!="":
        output = codecs.open('batterie_preprocess.svg', 'r', encoding='utf-8').read()
    # Wenn die Heizung einen Fehler anzeigt
    elif 'kein Fehler' not in fehlerspeicher:
        output = codecs.open('fehler_preprocess.svg', 'r', encoding='utf-8').read()
    # ansonsten abhaengig von speicher_unten ein SVG mit Luftdruck und Wind anzeigen. Ansonsten Puffertemperaturen
    elif speicher_unten<=28:
        output = codecs.open('daten_script_preprocess_lfw.svg', 'r', encoding='utf-8').read()
    else:
        output = codecs.open('daten_script_preprocess.svg', 'r', encoding='utf-8').read()
        
    # Platzhalter mit Daten ersetzen
    output = output.replace('ICON_ONE',wetter_icon.decode("utf-8"))
    output = output.replace('WETTER_BESCHR',wetter_icon.decode("utf-8"))
    output = output.replace('TEMP_A',fhem_task("get Aussenthermometer param temperature\r\n"))
    output = output.replace('LUFT_A',fhem_task("get Aussenthermometer param humidity\r\n"))
    output = output.replace('MIN_TEMP',str(mintemp))
    output = output.replace('MAX_TEMP',str(maxtemp))
    output = output.replace('PS_O',str(speicher_oben))
    output = output.replace('PS_U',str(speicher_unten))
    output = output.replace('DRUCK_A',luftdruck[3])
    output = output.replace('TENDENZ',tendenz[3])
    output = output.replace('WIND_A',wind[3])
    output = output.replace('ANZ_FENSTER',str(anz_fenster_offen))
    output = output.replace('STAT_ABWESENHEIT',abwesenheit)
    output = output.replace('STAT_GARAGE',stat_garage)
    output = output.replace('DATUM_UHRZEIT',datetime.strftime(datetime.now(), '%d.%m.%Y %H:%M:%S'))
    output = output.replace('FEHLERSPEICHER',fehlerspeicher)
    output = output.replace('BATTERIE',kontakt_batterie_low.replace(", ","\r"))
    # neues SVG schreiben
    codecs.open('daten_script_output.svg', 'w', encoding='utf-8').write(output)
else:
    # Platzhalter mit Daten ersetzen
    output = codecs.open('sleep_preprocess.svg', 'r', encoding='utf-8').read()
    output = output.replace('DATUM_UHRZEIT',datetime.strftime(datetime.now(), '%d.%m.%Y %H:%M:%S'))
    # neues SVG schreiben
    codecs.open('daten_script_output.svg', 'w', encoding='utf-8').write(output)

Viel Spaß mit den neuen Ideen, SVGs und dem Script. Falls ihr noch weitere Ideen habt den Kindle als Statusdisplay zu nutzen, lasst es mich wissen.

Gruß
Chris

Amazon Kindle als Statusdisplay

startseite_intranet
Webseite – Übersicht

Die Anzeige aller im Haus gesammelter Daten über eine Webseite ist nett (siehe Screenshot), benötigt aber einen Rechner, Handy, Tablet etc. wo diese Seite im Browser anzeigt wird. Unschön dabei ist, das wenn man schnell die Außentemperatur wissen will, immer erst das Gerät anschalten oder aufwecken muss, einen Webbrowser öffnen muss, die Webseite aufruft und wartet bis die Seite geöffnet wird. Das ist für einen kurzen Blick auf die Temperatur eher unpraktisch.

Es musste eine Anzeigemöglichkeit für die wichtigsten Daten her, welche immer angeschaltet ist. Nach kurzer Recherche im Internet stellte sich ein Amazon Kindle als Statusdisplay aufgrund des E-Paper-Displays als stromsparender Anwärter auf diesen Job heraus. Also schnell einen Kindle 4 (kein Touch) im Internet für ~ 30€ besorgt (da ich bisher keinen besaß).

Lösungsansätze

Es gibt verschiedene Ansätze den Kindle als Statusdisplay (z.B. für Wetterinformationen) zu nutzen. Es gibt Lösungen wie hier beschrieben die den Browser des Kindle nutzen. Besser gefielen mir aber die Lösungen die den Bildschirmschoner des Kindle zur Anzeige eines Statusbildes nutzen. Das macht unter anderem die Lösung für FHEM, als auch die Lösung von Matthew Petroff (von dem die FHEM-Lösung wahrscheinlich auch abgeleitet ist). Basierend auf dieser Lösung ist ausserdem diese hier mit weiterführenden Erklärungen der nötigen Schritte.
Ich bevorzuge anstelle der FHEM-Lösung die ursprüngliche Version, da ich nicht nur Daten aus FHEM anzeigen will, sondern auch Daten aus meiner MySQL-Datenbank und zusätzliche Informationen die direkt aus dem Internet stammen.

Den Kindle habe ich übrigens mittels „Kindersicherung“ der FritzBox vom Internet gekappt falls Amazon auf komische Gedanken kommt und mir mit einem gutgemeinten Online-Update irgendwas zerschießt.

Die Lösung, den Bildschirmschoner des Kindle mit einem im Netzwerk bereitgestelltem Bild zu nutzen, benötigt verschiedene Anpassungen des Kindle als auch einige Komponenten die auf einem Server bereit gestellt werden müssen (bei mir der Raspberry PI).

Beschreibung

Die Beschreibung der nötigen Schritte und die benötigte Software sind hier (ursprüngliche Idee), hier (erweiterte Anleitung) und hier (ausführliche Anleitung) erklärt. Aus diesem Grund liste ich die nötigen Arbeitsschritte hier nur Stichpunktartig auf:

Kindle:

    • Jailbreak des Kindle damit man damit auch anständig arbeiten kann
    • SSH für Kindle (USBNetwork Hacks)
    • Kite installieren um nach dem Starten des Kindle das Init-Script (init_daten.sh) ausführen zu lassen
      • Stoppen von powerd
        • das ist nötig, da im Sleep-Mode der Cronjob nicht ausgeführt wird
        • („@reboot“ in crontab funktioniert leider auf dem Kindle nicht)
      • Stoppen von framework
    • Cronjob einrichten um alle x Minuten/Stunden ein aktualisiertes Bild per wget zu laden
      • vi /etc/crontab/root
      • */10 5-22 * * * /mnt/us/anzeige/zeige_daten.sh (alle 10 Minuten zwischen 5 und 22 Uhr

Server:

      • Python-Script anpassen
        • Das Python-Script sammelt die Daten, ersetzt die Platzhalter im SVG und erstellt daraus das PNG mittels rsvg-convert und pngcrush
      • Cronjob zur Ausführung des Python-Script anlegen
        • */3 * * * * /var/www/kindle/daten-script.sh &> /dev/null
      • SVG-Template anpassen (mit Editor und/oder Inkscape)
        • hier mein SVG für die Datenanzeige und
        • hier für zwischen 23 und 5 Uhr
        • bei Änderungen mit Inkscape nicht im „Inkscape-Format“ abspeichern sondern als „Normales SVG“
      • rsvg-convert installieren (sudo apt-get install librsvg2-bin)
      • pngcrush installieren (sudo apt-get install pngcrush)

(Achtung! Die Dateinamen der Scripte in den Cron-Beispielen und die Dateinamen der SVG´s sind anders als in den oben verlinkten Anleitungen)

Python-Script

Das ursprüngliche Python-Script holt das Wetter von einer Webseite aus den USA. Das Wetter dort hat mich nicht wirklich interessiert und so habe ich das Script etwas angepaßt und verschiedene Wetterdaten und Statusinformationen aus meinen eigenen Quellen (FHEM und MySQL) gezogen.
Zur Anzeige der Wettericons nutze ich teilweise die Bilder aus dem ursprünglichen SVG. Einige habe ich allerdings gelöscht da ich hier z.B. keinen Blizzard erwarte. Die Werte für den Luftdruck und die Windstärke sowie die Auswahl des aktuellen Wetter-Icon erfolgt über die „condition“ des FHEM-Yahoo-Wetter-Moduls.

Mein Pythonscript sieht wie folgt aus:

Bitte das Update im nachfolgendem Artikel beachten!!

#!/usr/bin/python2

import codecs
import telnetlib
import MySQLdb
from datetime import datetime, time

################
# Hole FHEM data
################
tnet_host= "localhost"
tnet_port= 7072
def fhem_task(fcmd):
    tc= telnetlib.Telnet(tnet_host,tnet_port)
    tc.write(fcmd)
    erg= tc.read_until( "\n" )
    tc.close()
    return erg

# Abwesenheit
if "off" in fhem_task("list ABWESENHEIT STATE\r\n"):
    abwesenheit="nicht gesetzt"
if "on" in fhem_task("list ABWESENHEIT STATE\r\n"):
    abwesenheit="gesetzt"

# Fenster
anz_fenster_offen=0;
if "open" in fhem_task("get FensterHeizung param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterKeller param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterGaestezimmer1 param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterGaestezimmer2 param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterBuero1 param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterBuero2 param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterWohnen1 param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterWohnen2 param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterWohnen3 param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterWohnen4 param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterGaestebad param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterSpind param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get FensterBad1 param STATE\r\n"):
    anz_fenster_offen += 1
if "open" in fhem_task("get Garagentor param STATE\r\n"):
    stat_garage="offen"
else:
    stat_garage="geschlossen"

# Wetter
try:
    condition=str.split(fhem_task("get MeinWetter condition\r\n"))
    if len(condition)==5:
        wetter_icon=condition[3] + " " + condition[4]
    else:
        wetter_icon=condition[3]
except:
    wetter_icon="Fehler"


luftdruck=str.split(fhem_task("get MeinWetter pressure\r\n"))
tendenz=str.split(fhem_task("get MeinWetter pressure_trend_txt\r\n"))
wind=str.split(fhem_task("get MeinWetter wind_speed\r\n"))

####################
# Datenbank auslesen
####################
db = MySQLdb.connect(host="localhost", user="", passwd="", db="")        		
cur = db.cursor()
cur.execute("SELECT MIN(aussentemperatur), MAX(aussentemperatur) FROM temperaturen WHERE timestamp >= DATE(NOW()) ORDER BY timestamp")
for row in cur.fetchall():
    mintemp=round(row[0],2)
    maxtemp=round(row[1],2)

db.close()


################
# Preprocess SVG
################
now = datetime.now()
now_time = now.time()
if time(5,50) <= now.time() <= time(22,50):  
    # Open SVG to process
    output = codecs.open('daten_script_preprocess.svg', 'r', encoding='utf-8').read()
    # Insert icons and temperatures
    output = output.replace('ICON_ONE',wetter_icon.decode("utf-8"))
    output = output.replace('WETTER_BESCHR',wetter_icon.decode("utf-8"))
    output = output.replace('TEMP_A',fhem_task("get Aussenthermometer param temperature\r\n"))
    output = output.replace('LUFT_A',fhem_task("get Aussenthermometer param humidity\r\n"))
    output = output.replace('MIN_TEMP',str(mintemp))
    output = output.replace('MAX_TEMP',str(maxtemp))
    output = output.replace('DRUCK_A',luftdruck[3])
    output = output.replace('TENDENZ',tendenz[3])
    output = output.replace('WIND_A',wind[3])
    output = output.replace('ANZ_FENSTER',str(anz_fenster_offen))
    output = output.replace('STAT_ABWESENHEIT',abwesenheit)
    output = output.replace('STAT_GARAGE',stat_garage)
    output = output.replace('DATUM_UHRZEIT',datetime.strftime(datetime.now(), '%d.%m.%Y %H:%M:%S'))
    # Write output
    codecs.open('daten_script_output.svg', 'w', encoding='utf-8').write(output)
else:
    # Open SVG to process
    output = codecs.open('sleep_preprocess.svg', 'r', encoding='utf-8').read()
    output = output.replace('DATUM_UHRZEIT',datetime.strftime(datetime.now(), '%d.%m.%Y %H:%M:%S'))
    # Write output
    codecs.open('daten_script_output.svg', 'w', encoding='utf-8').write(output)

Es werden verschiedene Information aus FHEM mittels Telnet abgefragt und Daten aus einer MySQL-Datenbank (min/max-Werte) ermittelt. Neben Temperaturwerten zeige ich z.B. auch noch den Status der Fenster, des Garagentores und der Abwesenheitssteuerung an. Zwischen 5:50 und 22:50 Uhr wird alle 10 Minuten ein aktualisiertes Bild der Statusinformationen angezeigt, in der anderen Zeit ein Bild eines schlafenden Männchens. In dieser Zeit fragt der Kindle auch kein neues Bild per wget ab.

Ergebnis

Im Ergebnis schaut es dann so aus:

kindle_statusdisplay

Und hier die Anzeige für Nachts:

kindle_statusdisplay2

Als Erweiterung werde ich evtl. noch während der Heizperiode mit dem Kachelofen oder abhängig der Puffertemperatur, die obere und untere Temperatur des Pufferspeichers anstelle des Luftdruckes und der Windinformation anzeigen. Die Puffertemperatur ist in der Regel unser Maßstab ob Holz nachgelegt werden muss oder nicht.

Es könnte z.B. auch eine Display füllende Information ausgegeben werden wenn eine der Batterien der Fensterkontakte leer ist oder ein Warnhinweis falls die Heizung eine Störung oder anstehende Wartung anzeigt. Im Python-Script würde ich dann analog dem "Schlaf-Bild" ein spezielles PNG aus einem weiteren SVG erzeugen.
 

Chris

Gaszähler auslesen – Darstellung der Daten

Gaszähler auslesen – Darstellung der Daten

Jedes Jahr im Januar ist es wieder soweit – die Daten des Gaszähler müssen an den Lieferanten übermittelt werden. Dabei ist mir aufgefallen, das meine Darstellung der Daten aus der MySQL-Datenbank noch verbesserungswürdig sind. So hatte ich z.B. nur den Verbrauch der letzten 7 Tage wie im Artikel http://blog.bubux.de/gaszaehler-auslesen/ beschrieben ausgewertet. Da fehlt doch noch eine monatliche und jährliche Übersicht!

Nochmal zur Erinnerung: Ich speichere jede gezählte Umdrehung des Gaszählers als separate Zeile in einer MySQL-Datenbank.

Gaszaehler mySQL Datenbank

Daher müssen die einzelnen Zeilen nach den jeweiligen Kriterien gruppiert und dann das Ergebnis der Spalte „zaehlerstand“ summiert werden. Beim Stromzähler wird hingegen immer der aktuelle Gesamtverbrauch in die Datenbank geschrieben und aus den Datenbankeinträgen für die Tages-, Monats- und Jahresverbräuche die Differenz gebildet um entsprechende Auswertungen zu erzeugen.

Auswertung der letzten 12 Monate

Folgendes SQL-Statement ermittelt aus den einzelnen Datenbankeinträgen die Summe gruppiert nach Jahr und Monat. Dabei werden die letzten 12 Monate mittels „INTERVAL“ betrachtet.

SELECT
     CASE DATE_FORMAT(timestamp,'%m')
          WHEN 1 THEN 'Jan'
          WHEN 2 THEN 'Feb'
          WHEN 3 THEN 'Mär'
          WHEN 4 THEN 'Apr'
          WHEN 5 THEN 'Mai'
          WHEN 6 THEN 'Jun'
          WHEN 7 THEN 'Jul'
          WHEN 8 THEN 'Aug'
          WHEN 9 THEN 'Sep'
          WHEN 10 THEN 'Okt'
          WHEN 11 THEN 'Nov'
          WHEN 12 THEN 'Dez'
     ELSE 'fehler' END as Monat,
     year(timestamp), sum(zaehlerstand)
FROM gaszaehler WHERE year(timestamp) >= YEAR(CURRENT_DATE - INTERVAL 12 MONTH) AND  month(timestamp) >= month(CURRENT_DATE - INTERVAL 12 MONTH)
GROUP BY month(timestamp), year(timestamp) ORDER BY timestamp;

Auswertung der Jahresverbräuche

Fehlt noch der jährliche Verbrauch. Das SQL-Statement ist einfacher aufgebaut als vorheriges und summiert den Verbrauch pro Jahr für alle in der Datenbank enthaltenen Daten an.

SELECT 
     year(timestamp), sum(zaehlerstand) 
FROM gaszaehler
GROUP BY year(timestamp) ORDER BY timestamp;

Im Ergebnis sieht das Ganze dann wie folgt aus. Die Grafik zur Anzeige der Daten der letzten 12 Monate erstelle ich wie in diesem Artikel beschrieben

Gaszaehler Uebersicht

Viel Spaß bei der Kontrolle des Gasverbrauchs 🙂

Gruß

Chris

Arduino als AVR ISP zum Brennen des Bootloader

Arduino als AVR ISP zum Brennen des Bootloader

Erstmal noch ein frohes neues Jahr 2016! Es ist lange nichts mehr passiert hier in diesem Blog. Gründe, oder besser Ausreden dafür fallen mir genug ein. Ein Grund ist der Selbstbau einer Garage im letzten Sommer bzw. Herbst. Das hat mich einiges an Zeit und Nerven gekostet. Jetzt steht aber alles und das Auto im trockenen und somit ist wieder Zeit für andere Dinge. Daher heute etwas zum Thema Arduino und des darin benötigte Bootloader und wie man einen Arduino als AVR ISP zum Brennen des Bootloader nutzt. (ISP: In-System-Programmer).

An einem der letzten Wochenenden habe ich mit zwei Bekannten ein Wortuhr-Bau-Wochenende gemacht. Dabei sind an zwei Tagen 3 Wortuhren entstanden. Nach dem Bestücken der Platinen, dem Erstellen der LED-Matrix und der Verkabelung sollte der Sketch auf den Mikrocontroller geladen werden.

Bei dem Versuch wehrte sich die Arduino IDE allerdings den Sketch auf den Mikrocontroller zu spielen. Grund dafür war ein fehlender Bootloader. Da hatte ich bei der Bestellung der Platinen und der Bauteile wohl das entsprechende Häkchen für einen bereits vorprogrammierten Atmel vergessen.

Warum ein Bootloader?

Der Bootloader auf dem Atmel AVR wird benötigt um den Arduino mittels serieller Schnittstelle einfach mit Programmen (Sketch) z.B. mit der Arduino IDE programmieren zu können. Hierbei übernimmt der Bootloader zwei Dinge:

  1. Der Bootloader versucht beim Start festzustellen, ob ein neuer Sketch vom PC auf den Mikrocontroller geladen werden soll. Ist das der Fall, wird das Programm vom PC auf den Mikrocontroller geladen. Daher wird der Mikrocontroller beim Versuch neuen Code hoch zu laden, vorher immer durch die Arduino IDE resetet.
  2. Wenn nicht mittels PC versucht wird ein Sketch auf den Mikrocontroller zu laden, wird der der bereits installierte Code ausgeführt.

Eine Möglichkeit um den Bootloader auf den Atmel zu laden, ist einen anderen Arduino als Programmer zu nutzen. Da ich noch einen Arduino Nano hier rumliegen hatte, musste der dafür herhalten.

Einen Arduino Nano als AVR ISP (In-System Programmer)

Folgende Schritte sind zu befolgen um den Bootloader auf einen Atmel AVR zu spielen:

1. ArduinoISP-Sketch auf Arduino laden

In der Arduino IDE das Beispiel „ArduinoISP“ öffnen. Eine aktuelle Version ist auch auf GitHub zu finden.

isp1

Den Arduino Nano mittels USB an den Rechner anschliessen und ggf. unter „Werkzeuge->Port“ den entsprechenden Port einstellen. Den geladenen Sketch anschließend mit der „Pfeiltaste“ auf den Arduino Nano laden.

Mehr lesen

Wortuhr Bildschirmschoner – Update 2

Heute nochmal ein kleines Update für den Wortuhr Bildschirmschoner. Bei Geräten mit höheren Auflösungen gab es Probleme mit der Anzeigen der Umlaute. Die Buchstabenmatrix ist aufgrund der hohen Auflösung etwas zusammengeschoben worden, weshalb nicht alles korrekt dargestellt wurde. In den Bildschirmschoner-Einstellungen kann man nun die Schriftgröße und zusätzlich noch die Schriftart anpassen (dazu auf den Text hinter Schriftart klicken).

bildschirmschoner_einstellungen_neu

Download Wortuhr ScreenSaver (v1.1)

Gruß
Chris

Snippet – Daten vom internen Netz zum Strato Webspace

Nach langer Zeit Stillstand im Blog nochmal ein kleines Snippet. Problemstellung war, Daten vom Raspberry aus meinem lokalen Netz auf den Webspace von Strato zu bekommen. Ich wollte die aktuelle Temperatur und Luftfeuchte die meine Homematic-Sensoren regelmäßig in der lokalen Datenbank auf dem Raspberry speichern auch hier im Blog anzeigen.

Nichts leichter als das dachte ich, und richtete eine Datenbankverbindung zur MySQL-Datenbank auf dem Strato-Webspace auf dem Raspberry ein. Leider unterbindet Strato den Zugriff auf die Datenbanken wenn dieser nicht vom Strato-Webspace geschieht. Das ist unschön da ich mir was anderes einfallen lassen musste, aber bzgl. der Sicherheit geht das in Ordnung.

Der nun vorgestellte zweite Ansatz ist eine zweigeteilte Lösung mit einer Komponente auf dem Strato-Webserver (PHP-Script) und einem Aufruf dieses Scriptes auf dem Raspberry mittels Shell-Script etc. oder wie in meinem Beispiel mittels PHP-Script welches regelmäßig per Cron aufgerufen wird. Das ist die simpelste Art eines „Webservices“ ohne REST und SOAP und für meine Zwecke völlig ausreichend.

Serverkomponente

Der PHP-Teil auf dem Webspace sieht folgendermaßen aus: Nach der Prüfung eines übergebenen Hashwertes werden die beiden ebenfalls in der URL übergebenen Messwerte (Außentemperatur und Luftfeuchte) auf Vorhandensein geprüft. Hier können und sollten natürlich noch weitere Prüfungen vorgenommen werden ob diese Werte z.B. numerisch sind etc. Da dieses Script auf dem Webspace liegt und durch jeden aufgerufen werden kann, dient der Hashwert als Passwort für den Aufruf.

Ist mit den übergebenen Argumenten alles in Ordnung, werden die Messwerte mittels Prepared-Statement in die auf dem Strato-Webserver angelegte Datenbank-Tabelle „temperaturfuehler“ gespeichert.

Da ich die Messwerte in einer lokalen Datenbank schon historisiere, wird in der Tabelle im Webspace nur eine Zeile mittels „UPDATE“ aktualisiert. Hier muss darauf geachtet werden, dass mindestens einmal vor dem ersten Update ein „INSERT“ in dieser Tabelle vorgenommen werden muss. Das hatte ich über die MySQL-Admin-Oberfläche von Strato gemacht.

prepare("UPDATE temperaturfuehler SET temperatur=?,luftfeuchte=?");
			$stmt->bind_param("dd",number_format($_GET["temperatur"],1),number_format($_GET["luftfeuchte"],1));
			$stmt->execute();
			$stmt->close();
		} catch (Exception $e) {
			echo 'Fehler: ', $e->getMessage(), "\n";
		}
	}
	
} else {
	//echo "Fehler: Hashwert falsch\n";
}
?>

Hier die im obigen Script eingebundene Datei mit den Einstellungen:

");
define('DB_PASSWORD', "");
define('DB_DATABASE', "");
define('DB_SERVER', "");
define('HASHWERT', "");
?>

Lokale Komponente

Jetzt zu dem Teil der auf dem Raspberry lokal läuft. Hier wird obiges Script einfach z.B. per GET aus einem weiteren PHP- oder Shell-Script etc. mit den entsprechenden Argumenten aufgerufen. Wichtig ist, dass die Namen der übergebenen Argumente mit denen aus dem insert.php Script übereinstimmen.

exec("GET \"http://www.deine_url.de/beliebiger_pfad/insert.php?temperatur=$temp&luftfeuchte=$luft&hashwert=der_hashwert_der_beim_get_uebergeben_werden_muss\"");

Obiges Script und der Aufruf können natürlich um beliebig viele Übergabeparameter erweitert werden. Die so an die Strato-Datenbank übergebenen Werte können dann z.B. im WordPress mittels PHP-Plugin aus der Datenbank abgefragt und angezeigt werden. Hier im Blog ist das oben rechts zu sehen.

temperatur

Gruß
Chris

M-BUS – Wasserzähler

Von einem Freund habe ich einen M-Bus (Meter-Bus) Wasserzähler und einen Wärmemengenzähler bekommen. Der M-BUS ist ein Feldbus der über eine Zweidrahtleitung über sehr lange Strecken genutzt werden kann. Ein M-BUS Master fragt dabei alle Slaves im Strang oder Stern ab. Die Slaves werden teilweise vom M-Bus-Master mit Spannung versorgt. Mehr Details im Wiki.

Techem Wärmemengenzähler Techem Wasserzähler

Der M-Bus-Master sollte in meinem Fall aus dem Raspberry und einem Pegelwandler bestehen. Pegelwandler gibt es fertig von verschiedenen Herstellen (Relay, Wachendorff). Diese sind aber, je nachdem für wieviele Slaves sie ausgelegt sind, relativ teuer.

Mein erster Ansatz war daher der Selbstbau eines Pegelwandlers inkl. RS232-Schnittstelle zum Anschluss an den Raspberry Pi. Im Netz gibt es verschiedene Beschreibungen einer einfachen Schaltung und einige wenige Forumseinträge die sich mit dem Selbstbau eines Pegelwandlers bzw. generell mit M-Bus beschäftigen. Leider habe ich in keinem Forum eine Diskussion gefunden die bis zu einem funktionierenden System verfolgt wurde. Egal, ich habe es trotzdem mal versucht…

 

Selbstbau Pegelwandler

Auf der Platine ist der Pegelwandler inkl. einer RSA232 Schnittstelle die aus einem MAX3232 besteht. Die +/-15 Volt für den Pegelwandler habe ich mittels DCDC-Wandler IH0515S der Fa. XP Power erzeugt. Dieses Bauteil kann man z.B. bei Farnell beziehen. Dann das Ganze auf Lochraster zusammen gelötet und mit dem Raspi und dem Wärmemengenzähler verbunden.

IMG_7707 IMG_7708

max3232Lochrasterplan

Damit der Raspberry das M-Bus Protokoll versteht bzw. auch den Pegelwandler korrekt anspricht, habe ich die Bibliotheken von rSCADA genutzt. Die Quellen liessen sich problemlos auf dem Raspberry kompilieren. Im Ergebnis wurden verschiedene Binaries erzeugt um mit Slaves im Bus zu kommunizieren.

Meine ersten Versuche waren jedoch nicht von Erfolg gekrönt. Es wurde kein M-Bus-Gerät gefunden. Bei der Fehlersuche habe ich zuerst die serielle Schnittstelle separat getestet und mit Minicom über den Raspberry mit einem anderen Linux-Rechner kommuniziert. Das hat funktioniert. Die weitere Fehlersuche z.B. am M-Bus-Ausgang sind allerdings am fehlenden Oszilloskop gescheitert, da das Multimeter mich nicht wirklich weiter brachte.

Etwas niedergeschlagen habe ich dann nach drei Tagen erfolgloser Fehlersuche nochmal nach fertigen Pegelwandlern gesucht und ein relativ preiswertes Gerät gefunden und kurzerhand gekauft. Damit fiel die Fehlerquelle „Pegelwandler“ schon mal weg.

 

Versuch mit gekauftem Pegelwandler

Der neue Pegelwandler benötigt zum Anschluss an den Raspberry Pi auch eine RS232 Schnittstelle. Um mir diesmal das Löten zu ersparen, hab ich erstmal den kompletten Versuchsaufbau auf einem Breadboard gesteckt. Der Pegelwandler läuft mit einer Spannung von 12-24 V DC weshalb ich den DCDC-Wandler aus dem ersten Versich auch nicht benötige.

IMG_7739

Die Binaries von rSCADA unterscheiden zwischen TCP- und seriell angeschlossenen M-Bus-Pegelwandlern. Da meiner seriell angeschlossen ist, benutze ich „mbus-serial-scan“ um nach angeschlossenen Slaves im Bus zu suchen.
Als Argumente übergebe ich „-d“ für den Debugmodus, „-b 2400“ um 2400 Baud zu nutzen und „/dev/ttyAMA0“ als serielle Schnittstelle des Pi.

Zu meiner Überraschung wurde direkt ein Slave (der Wasserzähler) erkannt. Sehr schön…

pi@raspberry2 ~/libmbus-0.8.0/bin $ ./mbus-serial-scan -d -b 2400 /dev/ttyAMA0
Scanning primary addresses:
0 [2014-12-13 13:59:21] SEND (005): 10 40 00 40 16
[2014-12-13 13:59:21] RECV (001): E5

Found a M-Bus device at address 0
1 [2014-12-13 13:59:22] SEND (005): 10 40 01 41 16
2 [2014-12-13 13:59:22] SEND (005): 10 40 02 42 16
3 [2014-12-13 13:59:22] SEND (005): 10 40 03 43 16
4 [2014-12-13 13:59:22] SEND (005): 10 40 04 44 16
5 [2014-12-13 13:59:23] SEND (005): 10 40 05 45 16
6 [2014-12-13 13:59:23] SEND (005): 10 40 06 46 16
7 [2014-12-13 13:59:23] SEND (005): 10 40 07 47 16
...

Hat man alle angeschlossenen M-Bus-Geräte per Scan identifiziert, können mit einem weiteren Programm die Daten des Gerätes ausgelesen werden. Auch hier gibt es wieder das Argument „-d“ für den Debugmodus, „-b“ zur Einstellung der Baudrate, das Device der seriellen Schnittstelle und die vom Scan ermittelte Device-Nummer. Im Fall meines Wasserzählers ist das die „0“. Die Daten der Slaves werden in einer einfachen XML-Struktur zurück geliefert.

./mbus-serial-request-data -d -b 2400 /dev/ttyAMA0 0
[2014-12-13 14:06:46] SEND (005): 10 5B 00 5B 16
[2014-12-13 14:06:47] RECV (084): 68 4E 4E 68 08 00 72 12 37 16 46 68 50 49 07 B6 00 00 00 0C 14 53 42 00 00 8C 10 12 35 53 42 00 0B 3B 00 00 00 8C 20 14 53 42 00 00 8C 30 14 00 00 00 00 04 6D 21 0F CD 1C 4C 14 02 00 00 00 42 6C BF 1C 42 EC 7E DF 1C 0A 92 2A 00 10 0A 92 2B 00 10 3E 16
mbus_frame_print: Dumping M-Bus frame [type 4, 84 bytes]: 68 4E 4E 68 08 00 72 12 37 16 46 68 50 49 07 B6 00 00 00 0C 14 53 42 00 00 8C 10 12 35 53 42 00 0B 3B 00 00 00 8C 20 14 53 42 00 00 8C 30 14 00 00 00 00 04 6D 21 0F CD 1C 4C 14 02 00 00 00 42 6C BF 1C 42 EC 7E DF 1C 0A 92 2A 00 10 0A 92 2B 00 10 3E 16



46163712
TCH
73

Water
182
00
0000



Instantaneous value
Volume (1e-2  m^3)
4253
2014-12-13T14:06:47



Instantaneous value
Volume (1e-4  m^3)
425335
2014-12-13T14:06:47

...

Da es auf Anhieb funktioniert hat, habe ich die serielle Schnittstelle auf Lochraster gebannt und der Pegelwandler wird mittels kleinem 12V-Netzteil betrieben. Dann Raspberry Pi, Pegelwandler und Platine im Netzwerkschrank verstauen…

MAX3232

 

Software

Den Stand des Wasserzählers protokolliere ich nun einmal täglich um 23:59 Uhr. Das wird per Cronjob und einem kleinen PHP-Script erledigt. Warum PHP? Weil ich zu ungeduldig war und das schnell umsetzen wollte und schon das ein oder andere ähnliche PHP-Script fertig hatte.

Das Script ruft das Binary wie oben erklärt per shell_exec auf. Ab dem XML-Teil parse ich die Ausgabe und extrahiere die relevanten Informationen die dann in eine MySQL-Tabelle geschrieben werden.

[cc lang=“php“]
‚));
$xmloutput = new SimpleXMLElement($xmloutput);
$zaehlerID=$xmloutput->SlaveInformation->Id;
$zaehlerStand=$xmloutput->DataRecord[1]->Value/10000;

$mysqlhost=““;
$mysqluser=““;
$mysqlpwd=““;
$connection=mysql_connect($mysqlhost,$mysqluser,$mysqlpwd) or die („Verbindungsversuch fehlgeschlagen“);
$mysqldb=““;
mysql_select_db($mysqldb,$connection) or die(„Konnte die Datenbank nicht waehlen.“);
$sql = „INSERT INTO wasserzaehler (timestamp,zaehlerid,zaehlerstand) VALUES (CURRENT_TIMESTAMP,$zaehlerID,$zaehlerStand)“;
$query = mysql_query($sql) or die(„Anfrage 1 nicht erfolgreich“);
?>;
[/cc]

Da ich auf meiner Webseite aber nicht nur den absoluten Wasserverbrauch darstellen möchte sondern auch den Tagesverbrauch, kommt folgendes SQL zum Einsatz. Hier werden die Einträge aus zwei aufeinanderfolgenden Zeilen subtrahiert um die Differenz zum Vortag zu bestimmen.

SELECT 
    CASE DATE_FORMAT(wz1.timestamp,'%w')
	WHEN 0 THEN 'Sonntag'
	WHEN 1 THEN 'Montag'
	WHEN 2 THEN 'Dienstag'
	WHEN 3 THEN 'Mittwoch'
	WHEN 4 THEN 'Donnerstag'
	WHEN 5 THEN 'Freitag'
	WHEN 6 THEN 'Samstag'
    ELSE 'fehler' END,
	wz1.zaehlerstand - IFNULL(wz2.zaehlerstand, 0) AS verbrauch
    FROM wasserzaehler wz1
    LEFT JOIN wasserzaehler wz2
    ON wz2.timestamp = (
	SELECT MAX(timestamp)
	FROM wasserzaehler wz3
	WHERE wz3.timestamp < wz1.timestamp
   )
ORDER BY wz1.timestamp

Das Ergbnis sieht dann wie folgt aus. Ich war etwas erschreckt wieviel Wasser man an machen Tagen verbraucht!

wasserzaehler_screenshot

 

Selbstgebauter Pegelwandler

Da ich ja nun weiß das es generell funktioniert und der Fehler meiner ersten Lösung definitiv im selbstgebauten Pegelwandler liegt, werde ich den Versuch mit dem Selbstbau demnächst nochmal angehen.

 

Sobald der Wärmemengenzähler in den Wasserlauf des Kachelofens eingebaut ist, werde ich nochmal einen kurzen Beitrag schreiben. Das Prinzip des Auslesens ist ja analog zum Wasserzähler aber vielleicht gibt es in den zurückgelieferten Daten unterschiede.

 

Viel Spaß mit dem M-Bus!

Chris

Gaszähler auslesen

Nachdem meine Versuche den M-BUS Wärmemengen- und Wasserzähler auszulesen vorerst beendet sind und ich auf den bestellten M-BUS-Pegelwandler warte, habe ich mich dem Auslesen des Gaszählers gewidmet. Das sollte erfolgsversprechender sein…

Als ich dann endlich den vor langer Zeit bestellten Reed-Kontakt mk 471 b (z.B. bei Reichelt) wieder gefunden habe, konnte es losgehen.

Der Gaszähler hat an der letzten Stelle des Zählwerkes bei der „0“ einen Magneten wodurch der Reedkontakt bei jeder vollen Umdrehung einmal geschlossen wird. Diese Impulse gilt es mit einem Raspberry über einen GPIO zu zählen.

IMG_7735

Den Reedkontakt habe ich natürlich wieder professionell mit Klebeband fixiert…hält!

IMG_7734

Angeschlossen ist der Reedkontakt über eine Zwillingslitze direkt an einen GPIO und Ground des Raspberry PI. Pull-Up braucht es keinen. Dieser wird per Software aktiviert.

Den GPIO lese ich mit einem Python-Script aus welches in einer Endlosschleife ausgeführt wird und den GPIO (im Beispiel Pin „21“) jede Sekunde abfragt. Sekundenweise sollte reichen, da ich nicht hoffe das unser Gaszähler so schnell läuft. Immer wenn der Reed geschlossen wird, wird eine „1“ und der Zeitstempel in die Spalten „timestamp“ und „zaehlerstand“ einer MySQL-Tabelle geschrieben. Das passiert immer nur beim Wechsel des Reed von „Offen“ nach „Geschlossen“. Sollte der Zähler genau mit dem Magnet am Reed stehen bleiben, passiert nichts.

[cc lang=“python“]

import RPi.GPIO as GPIO
import time
import MySQLdb

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)

# GPIO definieren
REED_gas = 21
# definierten GPIO als Eingang setzen
GPIO.setup(REED_gas, GPIO.IN, pull_up_down=GPIO.PUD_UP)

status_alt=1
while True:
status_aktuell = GPIO.input(REED_gas)
# REEDKONTAKT geoeffnet
if status_aktuell == 1:
#print „Kontakt offen“
status_alt=GPIO.input(REED_gas)
# REEDKONTAKT geschlossen
elif status_aktuell==0:
#print „Kontakt geschlossen“
if status_alt!=status_aktuell:
status_alt=GPIO.input(REED_gas)
# Datenbankverbindung
db = MySQLdb.connect(host=“„, user=“„, passwd=“„, db=“„)
# Impuls in Datenbank eintragen
cursor = db.cursor()
cursor.execute(„““INSERT INTO gaszaehler (timestamp,zaehlerstand) VALUES (CURRENT_TIMESTAMP,1)“““)
db.commit()
cursor.close()
time.sleep(1)
[/cc]

IMG_7737

Da das Python-Script sich ab und an mal verabschiedet, starte ich es per Cronjob wieder neu falls der Prozess nicht mehr vorhanden ist. Ich sollte vielleicht lieber das Problem im Python-Script suchen und das ein oder andere Try&Catch einbauen, aber es geht auch erstmal so…

#!/bin/sh
if ps -ef | grep -v grep | grep gaszaehler.py ; then
    exit 0
else
    sudo python /usr/local/bin/gaszaehler.py &
    logger "gaszaehler.py neu gestartet"
    exit 0
fi

Zur Auswertung benutze ich dann folgende SQL-Querys:

SELECT sum(zaehlerstand) FROM gaszaehler

Hiermit werden alle gespeicherten „Ticks“ summiert. Dazu muss noch ein Startwert addiert werden da der Gaszähler ja schon eine zeitlang lief.
Dieser Startwert muss ggf. ab und an mal korrigiert werden falls der Raspi mal einen Umlauf des Zählers nicht mitbekommt weil z.B. der unwahrscheinliche Fall eintritt, dass das Klebeband nicht gehalten hat oder wahrscheinlicher, das Python-Script bzw. der ganze Raspi nicht mehr läuft. Den Startwert gebe ich als eine Zahl inkl. der drei Nachkommastellen an und addiere das Ergebnis der SQL-Query dazu. Um die richtige „Einheit“ kümmere ich mich in der Ausgabe auf der PHP-Seite mit folgender PHP-Zeile:

[cc lang=“php“]
$sql = „SELECT sum(zaehlerstand) FROM gaszaehler“;
$query = mysql_query($sql) or die(„Anfrage nicht erfolgreich“);
while ($wert = mysql_fetch_array($query)) {
$gesamtwert=($wert[0]*10)+$gas_startwert;
}
$gesamtwert=substr($gesamtwert,0,-3).“.“.substr($gesamtwert,-3,2);
[/cc]

Der Faktor 10 muss hier beachtet werden, da ja nur alle 0,01m³ Impulse gezählt werden und ich den Startwert mit allen drei Nachkommastellen angegeben habe. Die zweite Zeile setzt das Komma in der Ausgabe an die richtige Stelle.

Eine tägliche Auswertung funktioniert z.B. mit folgender SQL-Query:

SELECT CASE DATE_FORMAT(timestamp,'%w')
          WHEN 0 THEN 'Sonntag'
          WHEN 1 THEN 'Montag'
          WHEN 2 THEN 'Dienstag'
          WHEN 3 THEN 'Mittwoch'
          WHEN 4 THEN 'Donnerstag'
          WHEN 5 THEN 'Freitag'
          WHEN 6 THEN 'Samstag'
          ELSE 'fehler' END,
          sum(zaehlerstand)
FROM gaszaehler
WHERE DATE(timestamp)>=DATE_SUB(NOW(),INTERVAL 7 DAY)
GROUP BY day(timestamp)
ORDER BY timestamp

Auch hier bekommt man den korrekten Wert in m³ durch einfache Kommaverschieberei in der Ausgabe. Den Faktor 10 benötigt man bei der täglichen Auswertung nicht:

[cc lang=“php“]substr(($wert[1]),0,-2).“.“.substr(($wert[1]),-2)[/cc]

In der Webseite sieht das folgendermaßen aus:

gaszaehler_screenshot

Das alles läuft erst drei Tage und es gibt bestimmt noch Verbesserungspotential aber ein Anfang ist gemacht.

Gruß
Chris

Wortuhr Bildschirmschoner

Die Fa. BSH Bosch und Siemens Hausgeräte GmbH (Fabrik Giengen Kälte) projiziert nach ihrer Kantinenrenovierung meinen Wortuhr-Bildschirmschoner per Beamer an eine Wand.

Eine schöne Möglichkeit den manchmal stressigen Alltag etwas zu entschleunigen und mal nicht auf die Minuten zu schauen…

kantine

Download Wortuhr ScreenSaver

Weiterhin viel Spaß mit dem Bildschirmschoner!

Gruß
Chris

Homematik – Zisterne

Update 04.03.2019: Zur Messung des Füllstands der Zisterne habe ich einen neuen Artikel mit einem anderen Ansatz zur Messung verfasst. Dieser ist hier zu finden.

Wieder eins von diesen Projekten wo viele sagen: „Das braucht doch kein Mensch!“. Richtig, das braucht man auch nicht nicht. Es macht aber Spaß (zumindest mir), den Füllstand meiner Zisterne zu wissen ohne das ich den Betondeckel rausheben muss und mir dabei die Finger quetsche.

Im Homematik-Sensor-Park gibt es einen kapazitiven Füllstandssensor (Hm-Sen-Wa-Od) als Bausatz der diese Aufgabe übernehmen kann. Wobei „Bausatz“ nicht wirklich schwierige Lötarbeiten erfordert, sondern nur ein paar wenige Teile auf die Platine gelötet werden müssen (Batteriehalter, Funkmodul) und das Ganze in dem mitgelieferten Gehäuse verpackt werden muss.

IMG_3376

Nach dem Zusammenbau der Platine müssen die Messleitungen auf die entsprechende Länge (Tiefe der Zisterne und geplante Einbauhöhe des Sensors) angepaßt werden. Die Enden der Messleitungen müssen mit den beiligenden „Schrumpftüllen“ die mit Kleber gefüllt sind wasserdicht verschlossen werden. Dazu reicht ein normaler Fön.

Alle 10 cm von unten beginnen müssen nun die Stege befestigt werden. Dieser Abstand  wird später für die Kalibrierung benötigt. Dann die Anschlussleitungen durch die Kabeldurchführungen an den beiden Klemmen befestigen.

Reichweite

Ich war zuerst skeptisch ob das mit dem Funk vom Kellerraum bis in die Zisterne funktioniert?! Immerhin ist der Sensor etwa 1m unter der Erde im Betonverlies gefangen… Bei mir sind es aber nur 10m Luftline zwischen Sensor und COC und es gibt keine Probleme mit der Funkverbindung.

Anlernen

Zum Anlernen des Sensors muss die Zentrale in den Anlernmodus gebracht werden

set <zentrale> hmPairForSec <zeit_in_sekunden>

und danach am Füllstandssensor die „Sensor“-Taste für <1 Sekunde gedrückt werden. Die Setup-LED blinkt in der Anlernphase und erlischt bei Erfolg. Danach sollte in der fhem.cfg ein ähnlicher Eintrag wie folgt erstellt worden sein:

define Zisterne CUL_HM 226555
attr Zisterne .devInfo 020101
attr Zisterne .stc 60
attr Zisterne IODev COC
attr Zisterne autoReadReg 4_reqStatus
attr Zisterne expert 2_full
attr Zisterne firmware 1.2
attr Zisterne model HM-Sen-Wa-Od
attr Zisterne peerIDs
attr Zisterne rawToReadable 10:0 72:1000 144:2000 216:3000 288:4000
attr Zisterne room Garten
attr Zisterne serialNr KEQ0365449
attr Zisterne subType sensor
#attr Zisterne hmClass sender
define FileLog_Zisterne FileLog /var/log/fhem/Zisterne-%Y.log Zisterne
attr FileLog_Zisterne logtype text
attr FileLog_Zisterne room Garten

Ich hab im Beispiel den kryptischen Gerätenamen durch „Zisterne“ ersetzt. Das neue Gerät sollte dann auch in der FHEM-Weboberfläche im Raum „Garten“ zu finden sein.

Mit dem folgenden Befehl werden die Register des Füllstandsmessers ausgelesen:

get Zisterne regList

Dabei sollte folgende Ausgabe zu sehen sein. Werden die Register nicht korrekt ausgelesen kann das u.a. mit einer zu alten Version von FHEM zusammenhängen. In der Version 5.3 war das Gerät anscheinend noch nicht implementiert . Mit der FHEM Version 5.5 funktionierte das Auslesen der Register korrekt.

list:         register | range              | peer     | description
   0: cyclicInfoMsgDis |   0 to 255         |          | cyclic message
   0: intKeyVisib      |     literal        |          | visibility of internal channel options:visib,invisib
   0: localResDis      |     literal        |          | local reset disable options:on,off
   0: pairCentral      |   0 to 16777215    |          | pairing to central
   0: transmDevTryMax  |   1 to 10          |          | max message re-transmit
   1: caseDesign       |     literal        |          | case desing options:verticalBarrel,horizBarrel,rectangle
   1: caseHigh         | 100 to 10000cm     |          | case hight
   1: caseLength       | 100 to 10000cm     |          | case length
   1: caseWidth        | 100 to 10000cm     |          | case width
   1: fillLevel        | 100 to 300cm       |          | fill level
   1: ledOnTime        |   0 to 1.275s      |          | LED ontime
   1: meaLength        | 110 to 310cm       |          | 
   1: transmitTryMax   |   1 to 10          |          | max message re-transmit
   1: useCustom        |     literal        |          | use custom options:on,off
   1: waterUppThr      |   0 to 256         |          | water upper threshold
   1: waterlowThr      |   0 to 256         |          | water lower threshold
   4: expectAES        |     literal        | required | expect AES options:on,off
   4: fillLvlLoThr     |   0 to 255         | required | fill level lower threshold
   4: fillLvlUpThr     |   0 to 255         | required | fill level upper threshold
   4: peerNeedsBurst   |     literal        | required | peer expects burst options:on,off

Kalibrierung

Vor der Kalibrierung des Sensors müssen noch verschiedene Zisternen-spezifische Werte im Register gesetzt werden. Dazu gehören:

  • Behälterform
  • Behälterhöhe
  • Behälterdurchmesser
  • Länge der Messkabel
  • maximale Füllhöhe

Ich habe die maximale Füllhöhe und die Behälterhöhe auf die gleichen Werte gesetzt. Mit den folgenden Kommandos werden die Register gesetzt:

set Zisterne regSet caseDesign verticalBarrel
set Zisterne regSet caseHigh 130
set Zisterne regSet caseWidth 200
set Zisterne regSet meaLength 180
set Zisterne regSet fillLevel 130

Danach sollten die Werte in der Geräteübersicht in den Readings angezeigt werden:

zisterne_readings

Das „set_“ vor den Werten sollte dann nach mindestens 24 Stunden verschwinden. Bei Problemen mit dem korrekten Setzen der Register wurde u.a. hier behandelt.

Sind die Werte alle korrekt gesetzt, erfolgt die eigentliche Kalibrierung des Sensors die nur bei komplett gefüllter Zisterne erfolgen kann. Dazu wie in der Anleitung beschrieben verfahren:

ziosterne_kalibrierung

Falls die grüne LED nicht erlischt, d.h. die Tabelle noch nicht vollständig gefüllt ist, hat das evtl. mit einer falschen angabe der Messleitungslänge und/oder der maximalen Füllhöhe in den Registern zu tun.

Befestigung in der Zisterne

Ich habe den Sensor auf ein Brett geschraubt welches ich lose auf den Rand eines Betonringes in der Zisterne gelegt habe. Das sollte ausreichen!

IMG_6937

IMG_6935

Daten loggen

Den Füllstand der Zisterne lasse ich wieder per Cron stündlich in eine MySQL-Datenbanktabelle schreiben. Dazu wird der Sensor wieder per Telnet abgefragt:

get_zisterne.php

[cclN_php]
„;
$mysqluser=““;
$mysqlpwd=““;
$connection=mysql_connect($mysqlhost, $mysqluser, $mysqlpwd) or die („Verbindungsversuch fehlgeschlagen“);
$mysqldb=““;
mysql_select_db($mysqldb,$connection) or die(„Konnte die Datenbank nicht waehlen.“);
$sql = „INSERT INTO zisterne (timestamp,fuellstand) VALUES (CURRENT_TIMESTAMP,$zustand[1])“;
$query = mysql_query($sql) or die(„Anfrage 1 nicht erfolgreich“);
?>
[/cclN_php]

Visualisierung

Die Visualisierung habe ich wieder in meine „Intranet“-Seite eingebaut und neben dem aktuellen Füllstand in % wird noch ein Graph der letzten 14 Tage gezeichnet.

zisterne

Da wir die Tage einen Rollrasen verlegt haben wo ich ordentlich gießen musste und es zwei Tage später geregnet hat, sieht man das auch schön im Graphen. Die Einheit der X-Achse muss noch angepaßt werden.

Und mal wieder viel Spaß beim Datenloggen

Chris