Evaluations-Platine für Heimautomatisierung

Wechseln zu: Navigation, Suche

von Thomas Gauweiler

Dieser Artikel nimmt am Artikelwettbewerb 2012/2013 teil.

Das Projekt befasst sich mit einem Evaluationsboard für verschiedene Aspekte der Heimautomatisierung.

Es zeigt dabei das Zusammenspiel verschiedener Sensoren, die mit Hilfe eines Arduinos mit einem Rechner verbunden sind.

Es enthält Taster, Leds und Anschlüsse zu einer Relaisplatine, Temperatur und Feuchtigkeitssensor bis hin zu den Elementen einer Ir- oder Funkfernsteuerung. Umgesetzt ist es auf einer kleinen Streifenrasterplatine und erspart damit die Fertigung einer Pcb-Platine.

Die Platine ist mit Hilfe von fritzing entwickelt und dokumentiert. Für die Homeautomatisierung läuftt openHAB auf einem Kleinrechner wie Dockstar, Guruplug oder Raspberry Pi.

Eines gleich vorweg: Es ist nur eine Evaluierungsplatine. D.h. man kann verschiedene Sensoren ausprobieren, ob und wie sie funktionieren. Damit kommt man auf Ideen für sein eigenes Heim. Man wird jedoch nicht alles auf einmal in Betrieb nehmen können. Spätestens wenn man die Bibliothek für das Ethernet mit einbindet, wird der Sketch für den Programmspeicher des Arduinos mit allem drum und dran eh zu gross. Für Ethernet mit ein oder zwei Sensoren oder zusammen mit der Funksteuerung einer Schaltdose klappt es jedoch prima.


Fritzing zur Entwicklung einer Schaltung auf einer Rasterplatine

In der Ansicht vom Schaltplan werden die Bauelemente miteinander verbunden. In der Pcb-Ansicht stellen die Leitungen der Unterseite die Kupferstreifen dar. Die Trennstellen sind mit I markiert, können dabei zwischen oder entlang der Löcher befinden und sich über mehrere Bahnen erstrecken. Da sie in dem fertigen Layout gerne übersehen werden, sind sie ein 2. Mal darunter dargestellt. Ferner liegt dabei die Platine auf der Rückseite.

Der Vorteil einer Planung mit einem PCB-Tool wie fritzing ist, dass man die Korrektheit der Verdrahtung prüfen kann. Zudem lassen sich beim Design der Platine auch die Bausteine noch drehen oder verschieben. Insgesamt erhöht sich dabei die Dichte, was wiederum zu einer komplizierteren Platine führt. Aber die kann mehr und erhöht damit den Spassfaktor.

Der Aufbau

Kommen wir zum praktischen Teil: dem Aufbau der Platine

Screenshot des Entwurfs. Ausdrucken und zum Anzeichnen der Trennstellen und Einlöten der Bauelemente verwenden

Die Bilder sollen das Vorgehen illustrieren. Sie sind aber meist in kleinen Details von der Endversion verschieden. Massgebend ist der Entwurf in der Fritzing-Datei und dessen Screenshot (siehe rechts), in der die Korrekturen schon eingearbeitet sind. Ansonsten hat man natürlich auch kleine Freiheiten, in dem ein Bauteil entlang einer nicht unterbrochenen Bahn verschoben ist.

Liste der Bauelemente

Diese Liste umfasst nur die Elemente, die fest aufgelötet werden.

  • Leiterplatine mit mindestens 19 Reihen zu je 35 Löchern (50x90 mm)
  • 1 Widerstand 220 Ohm
  • 4 Widerstände 330 Ohm
  • 1 Widerstand 390 Ohm
  • 3 Widerstände 1,5k Ohm
  • 1 Widerstand 2,2k Ohm
  • 1 Widerstand 3,3k Ohm
  • 2 Widerstände 4,7k Ohm
  • 2 Widerstände 10k Ohm
  • 4 Taster
  • 4 Kondensatoren 100 nF
  • 1 Elko 2,2 uF
  • 3 LEDs in rot, gelb, grün
  • 1 IR LED
  • 3 NPN-Transistoren z.B. BC 547A
  • 1 Wannenstecker 10 polig
  • 1 IC-Sockel mit 32 Pins. Davon wird an einer Seite die Eckenpins entfernt, da die Arduino-Platine nur 30 Pins hat.
  • einige Buchsensockel mit 8,5 mm Höhe. Ich kaufe meist 30 oder 40 polige und verwende den Trennschleifer um die passende Anzahl der Pins zu bekommen. Dabei opfere ich dann immer einen Pin.

1. Schritt: Leiterbahnen auftrennen

Die linke Platine ist angezeichnet, die rechte bereits mit einem Trennschleifer behandelt.

Vor dem eigentlichen Auftrennen sollte man die Trennstellen mit einem Lackstift markieren. Der Lack ist bei einem Fehler deutlich leichter zu entfernen statt eine Trennung zu korrigieren.

Trennungen über einem Loch kann man auch mit einem harten Kratzstift durchführen. Für Trennungen zwischen den Löchern verwendet man besser eine Minibohrmaschine oder Gravurstift mit einer kleinen Trennscheibe. Anschließend unbedingt mit einer Lupe die Trennstellen kontrollieren, ob kleine Splitter zwischen die Kupferbahnen gekommen sind.

2. Schritt: Drähte und Widerstände auflöten

EPfH - Platine mit Draehten2.jpg

Die ersten Lötarbeiten umfassen die flachsten Bauteile: Die Drahtbrücken und liegende Widerstände.

Für Nachbauer: In dem Foto fehlt oben links neben dem Widerstand noch eine kleine Brücke.

Manche Drahtbrücken sind übrigens unter dem IC-Sockel für den Arduino. Daher bitte diesen erst einlöten, wenn wirklich alle Drähte darunter da sind. Für kurze Drahtbrücken verwende ich meist die Reste von abgeschnittenen Beinen von früher eingelöteten Bauteilen. Die längeren Drahtbrücken sind Lötdraht von 0,5 mm Durchmesser.

Man beachte, dass ich einige Widerstände etwas anders eingelötet habe, als es nicht sofort aus dem Screenshot vom PCB-Layout ersichtlich ist: Links ist der Widerstand um die Ecke gebogen und rechts einer länger. Da sind dann die Grenzen von fritzing, die eine Verlängerung (geschweige Biegung) der Beine hier nicht zulässt. Dargestellt habe ich es durch eine Leiterbahn, die auf der Oberseite weiterführt.

Ähnlich bin ich bei den Kondensatoren vorgegangen. Ich verwendete sie in der Bauform mit 2,54mm Abstand und langen Beinen, die entsprechend gebogen sind.

3. Schritt: Weitere Bauteile einlöten

Auch hier gilt: vom flachsten zum höchsten Bauteil. Die Beine der Transistoren sind etwas auseinander zu biegen.

4. Schritt: Smoke-Test

EPfH - SmokeTest.jpg

Standardmäßig kommen Arduinos mit einem Sketch (= Firmware), der eine LED blinken lässt.

Wenn sie das auch tut, wenn der Arduino mit der Platine verbunden ist, hat man zumindest mal keinen Kurzschluss zwischen VCC und GND.

Sehr sinnvoll ist es, mit einem Piepser VCC und GND zu prüfen und dann zum Test einen 230V zu USB Adapter zur Stromversorgung des Arduinos zu verwenden. Dann riskiert man keinen USB-Port am Rechner oder USB-Hub.

5. Schritt: Kontrolle

Hier sind noch Bilder der fertigen Platine mit und ohne aller Bauteile.

Sinnvoll ist eine Prüfung der Lötstellen mit einer Lupe. Zwischen den Bahnen sollte ein Kratzstift immer ohne Widerstand durchgezogen werden können.

Sobald die Platine funktioniert, kann man bei Bedarf die Unterseite der Platine auch mit einem Klarlack wie Urethan einsprühen.



Die einzelnen Elemente

Liste der Bauelemente

  • Arduino Nano (Wer Zeit hat und im Ausland kauft, zahlt weniger als EUR 15,-)
  • 433 MHz Funkmodule (weniger als EUR 5 pro Paar)
  • DS18B20 als Temperaturfühler (unter EUR 1,20 + Versand innerhalb der EU)
  • DHT22 oder AM2302 als Feuchtigkeits- und Temperatursensor (unter EUR 6)
  • ENC28J60 Ethernet LAN Network Module (unter EUR 4,00 - den mit 10 geraden Pins)
  • Fotowiderstand (ca. EUR 1)
  • 2 Kanal 5V Relais Modul für Arduino (unter EUR 4)

Der Arduino Nano

Ein Arduino Board enthält einen AVR Prozessor und oft einen USB-Port. Zur Programmierung gibt es eine IDE, die für alle gängigen Betriebssysteme verfügbar ist. Im Allgemeinen wird die Software installiert und ein angeschlossenes Board als USB-Gerät erkannt.

Ein Arduino Nano enthält einen 328P-Prozessor und ist in einem recht kleinen Format aufgebaut. Er lässt sich in einen IC-Sockel einsetzen. Leider ist in den letzten Monaten der Preis in Deutschland schier explodiert. Daher lieber im Ausland kaufen.

Manche Sensoren verlangen eine spezielle Bibliothek. Nach dem Herunterladen installiert man sie im Verzeichnis der Arduino-Installation im Ordner libraries. Wenn man die IDE startet, sollten unter Datei - Beispiele, dann deren Beispiele auch auftauchen.

Ist die Platine aufgebaut, kann man die Sketches der Testsuite ausprobieren. Der Ablauf ist dann

  • Sketch in der IDE laden.
  • Arduino ohne Evaluierungsboard anschliessen.
  • Sketch auf den Arduino übertragen
  • Die serielle Konsole aufrufen
  • Prüfen, ob sich der neue Sketch meldet
  • Die serielle Konsole beenden
  • Arduino wieder vom PC trennen
  • Sensor auf das Evaluierungsboard aufsetzen
  • Arduino in den Sockel setzen
  • Nochmal die Polarität des Sensors prüfen
  • Arduino an den PC anschliessen
  • Die serielle Console aufrufen
  • und ausprobieren

Ist die Platine fertig aufgebaut, kann man schon mal die Taster und LEDs testen. Für die LEDs mal den Sketch "traffic_lights" installieren. Um auch die Buttons auszuprobieren, den Sketch "buttons_and_leds" verwenden.

Die Taster

Schalter 1-3 mit jeweils einem Widerstand. In Verbindung mit dem obigen Widerstand von 10K ergibt sich ein Spannungsteiler.
Der Schalter in der Ecke und die blaue Anschlussklemme

Es gibt insgesamt vier Taster auf dem Board, die unterschiedlich angeschlossen sind. Zunächst klingt es logisch einen Taster an einen digitalen Port anzuschliessen. Das führt jedoch dazu, dass schnell alle Ports belegt sind, sobald man mehrere braucht.

Der Taster in der Ecke ist mit D3 verbunden. Zur Entprellung habe ich noch einen Kondensator und Widerstand als Passfilter eingesetzt. Parallel dazu ist eine Schraubklemme eingebaut, die man direkt an einen S0-Zähler betreiben kann. (Idee aus dem Projekt volkszähler)

Die anderen drei Taster teilen sich hingegen den Eingang von einem analogen Port. Dazu hat jeder Taster einen anderen Widerstand. Indem man jetzt den Pegel vom Spannungsteiler misst, erkennt der Prozessor welcher Taster gedrückt wurde.

Die LEDs

EPfH-Schaltbild-LEDs.png

Die rote LED folgt dem Prinzip, dass sie direkt an einen digitalen Port angeschlossen wird (AVR-Tutorial:_IO-Grundlagen). Das bedeutet aber auch, dass sie invertiert arbeitet: Pegel HIGH = LED aus und Pegel LOW = LED an.

Die gelbe, grüne und IR-LED haben dagegen einen Transistor davor und arbeiten somit nach dem Prinzip: HIGH = LED an.

Die Ansteuerung der gelben und grünen LED ist zudem an einen Ausgangsport herausgeführt und kann damit eine Relais-Platine schalten. Dann dient die LED als Kontrollleuchte.

Der Lichtsensor

EPfH-Schaltbild-LDR.png

Der LDR ist einfach nur ein variabler Widerstand. Somit wird er über einen analogen Port ausgelesen. Dazu wird wieder ein Spannungsteiler benutzt, damit man einen Spannungspegel messen kann.

Zum Austesten reicht der Standard-Sketch "Basics" - "AnalogReadSerial". Darin den Pin auf A4 anpassen.

int sensorValue = analogRead(A4);

Je kleiner der Wert, desto dunkler ist es. Bei meinem Board liegen die Werte zwischen 60 und 965.


Der Temperatursensor DS18x20

EPfH-Schaltbild-Temperatur.png
EPfH-MehrereTempSensoren.jpg

Der Temperatursensor sieht zwar nur wie ein Transistor aus, hat intern jedoch einen kompletten Chip drin. Dieser wird über ein serielles Protokoll ausgelesen und liefert dann eine ID und den Temperaturwert zurück.

Es ist auch möglich über ein Kabel mehrere Sensoren anzuschliessen. Diese sind dann alle parallel geschaltet. Anhand der ID kann der Mikroprozessor vom Arduino unterscheiden, zu welchem Sensor welcher Temperaturwert gehört.

Der Feuchtigkeitssensor DHT22

EPfH-Schaltbild-Feuchtigkeitssensor.png

Er liefert die relative Luftfeuchtigkeit und die Temperatur zurück. Auch er enthält einen Chip, der seriell ausgelesen wird.

Nebenbei: Gerade bei ihm auf die richtige Polarität achten. Ich habe mir schon einen Port von meinem USB-Hub durch das falsche Aufstecken zerstört.


Die Fernbedienung

Links der Sender, rechts der Empfänger, beide noch ohne Antennenkabel
Der Empfänger
Der Sender

Die 433 Mhz Funkmodule

Hier kommen relativ einfach Funkmodule zum Einsatz, die via Amplitutenmodulation arbeiten (ASK, bzw. OOK). Aus der Tüte heraus haben sie noch keine Antenne. Daher sind 17cm lange Drahtstücke anzulöten.

Die Bibliothek Rc-Switch simuliert eine Fernbedienung mit eines SC5262 Chip. Das dort verwendete Protokoll findet sich in einigen anderen Chips für Fernbedienung wieder. Daher lassen sich relativ viele gängige Funksteckdosen (Dreierset mit max. 1000 Watt Schaltleistung zu EUR 15,-) damit schalten. Möchte man einen Wasserkocher oder die Zuleitung zu einem Elektroauto schalten, braucht man Steckdosen mit einer Schaltleistung von 3600 Watt, die dann um die EUR 35 liegen.

Die IR-Elemente

Die IR-Diode und der dazu gehörige Empfänger sind hier als Ergänzung mit aufgenommen. Die Idee ist, dass die Chipsätze für die Funkfernbedienung auch für IR-Fernbedienungen eingesetzt werden. Daher sollten sich mit derselben Bibliothek auch IR-Fernbedienungen simulieren lassen.

Entsprechend sind sie parallel zu den Funkmodulen auf der Platine geschaltet.

Ethernet

EPfH-Schaltbild-Ethernet.png

Das Ethernet-Modul enthält einen enc28j60 Chip. Dafür gibt es eine ganze Reihe diverser Bibliotheken, die teilweise aufeinander aufbauen. Jedoch habe ich noch keine gefunden, mit der ich eine REST-Schnittstelle via PUT-Request ansteuern kann.

Wer auch fritzing zum Layouten benutzt, beachtet bitte, dass doppelreihige Stecker- oder Buchsenleisten in fritzing noch falsch nummeriert werden. Daher bitte höllisch aufpassen, ob jetzt wirklich in der PCB-Sicht die Bauteile an dem richtigen Pin der Leiste verbunden sind.

zu dem Fehler auch das Issue bei fritzing


Die Heimautomatisierung

openHAB verwaltet als Zentrale alle Elemente im Haus, die darüber gesteuert werden. Über eine Webseite oder App erhält man den Status von Licht, Schaltern und einiges mehr oder schaltet diese auch.

Sind Regeln definiert, schaltet openHAB beim Eintritt von bestimmten Bedingungen auch selbst die Aktoren.

Technisch ist es ein Java-Programm mit eigenem Webserver. Zahlreiche Hausautomatisierungssystem können über Bindungs angebunden werden. Hier in diesem Projekt interessiert dazu zunächst das serielle Binding.

Welche Elemente (items) im Haus verbaut sind, die mit openHAB verbunden werden und welche Regeln ggf. aktiv sind, definiert man in Textdateien in einer sogenannten Domainspezifischen Sprache. Das heisst nichts anderes, als das man Pseudocode in seinem Fachgebiet schreibt, die aber vom Computer verstanden und ausgeführt wird. Dafür bringt openHAB einen Designer mit, der den Anwender unterstützt.

Installation

Die Vorausetzung ist zunächst einmal eine durchgeführte Java-Installation.

Dabei gibt es zwei Einschränkungen: Es sollte eine Runtime-Engine von Oracle sein, darauf läuft ein Server unter Java spürbar schneller. Ferner muss es unter Window eine 32-Bit Version sein, sonst funktioniert das serielle Binding nicht.

Zunächst einmal installiert man openHAB am besten auf seinem Arbeitsrechner, vor dem Sie vermutlich gerade sitzen. Dann hat man es erheblich einfacher mit dem openHABs Designer, die Konfigurationsdateien zu erstellen. Später kommt das dann auf einen möglichst sparsamen Rechner, damit nicht mehr als nötig Stromenergie fliesst.

EPfH-DesignerOpenConfig.png

Von der Website holt man sich die Paket runtime, demo, addons und den passenden Designer. In einem passenden Verzeichnis entpackt man zunächst 'runtime'. Darüber installiert man 'demo' und erhält schon eine lauffähige Version. Aus dem 'addon'-Paket legt man 'org.openhab.binding.serial-1.1.0.jar' in das addon Verzeichnis.

Im Browser öffnet man die GUI von openHAB.

Man startet den Designer und öffnet den Konfigurationsordner 'configurations' seiner openHAB-Installation. Parallel dazu kann man das Startskript start.bat oder start.sh ausführen. Veränderungen an den Konfigurationsdateien im Designer erkennt die Server-Software und lädt sie sofort nach dem Speicher nach.

Im Folgenden sind nun die Dateien demo.items und demo.rules wichtig.

Zwei wichtige Tastenkürzel:

  • Strg-s speichert die Datei
  • Strg-Leertaste listet Vorschläge zur Vervollständigung des Befehls auf

Arduino und openHAB

Am Ende der beiden Dateien demo.items und demo.rules finden sich die Einträge für den Arduino. Er ist bei mir auf COM45 zu finden.

Der Eintrag in demo.items:

String Arduino  "eval arduino"  { serial="COM45" }

Das Prinzip ist, dass Strings zwischen den Beiden ausgetauscht werden. Diese werden dann vom Gegenpart rudimentär geparst und ausgeführt.

Regeln

Aus der Demo von openHAB, sind die Lampen in der Küche mit den Tastern vom Arduino verbunden. Auf Knopfdruck lassen sie sich ein- und ausschalten und dies zeigt sich dann im Browser.

In der Version 1.1.0 zerpflügt openHAB den String noch und verteilt ihn auf mehrere Events, daher wird jedes Update-Event erstmal in der Variable ArduinoUpdate gesammelt, bis das Endezeichen ";" enthalten ist.

Einträge in demo.rules:

var String ArduinoUpdate = ""

...

rule "Arduino on update"
	when 
		Item Arduino received update
	then
	    ArduinoUpdate = ArduinoUpdate + Arduino.state.toString.trim
	    println("ArduinoUpdate -> " + ArduinoUpdate)
	    if (ArduinoUpdate.contains(";")) {
			if (ArduinoUpdate.contains("item=B1")) {
				postUpdate(Light_GF_Kitchen_Ceiling, if(ArduinoUpdate.contains("value=ON")) ON else OFF)
			}
			if (ArduinoUpdate.contains("item=B2")) {
				postUpdate(Light_GF_Kitchen_Table, if(ArduinoUpdate.contains("value=ON")) ON else OFF)
			}
			ArduinoUpdate = ""
	    }
end

Diese Regel erwartet jetzt einen String wie "item=B1, value=ON;" Sobald man den Taster 1 drückt, sendet der Arduino diesen String an openHAB.

Regel zur Heizung:

rule "Arduino LED red"
	when
		Item Heating_GF_Kitchen received update
	then
		sendCommand(Arduino, "set led red " + (if(Heating_GF_Kitchen.state==ON) "on;" else "off;"))
		ArduinoUpdate = ""
end

Das ist die Gegenrichtung: openHAB sendet einen Befehl an den Arduino.

Sobald man im Browser die Heizung der Küche schaltet, sendet openHAB an den Arduino den Befehl "set led red on;", um die rote LED zu schalten.

Regel zur Temperatur:

rule "Arduino on update"
...
			if (ArduinoUpdate.contains("item=temperature")) {
				var int valueStartsOn = ArduinoUpdate.indexOf("value=") + "value=".length
				var String myTemperatureAsString = ArduinoUpdate.mid(valueStartsOn, ArduinoUpdate.indexOf(';')-valueStartsOn)
				println(myTemperatureAsString);
				var Number myTemperature = 0.0f
				myTemperature = Float::parseFloat(myTemperatureAsString)
				postUpdate(Temperature_GF_Kitchen, myTemperature)
			}
...
rule "Arduino Temperature"
	when
		Time cron "1 * * * * ?"
	then	
		sendCommand(Arduino, "get temperature;")
end

Zum einen sendet openHAB regelmäßig eine Anforderung um den DS18x20 auszulesen. Falls größere Temperatursprünge stattfinden, sendet der Arduino von sich aus die neue Temperatur. Verbunden ist der Temperaturwert mit dem der Küche.

Der Arduino

Der Sketch zum Arduino ist unten bei den Download-Links dabei.

Wenn man den Arduino-Sketch vorab ohne openHAB testen möchte, dann startet man wieder die Konsole. Sobald man einen der Buttons drückt, gibt der Arduino das aus, wie die obige Regel in openHAB das erwartet.

Mit einem Kommando wie "set led red on" an den Arduino schaltet man eine der Leuchtdioden.

Mit "get temperature" oder "get brightness" erhält man die Temperatur, bzw. die Helligkeit, falls der jeweilige Sensor angeschlossen ist.



Demo

Und hier sieht man es in Aktion: http://youtu.be/XRTbmI1zswQ



Downloads

Quellen

verwendete Software

Datenblätter

verwendete Arduino Bibliotheken

diverse Kleinrechner

(im Prinzip Linux-Rechner, die um die 5 Watt Leistungsaufnahme haben)

--Thgauweiler 22:59, 8. Mär. 2013 (UTC)