Einer der beiden Raspis soll nun dem neuen Odroid weichen. Dabei entschied ich mich für den zweiten Raspi, da die ganzen PHP-Scripte erstmal nicht anzupassen sind. Das scheint mir der meiste Aufwand zu werden.

Pi-Hole umziehen

Auch wenn „Pi“ im Namen steckt, läuft die Installation mit dem curl-Script auf den Odroid genauso problemlos wie auf dem Raspberry. Daher ist der Artikel über Pi-Hole auch für den Odroid soweit noch aktuell. Eine positive Anmerkung ist, das man neben den bereits vorkonfigurierten DNS-Servern aus der Installationsroutine, in der aktuellen Version von Pi-Hole jetzt auch die eigene Fritzbox als DNS in den Einstellungen der Pi-Hole-Oberfläche bequem eingeben kann. Damit entfällt die manuelle Anpassung in der Datei /etc/dnsmasq.d/01–pihole.conf.

Beim Aufbau der Pi-Hole-Oberfläche ist der Odroid auch spürbar schneller als der Raspberry Pi. Im Netz merkt man keinen Unterschied.

Das Script für den Gaszählers umziehen

Beim Gaszähler nutze ich ein Python-Script, welches die Schließimpulse eines Reed-Kontaktes mitzählt. Also einfach mal Pythonscript kopiert, gestartet und … Fehlermeldungen angeschaut! Das Python auf dem Odroid hat die von mir genutzte RPi.GIOP-Klasse angemeckert was auch verständlich ist. Auf dem Odroid muss das gegen WiringPi2 getauscht werden.

1. WiringPi 2 für Python installieren

git clone https://github.com/hardkernel/WiringPi2-Python.git
cd WiringPi2-Python
git submodule init
git submodule update

2. Bauen & Installieren

sudo python setup.py install

Das angepaßte Script zum Auslesen des Gaszählers schaut dann für den Odroid wie folgt aus:

[cc lang=“python“ tab_size=“2″ lines=“50″]
import wiringpi2 as wpi
import time
import MySQLdb
import sys

wpi.wiringPiSetupPhys()
# GPIO definieren
REED_gas = 21
# definierten GPIO als Eingang setzen
# 0 output, 1 input, 2 PWM mode
wpi.pinMode(REED_gas,0)

lt = time.localtime()
dateiname=“gaszaehler_“+time.strftime(„%Y%m%d“,lt) +“.log“

logger = open(dateiname,“w“)
logger.write(„gestartet…“+“\n“)
logger.close()

status_alt=1
while True:
try:
dateiname=“gaszaehler_“+time.strftime(„%Y%m%d“,lt) +“.log“
logger = open(dateiname,“a“)
status_aktuell = wpi.digitalRead(REED_gas)
# KONTAKT -> geoeffnet
if status_aktuell == 1:
#logger.write(„Kontakt offen“+“\n“)
status_alt=wpi.digitalRead(REED_gas)
# KONTAKT -> geschlossen
elif status_aktuell==0:
logger.write(„Kontakt geschlossen“+“\n“)
if status_alt!=status_aktuell:
logger.write(„Impuls“+“\n“ )
status_alt=wpi.digitalRead(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()
logger.close()
except:
e = sys.exc_info()[0]
dateiname=“gaszaehler_“+time.strftime(„%Y%m%d“,lt) +“.log“
logger = open(dateiname,“a“)
logger.write(„Es ist ein Fehler aufgetreten: %s“ % e)
logger.close()
time.sleep(1)
[/cc]

Neben WiringPi habe ich auch die Verbindung zur DB in die while-Schleife gepackt. Vorher wurde die Verbindung einmal am Anfang hergestellt und in der Schleife nur noch die Daten per Insert eingetragen. Es zeigt sich aber, das der Odroid oder die Datenbank die noch auf dem anderen Pi läuft die Verbindung nach einer Zeit kappt und es zu Fehlern kam. Auch das Logging habe ich etwas abgeändert, da während das while lief nur Blockweise wenn gerade Zeit war in die Datei geschrieben wurde. Das störte bei der Fehlersuche.

Hier auch nochmal die Pinbelegung des Odroid C2 und deren Zusammenhang mit den PinModes von WiringPi2:

Das war es schon für die Anpassungen des Scriptes für den Gaszähler. Bei diesem Script gibt es keine Performanceunterschiede im Vergleich wenn es auf dem Raspi lief.

Das Script für den Wasserzähler umziehen

Als nächstes kam der Wasserzähler mit M-BUS an die Reihe. Hier habe ich mir die Quellen in der Version 0.8.0 von rScada gezogen und anschliessend versucht diese zu bauen. Dies führte schon beim ./configure zu Fehlermeldungen. Die Quellen waren zu alt und konnten die Prozessorarchitektur des Odroid (ARM) nicht ermitteln. Um das zu beheben benötigt man aktuelle Versionen der Dateien config.guess und config.sub. Diese sind unter den beiden folgenden Links zu finden.

http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD

http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD

Die beiden Dateien einfach gegen die bereit vorhanden ersetzen und ./configure läuft durch. make und make install laufen dann auch fehlerfrei durch wie im Artikel beschrieben.

Die Pins zum zum Anschluss des M-BUS-Master (Tx & Rx) sind gleich belegt wie auf dem Raspberry.

Die Scripte von rScada funktionieren identisch wie vorher. Mit mbus-serial-scan wurde der Wasserzähler auf fehlerfrei erkannt. Leider scheiterte anschliessend der Versuch mit mbus–serial–request–data die Daten aus dem vorher erkannten Zähler auszulesen. Nahc den ersten ausgelesenen Bytes verabschiedete sich mbus–serial–request–data mit einem Segmentation Fault. In den Systemlogs war nicht wirklich rauszufinden warum dem so ist. Nach ein kurzer Analyse dachte ich ein Versuch mit der vorherigen Version 0.7.0 kann nicht schaden. Damit tat es dann auch fehlerfrei. Was nun genau das Problem des Segfaults war, weiß ich nicht. Die Unterschiede zur Version 0.8.0 sind auch anscheinend nicht relevant da alles wie gewünscht funktioniert.

Soviel zu den ersten beiden „Umzügen“. Fehlen noch der DVB-S Empfänger mit tvheadend und dann geht´s schon an die Dinge die aktuell noch auf dem anderen Raspberry Pi laufen.

Gruß

Chris

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

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

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

Die 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

Zum 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

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)
  • Root-Passwort für den Kindle ermitteln
• 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:

Und hier die Anzeige für Nachts:

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