Heizungssteuerung
Temperaturmessung mit Linux DS9490R
Retroshare auf dem Raspberry Pi
BeagleBoard Digitalen Ausgang
Umstellung der Website von 960gs Grid auf Fluid 960 Grid
Temperaturmessung mit Linux
Pegelwandler 3,3Volt => 5Volt
Pegelwandler 1,8Volt => 5Volt
Diagramme mittels rrdtool
Ubuntu auf dem BeagleBoard
Continous Integration Ampel
Tamiya TT-01

Heizungssteuerung

Heizungs­steuerung mit Linux - Raspberry PI

Bei diesem Projekt handelt es sich um die Entwicklung einer Fußboden­heizungssteuerung mittels des Rapberry PI.

Zielsetzung

Eine in die Jahre gekommene, mittels einer durch PIC AT89 implementierten Heizungs­steuerung , sollte nach einem Jahrzehnt durch eine neue Variante ersetzt werden. Da die Hardware, sowie die Programmierung des PIC Mikrocontrolers in Assembler, recht aufwändig ist, wird bei der neuen Heizungssteuerung keine spezialisierte Hardware eingesetzt, sondern ein Single Board Computer (SBC) sowie die einfache Programmiersprache PHP verwendet. Sogenannte UnitTests stellen eine einwandfreie Funktion der Applikation sicher.

Die Anforderung an den Regelkreis sind recht simpel: Der Brenner einer Heizung soll über die Regelung ein- und ausgeschaltet werden. Ob der Brenner ein- oder ausgechaltet wird, hängt von den beiden Temperatursensoren (Außentemperatur und Temperatur des zurücklaufenden Wassers) ab. Die Pumpe die in dem Wasser­kreislauf für die Strömung sorgt, soll ebenso über die Regelung gesteuert werden und nur bei Bedarf laufen, was Strom spart. Ein Sommermodus stellt sicher, das die Pumpe auch wenn nicht geheizt wird, mindestens einmal am Tag für 10 Minuten läuft.

Benutzerinterface/Display

Für die Heizung wird ein 7 Zoll großes Touchscreen verwendet werden. Das UI basiert auf jQuery Mobile, um die Bedienung zu vereinfachen. Die Menüführung weist den folgenden Aufbau auf:

  • Statistiken
    • Temperaturverlauf/Verbrauch für diesen Tag
    • Temperaturverlauf/Verbrauch für diese Woche
    • Temperaturverlauf/Verbrauch für diesen Monat
    • Temperaturverlauf/Verbrauch für dieses Jahr
  • Systekonfiguration
    • Sollwertkurve Rücklauf
    • Pumpenkonfiguration
    • Nachtabsenkung
    • Temperaturfühler
Die aktuellen Informationen sind in einer Fußzeile auf jeder Seite abzulesen.

Entscheidung für den Raspberry Pi

Die Heizungs­steuerung direkt unter Linux zu implementieren, bietet viele Vorteile, da das Zurückgreifen auf ein komplettes Betriebssystem viele Vorzüge bereithält. Hierzu gehören der einfache Netzwerk­an­schluss für Wartung, die Möglich­keit Daten­banken für Temperatur­werte zu verwenden, sowie ein Touch­screen als Interface anzu­schließen. Frühere aufwändige Arbeiten, wie das Anschließen eines DCF Empfängers (Funkuhr) werden damit unnötig, da hier z.B. das NTP des Internets zur Zeitsynchronisierung der Heizungs­steuerung herangezogen werden kann.

Die Kosten für einen kompletten PC sind mittlerweile recht gering, besonders wenn es sich um SingleBoard PCs handelt. Der Aufbau mittels Standard PC Hardware ermöglicht, die Steuerung noch lange in Betrieb zu halten und auch in 10 Jahren noch auf Ersatzteile zurückgreifen zu können.

Bezug des Quellcodes

Der Quellcode steht unter der GPL-Lizenz, so dass die Steuerung nach Belieben für andere Zwecke angepasst werden kann.

Download eines fertigen Images

Alle nachfolgenden Texte beschreiben die komplette Installation der Heizungs­steuerung, die besonders unabdingbar sind, wenn die Steuerung für andere Zwecke eingesetzt werden soll. Ein fertiges Image der Steuerung als Download liegt alternativ ebenfalls bereit. Dies ist für den schnellen Einstieg, oder Linux- und PHP-Anfänger, eine gute Wahl.

  • 09.02.2014 Aktualisierung auf Revision 31 - Umzug der kompletten Steuerung in /home/pi/heating
  • 27.09.2014 Aktualisierung auf Revision 81 - Der Raspberry PI B+ wird nun untersstützt
Das Image ist auf Sourceforge verfügbar. Die Zugangsdaten für den SSH Login des fertigen Images lauten:
  • Benutzername "pi"
  • Password "raspheat"
Das Image startet die grafische Oberfläche nicht automatisch, da dafür der 512MB Raspi nötig ist. Mann kann diese dann selber aktivieren.

#Installation des kompleten Images (4GB Speicherkarte nötig)

# Wichtig! /dev/sdX durch die Laufwerksbezeichnung der angeschlossenen Speicherkarte ersetzen 
# (Liste kann mit "cat /proc/partitions" ermittelt werden)
# Der Vorgang dauert einige Minuten und erzeugt erst nach Fertigstellung eine Ausgabe
sudo su -
cat /proc/partitions
bunzip2 -dc dateiname_des_heruntergeladenen_images.img.bz2 | dd bs=1M of=/dev/sdX

Meldungen dieser Art "dd: »/dev/sdd“ wird geschrieben: Auf dem Gerät ist kein Speicherplatz mehr verfügbar", erfordern den Einsatz einer größeren Speicherkarte. Da nicht alle 4GB-Speicherkarten eine einheitliche Speicherkapazität aufweisen, empfiehlt sich die Verwendung einer 8GB-Karte.

Grundlagen für die Heizungssteuerung

Einige der verwendeten Tools/Bauteile/Software sind in den folgend aufgeführten Artikeln teilweise ausführlicher beschrieben. Diese zu lesen ist nicht unbedingt erforderlich, sie können aber in Problemfällen hinzugezogen werden.

Hardwaresteuerung

Bei der Hardware handelt es sich um die externe Beschaltung (Platine), welche die Schnittstelle zwischen dem Raspberry Pi und der Heizung darstellt. Die Platine ist über ein Flachbandkabel und einen Stecker mit dem Raspberry Pi verbunden. Der Raspberry Pi wird durch die Verwendung von Relais galvanisch getrennt. Über diese digitalen Ausgänge sollten Schütze angesprochen werden, welche z.B. den Anlaufstrom der Pumpen verkraften.

Die Platine besitzt drei digitale Ausgänge, von denen zwei benötigt werden. Über das Ausgangsrelais eins werden die Pumpen angessteuert, über das zweite Relais wird der Brenner eingesschaltet.

Aufbau der externen Beschaltung am GPIO Port Das Fertigen zweier Platinen ist für unter 20€ möglich. Um sich die Platine herstellen zu lassen, kann die layout.brd - Datei für den Ätzservice an einen Platinenbelichter gesendet werden, beispielsweise an den Service von Platinenbelichter.de.

Layout der Platine

Raspberry Pi mit über GPIO geschalteten LEDs Wichtig: Pin 1 ist der PIN auf der Seite der LED, welcher über das Flachbandkabel mit PIN 1 des Raspberry PI verbunden werden muss.

Software

Als Basissystem wird auf dem Raspberry Pi Raspbian, eine Debian Variante, verwendet. Die Laufzeitumgebung ist eine typische LAMP Umgebung, bestehend aus dem Apache Webserver, Mysql Datenbank, und PHP als Programmiersprache. Dies alles kann problemlos auf einer 4GB großen SD-Speicherkarte abgelegt werden.

Basissystem einrichten

Nun folgt die Einrichtung des Betriebssystems. Die einzelnen Schritte auf der Console können direkt unter Linux ausgeführt werden. An Stellen, an denen eventuelle Anpassungen vorgenommen werden müssen, erscheint ein entsprechender Vermerk.

wget "http://downloads.raspberrypi.org/raspbian_latest"
unzip raspbian_latest
# Ergebnis ist ein Image, mit einem Dateinamen ähnlich wie: 2014-01-07-wheezy-raspbian.img
# Wichtig! /dev/sdX durch die Laufwerksbezeichnung der Speicherkarte ersetzen 
# (Liste der Speicherlaufwerke kann mit "cat /proc/partitions" angezeigt werden)
# Der folgende Vorgang dauert einige Minuten und erzeugt erst eine Ausgabe, wenn er fertig ist.
sudo dd bs=1024k if=2014-01-07-wheezy-raspbian.img of=/dev/sdX

Nun wird die erstellte SD-Karte in den Raspberry eingesteckt. Der Raspberry Pi verbindet sich mit dem Netzwerk und bootet. Der Raspberry PI erhält dann über DHCP, z.B. von einer FritzBox, eine IP für das lokale Netzwerk. Der Netzwerkname ist mit "raspberrypi" voreingestellt. Das initial Passwort von Rasbian ist "raspberry", der SSH Benutzer ist "pi".

# Auf den Raspberry über das Netzwerk verbinden, und 
# mit dem Benutzer "raspberry" und dem Passwort "pi" anmelden
ssh -lpi raspberrypi
# Initiale konfiguration
sudo raspi-config
# Einmal "Expand Filesystem" aufrufen und einmal "Internationalisation Options", dort unter "Change Locale" de_DE.UTF-8 UTF-8 
# stellen. Danach nochmal "Internationalisation Options" und dann "Change Timezone" auf "Europe/Berlin"  stellen.
# Danach das Passwort ändern "Change User Password". (Im verfügbaren fertigen Image wurde dies auf 'raspheat' gestellt). 
# Dann im Hauptmenü Advanced Options - Hostname den Namen des Systems auf "heating" setzen.
# 
# Danach "Finish" und den Raspberry einmal neustarten lassen.
# Erneut auf den Raspberry via Netzwerk verbinden 
ssh -lpi heating
sudo rpi-update

sudo apt-get update; sudo apt-get upgrade
sudo apt-get install mc rrdtool owfs-fuse
# Mit der Mysql Installation wird das mysql root passwort vergeben ('raspheat' habe ich genommen, bei mir im Image)
sudo apt-get install mysql-server-5.5 
# als server für phpmyadmin den apache2 wählen. konfiguration phpmyadmin mit dbconfig-common
# Im Image wurde erneut das Passwort raspheat vergeben
sudo apt-get install htop apache2 libapache2-mod-php5 phpmyadmin php-pear php-apc secure-delete
# Ist riesengroß und wird nicht gebraucht
sudo apt-get purge wolfram-engine libatlas3-base

Der Apache Webserver und phpmyadmin sind ab diesem Zeitpunkt verfügbar. Die Zugangsdaten für den phpmyadmin sind der Benutzer "root" und das Passwort "raspheat".

Temperatursensoren vorbereiten

Die Sensoren werden mittels owfs ausgelsen. Hierzu gibt es einen eigenen Artikel, Temperaturmessung mit Linux mittels DS9490R-USB, welcher ausführlich auf die Details eingeht. Der USB-Adapter und der Temperaturfühler sind vorab anzuschließen.

sudo mkdir /media/1-wire
sudo owfs --allow_other -u /media/1-wire
ls -lah /media/1-wire/
cat /media/1-wire/*/temperature

Eine Meldung, ähnlich dem folgenden Beispiel, erscheint. Ausgabe des Temperaturfühlers
Im vorliegenden Beispiel ist lediglich ein Sensor angeschlossen, welcher gerade 28.875° misst. Es gibt auch Sensoren die stets ausgelesen werden, unabhängig davon ob ein Temperaturfühler angeschlossen ist. Dieser Sensor der möglicherweise eingebaut ist, liefert immer unterschiedliche Temperaturen. Dieser ist zu ignorieren.

Hier ein Beispiel für den Raspberry Pi mit einem DS1820 Temperaturfühler sowie dem DS9490R USB Adapter: Raspi mit Temperaturfühler via DS9490R

Quellcode der Heizungssteuerung über das SVN Repository auschecken

Um die eingerichteten Temperaturfühler sinnvoll zu verwenden, wird nur der Quellcode des Projektes aus einem SVN Repository geladen.

sudo apt-get install subversion
cd ~
mkdir heating
cd heating

# Wenn nur lesend auf das Project heatingcontrol zugegriffen werden soll:
svn checkout svn://svn.code.sf.net/p/heatingcontrol/code/trunk heatingcontrol-code

# Wenn auch schreibender Zugriff auf das Projekt gewünscht ist (Sourceforge Account vorausgesetzt):
svn checkout --username=euer_sourceforge_name svn+ssh://notdefine@svn.code.sf.net/p/heatingcontrol/code/trunk heatingcontrol-code

Konfiguration des Apache Webservers

Im Folgenden ist der Inhalt der Datei "/etc/apache2/sites-available/default" dargestellt. Dieser Inhalt kann z.B mittels des Befehls "sudo mcedit /etc/apache2/sites-available/default" angepasst werden, nachdem eine Verbindung mit dem Raspberry via SSH aufgebaut wurde. Nachdem diese Anpassungen gemacht worden sind, verweist die Oberfläche http://heating schon auf den gerade geladenen PHP Quellcode.

<VirtualHost *:80>
    ServerAdmin webmaster@localhost

    DocumentRoot /home/pi/heating/www
    <Directory />
            Options FollowSymLinks
            AllowOverride None
    </Directory>
    <Directory /home/pi/heating/www/>
            Options Indexes FollowSymLinks MultiViews
            AllowOverride None
            Order allow,deny
            allow from all
    </Directory>

    ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
    <Directory "/usr/lib/cgi-bin">
            AllowOverride None
            Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
            Order allow,deny
            Allow from all
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/error.log

    # Possible values include: debug, info, notice, warn, error, crit,
    # alert, emerg.
    LogLevel warn

    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Der Apache Webserver benötigt auf das temp Verzeichnis schreibenden Zugriff:

cd ~/heating/www/common/temp
chmod 777 * -R .

Datenbank und Tabellen einrichten

Im Folgenden wird eine Verbindung zur Mysql Datenbank als root aufgebaut und danach ein Datenbankbenutzer inklusive Datenbank und dessen Tabellen angelegt.

mysql --user=root mysql --password

Folgender Befehl ist nun auszuführen:

CREATE DATABASE `heating` DEFAULT CHARACTER SET utf8 COLLATE utf8_bin;
CREATE USER 'pi'@'localhost' IDENTIFIED BY 'raspheat';

GRANT SELECT , INSERT , UPDATE , DELETE , CREATE , DROP , FILE ,
INDEX , ALTER , CREATE TEMPORARY TABLES , CREATE VIEW , EVENT,
TRIGGER, SHOW VIEW , CREATE ROUTINE, ALTER ROUTINE,
EXECUTE ON * . * TO 'pi'@'localhost' IDENTIFIED BY 'raspheat' WITH MAX_QUERIES_PER_HOUR 0 MAX_CONNECTIONS_PER_HOUR 0 MAX_UPDATES_PER_HOUR 0 MAX_USER_CONNECTIONS 0 ;

GRANT ALL PRIVILEGES ON `pi\_%` . * TO 'pi'@'localhost';

USE heating;

SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";
SET time_zone = "+00:00";

CREATE TABLE IF NOT EXISTS `desired_values` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `outside_temp` int(11) NOT NULL,
  `return_flow_temp` float NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `outside_temp` (`outside_temp`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='Ruecklauftemperatur in abhaengigkeit der aussentemperatur.' AUTO_INCREMENT=61 ;

INSERT INTO `desired_values` (`id`, `outside_temp`, `return_flow_temp`) VALUES
(1, -35, 36), (2, -34, 36), (3, -33, 36), (4, -32, 36), (5, -31, 36), (6, -30, 36), (7, -29, 36), (8, -28, 36), (9, -27, 36), (10, -26, 36), (11, -25, 36), 
(12, -24, 36), (13, -23, 36), (14, -22, 36), (15, -21, 36), (16, -20, 36), (17, -19, 36), (18, -18, 36), (19, -17, 36), (20, -16, 36), (21, -15, 36), (22, -14, 36), 
(23, -13, 36), (24, -12, 36), (25, -11, 36), (26, -10, 36), (27, -9, 36), (28, -8, 36), (29, -7, 36), (30, -6, 36), (31, -5, 36), (32, -4, 36), (33, -3, 35), 
(34, -2, 34), (35, -1, 32), (36, 0, 32), (37, 1, 32), (38, 2, 32), (39, 3, 32), (40, 4, 32), (41, 5, 31), (42, 6, 30), (43, 7, 30), (44, 8, 29), (45, 9, 29), 
(46, 10, 28), (47, 11, 28), (48, 12, 27), (49, 13, 27), (50, 14, 26), (51, 15, 26), (52, 16, 26), (53, 17, 25), (54, 18, 25), (55, 19, 25), (56, 20, 25), 
(57, 21, 11), (58, 22, 11), (59, 23, 11), (60, 24, 11);


CREATE TABLE IF NOT EXISTS `sensor_values` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(100) COLLATE utf8_bin NOT NULL,
  `value` float NOT NULL,
  `unit` varchar(100) COLLATE utf8_bin NOT NULL,
  `timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  KEY `name` (`name`),
  KEY `timestamp` (`timestamp`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=2657335 ;

CREATE TABLE IF NOT EXISTS `settings` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8_bin NOT NULL,
  `unit` varchar(255) COLLATE utf8_bin NOT NULL,
  `value` text COLLATE utf8_bin NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `name` (`name`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 COLLATE=utf8_bin AUTO_INCREMENT=6 ;

INSERT INTO `settings` (`id`, `name`, `unit`, `value`) VALUES
(1, 'heater', 'bool', '1'),
(2, 'pump_follow_up_time', 'minutes', '45'), (3, 'slider_nighly_temperature_sink_substract', 'celsius', '13'),
(4, 'slider_nighly_temperature_sink_to', 'hour', '23'), (5, 'slider_nighly_temperature_sink_from', 'hour', '6');

quit

Cronjobs konfigurieren

Die Heizungssteuerung muss automatisch jede Minute aktiv werden, um die Temperaturen zu erfassen und ggf. einzugreifen. Zudem werden Diagramme in einem regelmäßigen Turnus generiert. Dafür wird das auf Linux-Systemen verfügbare Cronjobmanagement verwendet. Folgend eine Liste der Cronjobs und deren Aufgaben:

  • Cleanup - Beschränkt die in der Datenbank abgelegten gemessenen Werte und löscht Altdaten.
  • Temperatur eintragen - Misst aktuelle Temperaturwerte und trägt diese in die Datenbank ein.
  • Graphen erstellen - Erstellt mittels RRDTool die verschiedenen Temperaturgraphen (für den aktuellen Tag, für die Woche, usw.).
Die genauen Funktionen können im SVN Quellcode angesehen werden.

Die Cronjobs des Benutzer pi kann man sich mit folgendem Befehl anzeigen lassen "crontab -l". Bearbeitet werden diese Cronjobs mit dem Befehl "crontab -e". Um diese Cronjobs nun auf den Raspberry zu übernehmen, müssen folgende Einträge (mittels "crontab -e") ergänzt werden:

0   2 * * *  cd /home/pi && ./heating/cleanup.sh

*   * * * *  cd /home/pi && ./heating/insert_new_temp.sh >> /dev/null
*/5 * * * *  cd /home/pi && ./heating/create_graph_quick.sh >> /dev/null
5 */2 * * *  cd /home/pi && ./heating/create_graph_slow.sh >> /dev/null

Ob die Cronjobs auch aufgerufen werden, kann mit dem Befehl "tail -f /var/log/syslog" geprüft werden. Diese Logdatei zeigt jede Ausführung eines Cronjobs an.

RRD Tool auf Jahres/Wochen und Tagesstatistiken vorbereiten

Um die gemessenen Werte grafisch darzustellen wird das bekannte RRDTool verwendet (siehe Verwendung von RRDTool).

Die Datenbank der Temperaturwerte wird so eingerichtet, dass diese die Temperaturwerte der letzten zwei Jahre beinhaltet. Die gemessenen Werte werden alle zwei Minuten eingetragen (120*24*365*2=525600 Anzahl der zu speichernden Temperatur­werte für den Zeitraum von zwei Jahren). Das Skript 'init_rrdtool.sh' legt die dafür nötige RRDTool Datenbank an.

cd heating/jobs
./init_rrdtool_db.sh

Angeschlossenene Sensoren zuweisen

Eine Liste aller Sensoren erhält man mit folgendem Befehlen:

cd heating/jobs
./list_sensors.sh

Dies sollte eine Liste wie diese hier anzeigen. Hiermit kann man bestimmen welcher Sensor welche Temperatur misst:

/media/1-wire/05.4AEC29CDBAAB Sensortyp: DS2405
/media/1-wire/10.49EE82020800 Sensortyp: DS18S20 Temperatur:       22.125
/media/1-wire/10.49EE83020800 Sensortyp: DS18S20 Temperatur:       32.125
/media/1-wire/10.49EE83020900 Sensortyp: DS18S20 Temperatur:        4.125
/media/1-wire/10.67C6697351FF Sensortyp: DS18S20 Temperatur:      63.5712
/media/1-wire/81.323132000000 Sensortyp: DS1420

Die einzelnen Sensoren weißt man (leider etwas unkomfortabel) direkt im Cronjob zu. Hierzu bearbeitet man die insert_new_temp.sh Datei mittels "mcedit ~/heating/jobs/insert_new_temp.sh".

Tests einrichten

Um die Steuerungssoftware automatisiert zu testen, wird PHPUnit verwende. Die Einrichtung ist für den Betrieb der Steuerung optional, aber für professionelle Softwareentwicklung unverzichtbar, besonders wenn Modifikationen an der Software gemacht werden sollen.

sudo apt-get install phpunit

Unleserliche xdebug "var_dump()" Befehle können, durch den Eintrag der Konfigurationsvariablen 'xdebug.overload_var_dump=0' in die PHP Serverkonfigurationsdatei '/etc/php5/apache2/php.ini', abgechaltet werden. Die Tests (phpunit) werden mittels folgenden Befehlen ausgeführt:

cd ~/heating/tests
phpunit

GPIO Schnittstellenports vorbereiten

Um die externe Beschaltung auf der Platine ansprechen zu können, müssen die GPIO Ports eingerichtet werden. Damit ohne Superuserrechte auf die GPIO Ports zugegriffen werden kann (InterfaceGpio.class.php), sind zwei Schritte erforderlich:

  1. Den Benutzer "www-data "in die Gruppe "gpio" eintragen.
  2. Die "/etc/rc.local" anpassen.

sudo usermod -aG gpio www-data

Es muss folgender Code in die /etc/rc.local eingetragen werden:

# Print the IP address
_IP=$(hostname -I) || true
if [ "$_IP" ]; then
  printf "My IP address is %s\n" "$_IP"
fi

/home/pi/heating/jobs/init_boot.sh

# wird später im Artikel beschreiben
unclutter&

exit 0

Fertig - Glücklich sein!

Die Steuerung ist nun komplett eingerichtet, und kann an die Heizung angeschlossen werden. Diese ist bei mir seit einem Jahr ohne Ausfall in Betrieb. Ich wünsche viel Erfolg, und fröhliches Basteln! Im folgenden Kapitel wird die Heizungssteuerung noch um ein Touchscreen erweitert, damit man zum programmieren keinen extra PC mehr braucht, aber das ist optional.

Touch Display für Raspberry PI

Hardware

Vorraussetzung dafür ist ein Raspberry PI mit 512 MB Speicher!
Als Display kommt ein 7" Tochscreen von Pollin zum Einsatz. Dieses kostet ~50 Euro. Ich habe mich dazu entschieden das Display mit Elektronik Schema der Heizungs­steuerung in ein einzelnes Gehäuse, getrennt von der Heizungssteuerung zu packen. Das erleichtert die Wartung, außerdem kann man es dann auch später vllt. gegen ein größeres Display tauschen. Als erstes habe ich das Display auf ein passendes Gehäuse aufgeklebt. Das Display wird mit 9-18Volt betrieben und benötigt bei 12Volt ungefähr 400 mA. Schema der Heizungs­steuerung Schema der Heizungs­steuerung Schema der Heizungs­steuerung Schema der Heizungs­steuerung Schema der Heizungs­steuerung

Software

Da das Display fehlerhafte EDID zurückgibt, muss die Auflösung manuell konfiguriert werden. Dazu muss die /boot/config.txt Datei angepasst werden, welches ich aus folgenden Artikel zum einrichten des Displays entnommen habe. Die in diesem Artikel erwähnten Kernel kompilierung ist nicht nötig.

# Datei mit "sudo mcedit /boot/config.txt" bearbeiten, und folgende Einträge hinzufügen
framebuffer_width=1024
framebuffer_height=600
hdmi_force_hotplug=1
hdmi_cvt=1024 600 60 3 0 0 0
hdmi_group=2
hdmi_mode=87

Nach einem Neustart (sudo reboot) ist die Console nun auch lesbar.

Die grafische Oberfläche ist mit "startx" startbar, und funktioniert auch schon mal recht gut. Gestartet wird die lxde Arbeitsfläche. STRG+ESC ruft das LXPanel (Start-Knopf) auf, was vor einer Kalibrierung des Touchscreens vllt. nicht aufrufbar ist. Allerdings muss das Touchscreen noch kalibriert werden. Dazu öffnet man auf der grafischen Oberfläche das LXTerminal, und installiert mit folgendem Befehl die notwendigen Pakete.

sudo apt-get install libx11-dev libxext-dev libxi-dev x11proto-input-dev

Das Kalibrierungstool muss heruntergeladen und compiliert werden

sudo mkdir /etc/X11/xorg.conf.d
wget http://github.com/downloads/tias/xinput_calibrator/xinput_calibrator-0.7.5.tar.gz
tar -xvzf xinput_calibrator-0.7.5.tar.gz
cd xinput_calibrator-0.7.5
./configure
make
./src/xinput_calibrator

Die Ausgabe des Tools nach erfolgreichem Aufruf muss dann in die /etc/X11/xorg.conf.d/99-calibration.conf eingetragen werden. Bspl. mittels "sudo mcedit /etc/X11/xorg.conf.d/99-calibration.conf". Beispielkonfiguration bei meinem Display:

#cat /etc/X11/xorg.conf.d/99-calibration.conf 
Section "InputClass"
  Identifier "calibration"
  MatchProduct "eGalax Inc. Touch"
  Option "Calibration" "35 1991 87 1961"
EndSection

"unclutter" ist ein kleines tool mit dem man den Mauszeiger der grafischen Oberfläche ausblenden kann. Das Tool ist zu installieren, und dann in die rc.local einzutragen (wurde schon weiter oben im Artikel gemacht).

sudo apt-get install unclutter

Browser midori automatisch starten

cd ~
mkdir .config/autostart
cd .config/autostart
mcedit browser_heizung.desktop
#Folgende drei Zeilen eintragen und speichern
[Desktop Entry] 
Type=Application
Exec=/usr/bin/midori -e Fullscreen -a http://localhost

Grafische Oberfläche automatisch starten

  • sudo raspi-config
  • Wähle: Enable Boot to Desktop/Scratch
  • Wähle: Desktop login as user 'pi' at the graphical desktop

Internen Watchdog verwenden

Der Raspberry PI verfügt über einen Hardware Watchdog. Die Funktion ist, das ein bestimmtes Signal an den Watchdog mindestens einmal pro Minute gesendet werden muss. Falls das nicht passiert, startet dieser den Raspberry neu.
Um diesen zu verwenden gibt es einen Watchdog Modul und einen Service, der die Anwendung verweinfacht.

sudo modprobe bcm2708_wdog
echo "bcm2708_wdog" | sudo tee -a /etc/modules
sudo apt-get install watchdog

Der Watchdog muss noch konfiguriert werden, indem die Datei /etc/watchdog.conf bearbeitet wird.

watchdog-device        = /dev/watchdog
max-load-1 = 24

# Hier schreibt der Cron jede minuten den gelesenen Fühlerwert rein
# mehr als 15minuten keine änderung, dann reboot
file = /home/pi/.last_value_read
change = 1000 
sudo /etc/init.d/watchdog start
sudo update-rc.d watchdog defaults

Notiz: Backup der Steuerung erstellen und Wiederherstellen

Speicherplatz nullen auf dem Raspberry, vor Erstellen des Images:

# secure delete installieren, für sfill
sudo apt-get install secure-delete
# Heruntergeladene Pakete löschen
sudo apt-get clean

sudo rm /var/log/*.gz
sudo rm /var/log/*.1
sudo rm /var/log/apache2/*.gz
sudo rm /var/log/apache2/*.1

cd ~
# Freien Speicherplatz mit "0" überscrheiben, dasmit das Image kleiner gepackt werden kann
sfill -ll -f -z .

Image der SD Karte erstellen und Wiederherstellen:

# Backup erstellen
sudo dd bs=1M if=/dev/sdd of=heating_control_2014_09_27_r81.img
# Backup wieder herstellen
sudo dd bs=1M if=heating_control_2014_09_27_r81.img of=/dev/sdd

Externe Quellen

Last Change: 28-Sep-2014 18:48

Kontakt und Infos zur Person: Thomas Eimers