Now Spinning – Now Playing

Now Spinning – Now Playing

Bei Hipstern und Männern zwischen 45 und 54 sind Vinyl-Schallplatten ja schon länger wieder voll angesagt. Als alter CD-Sammler (und vorher auch schon Schallplatten) bin auch irgendwann wieder dazu gekommen. Aber eher zufällig (oder weil ich zur zweiten Gruppe gehöre?). Über Kleinanzeigen hatte ich ein altes Röhrenradio gekauft (Blaupunkt “Wunschklang”) und der Verkäufer hatte noch einen Technics-Plattenspieler in der Ecke stehen den ich dort nicht stehen lassen konnte. Der war technisch etwas lädiert aber nach Reinigung der verharzten Mechanik, dem Einbau eines neuen Tonabnehmers und der Einstellung des Tonarms funktioniert er wieder einwandfrei.

Aber nun die drängende Frage: Wohin mit der Hülle der Vinylplatte während diese auf dem Plattenspieler dreht? Bisher lag die Hülle neben dem Plattenspieler. An sich ein guter Platz und kein Problem, aber es gibt ja auch schicke Halter im Internet. Diese zeigen meistens den Schriftzug “Now playing” oder “Now spinning” und halten die Platte mittels eines entsprechend geformten Holz-, Acryl- oder Metall-Konstruktes an der Wand, auf dem Sideboard oder wo auch immer. Das fand ich langweilig und daher musste eine andere Lösung her.

Wenn schon so ein Halter da rum steht, kann der auch was tun während keine Schallplattenhülle drin steht. Was liegt da näher als mal wieder einen Mikrocontroller mit einem Display zu bemühen. Heraus gekommen ist ein erster Prototyp meines “Now Spinning”-Plattenhalters.

Genutzt habe ich wieder einen NodeMCU mit ESP8266 und acht MAX7219 LED 8×8 Matrix-Module. Mittels Taster, der von der eingestellten Schallplattenhülle gedrückt bleibt, wird die Anzeige auf einen dauerhaften Text (bei mir “NOW SPINNING”) gesetzt. Das folgende kurze Video zeigt die Funktion des Tasters (Entschuldigung für die Focus-Probleme…ich werde in diesem Leben kein You-Tuber mehr…):

Wird der Taster nicht betätigt (also die Platte wieder woanders verstaut), werden auf dem Display verschiedene Informationen angezeigt deren Anzeige im 5-Sekunden-Takt wechselt. Das wäre einmal die Innentemperatur die mittels BME280-Sensor erfasst wird und dann noch verschiedene weitere Daten die nicht lokal gemessen werden, sondern durch den Aufruf eines HTTP-Endpunktes des NodeMCUs an diesen “von aussen” übergeben werden.

Dieser HTTP-Post erfolgt durch ein einfaches PHP-Script welches per Cron auf einem Raspberry Pi aufgerufen wird. Die anzuzeigenden Daten werden von diesen Script aus meinem FHEM (ja, ich nutze immer noch FHEM und bin weiterhin sehr zufrieden damit) ausgelesen und die URL des NodeMCUs mit den zu übergebenen Daten aufgerufen. Aktuell werden fünf übergebene Argumente verarbeitet:

  • Aussentemperatur
  • Akkustand der PV-Anlage
  • Aktuelle Leistung der PV-Anlage
  • Temperatur des Wasserpuffers oben
  • Temperatur des Wasserpuffers unten

Der Aufruf der URL und die Übergabe der Daten an den NodeMCU schaut beispielhaft wie folgt aus:

<ip_des_nodemcu>/receivedata?aussentemperatur=17.3&akkustand=67&pv=1.5&pufferoben=70&pufferunten=56

Das folgende Video zeigt den Wechsel der Daten:

PHP-Script zum übermitteln der Messwerte

Im PHP-Script (nowspinning.php) werden die Reading-Daten aus FHEM per CURL abgefragt, dann die URL mit den Messwerten zusammen gebaut und anschliesend wiederum per CURL vom NodeMCU aufgerufen. Warum PHP: Weil´s für mich am schnellsten ging. Wenn ich mal Muße habe ändere ich es nach Python. Es funktioniert jedenfalls bisher völlig unproblematisch.

<?php
function getFhemReading($readingName, $fhemUrl) {
    $fhemCmd = "list $readingName";
    $cmd = "curl -s \"$fhemUrl/fhem?cmd=".urlencode($fhemCmd)."&XHR=1\"";    
    $output = shell_exec($cmd);
    $value = null;
    $match=explode(" ", $output);
    $match=array_filter($match);
    return str_replace(array("\r","\n"),'',end($match));
}

$fhemUrl = "http://<url_zum_fhem>:<fhem_port>";

$aussentemperatur = round(getFhemReading("Aussenthermometer temperature", $fhemUrl),1);
$akkustand = round(getFhemReading("MQTT2_openWB_Client SOC",$fhemUrl),1);
$pvleistung = round(getFhemReading("MQTT2_openWB_Client SolarPower",$fhemUrl)/1000,1);
$pufferoben = round(getFhemReading("HeizungPufferOben state",$fhemUrl),1);
$pufferunten = round(getFhemReading("HeizungPufferUnten state",$fhemUrl),1);

$cmd = "curl -s \"http://<ip_nodemcu>/receivedata?aussentemperatur=".$aussentemperatur."&akkustand=".$akkustand."&pvleistung=".$pvleistung."&pufferoben=".$pufferoben."&pufferunten=".$pufferunten."\"";

shell_exec($cmd);
?>

Hier der Aufruf des Scriptes in der Crontab alle 3 Minuten:

*/3 * * * * php /usr/local/bin/nowspinning.php

Code für den NodeMCU

Der Code für den NodeMCU ist bisher relativ schnörkelfrei. Die WLAN-Zugangsdaten müssen aktuell noch fest im Code vergeben werden. Für das MAX7219 nutze ich die Parola-Bibliothek . Für den BME280 die Bibliothek von Adafruit. Der Schalter hängt an D0 und GND.

#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include <ESP8266WebServer.h>

//WLAN
const char* ssid = "<wlan_ssid>";
const char* pass = "<wlan_passwort>";
ESP8266WebServer server(80);

// Hardwaretyp des MAX7219
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW

// PINs und Anzahl der MAX-Elemente
#define MAX_DEVICES 8
#define CS_PIN 15

MD_Parola display = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);

// BME280
#define SEALEVELPRESSURE_HPA (1013.25)
Adafruit_BME280 bme; // I2C

//Schalter um Platte zu erkennen
int pinNowSpinning = D0; 

//Warteschleifen
unsigned long startMillisTemp;
unsigned long currentMillisTemp;
unsigned long startMillisWechsel;
unsigned long currentMillisWechsel;

//Externe Daten deklarieren
String aussentemperatur = "keine Daten";
String akkustand = "keine Daten";
String puffer = "keine Daten";
String pvleistung = "keine Daten";

//Sonstiges
int anzeigennummer=0;

void setup() {

  Serial.begin(115200); 

  display.begin();
  display.setIntensity(0);
  display.displayClear();
  display.setTextAlignment(PA_CENTER);
  
  pinMode(pinNowSpinning, INPUT); 

  bool status;
  status = bme.begin(0x76);  
  if (!status) {
    Serial.println("Kann BME Sensor nicht finden. Verkabelung prüfen!");
    while (1);
  }

  startMillisTemp = millis();
  startMillisWechsel = millis();

  //WLAN
  Serial.print("Verbinde zu: ");
  Serial.println(ssid);
  display.print("Verbinde Wifi");
  WiFi.begin(ssid, pass);
   
  while(WiFi.status() != WL_CONNECTED){
    delay(500); 
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi verbunden");
  Serial.print("IP-Adresse des ESP8266: ");  
  Serial.println(WiFi.localIP());
  display.displayClear();
  display.print(WiFi.localIP());
  delay(3000);

  //Webendpunkte
  server.on("/",handleRoot);
  server.on("/receivedata", receiveData);

  server.begin();
}

void loop() {
  //Client-Anfragen abfragen
  server.handleClient(); 

  if (digitalRead(pinNowSpinning) == HIGH) {
    //Text wenn eine Platte abgestellt ist    
    display.print("NOW SPINNING");
    Serial.println("Now Spinning");  
  } else {
    currentMillisWechsel = millis();    
    if (currentMillisWechsel - startMillisWechsel >= 5000) {
      startMillisWechsel = currentMillisWechsel;
      anzeigennummer++;
      Serial.print("Anzeigenummer: ");
      Serial.println(anzeigennummer);
      switch (anzeigennummer) {
        case 1:
          //Temperatur alle 30 Sekunden abfragen
          currentMillisTemp = millis();        
          if (currentMillisTemp - startMillisTemp >= 10000) {
            startMillisTemp = currentMillisTemp;
            String temperatur = String(bme.readTemperature());
            display.print("> "+temperatur.substring(0,temperatur.length()-1)+" \"C");

            Serial.print("Temperatur: ");
            Serial.print(bme.readTemperature());
            Serial.println(" °C");

            Serial.print("Luftfeuchte: ");
            Serial.print(bme.readHumidity());
            Serial.println(" %");
          }
          break;
        case 2:
          display.print(aussentemperatur);
          Serial.println(aussentemperatur);          
          break;
        case 3:
          display.print(akkustand);
          Serial.println(akkustand);          
          break;
        case 4:
          display.print(pvleistung);
          Serial.println(pvleistung);          
          break;
        case 5:
          display.print(puffer);
          Serial.println(puffer);          
          break;
        default:
          // statements
          break;
      }
      if (anzeigennummer>=5) { 
        anzeigennummer=0; 
        Serial.println("Anzeigenummer reset");
      }
    }  
  }
}

void handleRoot() {
  String message="<h1>Now Spinning</h1>";
  message += "Das ist die lieblose Webseite des 'Now Spinning'-Anzeigers</br></br>";
  message += "Temperatur: ";
  message += bme.readTemperature();
  message += " °C<br>";
  message += "Luftfeuchte: ";
  message += bme.readHumidity();
  message += " rel%<br>";
  server.send(200, "text/html", message);
}

void receiveData() {
  String message="<h1>Empfange Daten</h1>";
  message += "Daten werden empfangen...</br></br>";
  server.send(200, "text/html", message);

  Serial.println("Daten empfangen...");
 
  //Aussentemperatur
  Serial.print(server.argName(0));
  Serial.print(F(": "));
  Serial.println(server.arg(0));
  aussentemperatur="< " + server.arg(0) + " \"C";

  //Akkustand
  Serial.print(server.argName(1));
  Serial.print(F(": "));
  Serial.println(server.arg(1));
  akkustand="Akku "+ server.arg(1) + "%";

  //PV Leistung
  Serial.print(server.argName(2));
  Serial.print(F(": "));
  Serial.println(server.arg(2));
  pvleistung="PV "+ server.arg(2) + "KW";

  //Puffer oben u. unten
  Serial.print(server.argName(3));
  Serial.print(F(": "));
  Serial.println(server.arg(3));
  Serial.print(server.argName(4));
  Serial.print(F(": "));
  Serial.println(server.arg(4));
  puffer = "- " + server.arg(3) + "  _ " + server.arg(4); 
}

Schaltungsplan von Fritzing kommt noch und wenn ich mal Zeit finde, packe ich den Code auch noch nach Github.

Holzarbeiten

Hier hat mir dankenswerterweise Arnim (der immer mit meinen Kritzeleien zurecht kommen muss) sehr geholfen und hat mir einen ersten Prototyp aus Fichte gebaut.

Die Nut um die Platte zu halten, wurde mit leicht schräg gestelltem Sägeblatt der Tischkreissäge angefertigt und ist etwa 1 cm breit. Der vordere Ausschnitt um den NodeMCU und das Display unter zu bringen ist mit der Oberfräse gefräst.

Den Taster hab ich von unten in ein zweistufig gebohrtes Loch mit Heißkleber befestigt. Im Bild unten ist der Taster als kleines schwarzes Ding zu erkennen. Die Kabel des Schalters sind dann schräg nach vorne in die Ausfräsung verlegt.

Das Anschlusskabel verläuft duch eine Bohrung unter der Nut für die Platte und dann auch schräg nach oben in die Ausfräsung. Hier hab ich ein normales Micro-USB-Kabel genutzt, kurzerhand durchgeschnitten und wieder zusammengelötet.

Für die Unterbringung des Temperatursensors brauche ich noch eine gute Lösung. Dieser liegt aktuell einfach mit in der Ausfräsung in der Ecke. Ich kann mir aber vorstellen, dass dort durch das Display und den NodeMCU die Messung verfälscht wird.

Todo´s

Es ist ja der erste Prototyp des “Now spinning”-Plattenhüllenhalters und an der Software als auch an der Hardware (für den Mikorcontroller und den Halter selber) ist noch ein bisschen was zu tun. Spontan fällt mir da noch folgendes ein:

  • Acrylfront (dunkelrot oder milchig…muss ich mal testen) und Frage der Befestigung
  • Helligkeitssensor mittels simplem LDR (wenn dunkel, dann dunkler. wenn Heller, dann heller)
  • Uhrzeit (entweder per POST mit den anderen Messwerten übergeben oder Echtzeituhr-Modul)
  • Übergabe der Messwerte etwas flexibler gestalten (ohne das bei neuen Werten der Code des NodeMCU geändert werden muss sondern nur beim Aufruf der URL)
  • Maximalzeit nach der “Now Spinning” wieder zu der Anzeige der anderen Daten wechselt
  • “Now spinning” abwechselnd mit einen Spektrum Analyzer (FFT) per Mikrofon aufgenommen
  • Einen besseren Platz für den internen Temperatur-Sensor
  • Den Halter aus Eiche anstatt Fichte (Grüße an die Fräser)
  • Die Luftfeuchte vom BME280 anzeigen
  • Befestigung des Temperatursensors

Das war´s erstmal. Falls ihr Den Plattenhalter nachbauen wollt, würde ich mich über Erfahrungen, Verbesserungen, weitere Ideen und Bilder freuen. Bis dahin

Gruß Chris

Netzwerkweit Werbung blockieren mit Pi-hole

Netzwerkweit Werbung blockieren mit Pi-hole

pihole_logoHabt ihr genug von flackernden Werbebannern die mehr Raum einnehmen als der eigentliche Seiteninhalt oder gefühlte 100 Ad-Server die beim Öffnen einer einzigen Webseite kontaktiert werden? Adblock & Co. sind eine gute Sache, allerdings auf den Webbrowser beschränkt auf dem das Plugin installiert ist. Android oder iOS waren da meistens außen vor. Auf der Suche nach einem weiteren Beschäftigungsfeld für meinen Raspberry Pi bin ich auf ein nettes Projekt gestoßen!

Das ist ein Update des ursprünglichen Artikels da sich ein paar wichtige Dinge geändert haben und ich auch einen DNS-Loop eingebaut hatte…

Installation

Mit einer Zeile ist er auf dem Raspberry Pi installiert: der Werbeblocker Pi-hole

curl -L https://install.pi-hole.net | bash Mehr lesen

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

Vor- und Rücklauf vom Kachelofen mittels 1-wire Temperatursensoren messen

Unser Kachelofen von Brunner hat einen Wärmetauscher (HKD2.2) und versorgt damit den Wasserspeicher im Keller mit warmem Wasser. Aus diesem wird dann die Fußbodenheizung und das Warmwasser versorgt. Die Steuerung des Kachelofens übernimmt die EAS (Elektronische Abbrandsteuerung). Leider hat Brunner in der EAS keine mir bekannte Schnittstelle um die verschiedenen Temperaturen, die Statis der Abbrandsteuerung oder den Schalter der Kachelofentüre abzufragen.

IMG_5564

Die Abbrandsteuerung selber ist unabhängig von der eigentlichen Hydraulik zum Anschluss des Kachelofens an den Warmwasserspeicher. Hier nutzen wir eine Steuerung der Fa. ÖkoCentro mit einer SHR 10-Steuerung von EnergieControl. Aber auch diese hat keine mir bekannte Schnittstelle die man einfach abfragen kann.

IMG_7931

Als eine einfache Möglichkeit zumindest schon mal die Vorlauf- und Rücklauftemperatur zu messen, dachte ich an 1-Wire Temperatursensoren der Firma DALLAS (DS18B20). Diese sind günstig (z.B. 1,85€ bei Reichelt) und einfach am Raspberry PI zu implementieren. Die Vorbereitungen zur Nutzung der 1-Wire Sensoren ist nicht aufwändig und schnell passiert.

Sollen die 1-wire Sensoren nur parasitär versorgt werden, folgendes in der Shell eingeben um das entsprechende Kernelmodul zu laden:

sudo modprobe w1-gpio

oder wenn ein Pullup zur externen Stromversorgung genutzt wird, folgendes Kommando:

sudo modprobe w1-gpio pullup=1

Sollen Temperaturen über 70°C gemessen werden, wird zwecks der Genauigkeit der Sensoren die zusätzliche Stromversorgung mittels Pullup-Widerstand angeraten.
Mehr zum Thema Anschlussarten gibt es z.B. hier.

Unabhängig ob Pull-Up oder nicht wird noch ein weiteres Kernelmodul benötigt:

sudo modprobe w1-therm

Ab der Kernelversion 3.18.3 muss noch eine Anpassung gemacht werden. Die Kernelversion wird wie folgt bestimmt:

uname -r

Ist die Kernelversion > 3.18.3 muss in der Datei

/boot/config.txt

folgende Zeile eingefügt werden

# activating 1-wire with pullup
dtoverlay=w1-gpio-pullup

Ich habe die Sensoren mit separater Versorgung am Raspberry Pi angeschlossen. Wie das funktioniert, ist im Internet in verschiedensten Foren etc. zu lesen. Ich hatte mal eine kleine Platine rs232_raspi.fzz mit einem MAX3232 für eine RS232-Schnittstelle für das M-Bus-Projekt in Fritzing aufgebaut. Da hat auch noch der eine 4.7K Widerstand und eine Steckerleiste für 1-wire drauf gepaßt (oben Links zu sehen).

fritzing_1wire_rs232

Sind die Kernelmodule geladen, alle Konfigurationen gemacht und alles angeschlossen, sollten die 1-wire Sensoren nach einem Neustart des Raspberry PI unter

cd /sys/bus/w1/devices

auftauchen.

Die Sensoren werden z.B. per “cat” mit folgendem Befehl ausgelesen

cat 28-000005db9cea/w1_slave

Das Ergebnis sollte dann ähnlich wie folgt aussehen:

08 03 4b 46 7f ff 08 10 9e : crc=9e YES
08 03 4b 46 7f ff 08 10 9e t=48500

Die Temperatur wird hinter dem “t=” in der zweiten Zeile ausgegeben. Um diese Temperatur z.B. mit PHP abzufragen und für weitere Verarbeitung nutzen zu können, folgendes PHP-Code-Schnipsel

[cc lang=”php”]

[/cc]

Die Temperatur schreibe ich dann per Script, welches 10-minütig per Cron aufgerufen wird, in eine MySQL-Datenbank und stelle das Ergebnis in einer Webseite dar.

kachelofen_webseite

Soviel zum Thema 1-wire. Die größere Herausforderung wird es aber, an die Werte der EAS heran zu kommen. Diese sind in soweit auch interessanter, als das diese Steuerung den Abbrand überwacht und informiert ob das Feuer heiß genug ist (>450°C) um den geregelten Abbrand zu starten, zu heiß (>750°C) und eine Gewisse Panik zu erzeugen, der Abbrand beendet ist und Holz nach gelegt werden könnte oder die Türe des Kachlofens nicht richtig geschlossen ist.

Ein Anfang ist aber gemacht und die EAS eine neue Herausforderung.

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

Stabiler 24/7 Betrieb des Raspberry – Netzwerk neu starten

Zum Thema stabiler 24/7-Betrieb des Raspberry PI´s gibt es viele gute Blogeinträge die sich mit dem richtigen Netzteil, dem korrektem Umgang von Linux mit der SD-Karte, evtl. Hitzeprobleme und Netzwerkproblemen aufgrund zu hoher Last beschäftigen.

Siehe z.B.: hier oder hier

Unter anderem wird auch immer wieder der Hardware-Watchdog des PI genannt. Diesen Watchdog hab ich auch aktiviert, da ich in der Vergangenheit immer wieder Probleme mit dem Netzwerk (Stichwort smsc95xx errors und weiterführende Links) hatte. Dies äusserte sich immer wieder mit dem Einfrieren des PI. Der Watchdog machte im Fehlerfall einen Restart und gut war. Nach den letzten Firmwareupdates hat sich die Frequenz der Restarts auch stark verringert.

Dann aber war mein Raspi plötzlich per SSH nicht mehr erreichbar und auch die Webseite wurde nicht mehr angezeigt. Seltsamerweise erfolgte kein Neustart durch den Watchdog. Da ich den Raspi Headless betreibe, blieb mir nicht viel anderes übrig als ihn einfach vom Strom zu trennen und wieder anzuschliessen. Danach lief alles wieder einwandfrei. Leider häuften sich diese Probleme so das es mir zu nervig wurde, ständig den Strom zu kappen. Schliesslich ist mein Raspi ja ein Server und soll gescheit laufen.

Nach den Neustarts ist mir aber auch aufgefallen, das die Daten der Leseköpfe lückenlos in die Datenbank geschrieben wurden. Anscheind lief der Raspi noch und nur das Netzwerk war nicht verfügbar.

Das Problem war teilweise im Message-Log zu sehen:


Nov 22 12:51:10 raspberrypi kernel: [1279051.095475] usb 1-1: USB disconnect, device number 10
Nov 22 12:51:10 raspberrypi kernel: [1279051.095493] usb 1-1.1: USB disconnect, device number 11
Nov 22 12:51:10 raspberrypi kernel: [1279051.095887] smsc95xx 1-1.1:1.0 eth0: unregister 'smsc95xx' usb-bcm2708_usb-1.1, smsc95xx USB 2.0 Ethernet
Nov 22 12:51:10 raspberrypi kernel: [1279051.095954] smsc95xx 1-1.1:1.0 eth0: hardware isn't capable of remote wakeup
Nov 22 12:51:10 raspberrypi kernel: [1279051.136136] usb 1-1.2: USB disconnect, device number 12
Nov 22 12:51:10 raspberrypi kernel: [1279051.136650] cp210x ttyUSB0: cp210x converter now disconnected from ttyUSB0
Nov 22 12:51:10 raspberrypi kernel: [1279051.136748] cp210x 1-1.2:1.0: device disconnected
Nov 22 12:51:10 raspberrypi kernel: [1279051.137275] usb 1-1.3: USB disconnect, device number 13
Nov 22 12:51:10 raspberrypi kernel: [1279051.137769] ftdi_sio ttyUSB1: FTDI USB Serial Device converter now disconnected from ttyUSB1
Nov 22 12:51:10 raspberrypi kernel: [1279051.137876] ftdi_sio 1-1.3:1.0: device disconnected
Nov 22 12:51:10 raspberrypi kernel: [1279051.295583] Indeed it is in host mode hprt0 = 00021501
Nov 22 12:51:11 raspberrypi kernel: [1279051.575374] usb 1-1: new full-speed USB device number 14 using dwc_otg
Nov 22 12:51:11 raspberrypi kernel: [1279051.575636] Indeed it is in host mode hprt0 = 00021501
Nov 22 12:51:11 raspberrypi kernel: [1279051.825598] usb 1-1: not running at top speed; connect to a high speed hub
Nov 22 12:51:11 raspberrypi kernel: [1279051.825950] usb 1-1: New USB device found, idVendor=0424, idProduct=9512
Nov 22 12:51:11 raspberrypi kernel: [1279051.825971] usb 1-1: New USB device strings: Mfr=0, Product=0, SerialNumber=0
Nov 22 12:51:11 raspberrypi kernel: [1279051.836520] hub 1-1:1.0: USB hub found
Nov 22 12:51:11 raspberrypi kernel: [1279051.836765] hub 1-1:1.0: 3 ports detected
Nov 22 12:51:11 raspberrypi kernel: [1279052.115374] usb 1-1.1: new full-speed USB device number 15 using dwc_otg
Nov 22 12:51:11 raspberrypi kernel: [1279052.215553] usb 1-1.1: not running at top speed; connect to a high speed hub
Nov 22 12:51:11 raspberrypi kernel: [1279052.215947] usb 1-1.1: New USB device found, idVendor=0424, idProduct=ec00
Nov 22 12:51:11 raspberrypi kernel: [1279052.215973] usb 1-1.1: New USB device strings: Mfr=0, Product=0, SerialNumber=0
Nov 22 12:51:11 raspberrypi kernel: [1279052.219107] smsc95xx v1.0.4
Nov 22 12:51:11 raspberrypi kernel: [1279052.280966] smsc95xx 1-1.1:1.0 eth0: register 'smsc95xx' at usb-bcm2708_usb-1.1, smsc95xx USB 2.0 Ethernet, b8:27:eb:bd:01:0b
Nov 22 12:51:12 raspberrypi kernel: [1279052.375552] usb 1-1.2: new full-speed USB device number 16 using dwc_otg
Nov 22 12:51:12 raspberrypi kernel: [1279052.477284] usb 1-1.2: New USB device found, idVendor=10c4, idProduct=ea60
Nov 22 12:51:12 raspberrypi kernel: [1279052.477318] usb 1-1.2: New USB device strings: Mfr=1, Product=2, SerialNumber=3
Nov 22 12:51:12 raspberrypi kernel: [1279052.477334] usb 1-1.2: Product: CP2104 USB to UART Bridge Controller
Nov 22 12:51:12 raspberrypi kernel: [1279052.477349] usb 1-1.2: Manufacturer: Silicon Labs
Nov 22 12:51:12 raspberrypi kernel: [1279052.477362] usb 1-1.2: SerialNumber: 0065B522
Nov 22 12:51:12 raspberrypi kernel: [1279052.479039] cp210x 1-1.2:1.0: cp210x converter detected
Nov 22 12:51:12 raspberrypi kernel: [1279052.479519] usb 1-1.2: cp210x converter now attached to ttyUSB0
Nov 22 12:51:12 raspberrypi kernel: [1279052.491197] smsc95xx 1-1.1:1.0 eth0: hardware isn't capable of remote wakeup
Nov 22 12:51:12 raspberrypi kernel: [1279052.535606] smsc95xx 1-1.1:1.0 eth0: hardware isn't capable of remote wakeup
Nov 22 12:51:12 raspberrypi kernel: [1279052.555550] usb 1-1.3: new full-speed USB device number 17 using dwc_otg
Nov 22 12:51:12 raspberrypi kernel: [1279052.640093] smsc95xx 1-1.1:1.0 eth0: hardware isn't capable of remote wakeup
Nov 22 12:51:12 raspberrypi kernel: [1279052.661511] usb 1-1.3: New USB device found, idVendor=0403, idProduct=6001
Nov 22 12:51:12 raspberrypi kernel: [1279052.661547] usb 1-1.3: New USB device strings: Mfr=1, Product=2, SerialNumber=3
Nov 22 12:51:12 raspberrypi kernel: [1279052.661563] usb 1-1.3: Product: FT232R USB UART
Nov 22 12:51:12 raspberrypi kernel: [1279052.661577] usb 1-1.3: Manufacturer: FTDI
Nov 22 12:51:12 raspberrypi kernel: [1279052.661590] usb 1-1.3: SerialNumber: A4009G5A
Nov 22 12:51:12 raspberrypi kernel: [1279052.664914] ftdi_sio 1-1.3:1.0: FTDI USB Serial Device converter detected
Nov 22 12:51:12 raspberrypi kernel: [1279052.665117] usb 1-1.3: Detected FT232RL
Nov 22 12:51:12 raspberrypi kernel: [1279052.665314] usb 1-1.3: Number of endpoints 2
Nov 22 12:51:12 raspberrypi kernel: [1279052.665337] usb 1-1.3: Endpoint 1 MaxPacketSize 64
Nov 22 12:51:12 raspberrypi kernel: [1279052.665353] usb 1-1.3: Endpoint 2 MaxPacketSize 64
Nov 22 12:51:12 raspberrypi kernel: [1279052.665367] usb 1-1.3: Setting MaxPacketSize 64
Nov 22 12:51:12 raspberrypi kernel: [1279052.667714] usb 1-1.3: FTDI USB Serial Device converter now attached to ttyUSB1
Nov 22 12:51:13 raspberrypi kernel: [1279054.248030] smsc95xx 1-1.1:1.0 eth0: link up, 100Mbps, full-duplex, lpa 0xC5E1

An dem Raspi hängt der Lesekopf für den Stromzähler und für die Heizung. Der Raspi scheint die USB-Ports aus irgendwelchen Gründen unmotiviert neu zu starten. Das funktioniert für die USB-Ports immer erfolgreich, aber das Netzwerk blieb dabei gelegentlich auf der Strecke (obwohl in der letzten Zeile gegenteiliges behauptet wird). Das hängt anscheinend immer noch mit Fehlern im smsc95xx zusammen.

Neustart des Netzwerkinterfaces

Nun gut…dann muss das Netzwerk halt nochmal gestartet werden. Folgendes Bash-Script rufe ich alle 10 Minuten per Cron auf. Ist das Netzwerk verfügbar, passiert nichts. Ist das Netzwerk nicht verfügbar wird versucht des Interface neu zu starten. Gelingt auch das nicht, wird der Raspi rebootet. Mittels logger wird der Neustart in /var/log/messages geloggt.

[cc lang=”bash” lines=”40″]
#!/bin/sh
IP_TO_TEST=”
PING_COUNT=1
PING=”/bin/ping”
IFUP=”/sbin/ifup”
IFDOWN=”/sbin/ifdown –force”
INTERFACE=”eth0″ #Device angeben welches geprüft werden soll
LOCKF=”/opt/lockf”
$PING -c $PING_COUNT $IP_TO_TEST > /dev/null 2> /dev/null
if [ $? -ge 1 ]
then
logger “$INTERFACE scheint unten zu sein, versuche restart…”
if [ -e $LOCKF]
then
logger “$INTERFACE immer noch unten, NEUSTART…”
rm -f $LOCKF 2>/dev/null
sudo reboot
else
touch $LOCKF
logger $(sudo $IFDOWN $INTERFACE)
sleep 10
logger $(sudo $IFUP $INTERFACE)
fi
else
#logger “$INTERFACE laueft”
rm -f $LOCKF 2>/dev/null
fi
[/cc]

Im Log sieht man dann den erfolgreichen Neustart des Netzwerkinterfaces durch das obige Bach-Script.


Nov 22 12:51:12 raspberrypi kernel: [1279052.665353] usb 1-1.3: Endpoint 2 MaxPacketSize 64
Nov 22 12:51:12 raspberrypi kernel: [1279052.665367] usb 1-1.3: Setting MaxPacketSize 64
Nov 22 12:51:12 raspberrypi kernel: [1279052.667714] usb 1-1.3: FTDI USB Serial Device converter now attached to ttyUSB1
Nov 22 12:51:13 raspberrypi kernel: [1279054.248030] smsc95xx 1-1.1:1.0 eth0: link up, 100Mbps, full-duplex, lpa 0xC5E1
Nov 22 13:00:02 raspberrypi logger: eth0 scheint unten zu sein, versuche restart...
Nov 22 13:00:09 raspberrypi kernel: [1279589.925658] smsc95xx 1-1.1:1.0 eth0: hardware isn't capable of remote wakeup
Nov 22 13:00:09 raspberrypi kernel: [1279590.124240] smsc95xx 1-1.1:1.0 eth0: hardware isn't capable of remote wakeup
Nov 22 13:00:09 raspberrypi logger: Stopping NTP server: ntpd. Starting NTP server: ntpd.
Nov 22 13:00:11 raspberrypi kernel: [1279591.726167] smsc95xx 1-1.1:1.0 eth0: link up, 100Mbps, full-duplex, lpa 0xC5E1
Nov 22 13:00:32 raspberrypi logger: Stopping NTP server: ntpd. Starting NTP server: ntpd.

Seitdem läuft mein PI seit 16 Tagen durch. Mal sehen wie lange er ohne Neustart durchhält!

Gruß
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

Raspberry Pi in Watchdog-Loop

Da der Raspi bei mir durch die oft beschriebenen Probleme mit dem smsc95xx relativ wacklig auf dem Netzwerk und den beiden USB-Ports ist und dadurch in unregelmäßigen Abständen unmotiviert die Arbeit einstellt, hatte ich den Hardware-Watchdog des Raspi aktiviert. Dieser veranlasst in meinem Fall einen Neustart des Systems wenn länger als 15 Minuten nichts mehr in eine bestimmte Datei geschrieben wird. Wie die Einrichtung des Watchdog genau funktioniert, ist z.B. hier beschrieben.

Diese Woche war es nun plötzlich so, das der Raspi in einer Endlosschleife bootete und anschliessend sofort wieder ein Signal zum Shutdown bekam, bootete, shutdown, ….

Meine erste Vermutung war das Netzteil. Den gleichen Effekt gab es aber auch mit einem anderen Netzteil. Der Ersatz-Raspi mit der gleichen SD-Karte rebootete auch ständig. Also kein Hardware-Fehler!

Also Monitor angeschlossen und mal geschaut was da beim booten so passiert. Das letzte was der Raspi so von sich gab bevor er wieder neu startete war:

WDT device closed unexpectedly.  WDT will not stop!

WDT ist der Watchdog Timer. Dieser schien sich selbständig gemacht zu haben. Nun hieß es also irgendwie diesen Watchdog zu stoppen. Die Zeit zwischen einem möglichen Login, Befehl absetzen etc. ist aber so kurz, das ich es vor einem Shutdown nie geschafft habe irgendwas sinnvolles auf der Konsole zu tun.

Abhilfe schafft z.B. das Programm “pLink”. Die plink.exe ist Teil von puTTy und unter Windows im gleichen Verzeichnis wie die putty.exe zu finden. Hiermit muss nicht erst eine gesonderte SSH-Verbindung zum Server aufgebaut werden, sondern es kann direkt der entsprechende Befehl abgesetzt werden.

In meinem Fall habe ich dem Watchdog um seine Konfiguration beraubt, wodurch dieser beim nächsten Neustart (der ja höchstwahrscheinlich ein paar Sekunden später erfolgt) nicht mehr gestartet wird.

plink -ssh -pw <passwort> <benutzer>@<pi_ip> sudo mv /etc/watchdog.conf /etc/watchdog.alt

Beraubt um seine Konfigdatei, sollte der Watchdog beim nächsten Restart nicht mehr starten. Gespannt hab ich ein paar Sekunden gewartet aber es kam kein Neustart mehr.

Woran es letztendlich gelegen hat das der Watchdog diesen immerwährenden Neustart erzwungen hat weiß ich noch nicht. Auch die Konfiguration des Watchdogs muss ich nochmal prüfen. Jedenfalls läuft der Raspi nun wieder!

Viessmann Heizung auslesen

Viessmann Heizung auslesen

Wir haben eine Viessmann Vitodens 200-W Gastherme inkl. Solaranlage die über eine Vitotronic verfügt. Die Vitotronic hat eine optische Schnittstelle (Optolink) über die z.B. ein Heizungsmonteur verschiedene Parameter der Anlage auslesen und auch setzen kann.

vitotronic

Dafür benötigt man normalerweise den entsprechenden Lesekopf und eine passende Software der Fa. Viessmann.

Auf https://github.com/openv/openv/ gibt es aber auch eine andere Lösung! Die Jungs dort haben viel Arbeit in die “Entschlüsselung” des Viessmann-Protokolls gelegt und verschiedene Anwendungen zur einfachen Kommunikation mit der Heizung entwickelt.

An dieser Stelle nochmal meinen Dank an dieses hervorragende Forum!

Unter den verschiedenen Bauanleitungen für die Leseköpfe habe ich mich für die USB-Variante entschieden. Mein Raspi hat ja noch einen USB-Anschluss frei und kann neben der Stromzählung und der Homematic-Steuerung auch noch die Heizung auslesen. Nicht das ihm langweilig wird…

Das Platinchen muss über die V-Ausfräsung hinter der Klappe befestigt werden. Das habe ich dann “professionell” mit einem Papp-V und Tape erledigt. Hält!!

platine_frei

platine_tape

Ich nutze den vcontrold und da hier eine perfekte Anleitung zur Installation dieser Komponente auf dem Raspberry PI beschrieben ist, will ich auf die Installation und Konfiguration des Daemons auch nicht näher eingehen.

Der Daemon bietet eine Schnittstelle die z.B. mittels Telnet abgefragt werden kann. Ich nutze die Template-Möglichkeit (wird z.B. hier erklärt) um mehrere Heizungswerte auszulesen und die gelieferten Werte weiter verarbeiten zu können. Dazu wird bei mir folgendes Script (update.sh) alle 6 Minuten per Cron aufgerufen:

if [ !$(pgrep vclient) ]
then vclient -h localhost:3001 -f /opt/vcontrold/vc-commands.txt -t /opt/vcontrold/update.tmpl -x /opt/vcontrold/update.sh
fi

Der Eintrag in der Crontab sieht dann folgendermaßen aus:

*/6 * * * * sudo /opt/vcontrold/update.sh

Die Datei vc-commands.txt enthält eine Liste alle Werte die ausgelesen werden sollen. Diese Werte müssen auch in der “vito.xml” definiert sein.

getTempA
getTempWWist
getTempKist
getTempKol
getTempSpu
getBrennerStarts
getBrennerStunden1
getSolarStunden
getSolarLeistung
getPumpeStatusSolar
...

In der Datei update.tmpl werden die zurück gelieferten Werte in Variablen geschrieben und können dann beliebig weiter verarbeitet werden (z.B. eine Prüfung ob ein Wert zurück gegeben wurde).

if  [ "x$E1" != x ]; then
     echo -n `date`  >>/tmp/vc-err.txt
     echo "es ist ein Fehler aufgetreten: $C1:$E1" >>/tmp/vc-err.txt
     exit 1;
fi
if  [ "x$E2" != x ]; then
     echo -n `date`  >>/tmp/vc-err.txt
     echo "es ist ein Fehler aufgetreten: $C2:$E2" >>/tmp/vc-err.txt
     exit 1;
fi
...

Auf der openv-Webseite wird oft eine rrdb zur Auswertung der Daten genutzt. Da ich mich mit einer rrdb nicht wirklich gut auskenne, schreibe ich die Daten lieber in eine MySQL-Datenbank.

Tabellenstruktur

Hierfür habe ich folgende Tabellen in der MySQL-Datenbank angelegt:

Tabellenstruktur für Tabelle brenner

CREATE TABLE IF NOT EXISTS `brenner` (
 `timestamp` datetime NOT NULL,
 `brennerstarts` float NOT NULL,
 `brennerstunden` float NOT NULL,
 `brennerstatus` int(11) NOT NULL,
 KEY `timestamp` (`timestamp`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Tabellenstruktur für Tabelle solar

CREATE TABLE IF NOT EXISTS `solar` (
 `timestamp` datetime NOT NULL,
 `solarstunden` float NOT NULL,
 `solarleistung` float NOT NULL,
 `solarpumpe` int(11) NOT NULL,
 KEY `timestamp` (`timestamp`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Tabellenstruktur für Tabelle temperaturen

CREATE TABLE IF NOT EXISTS `temperaturen` (
 `timestamp` datetime NOT NULL,
  `aussentemperatur` float NOT NULL,
  `warmwasser` float NOT NULL,
  `speicher_unten` float NOT NULL,
  `kollektor` float NOT NULL,
  `vorlaufsolltemperaturM2` float NOT NULL,
  KEY `timestamp` (`timestamp`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Tabellenstruktur für Tabelle snapshot

CREATE TABLE IF NOT EXISTS `snapshot` (
 `timestamp` datetime NOT NULL,
 `brennerstatus` float NOT NULL,
 `brennerstarts` float NOT NULL,
 `brennerstunden` float NOT NULL,
 `solarstunden` float NOT NULL,
 `solarleistung` float NOT NULL,
 `aussentemperatur` float NOT NULL,
 `warmwasser` float NOT NULL,
 `speicher_unten` float NOT NULL,
 `kollektor` float NOT NULL,
 `kesseltemperatur` float NOT NULL,
 `vorlauftemperaturM2` float NOT NULL,
 `vorlaufsolltemperaturM2` float NOT NULL,
 `raumsolltemperaturM1` float NOT NULL,
 `raumsolltemperaturM2` float NOT NULL,
 `raumsolltemperaturredM1` float NOT NULL,
 `raumsolltemperaturredM2` float NOT NULL,
 `warmwassersoll` float NOT NULL,
 `kesseltemperatursoll` float NOT NULL,
 `pumpestatusM1` float NOT NULL,
 `pumpestatusSP` float NOT NULL,
 `pumpestatussolar` float NOT NULL,
 `statusstoerung` varchar(100) CHARACTER SET latin1 COLLATE latin1_german1_ci NOT NULL,
 `systemzeit` varchar(100) CHARACTER SET latin1 COLLATE latin1_german1_ci NOT NULL,
 `error0` varchar(500) CHARACTER SET latin1 COLLATE latin1_german1_ci NOT NULL,
 `BetriebArt` varchar(20) NOT NULL,
 `BetriebArtM2` varchar(20) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Die snapshot-Tabelle soll keine Historie enthalten, sondern immer nur eine Zeile mit den alle zwei Minuten ausgelesen Werten. Das hat sich nach ein paar Monaten Betrieb als sinnvoll erwiesen, da der Raspberry doch ganz schön ackern muss um aus einer Tabelle mit > 150.000 Zeilen (und wachsend) die aktuellen Werte auf der Webseite anzuzeigen.

Werte in Datenbank speichern

In oben beschriebene Datei update.tmpl werden dann die Werte genutzt, um sie in der MySQL-Datenbank zu speichen. Dazu nutze ich den Aufruf des Kommandozeilentools “mysql” welches bei der Installation der Datenbank enthalten ist.

Hier die drei Aufrufe mit INSERT-Statements für die Temperatur-, die Solar und die Brennerdaten. In $1, $2 , $3, … stehen die Werte gemäß der Reihenfolge der vc-commands.txt.

mysql --user= --password=  -e "INSERT INTO temperaturen (timestamp,aussentemperatur,warmwasser,kollektor,speicher_unten,vorlaufsolltemperaturM2) values (CURRENT_TIMESTAMP,$1,$2,$4,$5,$13);"
mysql --user= --password=  -e "INSERT INTO solar (timestamp,solarstunden,solarleistung) values (CURRENT_TIMESTAMP,$9,$10);"
mysql --user= --password=  -e "INSERT INTO brenner (timestamp,brennerstarts,brennerstunden,brennerstatus) values (CURRENT_TIMESTAMP,$6,$7,IFNULL('$19',0));"

Für die Snapshot-Tabelle nutze ich ein Update-Statement da diese Tabelle immer nur eine Zeile enthalten soll.

mysql --user= --password=  -e "UPDATE snapshot SET timestamp=CURRENT_TIMESTAMP,aussentemperatur=$1,warmwasser=$2,kollektor=$4,speicher_unten=$5,solarstunden=$9,solarleistung=$10,brennerstarts=$6,brennerstunden=$7,kesseltemperatur=$12,vorlauftemperaturM2=$13,vorlaufsolltemperaturM2=$14,raumsolltemperaturM1=$15,raumsolltemperaturM2=$16,raumsolltemperaturredM1=$17,raumsolltemperaturredM2=$18,brennerstatus=IFNULL('$19',0),warmwassersoll=$20,kesseltemperatursoll=$21,pumpestatusM1='$22',pumpestatussp='$23',pumpestatussolar='$24',statusstoerung='$R25',systemzeit='',error0='$R27',BetriebArt='$R29',BetriebArtM2='$R30';"

Wenn der Cron eingerichtet ist, sollte die Datenbank alle 6 Minuten mit den ausgelesenen Werten gefüllt werden.

Anzeige der Daten

Die Anzeige der Daten erfolgt mittels Webseite und PHP-Script. Auf einer Übersichtsseite lese ich die Snapshot-Tabelle aus. Das geht Dank der Snapshot-Tabelle auch recht schnell.

temp_uebersicht

Auf einer weiteren Seite werden zusätzliche Werte aus der Snapshot-Tabelle angezeigt.

temp_details

Weil die Erstellung des Graphen nicht auf der Snapshot-Tabelle basiert, dauerte die Anzeige dieser Seite auch immer recht lange. Daher wird die PNG-Grafik für den Graph nun viertelstündlich per Script erstellt und nur noch das fertige Bild in der Webseite angezeigt.

Hier der Crontab-Eintrag für das Script zur Erstellung der Grafik:

*/15 * * * * sudo php /var/www/heizung/update_graph.php &> /dev/null

und das Script selber. Zur Erstellung des Graphen nutze ich pChart.

[cclN_php]
= NOW()”;
$query = mysql_query($sql) or die(“Anfrage nicht 1 erfolgreich”);
while ($wert = mysql_fetch_array($query)) {
$aussentemperatur[]=$wert[0];
$warmwasser[]=$wert[1];
$speicher_unten[]=$wert[2];
$kollektor[]=$wert[3];
$vorlauf[]=$wert[4];
if ($zeit_tmp==$wert[5])
{ $zeit_tmp=NULL; }
else
{ $zeit_tmp=$wert[5]; }
$zeit[]=$zeit_tmp;
}
mysql_close($connection);

$MyData = new pData();
$MyData->addPoints($aussentemperatur,”TempA”);
$MyData->addPoints($warmwasser,”TempW”);
$MyData->addPoints($speicher_unten,”TempS”);
$MyData->addPoints($kollektor,”TempK”);
$MyData->addPoints($vorlauf,”TempV”);
$MyData->addPoints($zeit,”Labels”);

$MyData->setSerieWeight(“TempA”,5);
$MyData->setSerieWeight(“TempS”,5);
$MyData->setSerieWeight(“TempW”,5);
$MyData->setSerieWeight(“TempK”,5);
$MyData->setSerieWeight(“TempV”,5);

$MyData->setSerieOnAxis (“TempA”, 0);
$MyData->setSerieOnAxis (“TempS”, 0);
$MyData->setSerieOnAxis (“TempK”, 0);
$MyData->setSerieOnAxis (“TempW”, 0);
$MyData->setSerieOnAxis (“TempK”, 0);
$MyData->setAxisName(0,”Temperatur”);

$MyData->setSerieDescription(“Labels”,”Uhrzeit”);
$MyData->setSerieDescription(“TempA”,”Aussentemperatur”);
$MyData->setSerieDescription(“TempS”,”Speicher”);
$MyData->setSerieDescription(“TempW”,”Warmwasser”);
$MyData->setSerieDescription(“TempK”,”Kollektor”);
$MyData->setSerieDescription(“TempV”,”Vorlauf”);
$MyData->setAbscissa(“Labels”);

$serieSettings = array(“R”=>0,”G”=>0,”B”=>200);
$MyData->setPalette(“TempA”,$serieSettings);
$serieSettings = array(“R”=>200,”G”=>0,”B”=>0);
$MyData->setPalette(“TempS”,$serieSettings);
$serieSettings = array(“R”=>0,”G”=>200,”B”=>0);
$MyData->setPalette(“TempW”,$serieSettings);
$serieSettings = array(“R”=>0,”G”=>100,”B”=>100);
$MyData->setPalette(“TempK”,$serieSettings);
$serieSettings = array(“R”=>100,”G”=>100,”B”=>100);
$MyData->setPalette(“TempV”,$serieSettings);

$myPicture = new pImage(1205,330,$MyData);
$myPicture->Antialias = FALSE;
$myPicture->drawRectangle(0,0,1204,329,array(“R”=>111,”G”=>143,”B”=>204));
$myPicture->setFontProperties(array(“FontName”=>”/var/www/heizung/fonts/verdana.ttf”,”FontSize”=>11));
$myPicture->drawText(200,35,”Temperaturen der letzten 3 Tage”,array(“FontSize”=>12,”Align”=>TEXT_ALIGN_BOTTOMMIDDLE));
$myPicture->setFontProperties(array(“FontName”=>”/var/www/heizung/fonts/verdana.ttf”,”FontSize”=>7));
$myPicture->setGraphArea(50,40,1155,300);
$labelSkip = floor(count($zeit)/48);
$scaleSettings = array(“XMargin”=>10,”YMargin”=>10,”Floating”=>TRUE,”GridR”=>180,”GridG”=>180,”GridB”=>180,”DrawSubTicks”=>FALSE,”CycleBackground”=>TRUE,”ScaleSpacing”=>10,”LabelSkip”=>$labelSkip,”DrawYLines”=>array(0));
$myPicture->drawScale($scaleSettings);
$myPicture->drawLegend(600,20,array(“Style”=>LEGEND_NOBORDER,”Mode”=>LEGEND_HORIZONTAL));
$myPicture->Antialias = FALSE;
$myPicture->setShadow(TRUE,array(“X”=>1,”Y”=>1,”R”=>0,”G”=>0,”B”=>0,”Alpha”=>10));
$myPicture->drawLineChart(array(“DisplayValues”=>FALSE,”DisplayColor”=>DISPLAY_AUTO));
$myPicture->Render(“/var/www/heizung/tmp/temperaturen.png”);
?>
[/cclN_php]

Hier noch eine Übersichtsseite verschiedener Durchschnittswerte. Diese werden direkt mit Aufruf der Seite generiert was entsprechend lange dauert. Diese Seite schaue ich aber nicht so oft an…

temp_details2

Viel Spaß mit dem Auslesen der Viessmann-Heizung!
Chris