Smart Home

http://sites.prenninger.com/arduino-uno-r3/smart-home

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                         Wels, am 2015-11-10

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************

                         MEIN TECH BLOG.DE
http://www.meintechblog.de/2015/06/arduino-im-smart-home-howto-teil-1-das-steckt-dahinter/

            Haussteuerung mit dem ARDUINO

   Smart-Home-Technik   Smart-Home-Systeme

Smart Home
und Gebäudeautomation überschneiden sich thematisch.

                      https://de.wikipedia.org/wiki/Smart_Home


Arduino: das smarte Zuhause Taschenbuch – 20. Juli 201521,90

von Marius Riehl (Autor)

  • Taschenbuch: 326 Seiten
  • Verlag: CreateSpace Independent Publishing Platform; Auflage: 1 (20. Juli 2015)
  • Sprache: Deutsch
  • ISBN-10: 1-515-15584-6
  • ISBN-13: 978-1515155843
  • Größe: 14 x 1,9 x 21,6 cm



ARDUINO MEGA im Smart Home

Der wohl simpelste und ausführlichste Guide zum eigenen Smart Home!
Was erwartet Sie in diesem Buch?:
Steuern Sie ihr Haus, alle ihre Geräte, von Lampe bis Fernseher per Smartphone, von überall per Webbrowser - egal wo Sie sind.
Schauen Sie jeder Zeit nach, welches Gerät gerade ak- oder deaktiviert ist.
Lesen Sie nach belieben die Temperatur und Luftfeuchtigkeit in ihrem Zuhause aus - am Besten von Ihrem LCD Bildschirm, der gleichzeitig als Steuerzentrale dient.
In diesem Buch werden Sie die Grundlagen des Programmierens lernen, von Bedingungen, über for-Schleifen bis zu multidimensionalen Arrays.
In einer ausführlichen Planungsphase werden werden alle Komponenten der Haussteuerung ins kleinste Detail beleuchtet
- zusätzlich lernen Sie, wie ein Computer funktioniert, wie er aufgebaut ist und was Datentypen (Variablen) sind.
Gelerntes wird direkt in kleinen Arduino-Programmen in die Praxis umgesetzt, von ausgegebenen Textnachrichten bis Morsecode-LED's.
Im nachfolgenden Kapitel wird der Arduino mit dem Ethernet verbunden, gibt eine eigene Webseite zurück und steuert eine LED
- übers Internet! Im Anschluss folgt eine ausführliche Erklärung der "Hypertext Markup Language" (HTML)
- dieses Wissen benötigen wir für unser Webpanel.
Dieses gestalten wir optisch ansprechend mit CSS - von Buttons bis kleine "Ampeln" - CSS wird grundlegend erklärt.
Der Arduino wird die Temperaturdaten (und Gerätedaten) online in einer Datenbank speichern - auf diese greifen wir mit PHP zu.
Über ein Touchdisplay (LCD) können wir direkt von Zuhause aus alles steuern
- inklusive Homescreen - so etwas hat nicht jeder! Zuletzt entwerfen wir über Android 4 unsere eigene App!

Marius Riehl,
Mein bisher grösstes Projekt war mein "Smart Home", welches ich mit dem open-source Mikrocontroller "Arduino" realisiert habe.
Dazu habe ich ein 326 Seiten langes Buch verfasst.
Ein Banner oben auf dieser Seite zeigt den aktuellen Status, sowie die Temperaturdaten meiner Haussteuerung.

Marius Riehl
Bessungerstraße 177a
D-64347 Griesheim
Tel. 06155-5576
mailto:marius@priehl.de
http://www.mriehl.de/





*********************************************************
         ARDUINO UNO im Smart Home

Selbstbau-Sensoren im Smart Home mit FHEM nutzen: ein Guide für Einsteiger
http://www.meintechblog.de/2015/08/selbstbau-sensoren-im-smart-home-mit-fhem-nutzen-ein-guide-fuer-einsteiger/

Arduino im Smart Home - HowTo Teil 1: Das steckt dahinter
http://www.meintechblog.de/2015/06/arduino-im-smart-home-howto-teil-1-das-steckt-dahinter/#more-7511
Arduino im Smart Home – HowTo Teil 2: Bewegungsmelder per UDP an Loxone anbinden
http://www.meintechblog.de/2015/06/arduino-im-smart-home-howto-teil-2-bewegungsmelder-per-udp-an-loxone-anbinden/#more-7594
Arduino im Smart Home - HowTo Teil 3: Helligkeitssensor per UDP an Loxone anbinden
http://www.meintechblog.de/2015/06/arduino-im-smart-home-howto-teil-3-helligkeitssensor-per-udp-an-loxone-anbinden/#more-7654
Arduino im Smart Home - HowTo Teil 4: Status-LED per UDP ansteuern
http://www.meintechblog.de/2015/06/arduino-im-smart-home-howto-teil-4-status-led-per-udp-ansteuern/#more-7735
Arduino im Smart Home - HowTo Teil 5: 24 V LED-Spot per Schaltrelais ansteuern
http://www.meintechblog.de/2015/06/arduino-im-smart-home-howto-teil-5-24-v-led-spot-per-schaltrelais-ansteuern/#more-7716

HomeMatic FHEM-Wetterstation per UDP in Loxone integrieren
Integration: Daten zwischen Loxone und FHEM austauschen - Teil 2 Update


333_d_hofman-x_ARDUINO im Smart Home - HowTo Tl1..Tl5 (50 Seiten)_1a.pdf


Arduino im Smart Home – HowTo Teil 1: Das steckt dahinter


Arduino Uno Detail


Wer sein Zuhause in ein Smart Home verwandeln möchte, in welchem die Lampen bei anbrechender Dunkelheit automatisch dimmen und die Jalousien bei Sonneneinstrahlung rechtzeitig beschatten, noch bevor der Raum zu stark aufheizt, benötigt eine Menge Technik.

Trotz Open-Source-Lösungen wie FHEM, welche einen günstigen Einstieg in die Welt der Home Automation z.B. per Raspberry Pi ermöglichen, kommen bei den meisten Anwendern dennoch vorzugsweise Sensoren und Aktoren von Herstellern wie HomeMatic oder EnOcean zum Einsatz, die das Technikbudget des ambitionierten Bastlers schnell sprengen können.

Trotz hoher Anschaffungskosten stößt man als Anwender dennoch recht häufig auf technische Einschränkungen, da gewünschte Komponenten der präferierten Marke entweder nicht oder teilweise nur zu horrenden Preisen vertrieben werden.

Umstände, welche in der Blogserie "Arduino im Smart Home - HowTo" zum Anlass genommen werden sollen, um das schlummernde Smart-Home-Potenzial der enorm günstigen und beliebten Arduino-Plattform aufzuzeigen.

Nachfolgend wird dabei die Frage einleitend geklärt, was einen Arduino aus Smart-Home-Sicht so attraktiv macht und wie erste Projekte mit vertretbarem Aufwand in Angriff genommen werden können.

Arduino - Unbegrenzte Smart-Home-Möglichkeiten

"Arduino" ist der Standard einer quelloffenen Plattform, die sowohl Soft- als auch Hardware definiert (Wiki-Infos).

Die wohl bekannteste Arduino-Hardware-Plattform ist der Arduino Uno, welcher mittlerweile von unzähligen Anbietern (Affiliate-Link) für teilweise bereits weniger als zehn Euro vertrieben wird.

Arduino Uno


Er bildet mit seiner Vielzahl an Pins in Form von 14 digitalen Ein-/Ausgängen und 6 weiteren analogen Eingängen die Grundlage für Komponenten, die im Smart Home als Sensoren und Aktoren angesteuert werden können.

So lässt er sich bspw. einsetzen, um Fensterkontakte oder Bewegungsmelder (digitale Sensoren) anzubinden, die Temperatur oder Luftfeuchtigkeit (analoge Sensoren) zu messen, Verbraucher zu schalten (digitale Aktoren) und bspw. LEDs zu dimmen (PWM-Aktoren).

Günstige Sensoren und Aktoren im Zehnerpack

Der Clou daran: Der Großteil an Sensoren und Aktoren ist zu einem Spottpreis im Centbereich bzw. einstelligen Euro-Bereich erhältlich und oftmals im 10er-Pack normal günstiger, wie z.B.:



Prototypische Installation der Komponenten

Für erste "Gehversuche" können die gewünschten Komponenten zum Teil direkt über Steckbrücken (Affiliate-Link) mit den Pins des Arduino verbunden werden.



Wird für den Aufbau ein umfangreiches Setup genutzt, können auch sogenannte Steckplatinen (Affiliate-Link) eingesetzt werden.

Die auch Breadboards genannten Experimentierplatinen ermöglichen durch ihre vertikal bzw. horizontal verschalteten Kontakte komplexe Verdrahtungen, so dass eine Vielzahl an elektronischen Bauteilen auf einmal mit dem Arduino verbunden werden kann.



Programmierung der Hardware

Damit die Hardware auch das tut, was von ihr erwartet wird, müssen die gewünschten Funktionen auf den Mikrocontroller des Arduino-Boards geschrieben werden.

Der Atmel AVR-Mikrocontroller aus der megaAVR-Serie, welcher einen Arduino gewöhnlich antreibt, besitzt eine Taktrate von 16 MHz.

Was erst einmal nach wenig klingt, ist für den vorgesehenen Anwendungszweck aber mehr als ausreichend und hat zudem den Vorteil, dass ein Arduino wenig Hitze entwickelt und sehr wenig Strom konsumiert, was (zu einem gewissen Grad) sogar den mobilen Einsatz per Akku ermöglicht.

Zur Programmierung wird die quelloffene Arduino-Software (auch Arduino IDE "Integrated Development Environment" genannt) eingesetzt, welche für alle gängigen PC-Plattformen (Windows, Mac OS X und Linux) zur Verfügung steht. Programmiert wird dort in C bzw. C++, wobei erste Erfolge auch ohne umfangreiche Programmierkenntnisse in kurzer Zeit durch vorgefertigte Programme, auch Sketches genannt, erzielt werden können.

(Wer sich die Perl-Programmierung in FHEM zutraut, sollte nach kurzer Eingewöhnung auch hier keine allzu großen Probleme haben.)


Kommunikation mit der Smart-Home-Zentrale

Das Ganze wird gerade dann interessant, wenn der Arduino als Mittelsmann zwischen den an ihm angeschlossenen Komponenten und dem Smart-Home-Server in Form von FHEM oder Loxone eingesetzt wird und auf diese Weise ein bidirektionaler Datenaustausch stattfinden kann.

Hier stehen verschiedenste Möglichkeiten zur Verfügung, deren Vor- und Nachteile ebenfalls in nachfolgenden Blogbeiträgen behandelt werden sollen.

Dazu zählen vor allem die Übertragung per

  • Ethernet (LAN bzw. WLAN) z.B. per UDP-Protokoll
  • RS485
  • KNX

Arduino als Gateway weiterer Smart-Home-Standards

Zusätzlich kann der Arduino aber auch selbst als Gateway zwischen der Smart-Home-Zentrale und den verschiedensten einzusetzenden Smart-Home-Standards genutzt werden.

Dazu gehören unter anderem:

  • DMX
  • OneWire
  • RS485
  • Modbus (ähnlich RS485)
  • RS285
  • Bluetooth
  • Funk (z.B. 434 Mhz, 2,4 Ghz)
  • Infrarot

Denkbar ist dabei auch, dass ein kabelgebundener Arduino, welcher "direkt" mit der Smart-Home-Zentrale verbunden ist, selbst wiederum als Gateway für weitere kabellose Arduinos fungiert, so dass diese auch mit der Zentrale interagieren können.

Arduino im Dauereinsatz

Funktioniert nach abschließendem Testing mit Breadboard und Steckbrücken alles nach Plan, kann die neue Installation dauerhaft im Smart Home Einzug halten.

Dazu lassen sich die prototypisch realisierten Schaltungen mithilfe von Streifenrasterplatinen (Affiliate-Link), passenden Kopfleisten (Affiliate-Link) und Befestigungsschrauben (Affiliate-Link) sowie dem Einsatz eines Lötkolbens in eine permanente Umgebung bringen, die direkt auf dem Arduino Platz findet und damit eine Einheit bildet.

Um noch einen Schritt weiter zu gehen, können über Tools wie Fritzing sogar eigene passgenaue Leiterplatten (PCB-Boards) designt werden, welche von günstig von Firmen hergestellt werden können (mehr Infos dazu in einem folgenden Blogpost der Serie).

Wer möchte, kann seinen Arduino jetzt noch in einem passenden Gehäuse (Affiliate-Link) unterbringen bzw. hoffen, dass sich 3D-Drucker bald auch bei Endanwendern durchsetzen und ein passendes Gehäuse dann - hoffentlich bald - per Rapid Prototyping selbst herstellen.

Aus meinem täglichen Leben

Obwohl ich mich erst seit Kurzem intensiver mit dem Thema Arduino auseinandersetze, konnte ich bereits Testaufbauten mit verschiedenen Sensoren und Aktoren umsetzen und den Datenaustausch zwischen Arduino und Loxone bzw. FHEM per UDP-Mitteilungen realisieren, was ich in den kommenden Blogposts als HowTo-Anleitungen zum Nachbau verständlich machen möchte.





Besonders fasziniert mich dabei, dass man durch die Vielzahl an zur Verfügung stehender Pins sehr viele (verschiedene) Sensoren und Aktoren an nur einem Arduino betreiben kann und so exakt die Funktionalität erhält, die man benötigt.
Hinzu kommt, dass sämtliche Komponenten (gerade auch Sensoren) zu einem lächerlich günstigen Preis - meist aus Fernost - geordert werden können.
Vieles gibt es sogar per Prime-Versand, wobei ich die Komponenten bisher zumeist bei günstigeren Marketplace-Anbietern erworben habe.
Das Einzige, was dabei etwas stört, ist die Tatsache, dass man teilweise einige Wochen auf die Bestellung warten muss, da viele Elektronikbauteile direkt aus Asien versendet werden.
Apropos Einfuhr aus Nicht-EU-Staaten: Bis zu einem Warenwert von 22 Euro ist jede Sendung einfuhrabgabefrei, d.h. es fallen weder Zoll noch Einfuhrumsatzsteuer an.
Obwohl ich bereits recht viele Komponenten geordert habe, konnte ich diese Grenze bisher immer unterschreiten. Zur Not kann auch einfach die Bestellung gesplittet werden, da Versandkosten zumeist sowieso nicht anfallen.
Was hältst du von meinem Vorhaben den Arduino im Smart Home einzusetzen? Stimme einfach ab und hinterlasse einen Kommentar.

Arduino im Smart Home – HowTo Teil 2: Bewegungsmelder per UDP an Loxone anbinden



PIR Bewegungsmelder


Nachdem erste Grundlagen der Arduino-Plattform in HowTo Teil 1 der Blogserie "Arduino im Smart Home" angesprochen wurden,

geht es in diesem HowTo direkt an die Anbindung des ersten Sensors, dessen Messwerte mithilfe des Arduino Uno ausgewertet

und per UDP-Protokoll über eine Netzwerkverbindung an die Smart-Home-Zentrale in Form eines Loxone Miniservers (Affiliate-Link) gesendet werden.

In nachfolgendem Blogpost werden die dafür notwendigen Installationsschritte für Hard- und Software Schritt für Schritt erklärt und einige relevante Tipps gegeben, sodass der Einstieg auch für interessierte Einsteiger möglich ist.

Bewegungserkennung per Arduino

Aus der Vielzahl möglicher Sensoren, die am Arduino-Board betrieben werden können, wird für diese erste Installation ein Bewegungsmelder genutzt.

Das hat mehrere Gründe. Er ist super günstig, wird praktisch in jedem Raum für eine Anwesenheitserkennung benötigt, kann direkt an die Pins des Arduino angeschlossen werden

und liefert digitale Messwerte (Bewegung bzw. keine Bewegung), welche sehr einfach per UDP weiterverarbeitet werden können.


PIR Bewegungsmelder_

Benötigte Komponenten

Für die Anwesenheitserkennung werden insgesamt nur wenige Komponenten benötigt, welche für unter 30 Euro erhältlich sind:

Wer gleich alle - und noch viele weitere - Komponenten als Set erwerben möchte, kann sich auch das Funduino Lernset UNO 8 (Affiliate-Link) ansehen.

Bis auf das Ethernet Shield sind dort alle notwendigen Komponenten enthalten, die in diesem und folgenden HowTo-Anleitungen verwendet werden.

Affiliate-Link


Vorbereitung der Hardware

Obwohl erst für spätere Erweiterungen notwendig, wird an dieser Stelle bereits ein Breadboard genutzt, um die Verbindungen zwischen Arduino Uno und PIR (Passiver Infrarot Bewegungsmelder) herzustellen.




 

Noch eine kurze Info zum Breadboard selbst, die gerade Anfängern helfen kann, dessen Schaltkonzept zu verstehen.

Auf dem Breadboard sind bestimmte Kontakte vertikal bzw. horizontal miteinander verschaltet. So kann bspw. die vom Arduino über den Pin VCC zur Verfügung gestellte Netzspannung über das Breadboard an mehrere Verbraucher verteilt werden.

Dazu werden gewöhnlich die beiden obersten und untersten Reihen verwendet, welche vertikal miteinander verschaltet sind.

Die dazwischenliegenden Reihen sind hingegen vertikal miteinander verschaltet.

Auf diese Weise kann bei obigem Beispiel auch eine Verbindung zwischen den "übereinander" gesteckten Kontakten hergestellt werden, obwohl es auf der Abbildung erst einmal so aussieht, als ob keine Verbindung zustande kommt.

Nachfolgend noch einmal zur Verdeutlichung die miteinander verschalteten Kontakte:


Breadboard Verschaltung

Bevor der Arduino über die Steckbrücken mit dem Breadboard verbunden werden kann, wird das Ethernet Shield auf das Arduino-Board gesteckt, wodurch die fehlende Netzwerkfähigkeit des Arduino-Boards nachgerüstet wird.

Die Pins des Arduino-Boards werden dabei durch das Ethernet Shield durchgeschleift und können weiterhin als Ein- bzw. Ausgänge auf dessen Oberseite verwendet werden.





Danach kann der Bewegungsmelder mit dem Breadboard verbunden werden. Der

  • linke Pin des Bewegungsmelders wird an "Ground" (schwarz) angeschlossen, der
  • mittlere Pin (gelb) an Pin 2 des Arduino-Boards weiterverbunden und der
  • rechte Pin (rot) an VCC (+5 V).

PID Bewegungsmelder Pins


Wichtige Anmerkung zu den Pins des Arduino: Der Arduino Uno bietet insgesamt 14 digitale Pins, die als digitale Ein- oder Ausgänge genutzt werden können.

Davon sollten jedoch Pin 0 und 1 nicht direkt verwendet werden, da diese für die serielle Kommunikation zum PC (RX/TX) vorgesehen sind, sodass im Endeffekt beim Arduiono Uno noch 12 digitale Pins zur Verfügung stehen.

Aus oben genanntem Grund wird der Bewegungsmelder in diesem Beispiel direkt mit dem nächsten "freien" Pin 2 verbunden.

So sieht das Ganze dann als fertige Testinstallation aus.


Arduino Board Breadboard PID Bewegungsmelder


Der Bewegungsmelder besitzt zwei orangefarbene Drehregler.

Mit dem linken Drehregler kann die Dauer des geschalteten Signals nach dem Ende einer erkannten Bewegung eingestellt werden. Wird der Regler im Uhrzeigersinn gedreht, wird die Dauer erhöht.

Empfohlen wird an dieser Stelle die Dauer möglichst gering einzustellen, so dass er ca. drei Sekunden nach der zuletzt erkannten Bewegung ausschaltet (linken Regler gegen den Uhrzeigersinn drehen).

Mit dem rechten Drehregler kann die Empfindlichkeit eingestellt werden.

Die Sensibilität kann erhöht werden, indem der Drehregler im Uhrzeigersinn gedreht wird. Im Smart-Home-Einsatz kann meist die volle Intensität gewählt werden (rechten Regler im Uhrzeigersinn drehen).


Bewegungsmelder Drehregler

Vorbereitung der Arduino-Software

Der Arduino Uno wird nun per USB-Kabel an den PC angeschlossen.

Praktisch ist, dass der Arduino direkt per USB mit der Spannung von 5 V versorgt wird und auch beim späteren Testen kein separates Netzteil (7..12 V) benötigt wird, solange das Arduino-Board am USB-Kabel hängt.

Update vom 24.06.2015:

Der Einsatz eines separaten 9 V Netzweils (Affiliate-Link) macht spätestens ab Szenario 5 Sinn, bei dem ein stromhungriges Schaltrelais vom Arduino angesteuert wird. Die technischen Hintergründe werden im Szenario selbst beschrieben.

Die Arduino-Software, welche als Open-Source-Version heruntergeladen werden kann, steht für WindowsMac OS X und Linux zur Verfügung. Nachfolgender Screenshot ist von der Mac-Version, die anderen Plattformen bieten jedoch ein vergleichbares Look-and-Feel.

Über den Menüpunkt "Werkzeuge" -> "Platine" -> "Arduino Uno" wird das passende Modell ausgewählt.


Arduino Werkzeuge Platine Arduino Uno


Weiterhin wird über den Menüpunkt "Werkzeuge" -> "Port" -> "/dev/cu.usbmodem1411 (Arduino Uno" der vom Betriebssystem erkannte Arduino ausgewählt.

Unter Windows kann das anders aussehen und evtl. Treiber notwendig werden, die im besten Fall jedoch automatisch installiert werden sollten.


Arduino Werkzeuge Port dev usbmodem1411

Erstellung des Arduino-Programmcodes

Der genutzte Programmcode besteht aus mehreren Teilen.
Teil 1 werden die "Grundeinstellungen" vorgenommen und später verwendeten Variablen definiert.
Teil 2 umfasst das "Setup", welches die relevanten Parameter angibt, die beim Start des Arduino einmal initialisiert werden.
Teil 3 beinhaltet den eigentlichen Programmteil (loop), welcher permanent (mehrfach pro Sekunde) abgearbeitet wird.
Der komplette Sketch kann nachfolgend als Arduino-Datei heruntergeladen werden: sketch_udp_bewegungsmelder.ino (102 Downloads)

Teil 1 - Grundeinstellungen und Variablendeklaration
Zuerst werden benötigte Softwarebibliotheken mit dem Befehl "#include" eingebunden.
Da es sich dabei um "Standardbibliotheken" handelt, sind diese bereits vorhanden und müssen nicht extra heruntergeladen werden.
Mehr zu Bibliotheken dann in einem späteren HowTo.
Danach wird festgelegt, dass der Bewegungsmelder mit Pin 2 verbunden ist.
Weiterhin wird noch eine Variable namens "BewegungsmelderState" definiert, welche für den späteren Programmablauf notwendig ist, sodass bei einer Statusänderung des Bewegungsmelders jeweils nur ein UDP-Paket abgesendet wird und nicht bei jedem Programmdurchlauf.
Als nächstes werden die Netzwerkeinstellungen vorgenommen.
Hier muss unter "ip" die gewünschte Netzwerkadresse des Arduino vergeben werden, welche im Netzwerk noch nicht belegt ist.
An dieser Stelle werden einige Netzwerkkenntnisse vorausgesetzt. Möchte man später mehrere Arduinos im Netzwerk nutzen, muss darauf geachtet werden, dass sich die "byte mac"-Adresse der Arduinos unterscheidet, da es sonst zu Problemen kommen kann.
Die "Recipient IP" ist der Empfänger der UDP-Nachrichten. In diesem Fall werden die Daten an einen Loxone Miniserver mit der IP 192.168.3.11 und den Port 7001 gesendet, welcher in der Loxone Config frei gewählt werden kann.
Zusätzlich wird noch der Port 7002 als eingehender UDP-Port definiert, der zwar jetzt noch nicht genutzt, aber für spätere Setups relevant sein wird.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
 
// PIN Settings
#define Bewegungsmelder 2
 
// Variable Declaration
char BewegungsmelderState = 0;
 
// Network Settings
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 3, 19);
IPAddress gateway(192, 168, 3, 1);
IPAddress subnet(255, 255, 255, 0);
 
// Local UDP port to listen on
unsigned int localPort = 7002;
 
// Recipient IP
IPAddress RecipientIP(192, 168, 3, 11);
 
// Recipient UDP Port
unsigned int RecipientPort = 7001;
 
// buffers for receiving and sending data
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
 
// EthernetUDP instance to send and receive packets over UDP
EthernetUDP Udp;

Teil 2 - Setup

Im Setup-Teil werden nun relevante Funktionen definiert, die einmal beim Booten des Arduino durchlaufen werden.

Dabei wird der serielle Monitor mit "Serial.begin(9600);" gestartet, sodass später testweise am PC über die Arduino-Software auflaufende Statusmeldungen im "Seriellen Monitor" (zu finden unter dem Menüpunkt "Werkzeuge" verfolgt werden können.

Weiterhin werden mit "Ethernet.begin(mac,ip);" das Netzwerk und mit "Udp.begin(localPort);" die UDP-Funktionalität initialisiert und der Bewegungsmelder als Input definiert.

Zum Schluss wird noch testweise ein "UDP Ready"-Befehl in Empfängerrichtung geschickt, welcher später zur Kontrolle bspw. in der Loxone Config im aktivierten UDP-Monitor erscheint, kurz nachdem der Arduino mit Strom versorgt wird.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void setup()
{
// For debug only
Serial.begin(9600);
 
// Start Ethernet
Ethernet.begin(mac,ip);
 
// Start UDP
Udp.begin(localPort);
 
// Bewegungsmelder
pinMode(Bewegungsmelder, INPUT);
 
// Send UDP Ready
sendUDP("UDP Ready");
}

Teil 3 - Programmablauf (loop)

Als dritter Teil folgt der eigentliche Programmablauf im "loop"-Teil der Programmierung.

Die Programmlogik, die dabei permanent von oben nach unten durchlaufen wird, fragt mit "digitalRead(Bewegungsmelder)"den aktuellen Status des Bewegungsmelders ab und triggert je nach Status entsprechende UDP-Befehle.

Bei einer Bewegung lautet dieser UDP-Befehl "WZ.Bewegungsmelder: 1" und bei Nicht-Bewegung "WZ.Bewegungsmelder: 0".

Bei den jeweiligen if-Schleifen ist dabei wichtig die oben deklarierte Variable "BewegungsmelderState" zu nutzen und entsprechend beim Durchlauf vom Programm anpassen zu lassen.

Sie ist dazu gedacht, dass tatsächlich nur bei einer erfolgten Statusänderung ein einziger UDP-Befehl abgesetzt wird und nicht bei jedem Durchlauf der loop-Logik ein erneuter Befehl mit dem aktuellen Status abgesendet wird.

Am Ende wird mit "delay(20);" eine Zwangspause von 20 Millisekunden eingelegt, bevor der "loop" von vorne beginnt. Weitere Details dazu werden im HowTo Teil 3 vermittelt.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void loop()
{
// Bewegungsmelder (Send)
if (digitalRead(Bewegungsmelder) == LOW && BewegungsmelderState != 0)
{
  sendUDP("WZ.Bewegungsmelder: 0");
  BewegungsmelderState = 0;
}
if (digitalRead(Bewegungsmelder) == HIGH && BewegungsmelderState != 1)
{
  sendUDP("WZ.Bewegungsmelder: 1");
  BewegungsmelderState = 1;
}
 
delay(20);
}

Teil 4 - UDP-Sendefunktion

Alles, was jetzt noch fehlt, ist die entsprechende Funktion, welche die UDP-Pakete auch tatsächlich sendet.

1
2
3
4
5
6
7
8
// Function to send UDP packets
void sendUDP(String text)
{
Udp.beginPacket(RecipientIP, RecipientPort);
// Udp.write("Test");
Udp.print(text);
Udp.endPacket();
}

Flashen des Programmcodes auf das Arduino-Board

Sobald der Programmcode in der Arduino-Sofware hinsichtlich der eigenen Netzwerkparameter angepasst wurde, kann über den Play-Button (oben links) das gesamte Programm auf den per USB angeschlossenen Arduino übertragen werden.

Dabei wird links unten die Mitteilung "Sketch wird kompiliert" angezeigt. Nach wenigen Sekunden sollte die Mitteilung "Hochladen abgeschlossen" angezeigt werden.


Arduino flashen


Einrichtung des Smart-Home-Servers
Unter Loxone lässt sich die eingehende UDP-Nachricht über das Gruppierungselement "Virtueller UDP Eingang" unter Angabe des Ports "7001" abfangen. Dann fehlt nur noch ein "Virtueller UDP Eingang Befehl", welcher als Analogeingang (im Standard vorbelegt) mit der Befehlskennung "WZ.Bewegungsmelder: v" eingefügt werden kann.
Weitere Informationen zum Empfang von UDP-Nachrichten in der Loxone-Config gibt es im Artikel HomeMatic FHEM-Wetterstation per UDP in Loxone integrieren.
Das Signal des Bewegungsmelders steuert nun einen "Treppenlichtschalter" an, welcher die Lampe bei Bewegung schaltet und nach einigen Sekunden Nicht-Bewegung wieder ausschaltet.
Da der Treppenlichtschalter von einem Bewegungsmelder normalerweise bei jeder erkannten Bewegung ein kontinuierliches Trigger-Signal (1... 1... 1...) erwartet, muss etwas nachgeholfen werden, da der UDP-Bewegungsmelder anders (bzw. schlauer) arbeitet.
Er schaltet bei erkannter Bewegung ein (1) und nach einigen Sekunden Nicht-Bewegung wieder aus (0).
Dadurch würde der Treppenlichtschalter die Lampe bei der Erkennung einer Bewegung zwar einschalten, aber nach Ablauf des internen Treppenlichttimers auch wieder ausschalten, auch wenn weiterhin eine Bewegung erkannt wird.
Diese abweichende Logik lässt sich durch einen "Impulsgeber" wieder geradeziehen, welcher als Bindeglied zwischen die beiden Elemente gesetzt wird und den Treppenlichtschalter bei erkannter Bewegung (1) nun sekündlich triggert (1... 1... 1...).


Loxone Config Virtueller UDP Eingang Befehl Bewegungsmelder

Aus meinem täglichen Leben

Wer die Vorgehensweise und Programmierung einmal verinnerlicht hat, kann dieses Grundgerüst recht schnell ausbauen, um weitere digitale Sensoren an den Arduino anzubinden und per UDP-Protokoll Nachrichten über das Arduino Ethernet Shield zu verschicken.

Bei meinen Tests hat die UDP-Übertragung bisweilen anstandslos funktioniert.

Die Response-Zeiten sind dabei sehr gut. Sobald eine Bewegung erkannt wird, erfolgt so gut wie verzögerungsfrei der hinterlegte Schaltbefehl in Loxone.

Wer als Empfänger nicht Loxone sondern bspw. FHEM nutzen möchte, muss dort noch einige Einstellungen vornehmen, um auch UDP-Nachrichten empfangen zu können. Sobald ich mich auch damit beschäftigt habe, folgt eine entsprechendes HowTo.

Der Bewegungsmelder selbst macht für seinen günstigen Preis von nur knapp über 1 Euro (5 Stück kosten auf Amazon (Affiliate-Link) weniger als 6 Euro) im Dauereinsatz bisher aus technischer Sicht eine wirklich gute Figur.

PIR Bewegungsmelder2

Er erkennt Bewegungen verzögerungsfrei und zuverlässig bis zu einer Entfernung von etwas über 10 Metern (höchste Intensität), was ich erstaunlich finde.

Zur Seite hin nimmt die Sensibilität bautechnisch bedingt ab, sodass er einen Erfassungsbereich von 70° aufweist. Insgesamt kann man sich aber wirklich nicht beschweren.

PIR Sensor Erfassungsbereich

Neben digitalen Werten gibt es aber auch viele Sensoren, die analoge Werte in Form verschiedener Spannungswerte liefern. Wie diese Messwerte aufbereitet und per UDP-Protokoll übertragen werden können, ist Inhalt des nächsten Blogposts.

Wer sich noch mehr mit dem Arduino-Basics vertraut machen möchte, sollte einmal bei Funduino und Fritzing vorbeischauen.

Hier gibt es jede Menge Informationen für Einsteiger, wobei gerade auch die Fritzing-Videotutorials auf YouTube wirklich gut gemacht sind.

Und noch ein Tipp zum Schluss: Wer selbst Schaltskizzen erstellen möchte, sollte sich das Open-Source-Tool Fritzing der Fachhochschule Potsdam herunterladen.

Es ist für alle gängigen PC-Plattformen verfügbar und bietet eine intuitive Benutzeroberfläche zur schnellen Erstellung komplexer Zeichnungen.

Weiter geht es in der Blogserie mit HowTo Teil 3: Helligkeitssensor per UDP an Loxone anbinden.



Arduino im Smart Home – HowTo Teil 3: Helligkeitssensor per UDP an Loxone anbinden

Bewegungsmelder Fotowiderstand_


Nachdem die Anbindung des digitalen Bewegungssensors im vorangegangen HowTo Teil 2 der Serie "Arduino im Smart Home" beschrieben wurde, folgt nun ein analoger Helligkeitssensor.

Beim technischen Grundaufbau verändert sich im Vergleich zum vorherigen Szenario zwar nicht viel,
dennoch müssen gerade bei der softwareseitigen Umsetzung über die Arduino IDE-Sofware durch die nun analogen Messwerte einige Punkte beachtet werden,
damit die Übertragung per UDP auch in der gewünschten Form abläuft. Wie das im Detail funktioniert und welche Komponenten dazu benötigt werden, wird im nachfolgenden HowTo erläutert.

Helligkeitsmessung per Arduino

Zur Bestimmung der Helligkeit wird ein einfacher Fotowidestand genutzt, welcher später bspw. als Dämmerungssensor eingesetzt werden kann, um das Licht beim Unterschreiten eines bestimmten Helligkeitswertes automatisch einzuschalten.
Er unterscheidet sich im Vergleich zum vorher angebundenen Bewegungsmelder insofern, dass seine Sensorwerte nicht mehr digitale Werte (also 0 und. 1) liefern,
sondern analoge Werte im Bereich 0 und 1023, welche jeweils die gerade gemessene Helligkeit repräsentieren.
Die Messmethode des Fotowiderstands basiert dabei auf einem einfachen physikalischen Prinzip, wobei sich sein eigener Widerstand je nach Helligkeit variabel anpasst.
Je heller es ist, desto geringer wird sein Widerstand und entsprechend höher ist der Strom, der ihn durchfließt. Der Fotowiderstand wird dabei in Reihe mit einem normalen Widerstand geschaltet, welcher einen ähnlichen hohen Widerstand aufweist.
Dadurch wird in nachfolgender Schaltung die notwendige Spannungsteilung erzielt, welche für die Messung durch den Arduino relevant ist.
Der am Fotowiderstand anliegende Spannungswert kann dabei durch einen analogen Pin des Arduino ermittelt und als Zahl im Wertebereich zwischen 0 und 1023 (10 Bit) ausgegeben werden.
Im Endeffekt heisst das: Je heller es ist, desto höher ist auch der vom Arduino gemessene Sensorwert des Fotowiderstands.
Genau die Information, die benötigt wird, um je nach Helligkeit eine gewünschte Aktion auszulösen.

LDR03 LDR05 LDR07

Benötigte Komponenten

Für die Helligkeitsermittlung werden einige Komponenten benötigt, welche (wie beim vorangegangen Szenario auch) für unter 30 Euro erhältlich sind:

Wer das vorangegangene Szenario aus HowTo Teil 2 als Ausgangspunkt verwendet, benötigt für das folgende Setup lediglich die beiden letztgenannten Komponenten aus obiger Liste, die mit weniger als einem Euro zu Buche schlagen und bspw. auch im Set Funduino UNO 8 (Affiliate-Link) B00P0UMEE0 enthalten sind.

Vorbereitung der Hardware

Spätestens jetzt kommt das bisher noch nicht zwingend notwendige Breadboard zum Einsatz, um die Sensoren "geordnet" mit dem Arduino-Board zu verbinden.

Neben dem Bewegungsmelder aus HowTo Teil 2 nehmen nun also auch der Fotowiderstand und der 1K Ohm Widerstand auf dem Breadboard direkt nebeneinnder Platz.

Steckplatinenskizze Fotosensor

Wie bereits angesprochen, werden die beiden neuen Komponenten in Reihe geschaltet, sodass die anliegende Spannung des Arduino-Boards zwischen den Komponenten aufgeteilt wird.


Bewegungsmelder Fotowiderstand


Das eine Ende des Fotowiderstands wird mit +5 V (VCC) verbunden, das andere Ende mit dem analogen Pin A0 des Arduino.

Der 1K Ohm Widerstand, welcher jetzt bereits auch mit einem Ende an +5 V angeschlossen ist, wird jetzt noch über das andere Ende mit GND / GROUND verbunden, sodass der Stromkreis geschlossen wird.


Arduino Board Bewegungsmelder Fotowiderstand

Erstellung des Arduino-Programmcodes

Genutzt wird die bereits in HowTo Teil 2 erstellte Programmlogik, welche nun erweitert wird.

Der komplette Sketch kann nachfolgend auch direkt als Arduino-Datei heruntergeladen werden:   sketch_udp_helligkeitssensor.ino (52 Downloads)

Teil 1 - Grundeinstellungen und Variablendeklaration

Mit dem Befehl "int Helligkeitssensor = 0;" wird der gerade installierte Fotowiderstand definiert. Weiterhin werden einige weitere Variablen deklariert, die für die spätere Auswertung der Messwerte des Fotowiderstands notwendig sind.

Sie werden als eine Art Puffer genutzt, sodass nicht sofort bei geringen Helligkeitsänderungen ein UDP-Befehl in Richtung Smart-Home-Server abgesetzt wird, sondern erst dann, wenn sich die Messwerte seit der letzten Übertragung um "int HelligkeitssensorSchwellwert = 5;" ändern.

Mit "char msg[25];" wird noch eine weitere Variable vom Typ Charakter festgelegt, welche für die UDP-Übertragung der analogen Messwerte als Zeichenkette benötigt wird.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
 
// PIN Settings
#define Bewegungsmelder 2
 
// Variable Declaration
char BewegungsmelderState = 0;
int Helligkeitssensor = 0;
int HelligkeitssensordIdle = 100;
int HelligkeitssensorCounter = 0;
int HelligkeitssensorSchwellwert = 5;
int HelligkeitssensorObergrenze = 0;
int HelligkeitssensorUntergrenze = 0;
char msg[25];
 
// Network Settings
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 3, 19);
IPAddress gateway(192, 168, 3, 1);
IPAddress subnet(255, 255, 255, 0);
 
// Local UDP port to listen on
unsigned int localPort = 7002;
 
// Recipient IP
IPAddress RecipientIP(192, 168, 3, 11);
 
// Recipient UDP Port
unsigned int RecipientPort = 7001;
 
// buffers for receiving and sending data
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
 
// An EthernetUDP instance to send and receive packets over UDP
EthernetUDP Udp;

Teil 2 - Setup

Der Setup-Teil bleibt im Vergleich zum vorhergehenden Szenario unverändert.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void setup()
{
// for debug only
Serial.begin(9600);
 
// start Ethernet
Ethernet.begin(mac,ip);
 
// Start UDP
Udp.begin(localPort);
 
// Bewegungsmelder
pinMode(Bewegungsmelder, INPUT);
 
// send UDP Ready
sendUDP("UDP Ready");
}


Teil 3 - Programmablauf (loop)
An dieser Stelle wird es richtig spannend. Zuerst wird bei jedem "loop"-Durchlauf der aktuelle Helligkeitswert mit "Helligkeitssensor=analogRead(A0);" ermittelt.
Währenddessen zählt ein Counter mit, welcher die Variable "HelligkeitssensorCounter" bei jedem Durchlauf um den Wert 1 erhöht, was später wichtig sein wird.
Als nächstes fragt eine if-Schleife ab, ob der gerade gemessene Wert "Helligkeitssensor" entweder größer oder gleich dem Wert "HelligkeitssensorObergrenze" oder kleiner gleich dem Wert "HelligkeitssensorUntergrenze" ist.
Damit wird verhindert, dass jede kleinste Helligkeitsänderung eine UDP-Nachricht auslöst. Über die Variable "HelligkeitssensorSchwellwert", welche am Anfang festgelegt wurde, kann dieser Schwellwert entsprechend eingestellt werden.
Sofern nun keine der Bedingungen zutrifft, passiert nichts weiter.
Sofern sich aber mindestens eine Bedingung bewahrheitet, kommt sofort die nächste if-Abfrage ins Spiel. Dabei wird geprüft, ob der Wert der Variable "HelligkeitssensorCounter" mindestens genauso groß ist wie der Wert der Variable "HelligkeitssensordIdle". Ist der initial festgelegte Wert von "HelligkeitssensordIdle" groß genug, kann so sichergestellt werden, dass nach dem Senden einer UDP-Mitteilung etwas Zeit vergeht, bevor eine neue Nachricht abgesendet werden kann.
Damit wird verhindert, dass der Empfänger zu viele kurz getaktete Nachrichten hintereinander erhält, sofern sich die Lichtverhältnisse in kürzester Zeit (z.B. Strobo-Licht) drastisch ändern.
Die eigentliche UDP-Nachricht wird dann über "sprintf(msg, "WZ.Helligkeitssensor: %d", Helligkeitssensor);" zusammengesetzt. Dieser "Umweg" ist notwendig, da die "sendUDP"-Funktion den eingelesenen Helligkeitswert direkt als String erwartet. Würde man die Variable "Helligkeitssensor" hingegen direkt in der Funktion selbst angeben, würde der korrekte Wert nicht übermittelt werden.
Zum Schluss werden die neuen Ober- und Untergrenzen ("HelligkeitssensorObergrenze" und "HelligkeitssensorUntergrenze") für den nächsten Durchlauf berechnet und der "HelligkeitssensorCounter" auf 0 zurückgesetzt.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
void loop()
{
 
// Bewegungsmelder (Send)
if (digitalRead(Bewegungsmelder) == LOW && BewegungsmelderState != 0)
{
  sendUDP("WZ.Bewegungsmelder: 0");
  BewegungsmelderState = 0;
}
 
if (digitalRead(Bewegungsmelder) == HIGH && BewegungsmelderState != 1)
{
  sendUDP("WZ.Bewegungsmelder: 1");
  BewegungsmelderState = 1;
}
 
// Helligkeitssensor (Send)
Helligkeitssensor=analogRead(A0);
 
HelligkeitssensorCounter = HelligkeitssensorCounter + 1;
 
if (Helligkeitssensor >= HelligkeitssensorObergrenze || Helligkeitssensor <= HelligkeitssensorUntergrenze)
{
if (HelligkeitssensorCounter >= HelligkeitssensordIdle)
  {
  sprintf(msg, "WZ.Helligkeitssensor: %d", Helligkeitssensor);
  Serial.println(msg);
  sendUDP(msg);
 
  HelligkeitssensorObergrenze = Helligkeitssensor + HelligkeitssensorSchwellwert;
  HelligkeitssensorUntergrenze = Helligkeitssensor - HelligkeitssensorSchwellwert;
  HelligkeitssensorCounter = 0;
  }
}
 
delay(20);
}

Teil 4 - UDP-Sendefunktion

Die Sendefunktion für die UDP-Nachrichten bleibt im Vergleich zum vorangegangenen Szenario unverändert.

1
2
3
4
5
6
7
8
// Function to send UDP packets
void sendUDP(String text)
{
Udp.beginPacket(RecipientIP, RecipientPort);
// Udp.write("Test");
Udp.print(text);
Udp.endPacket();
}

Programmprüfung per "Seriellem Monitor"

Nach dem Flashen des Arduino-Boards bietet die Arduino-Software mit dem "Seriellen Monitor" ein praktisches Tool, um die Programmierung zu überprüfen.

Mit Klick auf "Werkzeuge" -> "Serieller Monitor" wird ein Fenster geöffnet, in welchem die vom Arduino an den PC übertragenen Daten angezeigt werden können.

Damit entsprechende Daten vom Arduino gesendet werden, muss eine Verbindung zum PC hergestellt (am einfachsten per USB-Kabel) und im Setup-Teil des Sketches die Anweisung "Serial.begin(9600);" enthalten sein.

Weiterhin müssen die gewünschten Informationen, bspw. die ermittelten Messwerte, über "Serial.println(msg);" im "loop"-Teil definiert werden und können dann per "Seriellem Monitor" bequem kontrolliert werden.


Arduino IDE Serieller Monitor


Einrichtung des Smart-Home-Servers

In der Loxone-Config lässt sich dann ein neuer "Virtueller UDP Eingang Befehl", in diesem Fall mit dem Namen "WZ.Helligkeitssensor" und der Befehlskennung "WZ.Helligkeitssensor: v", analog zum Beispiel im vorausgegangen Blogpost anlegen und zusammen mit dem Bewegungsmelder aus dem vorangegangen Szenario am virtuellen "Treppenlichtschalter" anschließen.

Er sperrt die Eingänge des Treppenlichtschalters solange er einen Wert kleiner 200 aufweist. Erst ab einem höheren Wert kann der Bewegungsmelder das Licht einschalten.


Loxone Config Virtueller UDP Eingang Befehl Helligkeitssensor


Prüfen von Widerständen

Noch kurz zum Thema Widerstände: Man liest recht häufig, dass gerade günstige Widerstände (Affiliate-Link) durch Produktionsungenauigkeiten teilweise Schwankungen aufweisen.


Widerstaende 200 Ohm


Obwohl das sicher nicht die Regel darstellt, wird an dieser Stelle empfohlen den angegebenen Ohm-Wert von Widerständen

(in diesem Fall ein 1K Ohm Widerstand) vorab mithilfe eines Digitalmultimeters (Affiliate-Link) B000VE5QPY zu überprüfen,

da man bei Widerständen mit zu geringen Ohm-Werten seine Komponenten durch Überspannung gefährdet.


Multimeter 1K Ohm Widerstand

Günstige Multimeter sind zwar auch nur beginnt genau, dennoch sollte das für den Privatanwender mehr als ausreichend sein.


Aus meinem täglichen Leben
Das oben beschriebene Setup habe ich jetzt auch erst seit Kurzem im Einsatz, da ich den Programmcode mehrfach abgeändert habe.
Grund war schlicht die Tatsache, dass ich weder zu viele unnötige, noch zu wenige Messwerte per UDP in Richtung Loxone Miniserver schicken wollte.
Die obige Logik muss sich zwar erst noch bewähren, ich denke aber, dass die Kombination aus "übermittle erst, wenn sich neue erst ein Stück weit von den alten Messwerten unterscheiden" und "übermittle erst, wenn etwas Zeit seit der letzten Übertragung vergangen ist" dauerhaft vernünftig funktionieren sollte. Wer einen besseren Vorschlag hat, gerne wie immer her damit per Kommentarfunktion.
Die ermittelten Messwerte sollten sich irgendwo bei 90 bei Dunkelheit und 800 bei Helligkeit einpendeln.
Diese Werte können, je nach eingesetzten Widerständen, jedoch auch abweichen.
Auf Basis der Messwerte habe ich jetzt meinen Loxone Miniserver entsprechend konfiguriert. Bei Bewegung wird erst dann die Beleuchtung eingeschaltet, sofern die Helligkeit unter den Wert 200 fällt.
Um auf obige Logik zurückzukommen. Grundlegend gibt es zwei Möglichkeiten um festzulegen, welche Parameter darüber entscheiden, unter welchen Voraussetzungen neue Messwerte (per UDP) übertragen werden. Gewöhnlich werden neue Messwerte einfach in regelmäßigen Abständen übertragen, auch wenn sich ein Wert nicht oder nur unwesentlich vom vorherigen Wert unterscheidet.
Die hier angewendete Vorgehensweise, nicht direkt bei jeder unwesentlichen Helligkeitsschwankung sofort einen UDP-Befehl zu übertragen, sondern erst dann, sobald sich der aktuelle Messwert um einen festgelegten Schwellwert seit der letzten Übertragung geändert hat, halte ich in diesem Fall für eine elegantere Lösung.
Auf diese Weise werden "unnötige" Nachrichten vermieden, die nichts anderes tun, als den bisherigen (identischen) und bereits übertragenen Wert auf Seiten des Smart-Home-Servers zu bestätigen.
Auf der anderen Seite können bei höheren, schnell aufeinanderfolgenden Messwertänderungen, die den vorgegebenen Schwellwert überschreiten, schnell getaktete UDP-Befehle hintereinander abgesetzt werden, was jedoch durch obige Logik dennoch gewollt begrenzt werden kann.
Auf diese Weise ist die Smart-Home-Zentrale immer auf dem Laufenden und kann verzögerungsfrei reagieren und bspw. sofort das Zimmerlicht einschalten, sobald die Rollos herunterfahren und den Raum verdunkeln.
Weiter geht es in der Blogserie mit HowTo Teil 4: Status-LED per UDP ansteuern.



Arduino im Smart Home – HowTo Teil 4: Status-LED per UDP ansteuern

LED-Leuchtdioden_

In den ersten drei Artikeln der Serie Arduino im Smart Home wurden nach einer kurzen Einführung in die Thematik sowohl digitale als auch analoge Messwerte über einen Arduino Uno erfasst und per UDP-Protokoll mithilfe eines Ethernet Shield an die netzwerkseitig angebundene Smart-Home-Zentrale Loxone gesendet. Daneben lassen sich über das Arduino-Board aber nicht nur Sensorwerte erfassen, sondern auch Aktoren steuern, wobei hierfür mehrere Möglichkeiten zur Verfügung stehen.

Zu diesem Zweck sendet die Smart-Home-Zentrale Loxone (oder FHEM) eine UDP-Nachricht an den Arduino, welcher eine dort angeschlossene LED-Diode ansteuert.

Umgesetzt wird das Ganze über eine LED-Leuchtdiode, welche den aktuellen Verbindungsstatus der angebundenen Smart-Home-Zentrale signalisiert.

Eine leuchtende LED gibt so schnell Auskunft darüber, dass eine funktionstüchtige Netzwerkverbindung zwischen Arduino und Zentrale hergestellt ist.

Wie das im Detail funktioniert und welcher entscheidende Zusatznutzen in Kombination mit der Arduino-Programmlogik entsteht, wird in nachfolgendem Artikel erläutert.

Signal-LED per Arduino schalten

Zur Anzeige des aktuellen Onlinestatus der Smart-Home-Zentrale wird eine grüne LED-Leuchtdiode an Pin 4 des Arduino angeschlossen, welcher nicht nur als digitaler Eingang, sondern wie in diesem Anwendungsfall, auch als digitaler Ausgang genutzt werden kann.

LED-Leuchtdiode

 

Da die hier verwendete grüne LED-Leuchtiode nativ für eine Spannung von 3,7 V ausgelegt ist, der Arduino jedoch eine Versorgungsspannung von 5 V aufweist, wird die LED in Reihe mit einem 100 Ohm Widerstand geschaltet, um ein Durchbrennen zu vermeiden.

Der Widerstand ist so berechnet, dass er die überschüssige Spannung schluckt und diese in Wärme umwandelt, wodurch die LED nur noch die benötigte Betriebsspannung erhält.

Wer eine andersfarbige LED (weiß, gelb, blau) aus einem Funduino Lernset (Affiliate-Link) verwenden möchte, kann ebenfalls einen 100 Ohm Widerstand als Spannungsteiler nutzen, im Fall der roten LED muss jedoch ein 200 Ohm Widerstand eingesetzt werden, da die rote LED für 2,1 V konzipiert wurde.


LED-Leuchtdioden

 

 LED-gestützter Onlineverbindungsstatus

Damit der Onlineverbindungsstatus zuverlässig ermittelt werden kann, nutzt das nachfolgende Szenario zwei zusammenspielende Sende- und Empfangsbenachrichtigungen.

Konzept Onlineverbindungsstatus

 

Der Arduino sendet in regelmäßigen Abständen per UDP-Nachricht ein Lebenszeichen in Form von "Ping" an den Smart-Home-Server. Sobald der Smart-Home-Server (in diesem Beispiel Loxone) die Nachricht empfängt, sendet er zwei direkt aufeinanderfolgende"Pong"-Rückantworten mit dem Inhalt "000" und "001" an den Arduino zurück.

Sobald diese Nachrichten dort eingeht, wird die grüne LED geschaltet. Empfängt der Arduino in einem festgelegten Zeitraum keine Rückantwort (Timeout), wird die LED ausgeschaltet. Mehr Details dazu dann direkt in der Erläuterung zum Arduino-Programm.

Benötigte Komponenten

Für die Ansteuerung einer Signal-LED zur Anzeige des Onlineverbindungsstatus der angebundenen Smart-Home-Zentral werden einige Komponenten benötigt, welche (wie beim vorangegangen Szenario auch) für unter 30 Euro erhältlich sind:

Wer die vorangegangenen Szenarien (HowTo Teil 2 und HowTo Teil 3) als Ausgangspunkt nutzt, benötigt für das folgende Setup lediglich die beiden letztgenannten Komponenten aus obiger Liste, die mit weniger als einem Euro zu Buche schlagen und bspw. bereits im Lernset Funduino UNO 8 (Affiliate-Link) enthalten sind.

Vorbereitung der Hardware

Das bereits für die vorherigen Szenarien eingesetzte Breadboard wird mit einer grünen LED-Leuchtdiode und einem 100 Ohm Widerstand erweitert, welche in Reihe geschaltet werden.

Da der elektrische Strom nur in einer Richtung durch die LED fließt, muss auf die korrekte Polarisation geachtet werden.

Der längere Kontakt der LED-Leuchtdiode (in der Zeichnung mit dem abgeknickten rechten Beinchen symbolisiert) wird gewöhnlich an VCC (+5 V) (in diesem Fall am Pin 4 des Arduino-Boards) und der kürzere Kontakt über den benachbarten Widerstand an GND (Ground) angeschlossen.


Steckplatinenskizze Status-LED

Die Installation füllt sich dabei weiter mit Leben, wobei das Ganze durch den Einsatz des Breadboards dennoch überraschend übersichtlich bleibt.


Arduino Board LED


Wie man unschwer erkennen kann, ist sogar noch genügend Platz auf dem Breadboard für spätere Erweiterungen.

Langsam wird es aber dennoch Zeit für einen neuen Satz Drahtbrücken (Affiliate-Link), damit es künftig keine Engpässe bei der prototypischen Verkabelung gibt.


Arduino Board Bewegungsmelder Fotowiderstand LED

Erstellung des Arduino-Programmcodes

Genutzt wird die bereits in HowTo Teil 3 erstellte Programmlogik, welche teilweise etwas verbessert wurde und nun erweitert wird.
Der komplette Sketch kann nachfolgend auch direkt als Arduino-Datei heruntergeladen werden: sketch_onlinestatus_led.ino (62 Downloads)

Teil 1 - Grundeinstellungen und Variablendeklaration
Da eine schnelle Response-Zeit z.B. beim Bewegungsmelder oder einem Tastendruck erzielt werden soll, ist es notwendig, dass der Arduino-Programmcode mehrmals pro Sekunde durchlaufen wird.
Damit man die Timings für verschiedene Intervallabfragen adäquat umsetzen kann, wird die Variable "Programmfrequenz" eingeführt, die mit einem Wert von 50 (Hz) für den Anwendungsfall passend erscheint.
Die angegebene Variable wirkt sich dabei maßgeblich auf das am Ende des loop-Teils angegebene Delay "delay(1000/Programmfrequenz);" aus, wodurch dem Arduino pro Programmdurchlauf eine Zwangspause von 20 ms (1000/50) auferlegt wird, was in der Konsequenz einer Programmfrequenz von 50 Hz entspricht.
Über die Variable "OnlinestatusCheckEachSekOnline" wird angegeben, in welchem zeitlichen Abstand ein "Ping"-Impuls vom Arduino versendet wird. Testweise ist dieser Wert auf 10 Sekunden gesetzt, künftig soll er den Wert 60 tragen, so dass der Onlinestatus jede Minute abgefragt werden kann.
Dieser Wert wird dabei situationsbedingt nur dann verwendet, sofern der vorausgegangene Onlinecheck erfolgreich war und eine Rückantwort eingegangen ist.
War der letzte Check negativ (keine Rückantwort vom Empfänger), wird stattdessen der Wert der Variablen "OnlinestatusCheckEachSekOffline" verwendet. Der Hintergrund ist, dass der Arduino nach einer Verbindungstrennung in kürzeren Intervallen ein "Ping"-Signal aussenden soll, damit der Status schneller korrigiert wird, sobald die Verbindung wieder steht. Vermutlich kann dieser Wert auch langfristig mit 2 (Sekunden) besetzt werden.
Die Variable "OnlinestatusCheckTimeoutSek" gibt an, wieviele Sekunden vom Aussenden der "Ping"-Nachricht bis zur "Pong"-Antwort der Zentrale maximal vergehen dürfen, bis der Status von "Online" auf "Offline" wechselt.
Mit den hier angegebenen Werten kam es bei ersten Tests zwischen Arduino und Loxone im Schnitt über mehrere Stunden hinweg zu keinen Paketverlusten, was für die Testumgebung ein gutes Setting darstellt. Im späteren Dauerbetrieb sollte der Wert auf mehrere Sekunden erhöht werden, um einen größeren Puffer einzubauen.
Danach folgen weitere Variablen, die unter anderem auch zur Berechnung bzw. Umrechnung der in Sekunden angegebenen Parameterwerte in die Laufzeitumgebung des Arduino genutzt werden.
So wird aus dem in Sekunden angegebenen Wert "OnlinestatusCheckEachSekOnline" (10) durch die Multiplizierung mit der angegebenen "Programmfrequenz" (50) die im weiteren Programmcode verwendete Variable "OnlinestatusCheckOnline" (10 x 50 = 500) gebildet, sodass durch die noch folgende Logik im loop-Teil nur bei jedem 500. Programmdurchlauf (also alle 10 Sekunden) ein Ping-Signal ausgesendet wird.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
 
// PIN Settings
#define Bewegungsmelder 2
#define OnlinestatusLED 4
 
// Variable Declaration
int Programmfrequenz = 50; // loop-Durchlauf pro Sekunde (ca.)
 
int HelligkeitssensordIdleSek = 2; // Minimale Pause zwischen zwei Helligkeitbenachrichtigungen in Sek
int HelligkeitssensorSchwellwert = 10; // Schwellwert fuer Helligkeitsbenachrichtigungen (empfohlen 5-20)
 
int OnlinestatusCheckEachSekOnline = 10; // Ping in Sek wenn letzter Status Online war
int OnlinestatusCheckEachSekOffline = 2; // Ping in Sek wenn letzter Status Offline war
int OnlinestatusCheckTimeoutSek = 1; // Status auf Offline setzen wenn Rueckmeldung nicht innerhalb x Sek
 
char BewegungsmelderState = 0;
int Helligkeitssensor = 0;
int HelligkeitssensorCounter = 0;
int HelligkeitssensorObergrenze = 0;
int HelligkeitssensorUntergrenze = 0;
char msg[25];
int HelligkeitssensordIdle = HelligkeitssensordIdleSek * Programmfrequenz;
int OnlinestatusSendCounter = 0;
int OnlinestatusReceiveCounter = 0;
char OnlinestatusLoxone = 0;
int OnlinestatusCheckOnline = OnlinestatusCheckEachSekOnline * Programmfrequenz;
int OnlinestatusCheckOffline = OnlinestatusCheckEachSekOffline * Programmfrequenz;
int OnlinestatusCheckTimeout = (OnlinestatusCheckTimeoutSek + OnlinestatusCheckEachSekOnline) * Programmfrequenz;
 
// Network Settings
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 3, 19);
IPAddress gateway(192, 168, 3, 1);
IPAddress subnet(255, 255, 255, 0);
 
// Local UDP port to listen on
unsigned int localPort = 7002;
 
// Recipient IP
IPAddress RecipientIP(192, 168, 3, 11);
 
// Recipient UDP Port
unsigned int RecipientPort = 7001;
 
// buffers for receiving and sending data
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
 
// An EthernetUDP instance to send and receive packets over UDP
EthernetUDP Udp;

Teil 2 - Setup

Im Setup-Teil wird im Vergleich zum vorhergehenden Szenario lediglich die neu verwendete grüne Status-LED an Pin 4 als "pinMode" mit dem Attribut "OUTPUT" definiert.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void setup()
{
// for debug only
Serial.begin(9600);
 
// start Ethernet
Ethernet.begin(mac,ip);
 
// Start UDP
Udp.begin(localPort);
 
// Bewegungsmelder
pinMode(Bewegungsmelder, INPUT);
 
//OnlinestatusLED
pinMode(OnlinestatusLED, OUTPUT); // LED an Pin4
 
// send UDP Ready
sendUDP("UDP Ready");
}


Teil 3 - Programmablauf (loop)
Der nun recht umfangreiche loop-Teil kümmert sich nun um das Aussenden und Empfangen der UDP-Mitteilungen sowie deren Auswertung.
Zuerst werden zwei if-Bedingungen für das situationsbezogene zeitliche Versenden der "Ping"-Nachricht definiert.
Die erste if-Abfrage wird getriggert, sobald der in jedem loop-Durchlauf um den Wert 1 erhöhte Zähler "OnlinestatusSendCounter" mit dem oben durch den Nutzer festgelegten "OnlinestatusCheckOnline" übereinstimmt und weiterhin der Wert von "OnlinestatusReceiveCounter", welcher die Zeit seit dem letzten Versenden der Ping-Nachricht berechnet, nicht mit dem vom Nutzer angegebenen bzw. berechneten Wert von "OnlinestatusCheckTimeout" übereinstimmt.
Die zweite Abfrage ist für den Fall gedacht, dass die letzte Ping-Anfrage im Nirvana gelandet ist. In diesem Fall ist der Unterscheid zur vorherigen if-Abfrage, dass nun "OnlinestatusReceiveCounter" und "OnlinestatusCheckTimeout" übereinstimmen.
Sobald eine der if-Bedignungen erfüllt ist, wird der "Ping" ausgesendet und der Durchzählwert von "OnlinestatusSendCounter" resettet.
Nachdem die Ping-Nachricht beim Empfänger eintrifft, werden zwei kurz hintereinander getaktete "Pong"-Rückmeldungen von der Smart-Home-Zentrale mit den Werten "000" und "001" in Richtung Arduino zurückgesendet (Details dazu weiter unten im Programmcode).
Beim Eintreffen der ersten Nachricht (000) wird der Wert von "OnlinestatusReceiveCounter" auf 0 zurückgesetzt und bei der zweiten Nachricht (000) der Statuswert "OnlinestatusLoxone" auf 1 gesetzt.
Weiterhin wird die installierte grüne LED an Pin 4 mit der Anweisung "digitalWrite(OnlinestatusLED, HIGH);" mit Strom versorgt.
Dieser "Umweg" mit zwei Nachrichten erschien notwendig, da der UDP-Empfangspuffer des Arduino nur einmal kurz die Variable "OnlineStatusReceiveCounter" resetten soll.
Würde der Empfangspuffer, der durch die erste Nachricht mit "000" gefüllt ist, direkt im Anschluss nicht mit dem Wert "001" überschrieben werden, würde bei jedem neuen Programmdurchlauf weiterhin "000" im Puffer stehenbleiben, so dass immer wieder der Variablenwert von "OnlineStatusReceiveCounter" zurückgesetzt werden würde und dieser nicht mehr hochzählen könnte, sofern nicht zufällig eine anderslautende eingehende UDP-Nachricht den UDP-Puffer überschreibt. Vermutlich lässt sich dieser eher unsaubere Workaround auch viel eleganter lösen, jedoch mangelt es mir derzeitig an dem dafür notwendigen Hintergrundwissen.

Mit "if (OnlinestatusReceiveCounter < OnlinestatusCheckTimeout)" wird weiterhin geprüft, ob der Zähler "OnlinestatusreceiverCounter" kleiner ist als der hinterlegte Timeout durch "OnlinestatusCheckTimeout". Sofern das der Fall ist, wird der Wert von "OnlinestatusReceiverCounter" um 1 erhöht.

Dadurch wird erreicht, dass das Hochzählen automatisch gestoppt wird, sobald der Timeout stattfindet.
Sobald der Timeout einmal erreicht ist (letzte if-Abfrage des Loops), wird der Status von "OnlinestatusLoxone" auf 0 gesetzt und die LED mit dem Befehl "digitalWrite(OnlinestatusLED, LOW);" ausgeschaltet.
Wer das Ganze nicht sofort durchblickt, knappt sich am besten eine Tasse Kaffee und spielt die einzelnen Punkte des Loops noch einmal gedanklich durch.
Es hat auch einige Zeit gedauert und Nerven gekostet, bis dieser Lösungsweg in der vorliegenden Form zuverlässig lief. Wer Verbesserungen zum Code einbringen möchte, kann gerne die Kommentarfunktion nutzen. Ich bin mit C und UDP-Empfangspuffern nicht wirklich fit, vermutlich lässt sich das Ganze noch viel eleganter umsetzen.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
void loop()
{
 
checkUDP();
 
// Bewegungsmelder (Send)
if (digitalRead(Bewegungsmelder) == LOW && BewegungsmelderState != 0)
{
  sendUDP("WZ.Bewegungsmelder: 0");
  BewegungsmelderState = 0;
}
 
if (digitalRead(Bewegungsmelder) == HIGH && BewegungsmelderState != 1)
{
  sendUDP("WZ.Bewegungsmelder: 1");
  BewegungsmelderState = 1;
}
 
// Helligkeitssensor (Send)
Helligkeitssensor=analogRead(A0);
 
HelligkeitssensorCounter = HelligkeitssensorCounter + 1;
 
if (Helligkeitssensor >= HelligkeitssensorObergrenze || Helligkeitssensor <= HelligkeitssensorUntergrenze)
{
 
  if (HelligkeitssensorCounter >= HelligkeitssensordIdle)
  {
   sprintf(msg, "WZ.Helligkeitssensor: %d", Helligkeitssensor);
   Serial.println(msg);
   sendUDP(msg);
 
   HelligkeitssensorObergrenze = Helligkeitssensor + HelligkeitssensorSchwellwert;
   HelligkeitssensorUntergrenze = Helligkeitssensor - HelligkeitssensorSchwellwert;
   HelligkeitssensorCounter = 0;
  }
}
 
// Onlinestatus-Ping (Send)
OnlinestatusSendCounter = OnlinestatusSendCounter + 1;
 
if (OnlinestatusSendCounter == OnlinestatusCheckOnline && OnlinestatusReceiveCounter != OnlinestatusCheckTimeout)
{
  Serial.println("SendUDP: Ping");
  sendUDP("Ping");
  OnlinestatusSendCounter = 0;
}
 
if (OnlinestatusSendCounter == OnlinestatusCheckOffline && OnlinestatusReceiveCounter == OnlinestatusCheckTimeout)
{
  Serial.println("SendUDP: Ping");
  sendUDP("Ping");
  OnlinestatusSendCounter = 0;
}
 
// Onlinestatus-Pong (Receive)
if (!strcmp(packetBuffer, "000"))
{
  OnlinestatusReceiveCounter = 0;
}
 
if (!strcmp(packetBuffer, "001"))
{
  OnlinestatusLoxone = 1;
  digitalWrite(OnlinestatusLED, HIGH);
}
 
if (OnlinestatusReceiveCounter < OnlinestatusCheckTimeout)
{
  OnlinestatusReceiveCounter = OnlinestatusReceiveCounter + 1;
}
 
if (OnlinestatusReceiveCounter == OnlinestatusCheckTimeout)
{
  OnlinestatusLoxone = 0;
  digitalWrite(OnlinestatusLED, LOW);
}
 
delay(1000/Programmfrequenz);
}

Teil 4 - UDP-Sendefunktion

Die Sendefunktion für die UDP-Nachrichten bleibt im Vergleich zum vorangegangenen Szenario unverändert.

1
2
3
4
5
6
7
8
// Function to send UDP packets
void sendUDP(String text)
{
Udp.beginPacket(RecipientIP, RecipientPort);
// Udp.write("Test");
Udp.print(text);
Udp.endPacket();
}

Teil 5 - UDP-Empfangsfunktion

Die Empfangsfunktion für die UDP-Nachrichten ist der Gegenpart zur der soeben in Teil 4 angesprochenen Sendefunktion und wird abschließend deklariert.

Wer möchte, kann den auskommentierten Teil am Ende der Funktion für Testzwecke aktivieren, damit beim Empfang einer neuen eingehenden UDP-Nachricht der Wert "ACK" an den Sender zurückübermittelt wird.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Function to check for new incoming UDP packets
void checkUDP()
{
// if there's data available, read a packet
int packetSize = Udp.parsePacket();
if(packetSize)
{
  // read the packet into packetBufffer
  Udp.read(packetBuffer,UDP_TX_PACKET_MAX_SIZE);
 
  // For debug only
  // Write packetBuffer to serial
  Serial.print("ReceiveUDP: ");
  Serial.println(packetBuffer);
 
  // send "ACK" as reply
  //Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
  //Udp.write("ACK");
  //Udp.endPacket();
}
}

Einrichtung des Smart-Home-Servers

In der Loxone-Config werden nun ebenfalls zwei Komponenten benötigt. Zum einen der "Virtueller UDP Eingang Befehl", welcher die Nachricht des Arduino mit dem Wert "Ping" entgegennimmt und zum anderen der "Virtuellen Ausgang Befehl", welcher die beiden Nachrichten "000" und "001" in Richtung Arduino zurücksendet.

In Eingangsrichtung wird der bereits im HowTo Teil 2 eingeführte "Virtuelle Eingang" namens "WZ.Arduino" mit dem Empfangsport "7001" genutzt. Ihm untergliedert wird nun der "Virtuelle Eingang Befehl" namens "Ping", welcher mit der Option "Als Digitaleingang verwenden" angelegt wird. Die "Befehlserkennung" lautet dabei schlicht "Ping".

Loxone Config Anwesenheitsstatus Ping

Der Gegenpart ist der "Virtueller Ausgang" mit der "Adresse" "/dev/udp/192.168.3.19/7002". Hier werden die zugewiesene IP des Arduino "192.168.3.19" und dessen UDP-Port "7002" angegeben, damit die Pakete auch zum Empfänger gelangen.

Loxone Config Virtueller Ausgang UDP

Ihm unterstellt wird der "Virtuelle Ausgang Befehl" namens "Pong", der im Falle von "Befehl bei Ein" den Wert "000" und im Falle von "Befehl bei Aus" den Wert "001" kurz nacheinender zurück an den Arduino überträgt.

Loxone Config Anwesenheitsstatus Pong


Da der UDP-Empfangspuffer des Arduino eher rudimentärer Natur ist, sollte er grundsätzlich nur mit Stringwerten gefüttert werden, die alle die selbe Länge (in diesem Fall die Länge von 3 Zeichen) aufweisen.

Anfangs hatte ich bspw. abwechselnd "Pong" und "Reset" zurückgesendet. Sobald jedoch der neu eintreffende Wert "Pong" den bereits im UDP-Empfangspuffer stehenden Wert "Reset" überschreiben sollte, stand plötzlich "Pongt" im Puffer, da sich die Strings in der Länge unterscheiden und anscheinend ein kurzer String einen bereits im Puffer befindlichen längeren String nicht komplett überschreibt. Eine wichtige Erkenntnis, die auf jeden Fall berücksichtigt werden muss, um nicht in unnötige Probleme zu laufen.

Ein zusätzlicher virtueller "Treppenlichtschalter", welcher am "Ping"-Signal angeschlossen ist, gibt auf Seiten von Loxone schließlich noch Aufschluss über den aktuellen "Onlinestatus" des Arduino.

Ein Treppenlichtschalter bietet sich dabei gerade für Tests an, da durch seinen "Sanduhreffekt" sehr schnell deutlich wird, wann der letzte "Ping" erfolgt ist und wie lange es noch bis zum potenziellen Timeout dauert.

Die Ausschaltzeit wurde dabei testweise auf 11 Sekunden (nur eine Sekunde höher als die Standard-Ping-Zeit des Arduino) gesetzt. Dieser sollte jedoch künftig hochgesetzt werden, um das Timeout sinnvollerweise zu erhöhen.


Loxone iPhone App Onlinestatus

Aus meinem täglichen Leben

Ursprünglich wollte ich nur kurz beschreiben, wie eine UDP-Nachricht an den Arduino gesendet und eine einfache LED mithilfe des Befehls "digitalWrite(OnlinestatusLED, HIGH);" geschaltet werden kann.

Da ich jedoch schon von Anfang an eine zuverlässige Möglichkeit gesucht habe, um schnell prüfen zu können, ob aktuell ein Datenaustausch zwischen Arduino und Smart-Home-Zentrale möglich ist, habe ich kurzerhand obiges Szenario umgesetzt. Nichtsahnend, dass die Umsetzung doch etwas länger dauert und mehr logische Abfragen benötigt, als ursprünglich erwartet. Gerade der UDP-Empfangspuffer hat mir dabei etwas Kummer bereitet.

Bis auf diese Tatsache, dass aktuell eine "doppelte Rückmeldung" vom Arduino erwartet wird, finde ich das Gesamtkonzept jedoch schon recht rund.

Zukünftig lässt sich der Onlinestatus auch noch für viel spannendere Dinge nutzen als "nur" den aktuellen Verbindungsstatus per LED zu kontrollieren.

Dadurch, dass künftig bspw. auch Verbraucher über Relais am Arduino per Smart-Home-Zentrale geschaltet werden sollen (HowTo folgt im nächsten Blogpost), lässt sich der Onlinestatus gerade auch für situationsbedingte Schaltvorgänge in Abhängigkeit der Netzwerkverfügbarkeit nutzen.

Besteht eine Verbindung zwischen Arduino und Smart-Home-Server (Loxone oder FHEM), leitet ein am Arduino angeschlossener Taster den Tastendruck regulär an Loxone weiter.

Dort wird der Befehl ausgewertet und der am Arduino betriebene Aktor (z.B. Beleuchtung) erst dann geschaltet, sofern es die Zentral zulässt (z.B. bei geringer Helligkeit).

Besteht jedoch gerade keine Verbindung zur Zentrale, kann der Tastendruck des Arduino per Fallback über die Programmregel "wenn Onlinestatus = 0" den Aktor direkt schalten.

Dadurch wird die aus meiner Sicht derzeit noch größte Schwachstelle vieler zentraler Lösungen auf smarte Weise umgangen , die auf dem Konzept einer Smart-Home-Zentrale basieren (dazu gehört gerade auch Loxone).

Ein an der Smart-Home-Zentrale angebundener Arduino, welcher als ein solches "Gateway" eingesetzt wird, kann auf diese Weise mit einer Grundintelligenz ausgestattet werden, die trotz temporärer Nichtverfügbarkeit der Zentrale zumindest rudimentäre Aktionen (Licht an, Rollos hoch) umsetzen kann.

Konzept Onlineverbindungsstatus Standard Fallback

Ein spannendes Zusatzfeature, welches ich bisher noch gar nicht auf dem Schirm hatte und das aus meiner Sicht einen wertvollen Zusatznutzen generiert, auch wenn die Infrastruktur so konzipiert ist, dass die Zentrale dauerhaft erreichbar ist.

Manchmal ist sie es, egal ob gewollt (Neustart, Update) oder nicht (Fehlkonfiguration, Absturz, Stromausfall, Austausch) doch einmal nicht.

Was hältst du von dieser durch den Arduino ermöglichten Fallback-Lösung? Stimme einfach ab und hinterlasse einen Kommentar.



Arduino im Smart Home – HowTo Teil 5: 24 V LED-Spot per Schaltrelais ansteuern

Schaltrelais LED-Spot


Nachdem im vorangegangenen HowTo Teil 4 der Blogserie Arduino im Smart Home eine Status-LED über den Arduino angesteuert wurde, folgt nun im direkten Anschluss die netzwerkseitige Anbindung eines weiteren digitalen Aktors.

Durch den Einsatz von günstigen Schaltrelais lassen sich dabei auch leistungshungrige Verbraucher, wie bspw. LED-Lampen, ein- und ausschalten, die sich aufgrund höherer Spannungen und Stromstärken nicht direkt an den Pins des Arduino betreiben lassen.

Welche Komponenten dazu notwendig sind und wie der Aufbau im Fall eines 24 V LED-Spot aussieht, ist Inhalt des nachfolgenden Artikels.

Relaisschaltung per Arduino

In diesem Beispiel wird das Relaismodul aus dem Funduino Set 8 (Affiliate-Link) verwendet, mit dem ein Verbraucher mit bis zu 10 A geschaltet werden kann.

Das deutsche Stromnetz aus der "Steckdose" liefert eine Wechselspannung von knapp 220 V, was bedeutet, dass theoretisch Verbraucher bis zu 2.200 W (220 V x 10 A) über das Relais betrieben werden können. Weiterhin sind auch andere (Mehrfach-)Relaismodule erhältlich, die je nach Modell bis zu acht Verbraucher (Affiliate-Link) gleichzeitig ansteuern können und umgerechnet oft weniger als ein Euro pro Kanal kosten.

Mittlerweile sind zudem noch größere Schaltrelais-Module mit 16 Kanälen (Affiliate-Link) verfügbar.


Schaltrelais

Bevor es an die Installation von Verbrauchern an den Relais geht, sollte man sich jedoch im Vorfeld intensiv mit dem Thema Elektrizität auseinandersetzen, da es gefährlich werden kann, sobald man unbedarft an die Sache herangeht.

Hinweis zum Umgang mit elektrischen Strömen

Bei Arbeiten an Elektroinstallationen, die vorgegebene Grenzwerte für Kleinspannung von 50 V AC (Wechselspannung) bzw. 120 V DC (Gleichspannung) überschreiten, besteht Lebensgefahr! Sofern auf einen Schutz gegen Berühren (Isolation) verzichtet wird, dürfen weiterhin die Grenzwerte von 25 V AC (Wechselspannung) bzw. 60 V DC (Gleichspannung) nicht überschritten werden.

Arbeiten oberhalb der Grenzen von 25 V AC (Wechselspannung) bzw. 60 V DC (Gleichspannung) sollen und dürfen deshalb nur von ausgebildetem Fachpersonal ausgeführt werden.

Wer höhere externe Spannungen als die vom Arduino-Board bereitgestellten 9 V DC (Gleichspannung) nutzen möchte, muss sich deshalb im Vorfeld genau über die Grenzwerte im Klaren sein, da sonst Lebensgefahr bestehen kann.

Weiterhin sollten die Pins des Arduino auf keinen Fall direkt (ohne Einsatz von passenden Relais) mit externen Stromquellen verbunden werden, die 9 V DC (Gleichspannung) überschreiten.

Der Arduino scheint zwar bis 24 V DC (Gleichspannung) in gewissem Maße "abgesichert" zu sein, ein Dauerbetrieb solcher Spannungen ist jedoch nicht vorgesehen und schädigt die Hardware dauerhaft. AC (Wechselspannung) darf nicht direkt am Arduino betrieben werden, da er dafür nicht ausgelegt ist.

Oben genannte Grenzwerte haben ihre Berechtigung, an die sich jeder unbedingt halten sollte. Also Finger weg vom Strom direkt aus der "Steckdose", welche gewöhnlich 220 V AC (Wechselspannung) liefert.

24 V LED-Spot am Schaltrelais installieren

Aus oben genannten Gründen wird an dieser Stelle auf die Ansteuerung von Verbrauchern mit 220 V AC (Wechselspannung) verzichtet

und stattdessen die Anbindung eines 10 W LED-Spot von revoart mit der laut obigen Grenzwerten vertretbaren Spannung von 24 Volt DC (Gleichspannung) verdeutlicht.


LED-Spot


Das Relais übernimmt dabei die Aufgabe, die vom Arduino anliegende Steuerspannung in Höhe von 5 V nutzbar zu machen, um einen abhängigen Laststromkreis zu schalten, über den eine höhere Verbrauchsspannung fließen kann, welche für den Betrieb des LED-Spots verwendet werden kann.

Das Prinzip basiert dabei auf der galvanische Trennung, sodass beide elektrischen Ströme voneinander getrennt sind.

Wer mehr Details nachlesen möchte, kann das Funktionsprinzip mechanischer Relais auf Wikipedia genauer studieren.


Testinstallation 24 V LED-Lampe Schaltrelais Detail 2


Der LED-Spot bezieht seine Betriebsspannung von 24 V DC (Gleichstrom) über eine separate Stromquelle, einem Mean Well Schienennetzteil mit max. 10 A (Affiliate-Link),

welches für den gleichzeitigen Betrieb mehrerer Verbraucher bis zu 240 W Gesamtleistung verwendet werden kann (bis zu 24 der hier verwendeten 10 W LED-Spots).


24 V Schienennetzteil


Der Minuspol "-V" des Netzteils wird über eine Lüsterklemme direkt mit dem entsprechenden Anschluss der LED-Lampe verbunden.

Der Pluspol "+V" des Netzteils wird über das Schaltrelais mit der LED-Lampe verbunden, sodass dieses den Stromfluss je nach Anwenderwunsch herstellen bzw. trennen kann.


Testinstallation 24 V LED-Lampe Schaltrelais Netzteil


Die Zuleitung vom Netzteil "+V" wird mit der mittleren Schraubklemme (Anschluss A) des Schaltrelais verbunden.

Erfolgt die "Weiterleitung" zur LED-Lampe über die rechts davon angebrachte Schraubklemme (Anschluss B), schließt der Kontakt, solange vom Arduino keine Steuerspannung anliegt (Öffner/Ruhekontakt/Normally Closed).

Wird die weiterführende Leitung zur LED-Lampe hingegen nicht mit der rechten, sondern mit der linken Schraubklemme (Anschluss C) verbunden, kehrt sich die Logik um.

Wenn eine Steuerspannung vom Arduino angelegt wird, fließt Strom durch das Relais und die LED-Lampe leuchtet (Schließer/Arbeitskontakt/Normally Open).


Schaltrelais Anschluesse


Benötigte Komponenten

Für die Ansteuerung des LED-Spots werden einige Komponenten benötigt, welche (wie beim vorangegangen Szenario auch) für unter 30 Euro erhältlich sind:
Arduino Uno (Affiliate-Link)
Arduino Ethernet Shield (Affiliate-Link)
Steckbrücken (Affiliate-Link)
Breadboard (Affiliate-Link)
1-Kanal Schaltrelais (Affiliate-Link)
9 V Netzteil (Affiliate-Link)

Wer die vorangegangenen Szenarien als Ausgangspunkt nutzt, benötigt für das folgende Setup lediglich die beiden letztgenannten Komponenten obiger Liste, die mit knapp 10 Euro zu Buche schlagen.
Das Schaltrelais ist dabei bereits im Lernset Funduino UNO 8 (Affiliate-Link) enthalten.
Das 9 V Netzteil, welches den Arduino mit Strom versorgt, ist jetzt zwingend notwendig, da das Schaltrelais bei "angezogenem" Kontakt mehr Strom konsumiert als durch die bisher genutzte Stromversorgung des Arduio über USB (5 V) geliefert wird.
Wird kein separates Netzeil verwendet, fällt die Spannung aufgrund des angeschlossenen Relais an den Pins des Arduino auf knapp 4 V ab, was sich auch auf andere Sensoren auswirkt.
Der Bewegungsmelder liefert dann bspw. fälschlicherweise ein "Motion"-Signal, obwohl keine Bewegung stattfindet.
Weiterhin wird noch ein Verbraucher und eine Stromquelle, wie im Fall des verwendeten 24 V LED-Spot, ein passenden Netzteil mit genügend Leistung benötigt.

Vorbereitung der Hardware

Das bereits für die vorherigen Szenarien eingesetzte Breadboard wird mit einigen Steckbrücken erweitert, um die Verbindung mit dem Schaltrelais herstellen zu können.
Neben +5 V (rot) und GND (schwarz), die über die beiden unteren Kontaktereihen des Breadboard weitergereicht werden, wird weiterhin Pin 5 des Arduino als Signalkabel (blau) für die Ansteuerung des Schaltrelais verwendet.


Steckplatinenskizze Schaltrelais

Erstellung des Arduino-Programmcodes

Genutzt wird die bereits in HowTo Teil 4 erstellte Programmlogik, welche teilweise wieder etwas angepasst wurde und nun erweitert wird.

Der komplette Sketch kann nachfolgend auch direkt als Arduino-Datei heruntergeladen werden:  sketch_relais.ino (40 Downloads)

Teil 1 - Grundeinstellungen und Variablendeklaration

Die einzige Erweiterung, die in Teil 1 des Arduino-Programmcodes notwendig ist, definiert das Schaltrelais an Pin 5. Der restliche Code bleibt unverändert.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
 
// PIN Settings
#define Bewegungsmelder 2
#define OnlinestatusLED 4
#define Schaltrelais 5
 
// Variable Declaration
int Programmfrequenz = 50; // loop-Durchlauf pro Sekunde (ca.)
 
int HelligkeitssensordIdleSek = 5; // Minimale Pause zwischen zwei Helligkeitbenachrichtigungen in Sek
int HelligkeitssensorSchwellwert = 1; // Schwellwert fuer Helligkeitsbenachrichtigungen (empfohlen 5-20)
 
int OnlinestatusCheckEachSekOnline = 30; // Ping in Sek wenn letzter Status Online war
int OnlinestatusCheckEachSekOffline = 5; // Ping in Sek wenn letzter Status Offline war
int OnlinestatusCheckTimeoutSek = 3; // Status auf Offline setzen wenn Rueckmeldung nicht innerhalb x Sek
 
char BewegungsmelderState = 0;
int Helligkeitssensor = 0;
int HelligkeitssensorCounter = 0;
int HelligkeitssensorObergrenze = 0;
int HelligkeitssensorUntergrenze = 0;
char msg[25];
int HelligkeitssensordIdle = HelligkeitssensordIdleSek * Programmfrequenz;
int OnlinestatusSendCounter = 0;
int OnlinestatusReceiveCounter = 0;
char OnlinestatusLoxone = 0;
int OnlinestatusCheckOnline = OnlinestatusCheckEachSekOnline * Programmfrequenz;
int OnlinestatusCheckOffline = OnlinestatusCheckEachSekOffline * Programmfrequenz;
int OnlinestatusCheckTimeout = (OnlinestatusCheckTimeoutSek + OnlinestatusCheckEachSekOnline) * Programmfrequenz;
 
// Network Settings
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 3, 19);
IPAddress gateway(192, 168, 3, 1);
IPAddress subnet(255, 255, 255, 0);
 
// Local UDP port to listen on
unsigned int localPort = 7002;
 
// Recipient IP
IPAddress RecipientIP(192, 168, 3, 11);
 
// Recipient UDP Port
unsigned int RecipientPort = 7001;
 
// buffers for receiving and sending data
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
 
// An EthernetUDP instance to send and receive packets over UDP
EthernetUDP Udp;

Teil 2 - Setup

Im Setup-Teil wird im Vergleich zum vorhergehenden Szenario lediglich das neu verwendete Schaltrelais an Pin 5 als "pinMode" mit dem Attribut "OUTPUT" definiert.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void setup()
{
// for debug only
Serial.begin(9600);
 
// start Ethernet
Ethernet.begin(mac,ip);
 
// Start UDP
Udp.begin(localPort);
 
// Bewegungsmelder
pinMode(Bewegungsmelder, INPUT);
 
//OnlinestatusLED
pinMode(OnlinestatusLED, OUTPUT); // LED an Pin4
 
//Schaltrelais
pinMode(Schaltrelais, OUTPUT); // Schaltrelais an Pin5
 
// send UDP Ready
sendUDP("UDP Ready");
}

Teil 3 - Programmablauf (loop)

Der loop-Teil kümmert sich nun um die Auswertung der eingehenden UDP-Mitteilungen "051" und "050".

Der Eingang der ersten Mitteilung wird über "if (!strcmp(packetBuffer, "051"))" abgefragt. Sofern der Wert "051" im UDP-Empfangspuffer aufzufinden ist, schaltet der Arduino über den Befehl "digitalWrite(Schaltrelais, HIGH);" das Schaltrelais ein.

Der umgekehrte Fall mit "050" und einem Ausschaltvorgang folgt im Code mit analogem Aufbau.

Weiterhin wurde noch mit der Anpassung von "Helligkeitssensor=(analogRead(A0)-100)/8;" bewirkt, dass der Helligkeitssensor einen verbesserten Wertebereich zwischen 0 und 100 (vorher 100 bis 800) für die Auswertung liefert.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
void loop()
{
 
checkUDP();
 
// Bewegungsmelder (Send)
if (digitalRead(Bewegungsmelder) == LOW && BewegungsmelderState != 0)
{
  sendUDP("WZ.Bewegungsmelder: 0");
  BewegungsmelderState = 0;
}
 
if (digitalRead(Bewegungsmelder) == HIGH && BewegungsmelderState != 1)
{
  sendUDP("WZ.Bewegungsmelder: 1");
  BewegungsmelderState = 1;
}
 
// Helligkeitssensor (Send)
Helligkeitssensor=(analogRead(A0)-100)/8;
 
HelligkeitssensorCounter = HelligkeitssensorCounter + 1;
 
if (Helligkeitssensor >= HelligkeitssensorObergrenze || Helligkeitssensor <= HelligkeitssensorUntergrenze)
{
  if (HelligkeitssensorCounter >= HelligkeitssensordIdle)
  {
   sprintf(msg, "WZ.Helligkeitssensor: %d", Helligkeitssensor);
   Serial.println(msg);
   sendUDP(msg);
 
   HelligkeitssensorObergrenze = Helligkeitssensor + HelligkeitssensorSchwellwert;
   HelligkeitssensorUntergrenze = Helligkeitssensor - HelligkeitssensorSchwellwert;
   HelligkeitssensorCounter = 0;
  }
}
 
// Onlinestatus-Ping (Send)
OnlinestatusSendCounter = OnlinestatusSendCounter + 1;
 
if (OnlinestatusSendCounter == OnlinestatusCheckOnline && OnlinestatusReceiveCounter != OnlinestatusCheckTimeout)
{
  Serial.println("SendUDP: Ping");
  sendUDP("Ping");
  OnlinestatusSendCounter = 0;
}
 
if (OnlinestatusSendCounter == OnlinestatusCheckOffline && OnlinestatusReceiveCounter == OnlinestatusCheckTimeout)
{
  Serial.println("SendUDP: Ping");
  sendUDP("Ping");
  OnlinestatusSendCounter = 0;
}
 
// Onlinestatus-Pong (Receive)
if (!strcmp(packetBuffer, "000"))
{
  OnlinestatusReceiveCounter = 0;
}
 
if (!strcmp(packetBuffer, "001"))
{
  OnlinestatusLoxone = 1;
  digitalWrite(OnlinestatusLED, HIGH);
}
 
if (OnlinestatusReceiveCounter < OnlinestatusCheckTimeout)
{
  OnlinestatusReceiveCounter = OnlinestatusReceiveCounter + 1;
}
 
if (OnlinestatusReceiveCounter == OnlinestatusCheckTimeout)
{
  OnlinestatusLoxone = 0;
  digitalWrite(OnlinestatusLED, LOW);
}
 
// Schaltrelais
if (!strcmp(packetBuffer, "051"))
{
  digitalWrite(Schaltrelais, HIGH);
}
 
if (!strcmp(packetBuffer, "050"))
{
  digitalWrite(Schaltrelais, LOW);
}
 
delay(1000/Programmfrequenz);
}

Teil 4 - UDP-Sendefunktion

Die Sendefunktion für die UDP-Nachrichten bleibt im Vergleich zum vorangegangenen Szenario unverändert.

1
2
3
4
5
6
7
8
// Function to send UDP packets
void sendUDP(String text)
{
Udp.beginPacket(RecipientIP, RecipientPort);
// Udp.write("Test");
Udp.print(text);
Udp.endPacket();
}

Teil 5 - UDP-Empfangsfunktion

Auch die Empfangsfunktion für die UDP-Nachrichten bleibt im Vergleich zum vorangegangenen Szenario unverändert.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Function to check for new incoming UDP packets
void checkUDP()
{
// if there's data available, read a packet
int packetSize = Udp.parsePacket();
if(packetSize)
{
  // read the packet into packetBufffer
  Udp.read(packetBuffer,UDP_TX_PACKET_MAX_SIZE);
 
  // For debug only
  // Write packetBuffer to serial
  Serial.print("ReceiveUDP: ");
  Serial.println(packetBuffer);
 
  // send "ACK" as reply
  //Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
  //Udp.write("ACK");
  //Udp.endPacket();
}
}

Einrichtung des Smart-Home-Servers

Analog zum "Virtuellen Ausgang Verbinder" im vorherigen HowTo Teil 4 wird nun das "Schaltrelais" in die Loxone Config eingefügt.

Das Element sendet entsprechend "051" zum Arduino, sofern der vorgelagerte "EIB-Taster" ein Ein-Signal (1) liefert und "050", sobald das Signal auf Aus (0) wechselt.


Loxone Config Schaltrelais


Aus meinem täglichen Leben
Mithilfe der hier gezeigten Anbindung lässt sich der LED-Spot bequem über die Loxone-Visualisierung ein- und ausschalten.
Zu Testzwecken habe ich das Szenario auch noch etwas erweitert, sodass der LED-Spot eingeschaltet wird, sofern über den Arduino eine Bewegung (siehe HowTo Teil 2) erkannt wird und die Helligkeit unterhalb eines festgelegen Schwellwerts (siehe HowTo Teil 3) liegt.
Gerade am Anfang hatte ich das oben bereits kurz angesprochene Problem von Fehlauslösungen des Bewegungsmelders aufgrund der höheren Leistungsaufnahme des Relais, welches beim Betrieb des Arduino über USB (5 V) ungewollte Spannungsabsenkungen der auf den Pins angeschlossenen Komponenten bewirkt. Mithilfe eines separaten 9 V Netzteils (Affiliate-Link) mit genug Leistung konnte dieses Fehlverhalten jedoch behoben werden.
Das einzige Problem, welches künftig noch adressieren werden soll, ist das Verhalten des Relais bei einem Neustart des Arduino bspw. infolge einer vorangegangenen Stromtrennung.
Denn dabei erhält das Relais ein kurzes ungewolltes Spannungssignal, wodurch auch der LED-Spot kurz einschaltet. Sofern ich herausgefunden habe, wie sich dieses Verhalten verhindern lässt, folgt ein Update.
Dabei bin ich natürlich für jeden Tipp dankbar, der mich diesbezüglich weiterbringt.
Insgesamt läuft die prototypische Installation bisher ohne jegliche Hänger. Mal sehen, ob das so bleibt, sobald ein PWM-Aktor das Szenario im nachfolgenden HowTo erweitert.


Quelle:

Jörg Hofman
hat im April 2011 meintechblog.de gegründet, um seine Technikbegeisterung und Erkenntnisse mit anderen zu teilen.
Mittlerweile veröffentlicht er regelmäßig Howtos in den Bereichen Smart Home und Home Entertainment.

http://www.meintechblog.de/2015/06/arduino-im-smart-home-howto-teil-1-das-steckt-dahinter/





DIN A4 ausdrucken
*********************************************************

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE










a
Comments