Gaszähler auslesen mit Magnetometer HMC5883 und Raspberry Pi

Gaszähler mit Magnetometer HMC5883

In einem mittels Erdgas beheizten Haushalt hat der Gasverbrauch sehr großen Einfluss auf die Energiekosten. Im Zuge einer Reduzierung dieser Kosten ist die genaue Erfassung des Gasverbrauchs über verschiedene Zeiträume ein sinnvoller Einstiegspunkt, um Möglichkeiten zur Einsparung zu finden. Der Artikel beschreibt ein Verfahren zum Auslesen des vorhandenen Gaszählers mittels eines Magnetometers. Die Erfassung, Speicherung und Auswertung der Daten erledigt dabei ein Raspberry Pi.

Gaszähler

In vielen Haushalten befindet sich ein Gaszähler ähnlich dem oben abgebildeten Modell. Es ist für eine elektronische Erfassung des Gasverbrauchs vorbereitet. Dazu befindet sich auf dem rechten Zählring ein kleiner Magnet. Der Magnet rotiert mit dem Ring. Durch Auswertung des Magnetfeldes kann man somit die Umdrehungen des Zählrings erfassen und daraus den Gasverbrauch berechnen.

Ob ein Zähler mit einem solchen Magneten ausgerüstet ist, können Sie leicht mit einem Smartphone testen. Die meisten aktuellen Modelle besitzen ein eingebautes 3-Achsen Magnetometer zu Erfassung des Erdmagnetfeldes. Mittels einer Kompass-App oder einem Programm zum Auslesen der Sensorwerte wie zum Beispiel Sensor Kinetics lässt sich das Magnetfeld in der Nähe des Gaszählers erfassen. Ergeben sich bei einer durch den aktuellen Gasverbrauch bedingten Rotation des Zählrings signifikante Veränderungen im Magnetfeld, dann hat der Gaszähler mit hoher Wahrscheinlichkeit einen eingebauten Magneten.

Zur Erfassung der Rotation des Magneten zum Zwecke der ständigen Gasverbrauchsmessung gibt es mehrere Realisierungsmöglichkeiten:

  1. Verwendung eines kommerziellen Zusatzgerätes, das Energieversorger oder Zählerhersteller möglicherweise anbieten. Diese Geräte besitzen in der Regel einen Reed-Kontakt, der sich bei jeder Annäherung des Magneten schließt. Den Kontakt könnte man zum Beispiel mit der GPIO-Schnittstelle eines Raspberry Pi verbinden und so die Impulse zählen.
  2. Selbstbau auf der Basis eines Reed-Kontaktes.
  3. Eine kontaktlose Variante ist der Hall-Sensor. Er vermeidet das bei den mechanischen Reed-Kontakten oft auftretende Prellen und Kleben.
  4. Verwendung eines 3-Achsen Magnetometers, wie es in Smartphones zur Anwendung kommt.

Für einen Selbstbau nach Variante 2 oder 3 sprechen zunächst die geringen Anschaffungskosten eines Reed-Kontakts oder Hall-Sensors. Preise für die Einzelabnahme liegen bei 1 bis 3 €. Allerdings gibt es hier eine Vielzahl von Modellen, die sich in ihren Eigenschaften (Empfindlichkeit, Triggerwert und -hysterese) deutlich unterscheiden. Man muss wahrscheinlich mehrere unterschiedliche Typen ausprobieren und mit der Art der Befestigung am Zähler (Abstand und Winkel zum Zählmagnet) experimentieren.

Aus dieser Sicht erscheint die Verwendung eines 3-Achsen Magnetometers (Variante 4) attraktiv. Da es für die Messung des Erdmagnetfeldes konzipiert ist, sollte seine Empfindlichkeit zur Erfassung des Zählmagnetfeldes locker ausreichen. Im Gegensatz zu Reed-Kontakten und den meisten Hall-Sensoren besitzt es keinen eingebauten, festeingestellten Trigger, sondern überträgt den Absolutwert der gemessenen magnetischen Induktion per I²C Bus an den Computer. Dort kann man die Einstellung von Triggerschwellwert und -hysterese bequem in Software realisieren. Die Preise von 5 bis 20 € für 3-Achsen Magnetometer sind aufgrund ihrer massenhaften Verwendung in Smartphones mittlerweile durchaus akzeptabel.

3-Achsen Magnetometer HMC5883L

HMC5883L Breakout von Sparkfun
Abb. 1: HMC5883L Breakout von Sparkfun

Die Wahl fiel schließlich auf das 3-Achsen Magnetometer HMC5883L von Honeywell. Vor seinem Einsatz gilt es allerdings die Hürde zu nehmen, dass es nur in einem LPCC Surface-Mount Gehäuse vorliegt. Dessen Verarbeitung dürfte die meisten Hobbywerkstätten überfordern. Zum Glück haben sich Sparkfun und Adafruit des Problems angenommen und entsprechende Breakout-Boards im Angebot. Das Bild links zeigt das Modell von Sparkfun. In Deutschland vertreibt zum Beispiel Watterod das Sparkfun-Breakout.

Der Sensorschaltkreis ist für eine Betriebsspannung von 3.3 V ausgelegt. Da das Breakout-Board bereits die Pullup-Widerstände für den I²C Bus enthält, gestaltet sich die elektrische Verbindung mit der GPIO-Schnittstelle des Raspberry Pi sehr einfach und beschränkt sich auf das Verbinden von 3V3 Betriebsspannung, Masse sowie der SDA und SCL Anschlüsse des I²C Bus. Dazu verwendete ich ein vieradriges abgeschirmtes Kabel von etwa 1 Meter Länge. Somit hat man bei der Anbringung von Sensor und Raspberry Pi etwas Spielraum.

Raspberry Pi GPIO --- HMC5883L Breakout 
Pin Signal              Beschriftung
 1   3V3 --------------- VCC
 3   SDA --------------- SDA
 5   SCL --------------- SCL
 6   GND --------------- GND

Raspberry Pi und HMC5883

Der Raspberry Pi übernimmt die Ansteuerung des Sensors über den I²C Bus, die Speicherung der Messwerte in einer Datenbank und die Ausgabe der aktuellen und historischen Daten über ein Webinterface. Man kann sowohl Modell A als auch B verwenden. Da sich der Gaszähler in der Regel im Keller befindet, sollte man die Verwendung eines WLAN-USB-Sticks für die drahtlose Netzwerkanbindung vorsehen.

Als Betriebssystem kommt die Linux-Distribution Raspbian "wheezy" zum Einsatz. Sie erlaubt die einfache Installation der für das Projekt erforderlichen Software.

Als erstes sollte nun der Test der elektrischen und softwaretechnischen Kommunikation zwischen Computer und Sensor über den I²C Bus erfolgen. Die dazu notwendigen Kernelmodule sind Bestandteil des Betriebssystems. Ihre Aktivierung erfolgt durch Eintragen der Modulnamen in die Datei /etc/modules:

i2c-bcm2708
i2c-dev

In /etc/modprobe.d/raspi-blacklist.conf sind die entsprechenden blacklist Einträge zu löschen oder auszukommentieren:

#blacklist spi-bcm2708
#blacklist i2c-bcm2708

Neuere Versionen des Raspbian Betriebssystems ab Kernel 3.18 (Februar 2015) erfordern zusätzlich die Aktivierung des Devicetree Overlay für I²C. Am einfachsten erfolgt dies per

sudo raspi-config

Im Menü wählt man dann Advanced Options - I2C aus und bestätigt den Auswahldialog mit Yes.

Da das Datenerfassungsprogramm später unter Python laufen soll, installiert man jetzt auch gleich die erforderlichen Python-Module und Tools für die Arbeit mit dem I²C-Bus:

sudo apt-get install python-smbus i2c-tools

Damit für die weiteren Arbeiten nicht ständig Root-Rechte erforderlich sind, macht man den entsprechenden Benutzer (zum Beispiel den Standardbenutzer pi) zum Mitglied der Gruppe i2c:

sudo adduser pi i2c

Jetzt bootet man den Raspberry Pi mit angeschlossenem Magnetometer neu. Nach dem Einloggen lässt sich mittels i2cdetect überprüfen, ob Hard- und Software soweit funktionieren. Da der HMC5883 die I²C Adresse 1e (hex) hat, sollte die Ausgabe etwa folgendermaßen aussehen:

i2cdetect -y 1

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- 1e -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: -- -- -- -- -- -- -- --

Erste Tests: Messung der magnetischen Induktion

Das Magnetometer misst die magnetische Flussdichte oder Induktion B. Es handelt sich hierbei um eine gerichtete Vektorgröße. Ein 3-Achsen Magnetometer trägt dem Rechnung, indem es die Komponenten der Flussdichte Bx, By, Bz getrennt in x, y und z-Richtung des Raumes misst. Das Koordinatensystem ist auf dem Breakout-Board eingezeichnet (siehe Abb.1). Daraus berechnet sich der Betrag der magnetischen Flussdichte |B| mit:

| B | = B x 2 + B y 2 + B z 2

Die SI-Einheit für die magnetische Flussdichte ist das Tesla (T). In den Datenblättern von Magnetometern und Hall-Sensoren findet man dagegen meistens die Einheit Gauß (G). Es gilt: 1 T = 10000 G.

In einem ersten Versuch soll nun die Messung der Induktion mit Hilfe des HMC5883 erfolgen. Als Werkzeug zur Datenspeicherung und Visualisierung dient RRDtool, welches zunächst noch mit der Paketverwaltung zu installieren ist:

sudo apt-get install rrdtool python-rrdtool

Die in diesem Artikel besprochene Software steht als Git-Repository auf Github zur Verfügung. Dieses klont man per

git clone https://github.com/skaringa/hmc5883-gas-counter.git

in sein Home-Verzeichnis. Nun positioniert man das Magnetometer in der Nähe des Zählwerks des Gaszählers. Das im Test verwendete Modell hat an der Unterseite eine Aussparung, die sich dafür anbietet (siehe Artikelbild ganz oben links). Eine erste Testmessung zeichnet den zeitlichen Verlauf der magnetischen Induktion auf:

cd hmc5883-gas-counter/
./hmc5883_gas_counter.py --create --magnetometer

Der Parameter --create besorgt das Anlegen der Round Robin Datenbanken und --magnetometer weist das Programm an, die x-, y-, und z-Werte der magnetischen Induktion in der Datenbank mag.rrd zu speichern. Die hierfür interessanten Programmteile von hmc5883_gas_counter.py sind:

# Init HMC5883
write_byte(0, 0b01110000) # Rate: 8 samples @ 15Hz
write_byte(1, 0b11100000) # Sensor field range: 8.1 G
write_byte(2, 0b00000000) # Mode: Continuous sampling

while(1==1):
  # read data from HMC5883
  data = read_data()

  # get x,y,z values of magnetic induction
  bx = convert_sw(data, 3) # x
  by = convert_sw(data, 7) # y 
  bz = convert_sw(data, 5) # z

  # write values into mag rrd
  write_mag_rrd(bx, by, bz)

  time.sleep(1)

Die ersten drei Anweisungen konfigurieren den HMC5883 durch Schreiben seiner Steuerregister. Insbesondere kann man hier Samplerate und Empfindlichkeit einstellen sowie den Schaltkreis in einen Modus versetzen, in dem er kontinuierlich Daten erfasst und sendet. Genaue Informationen hierzu liefert das Datenblatt des HMC5883.

Diese Daten holt read_data im Block ab. Ein einzelner Messwert für Bx, By und Bz besteht aus jeweils zwei Byte im Zweierkomplement, wobei allerdings nur Werte im Bereich von -2048 bis 2047 gültig sind. Die Umwandlung in einen Integerwert erfolgt mittels convert_sw, anschließend schreibt write_mag_rrd die Messwerte in die Round Robin Datenbank mag.rrd.

Nachdem der Zähler bei laufender Heizung einige Runden absolviert hat, lohnt es sich, das Ergebnis zu visualisieren. Dazu öffnen Sie eine zweite Konsole, wechseln in das gleiche Verzeichnis wie oben und erstellen mit rrdtool graph eine Grafikdatei mit dem gemessenen Verlauf der Induktion:

rrdtool graph mag.gif -s 'now - 30 min' -e 'now' \
  DEF:bx=mag.rrd:bx:AVERAGE \
  DEF:by=mag.rrd:by:AVERAGE \
  DEF:bz=mag.rrd:bz:AVERAGE \
  CDEF:b=bx,bx,*,by,by,*,+,bz,bz,*,+,SQRT \
  LINE2:bx#FF0000:Bx \
  LINE2:by#00FF00:By \
  LINE2:bz#0000FF:Bz \
  LINE1:b#000000:B
Verlauf der magnetischen Induktion
Abb. 2: Zeitlicher Verlauf der magnetischen Induktion bei Rotation des Zählrings

Abb. 2 zeigt den gemessenen Verlauf der drei Raumkomponenten der magnetischen Induktion (rot, grün, blau) sowie den daraus berechneten Absolutbetrag (schwarz). Man erkennt deutlich die durch die Annäherung des Magneten an den Sensor verursachten Maxima.

Das Diagramm ist im Herbst entstanden, als es noch nicht so kalt war. Der Brennwertheizkessel feuert dann nicht ununterbrochen, sondern nur nach Bedarf. Offenbar hat er im Beobachtungszeitraum von einer halben Stunde dreimal für zwei Minuten gezündet und dabei jeweils 2 Umdrehungen (= 2 * 0.01 m³) Gas verbraucht. Dazwischen sind jeweils 7 Minuten Pause zu erkennen, in denen der Brenner aus war und nur die Umwälzpumpe das erwärmte Wasser durch den Heizungskreislauf gepumpt hat.

Bei einem derart eindeutigen Bild dürfte einer automatischen Auswertung nichts im Wege stehen. Ist der Verlauf dagegen nicht so deutlich ausgeprägt, dann ist die gemessene Induktion entweder zu schwach oder es kommt zu Übersteuerungen. Diese erkennt man auch durch das Auftreten des Wertes -4096, der eine ungültige Messung kennzeichnet. In beiden Fällen hilft das Experimentieren mit unterschiedlichen Sensorpositionen und eine Veränderung des Messempfindlichkeit. Sie kann man durch den in das Steuerregister 1 geschriebenen Wert einstellen.

Aufzeichnung von Zählerstand und Verbrauch

Mit dem aktuellen Projektstand ist der «technologische Durchstich» vollzogen. Das 3-Achsen Magnetometer ist in der Lage, den vom Zählmagneten erzeugten magnetischen Fluss zu erfassen und diese Messwerte landen letztendlich in einer Datenbank auf dem Raspberry Pi. Ziel des Projektes ist allerdings die Messung des Gasverbrauchs und nicht die Aufzeichnung des Magnetfeldes! Somit fehlt noch der letzte Schritt: Wie gelangt man von der gemessenen Induktion zu Zählerstand und Verbrauch?

Als erstes leitet man aus dem kontinuierlichen Verlauf der magnetischen Induktion einen Trigger ab, der jeweils bei Annäherung des Magneten an den Sensor anspricht und damit einer Umdrehung des Zählrings entspricht. Da letzterer auch längere Zeit in der Nähe des Sensors stehen bleiben kann, ist eine ausreichend große Hysterese nötig. Die konkreten Werte müssen Sie entsprechend Ihres konkreten Messaufbaus festlegen. Dabei hilft ein Blick auf eine Induktionsmessung wie in Abb. 2. Für meinen Zähler entnehme ich daraus die Werte 1000 für den Triggerpegel und eine Hysterese von ±100.

Der für die Triggerauswertung zuständige Programmcode sieht folgendermaßen aus:

# Trigger level and hysteresis
trigger_level = 1000
trigger_hyst = 100
trigger_step = 0.01

trigger_state = 0
while(1==1):
  # read data from HMC5883
  # ... (siehe oben)

  # compute the scalar magnetic induction
  # and check against the trigger level
  old_state = trigger_state
  b = math.sqrt(float(bx*bx) + float(by*by) + float(bz*bz))
  if b > trigger_level + trigger_hyst:
    trigger_state = 1
  elif b < trigger_level - trigger_hyst:
    trigger_state = 0
  if old_state == 0 and trigger_state == 1:
    # trigger active -> update count rrd
    counter += trigger_step
    update = "N:%f:%f" % (counter, trigger_step)
    #print update
    rrdtool.update(count_rrd, update)

  time.sleep(1)

Wenn der Trigger auslöst, erhöht sich der Zählerstand um 0.01. Das entspricht der beobachteten Situation an meinem Zähler: Eine Umdrehung des Magneten bedeutet einen Verbrauch von 0.01 m³ Gas. Wenn Ihr Zähler sich anders verhält, dann müssen Sie den Wert für trigger_step entsprechend anpassen.

Nachdem Sie die richtigen Werte für trigger_level, trigger_hyst und trigger_step in hmc5883_gas_counter.py eingetragen haben, muss ein Neustart erfolgen. Dabei schickt man das Programm am besten gleich in den Hintergrund, sodass es ein Ausloggen überlebt:

nohup ./hmc5883_gas_counter.py &

Das Programm schreibt bei einer Auslösung des Triggers den neuen Zählerstand und die seit dem letzten Trigger verbrauchte Gasmenge (also hier 0.01 m³) in die Round Robin Datenbank count.rrd. An dieser Stelle ist daher ein kurzer Blick auf die Definition dieser Datenbank angebracht (siehe hierzu auch rrdcreate):

rrdtool.create(count_rrd, 
  '--no-overwrite',
  '--step', '60',
  'DS:counter:GAUGE:86400:0:100000',
  'DS:consum:ABSOLUTE:86400:0:1',
  'RRA:LAST:0.5:1:4320',
  'RRA:AVERAGE:0.5:1:4320',
  'RRA:LAST:0.5:1440:30',
  'RRA:AVERAGE:0.5:1440:30',
  'RRA:LAST:0.5:10080:520',
  'RRA:AVERAGE:0.5:10080:520')

Die Datenbank enthält zwei Datenquellen (DS): counter für den aktuellen Zählerstand und consum für den Verbrauch pro Zeiteinheit. Als grundlegendes Datenerfassungsintervall sind 60 Sekunden festgelegt. Allerdings hebt man diese Werte nicht für alle Ewigkeiten auf, sondern nur für drei Tage. Das erledigt die Definition der ersten beiden Round Roubin Archive (RRA), die eine Anzahl von 4320 Werten (entspricht 3 Tagen * 24 Stunden * 60 Minuten) unverdünnt aufnehmen.

Die nächsten beiden RRAs konsolidieren jeweils 1440 Werte - das ist genau ein Tag - zu einem neuen Wert, der dann 30 Tage aufgehoben wird. Dafür sind zwei RRAs definiert, die sich in ihrer Konsolidierungsfunktion unterscheiden: Die Konsolidierung LAST benötigt man für den Zählerstand, denn hier interessiert ja in der Regel der letzte gemessene Wert. Anders beim Verbrauch - hier will man nicht den letzten Wert kurz vor Mitternacht, sondern den Tagesdurchschnitt wissen. Das übernimmt die Funktion AVERAGE.

Die letzten beiden RRAs besorgen die Berechnung und Speicherung von Wochenwerten (7 * 24 * 60 = 10080) über knapp 10 Jahre (520 Wochen). Selbstverständlich können Sie andere Festlegungen für Ihre Datenhaltung treffen und andere Parameter für die RRAs wählen. Das muss allerdings vor dem Anlegen der Datenbank passieren, spätere Änderungen sind kaum noch möglich!

Grafik

Mit rrdtool lassen sich ebenfalls ansprechende Grafiken erstellen. Dazu sollte die Datenerfassung natürlich erst einmal ein paar Stunden laufen. Dann kann man eine Grafik mit dem Verbrauchsverlauf der letzten 24 Stunden mit folgendem Kommando erzeugen:

rrdtool graph consum-ph.gif -s 'now - 1 day' -e 'now' \
  DEF:consum=count.rrd:consum:AVERAGE \
  CDEF:conph=consum,3600,* \
  LINE2:conph#00FF00:m³/h 

Die Definition DEF selektiert die Datenquelle consum und konsolidiert die Werte mittels Durchschnittsbildung. RRDtool speichert eine Verbrauchsrate immer in der Einheit pro Sekunde. Um auf den handlicheren Wert Kubikmeter pro Stunde zu kommen, bildet man eine zweite virtuelle Datenquelle conph durch Multiplikation jedes Wertes mit 3600. Diese wird dann als Linie LINE2 in die Grafik gezeichnet. Deren Dateinamen legt der zweite Parameter fest, die im Beispiel erzeugte GIF-Datei kann man mit jedem Bildbetrachter ansehen (Abb. 3):

Gasverbrauch über einen Tag
Abb. 3: Gasverbrauch im Verlauf von 24 Stunden. Man erkennt gut die Nachtabsenkung der Heizung.


Die Optionen -s und -e steuern den angezeigten Zeitraum. Um zum Beispiel den täglichen Verbrauch der letzten Woche anzuzeigen (siehe Abb. 4), ändert man das Kommando folgendermaßen ab:

rrdtool graph consum-pd.gif -s 'now - 1 week' -e 'now' \
  DEF:consum=count.rrd:consum:AVERAGE \
  CDEF:conpd=consum,3600,*,24,* \
  LINE2:conpd#00FF00:m³/d 
Gasverbrauch über einen Tag
Abb. 4: Gasverbrauch über eine Woche. Die Werte sind zum Tagesverbrauch konsolidiert.

Zählerstand

Der ebenfalls in der Datenbank erfasste Zählerstand lässt sich natürlich ebenso visualisieren. Man muss dementsprechend die Datenquelle counter und die Konsolidierungsfunktion LAST verwenden. Eine grafische Darstellung der Zählerstandes ist allerdings nicht so aussagekräftig wie die Verbrauchscharts.

RRDtool kann jederzeit den aktuellen in der Datenbank gespeicherten Zählerstand auf der Konsole ausgeben:

rrdtool lastupdate count.rrd

1415738426: 2741.200000 0.010000

Er stimmt allerdings höchstwahrscheinlich jetzt noch nicht mit dem mechanischen Zählwerk überein. Dazu sind weitere Maßnahmen erforderlich:

Die Aufsummierung des Zählerstandes erfolgt bei jedem durch den Zählmagneten ausgelösten Trigger in der Progammvariablen counter. Diese schreibt das Programm dann in die Datenbank. Beendet und startet man nun das Programm neu, dann liest es den letzten Stand von counter aus der Datenbank aus und initialisiert die Variable damit. So ist eine fortlaufende Zählung sichergestellt. Zuständig dafür ist die Funktion last_rrd_count().

Dieses Verhalten ist auch der Weg, um elektronischen und mechanischen Zähler zu synchronisieren: Man notiert sich hierzu den mechanischen Zählerstand (zum Beispiel 2707.32) und schreibt diesen möglichst zeitnah in die Datenbank:

rrdtool update count.rrd N:2707.32:0

Dann startet man sofort hmc5883_gas_counter.py neu. Es nimmt dann wie beschrieben den Wert aus der Datenbank als neuen Startwert und setzt damit die Zählung fort. Von Zeit zu Zeit sollten Sie dann mittels rrdtool lastupdate count.rrd überprüfen, ob beide Zähler noch synchron laufen.

Service im Intranet

Bisher muss man sich jedesmal auf dem Raspberry Pi einloggen, um Verbrauchsgrafiken zu erzeugen oder den Zählerstand abzufragen. Schicker wäre es, wenn diese Daten im Intranet zur Verfügung ständen und sich zum Beispiel mit dem Webbrowser des Smartphones anzeigen ließen. Dazu enthält das Git-Repository im Unterverzeichnis www eine vorbereite Lösung, die aus der HTML-Seite index.html besteht, die Grafiken und tabellarische Übersichten für verschiedene Zeiträume präsentiert. Für deren Erzeugung sind die beiden Perl-CGI-Scripte graph.pl und table.pl zuständig.

Um die Seite ins Intranet zu bringen, benötigt man - außer natürlich einer Netzwerkverbindung für den Raspberry - noch einen Webserver. Ein relativ leichtgewichtiger Vertreter ist lighttpd «lighty». Die Installation erfolgt durch:

sudo apt-get install librrds-perl lighttpd

Nun muss man lighttpd noch so konfigurieren, dass es Perl-CGI-Scripte ausführt. Dazu sind Rootrechte erforderlich, die per sudo -s zu erlangen sind. Dann schaltet man die Module cgi und userdir an:

sudo -s
lighty-enable-mod cgi
lighty-enable-mod userdir

Damit lighttpd Perl-Scripte mit der Extension .pl auch wirklich ausführt, ist jetzt noch die Datei /etc/lighttpd/conf-enabled/10-cgi.conf zu editieren. Im Block cgi.assign muss man das Kommentarzeichen vor der entsprechende Zeile entfernen:

cgi.assign      = (
        ".pl"  => "/usr/bin/perl"
)

Danach startet man den Server neu und verlässt den Superuser Modus wieder:

/etc/init.d/lighttpd restart
exit

Das Modul userdir bewirkt, dass lighttpd auch die HTML-Dateien und CGI-Scripte bereitsellt, die sich in den Home Directories der User unterhalb des Verzeichnisses public_html befinden. Somit können normale Benutzer wie pi Webseiten erstellen und editieren, Rootrechte sind dafür nicht erforderlich. Durch Anlegen eines symbolischen Links, der auf das erwähnte Verzeichnis www zeigt, bringt man nun lighttpd dazu, selbiges im Netz zu servieren:

cd
mkdir public_html
cd public_html
ln -s ../hmc5883-gas-counter/www/ gas

Ein Aufruf der Adresse http://localhost/~pi/gas/ zeigt nun die HTML-Seite im Browser an - falls Sie diesen Artikel auf dem Raspberry Pi lesen! Andernfalls ist natürlich localhost durch seinen Hostnamen oder seine IP-Adresse zu ersetzen.

Fazit

Ein nach dem beschriebenen Verfahren gebauter Prototyp funktioniert seit einigen Wochen hervorragend und hat schon wertvolle Erkenntnisse über die Funktion der Heizungsanlage und das persönliche Heizverhalten geliefert.

Der Energieversorger rechnet nicht die verbrannte Gasmenge in Kubikmetern, sondern den Energieverbrauch in Kilowattstunden ab. Zu diesem gelangt man durch Multiplikation des Gasverbrauchs mit einem Faktor, in den der Brennwert und die Zustandszahl des aktuell gelieferten Gases eingehen. Da sich die Gasqualität von Zeit zu Zeit ändert, ändert sich auch der Faktor. Für eine exakte Verbrauchsmessung müsste man daher den Umrechnungsfaktor täglich vom Energieversorger abfragen, mit in die Datenbank schreiben und bei der Berechnung berücksichtigen. In der Regel erfährt man den Faktor erst Monate später aus der Gasrechnung. Eine regelmäßige, automatisierte Abfrage, zum Beispiel über einen durch den Energieversorger bereitgestellten Webservice ist wohl noch Zukunftsmusik.