Analogen Stromzähler elektronisch auslesen

Johannes Kaufmann
Nikolai Kraler
Michael Liebert

Variante 1: Texterkennung

Mit einer am Gnublin angeschlossenen Webcam sollen in regelmäßigen Abständen Bilder gemacht werden, aus welchen dann der aktuelle Zählerstand ausgelesen werden soll. Die erhaltenen Informationen sollen auf einer kleinen Webseite dargestellt werden. Als Basis für weitere Nachforschungen haben wir einen Stromzähler im Keller bei nicht idealen Lichtbedingungen mit der Webcam fotografiert:

Abb. 1: Bildqualität wird zum Problem

Mit Hilfe der Open-Source OCR-Tools (Optical Character Recognition) tesseract und GOCR, haben wir versucht, den Text auszulesen.

tesseract strom.tif out.txt
cat out.txt
vE`ILUB.·g

Dieses schlechte Ergebnis ist, angesichts der eigentlich für einen Menschen recht gut lesbaren Ziffern, sehr überraschend. Als nächsten Schritt haben wir tesseract so konfiguriert, dass es nur Ziffern erkennt, womit die Anzahl an Möglichkeiten auf 10 (0-9) eingeschränkt wird. Seit der Version 3.0 von tesseract kann dies, mit Hilfe des Schlüsselworts “digits”, ganz einfach erreicht werden.

tesseract strom.tif out.txt nobatch digits
cat out.txt
5 777 5
8110523

Auch mit diesem Ergebnis können wir nicht wirklich zufrieden sein, weshalb wir es schließlich mit einem hoch auflösendem Bild eines Stromzählers versuchten:

Abb. 2: Hochauflösendes Bild

tesseract stromi.tif out.txt nobatch digits
cat out.txt
3 3 5 1 2 9

Da selbst bei diesem perfekten Bild eines Stromzählers die “2” nach dem Komma als “9” erkannt wird, haben wir erkannt, dass wir mit Hilfe von Texterkennung nicht weiter kommen.

Variante 2: Ferrariszähler-Drehscheibe beobachten

Abb. 3: Eine Ferrariszähler-Drehscheibe

Da die Texterkennung des aktuellen Zählerstandes nich t umsetzbar war, haben wir uns entsch lossen, die Ferrariszähler-Drehsch eibe mit Hilfe einer Lich tsch ranke zu beobach ten. Dabei entspricht jede Umdrehung der Ferraris-Zählersch eibe einem angegebenem Teil einer Kilowattstunde. In Abbildung 3 ist zu erkennen, dass 71 Umdrehungen einer KW/h entsprechen.

Den Durchlauf einer Umdrehung ermitteln wir mit Hilfe eines Phototransistors, welch er auf die unterschiedlich stark reflektierenden Farben der Zählerscheibe reagiert – Silber spiegelt besser als Rot. Da wir eine klassische Lichtschranke einsetzen steigt die Spannung, wenn die rote Markierung vorbeikommt – somit haben wir bei jeder Umdrehung einen kurzen Impuls.

Die folgende Grafik (siehe Abb.4) zeigt den Schaltplan einer Lichtschranke – D1 ist eine Infrarot-LED und T2 ein Phototransistor. Zur Vereinfachung der Schaltung, wurde in einem ersten Versuch auf den Transistor T2 verzichtet und die Messspannung direkt am zwischen R und T1 abgegriffen.

Abb. 4: Detektionsschaltung

Angeschlossen wird die Platine mit 3 Adern: Die Versorgungsspannung (+3,3 V) und Masse wird über die Anschlüsse 3,3V sowie GND am Gnublin-Board bereitgestellt. Als Mess-Eingang entschieden wir uns zuerst für den GPIO-Ansch luss IO11 und konfigurierten ihn wie im Gnublin-Wiki (http://wiki.gnublin.org/index.php/GPIO) beschrieben als Eingang. Wenn nun die InfrarotLED frontal auf den Fototransistor augerichtet wird und der Eingang mittels cat /sys/class/gpio/gpio11/value ausgelesen wird, erscheint eine 0 (keine Unterbrechung der Lichtschranke). Wenn die beiden Bauteile voneinander entfernt werden und value ausgelesen wird, wird eine 1 ausgegeben (Lichtschranke unterbrochen). Um den Wert des GPIO automatisch auszulesen, entschieden wir uns für die ressourcenschonende Variante mit Hilfe des System Calls poll und Interrupts. Dazu wird zuerst mittels echo „falling“ > /sys/class/gpio/gpio11/edge der Eingang so konfiguriert, dass bei fallender Flanke, also wenn die Lichtschranke unterbrochen wird, ein Interrupt ausgelöst wird. Der Sourcecode eines ebenfalls im Wiki unter GPIO abgelegten Tools, wurde von uns modifiziert (poll2.c), sodass es dauerhaft läuft und bei jedem Interrupt die aktuelle Uhrzeit und eine Zählervariable auf der Konsole ausgibt. Nun ist es an der Zeit, die Schaltung im vorgesehenen Zielumfeld zu testen. InfrarotLED und Fototransistor werden dazu mit Hilfe eines Pappkartons, in den zwei Löcher für die beiden Bauteile gebohrt sind, leicht schräg ausgerichtet direkt vor der Ferraris-Drehscheibe des Zählers montiert.

Abb. 5: Aufbau der Lichtschranke

Dadurch kann die Drehscheibe direkt als “Spiegel” verwendet werden. Nach Starten des Tools poll2 erfolgt das ernüchternde Ergebnis: auch nach 5 Minuten warten erscheint keine einzige Ausgabe auf dem Terminal. Offenbar ist die Spiegelung zu gering, sodass die Lichtschranke immer als unterbrochen angesehen wird. Da beim Digitaleingang wohl ein uns unbekannter Schwellwert im Treiber entscheidet, bei welch er Eingangsspannung zwischen 1 und 0 umgeschaltet wird, konnten wir hier erstmal nicht ohne weiteres fortfahren. Anstatt die Messleitung an den GPIO anzuschließen, entschieden wir uns testweise für das Verwenden des Analogeingangs GPA1. Da dort kein Polling mittels Interrupts möglich ist, schrieben wir ein kurzes Shell-Script, welch es in einer Dauerschleife gnublin-adcint -c 1 -b aufruft , um die aktuell anliegende Spannung in mV am GPA1 zu messen. Nach ersten Tests konnte ein Grenzwert (Variable THRESHOLD) festgelegt werden, unterhalb welchem “silber” und überhalb welchem “rot” angenommen werden soll.

Das shell-Script: adclog.sh

#!/bin/bash
LOG=adc.log
THRESHOLD=2700
VAL=0;
while true
do
 VAL=`gnublin-adcint -c 1 -b`
 if [ $VAL -gt $THRESHOLD ]
 then
 echo „$VAL $(date) !!!“ | tee -a $LOG
 echo „$VAL $(date)“ >> peaks.log
 else
 echo „$VAL $(date)“ | tee -a $LOG
 fi
done

Ausgabe von adclog.sh

2581 Sun Jun 23 15:41:05 UTC 2013
2581 Sun Jun 23 15:41:06 UTC 2013
2581 Sun Jun 23 15:41:06 UTC 2013
2581 Sun Jun 23 15:41:07 UTC 2013 !!!
2581 Sun Jun 23 15:41:07 UTC 2013 !!!
2581 Sun Jun 23 15:41:08 UTC 2013
2581 Sun Jun 23 15:41:09 UTC 2013
2581 Sun Jun 23 15:41:00 UTC 2013

Aktuellen Stromverbrauch berechnen und bereitstellen

Nachdem der Analogeingang als für das Vorhaben geeignet evaluiert wurde, ging es an die Implementierung von gnublin-ferraris. Diese in C++ geschriebene Anwendung läuft als Deamon auf dem GNUBLIN und liest in einstellbaren, periodischen Abständen die Spannung aus, die am Analogeingang anliegt. Basierend auf einem konfigurierten Schwellwert wird analog zu adclog.sh erkannt, wann die rote Markierung eine Runde im Zähler vollzogen hat. Aus Zählerkonstante und verstrichener Zeit wird mithilfe der Formel “3600 / Umdrehungen_pro_kWh / Sekunden_Umdrehung * 1000” der aktuelle Stromverbrauch in Watt berechnet.

Alle Informationen werden dann nach jeder Runde in der Datei /var/www/gnublin-ferraris.csv gespeichert, welche im Browser über http://gnublin-ip/gnublin-ferraris.csv abgerufen werden kann. Alternativ können die Informationen über eine auf Lesbarkeit optimierte Version unter http://gnublin-ip/cgi-bin/powermeter betrachtet werden – mehr Details zur Implementierung mittels cgi-bin im Kapitel Lighttpd mit CGI-Script. Der Sourcecode von gnublin-ferraris kann über Github bezogen werden und kann direkt auf dem GNUBLIN oder cross-kompiliert werden [1].

Web-Frontend: Node.js testen

Um stets die aktuellsten Stromzähler-Informationen über ein Web-Frontend bereitzustellen, wurde versucht, node.js auf dem GNUBLIN zum Laufen zu bekommen. Unter https://github.com/downloads/ant9000/FoxNode/nodejs-foxboard-debs.tar stehen bereits für ARM vorkompilierte nodejs-deb-Pakete bereit. Nachdem deren Abhängigkeit libc-ares2 mittels apt-get install nachinstalliert wurde, ließen sich die Pakete manuell mittels dpkg -i <paketname> installieren. Leider ließ sich ein kleines Beispiel-Projekt mit Web- und WebSocket-Server aufgrund der Fehlermeldung RangeError: Maximum call stack size exceeded nicht starten. Aufgrund dessen und bedingt durch die Tatsache, dass node eher zu ressourcenlastig für das GNUBLIN-Board ist, wurde fürs erste entschieden, das Web-Frontend mit Lighttpd und cgi-bin zu realisieren.

Lighttpd mit CGI-Script

CGI-Modul von lighttpd aktivieren:

lighty-enable-mod cgi

CGI-Config /etc/lighttpd/conf-enabled/10-cgi.conf wie folgt bearbeiten:

$HTTP[„url“] =~ „^/cgi-bin/“
{
 cgi.assign += ( „.py“ =>
„/usr/bin/python“ )
 cgi.assign += ( „“ => „“ )
}

Damit auch python-Scripte ausgeführt werden können, muss zusätzlich zu „“ => „“, die Endung .py mit dem python-Interpreter verbunden werden (Achtung: Reihenfolge beachten!):

„.py“ => „/usr/bin/python

Standardmäßig werden die cgi-Scripte in /usr/lib/cgi-bin/ abgelegt. Damit diese Scripte unter <server-ip>/cgi-bin/ erreichbar sind, muss zusätzlich in der lighttpd-Config /etc/lighttpd/lighttpd.conf ein Alias eingefügt werden:

alias.url += ( "/cgi-bin/" => "/usr/lib/cgi-bin/" )

Außerdem müssen die Endungen .sh und .py exkludiert werden:

static-file.exclude-extensions = ( ".php", ".pl", ".fcgi", ".sh", ".py",

Nachdem alles richtig Konfiguriert wurde muss lighttpd neugestartet bzw. die Konfiguration neu geladen werden:

service lighttpd restart/reload

Im cgi-bin/-Verzeichnis können nun beliebige CGI-Scripte geschrieben werden. Unser CGI-Script schrieben wir der Einfachheit halber als bash-Script powermeter. Das Script liest lediglich die wichtigsten Daten von einem, von unserem Backend erstellten, File und stellt diese einem Browser zur Verfügung. Damit das Script im Browser angezeigt wird, muss es noch ausführbar gemacht werden:

chmod +x powermeter

Die cgi-bin Datei powermeter (vgl-Abb.6)

#!/bin/bash
cat << EOF
Content-Type: text/html
<html>
<head>
<title>Powermeter</title>
<meta http-equiv="refresh" content="5">
</head>
<body>
<center>
<h1>Powermeter Stats</h1>
EOF
IN=$(head -n 1 /var/www/gnublin-ferraris.csv)
IFS=";" read -a ARR <<< "$IN"
echo "<table border=\"1\">"
echo "<tr><td>Current power consumption</td><td>${ARR[0]} W</td></tr>"
echo "<tr><td>Last cycle duration</td><td>${ARR[1]} s</td></tr>"
echo "<tr><td>Last cycle completed on</td><td>${ARR[2]}</tr>"
echo "<tr><td>Cycles per KWh</td><td>${ARR[3]}</td></tr>"
echo "</table>"
cat << EOF
</center>
</body>
</html>
EOF

Abb. 6: Ausgabe auf der Benutzeroberfläche

Links

[1] Sourcecode zu diesem Projekt https://github.com/michael-liebert/gnublin-ferraris