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

Loxone im Einsatz? Dann schau dir unseren LoxKurs an und profitiere von unserem Wissen!

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

[easyazon_image align=“none“ height=“375″ identifier=“B00P0UMEE0″ locale=“DE“ src=“https://www.meintechblog.de/wordpress/wp-content/uploads/2015/06/5145YSBb9mL.jpg“ tag=“meintechblog-150617-21″ width=“500″]

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.

Steckplatine Bewegungsmelder

 

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.

Arduino mit Ethernet Shield

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.

In 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 (3128 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.

#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.

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.

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.

// 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.

Affiliate-Links

[easyazon_image align=“none“ height=“76″ identifier=“B00OEIMCIW“ locale=“DE“ src=“https://www.meintechblog.de/wordpress/wp-content/uploads/2015/06/51cJci1hCCL.SL1101.jpg“ tag=“meintechblog-150617-21″ width=“110″][easyazon_image align=“none“ height=“110″ identifier=“B00PL70PA2″ locale=“DE“ src=“https://www.meintechblog.de/wordpress/wp-content/uploads/2015/06/517P2BCdff7L.SL110.jpg“ tag=“meintechblog-150617-21″ width=“110″][easyazon_image align=“none“ identifier=“B008AESDSY“ locale=“DE“ src=“http://ecx.images-amazon.com/images/I/51bqqVaHMQL._SL1048_.jpg“ tag=“meintechblog-150617-21″ width=“110″][easyazon_image align=“none“ height=“110″ identifier=“B00PXBVRZS“ locale=“DE“ src=“https://www.meintechblog.de/wordpress/wp-content/uploads/2015/06/51SmvUd37QL.SL110.jpg“ tag=“meintechblog-150617-21″ width=“110″]

Loxone im Einsatz? Dann schau dir unseren LoxKurs an und profitiere von unserem Wissen!

Verpasse keine Inhalte mehr! Trage dich in den Newsletter ein und folge uns auf Facebook.

Was ist ein Affiliate-Link? Wenn du auf einen Affiliate-Link klickst und über diesen Link einkaufst, bekomme ich vom betreffenden Online-Shop oder Anbieter eine Provision, was mich u.A. bei den laufenden Kosten den Blogs unterstützt. Für dich verändert sich der Preis nicht.

Jörg

hat meintechblog.de ins Leben gerufen, um seine Technikbegeisterung und Erkenntnisse zu teilen. Er veröffentlicht regelmäßig Howtos in den Bereichen Smart Home und Home Entertainment. Mehr Infos

23 Gedanken zu „Arduino im Smart Home – HowTo Teil 2: Bewegungsmelder per UDP an Loxone anbinden“

    1. Wie viele Bewegungsmelder (bzw. andere Sensorik) kann man denn an einen Arduino anschließen? (14?) Und wie lange sind die maximalen Leitungslängen?

    2. Hi Herbert,
      der Arduino Uno bietet insgesamt 14 digitale Pins, die als Ein- oder Ausgänge genutzt werden können. Davon sollten jedoch Pin 0 und 1 nicht direkt verwendet werden, da diese für die Übertragung zum PC vorgesehen sind. Habe diese Info im Blogpost vermerkt. Man sollte also bis zu 12 digitale Sensoren (wie Bewegungsmelder) an einem Board betreiben können. Weiterhin stehen 6 analoge Eingänge zur Verfügung, die bspw. für die Messung von Temperatur, Luftfeuchtigkeit, CO2, Regenintesität etc. eingesetzt werden können. (BTW: Arduino Mega (Affiliate-Link), der nur einige Euro mehr kostet als ein Arduino Uno bietet gleich eine Vielzahl dieser In- und Outputs.)

      Über die maximale Kabellänge kann ich leider noch nichts Genaues sagen. Sobald sich das ändert, werde ich diesen Punkt definitiv aufgreifen.

      Grüße
      Jörg

  1. Hallo, sehr schöner Artikel! Ich hab letztens für den Arduino das ESP8266 Board gefunden, mit dem sich das ganze vermutlich auch über WLAN realisieren lässt, falls in dem Raum kein Ethernet vorhanden ist. Vielleicht könnte man dazu auch mal einen Artikel erstellen.

    Gruß
    Lutz

  2. Prima Anleitung. Ich habe selber mit dem Arduino etwas gespielt. Mir fehlte aber noch der richtige Ansatz für die Übermittlung der ermittelten Daten. Sei es nun Bewegungsmelder oder Temperatur Sensoren. UDP scheint mir ein guter Ansatz zu sein. Ich habe aber leider noch nichts genaues gefunden, wie man die Daten in FHEM empfangen und verarbeiten kann. Ich bin schon gespannt auf einen Folgeartikel.

    Gruss Thomas

    1. Hi Thomas,
      in Loxone funktioniert die UDP-Verarbeitung beinahe in Echtzeit, was ich schon recht lange in Verbindung mit FHEM als Sendeeinheit mit einem Raspberry Pi erfolgreich nutze.

      In Empfangsrichtung kann man in FHEM eingehende UDP-Pakete wohl auch recht einfach bspw. jede Sekunde abfragen und verarbeiten. Das ist aber gerade für kurze Reaktionszeiten und schnelle Schaltwechsel (z.B. schneller Doppelklick eines Tasters) tödlich. Evtl. lässt sich das auch weiter verbessern, wobei ich die Übertragung künftig vor allem per kabelgebundenem RS485 realisieren möchte. Dieser Übertragungsstandard scheint mir perfekt für den Anwendungsfall bspw. in einem Neubau geeignet zu sein, um viele Daten von bis zu 32 angebundenen Einheiten im Bus (ähnlich KNX) über eine lange Distanz (bis zu 1,2km) übertragen zu können, wofür nur zwei Drähte benötigt werden. Die Datenverarbeitung sollte dabei über passende Gateways auch in FHEM bestens funktionieren. Werde mich mit RS485 bald mehr auseinandersetzen, warte aber noch auf die dafür notwendigen Komponenten aus Asien, die wohl noch irgendwo auf dem Postweg herumschwirren.

      Daneben möchte ich aber auch funkbasierte Lösungen mit 2,4 GHz testen. Passende Sender und Empfänger kosten teilweise weniger als einen Euro und sollten auch gute Voraussetzungen für die Anbindung bilden, wobei dann (zumindest aktuell) immer noch das Problem einer fehlenden Verschlüsselung besteht. Ich bin jedenfalls gespannt, wohin die Reise mittelfristig gehen wird.

      Grüße
      Jörg

    2. Hi Stefan,
      danke für den Link! Deine Arduino-Anleitungen sind super und haben mir bei der Umsetzung schon oft geholfen.

      Grüße
      Jörg

      PS: Wir müssen endlich mal wieder telefonieren… :)

  3. Das Thema Arduino finde ich super. Ich hege den Wunsch eines Tages mal einen Arduino nano in eine normal 55mm Unterputzdose zu bauen (inc. eines kleinen und effizienten Netzteil), an dessen Front ein Blinddeckel mit diversen eingebauten LEDs sitzt, die vom Nano dann an- oder ausgeschaltet werden.
    Der Nano soll per 433MHz oder 868MHz mit dem FHEM-Server „reden“ und als kleines Mini-Statusdisplay für eine normale Unterputzdose dienen.

    Ich würde mir wünschen in deiner neuen Arduino-Reihe ein paar Tipps dafür zu bekommen.

    Gruss
    Thomas

    1. Hi Thomas,
      guter Punkt. Dafür sollte ein Arduino tatsächlich bestens geeignet sein.

      Mittlerweile gibt es auch Kleinstdispalys um 1-3 Zoll, die am Arduino betrieben werden können. Dazu zählen neben (O)LED-Displays auch neuerdings ePaper-Displays (z.B. von Embedded Artists), die für solche Anwendungsfälle neben normalen LEDs meiner Meinung nach sehr interessant sind.

      Das Thema externe Stromversorgung und Funkübertragung steht bei auch noch auf dem Programm. Diese Punkte werden definitiv in späteren Blogposts behandelt werden.

      Grüße und danke für das Feedback
      Jörg

  4. Hallo Jörg,

    ich verfolge schon seit längerem eure super Blogbeiträge und sie haben mir schon oft weitergeholfen.

    Ich wäre ebenfalls wie Thomas Cristo sehr an einem Folgeartikel über die Einbindung in FHEM interessiert (am besten über Ethernet/UDP), da ich mich in diesem Bereich wenig auskenne.

    Vielen Dank für die hilfreichen Artikel und Ideen.

    Mit freundlichen Grüßen

    Julian Stanulla

    1. Hi Julian,
      freut mich, dass dieses Thema gut ankommt. Ich habe das Thema FHEM und Arduino definitiv auf dem Schirm. Sobald ich noch einige Basics zum Thema Arduino veröffentlicht und die mir noch fehlenden Puzzleteile bzgl. FHEM zusammengefügt habe, wird sich ein Blogpost definitiv auch mit dieser Thematik beschäftigen.

      Grüße
      Jörg

    2. Hallo Jörg,
      freut mich das zu hören! Macht bitte weiter so :)

      schönen Sonntag noch

      Grüße
      Julian

  5. Hi Jörg,
    ich verfolge schon eine Weile Deine Beiträge. Sie sind super anschaulich, eignen sich für den praktischen Einsatz und ermutigen zur Nachahmung. Ich bin „elektrisch“ zwar ein Laie, muss mich jedoch wegen meines Hausbaus mit dem Thema Hausautomation auseinandersetzen. Ich habe mich für Loxone entschieden und muss, weil der zum schlüsselfertigen Haus zugehörige Elektriker wirklich keine Ahnung von der Materie hat, um ALLES selbst kümmern. Deine Artikel haben mir sehr geholfen und sowohl FHEM (für Einbindung von Homematic-Produkten) als auch Arduino für günstige Lösungen machen mit Mut. Vielen Dank für Dein Engagement!
    Jürgen

  6. Hi!
    Ein richtig tolles Tut – vielen Dank dafür! Doch ich habe eine Frage: über eine Linux-Shell kann ich UDP-Pakete mit Daten an eine IP-Adresse schicken. Die Idee ist folgende: eine eigene Weboberfläche erstellen, die auf einem Linux-Debian-Server läuft und mit der man über grafische Regler UDP-Pakete an einen Funduino verschicken kann, um z.B. eine Lampe An/Auszuschalten. Das sollte doch mit diesem Skript „fast“ genauso funktionieren, oder?

    1. Öh,
      denke schon. Es gibt sogar Projekte, die dem Arduino eine http-Oberfläche verpassen, die man dann manuell per Browser aufrufen kann oder entsprechend per http-Abfragen.

      Grüße
      Jörg

  7. Hi,
    super Tutorials. Danke dafür. Ich probiere mich auch gerade an Arduino und Loxone. Ein PIR am Ardu funktioniert wunderbar. Leider funktioniert es bei mir nicht mit 2 PIRs (Sollen völlig unabhänging von einander unterschiedliche Räume bedienen). Hast du mir einen Tip wie ich das im Arduino programmieren muß.

    Danke & Grüße,
    Michael

  8. Hei, statt dezentraler Arduinos schwebt mir immer noch ein zentraler Arduino mit WiFi-Links zu dezentral operierenden ESP8266 (NodeMCU), für die z.B. eine Versorgung im Außenbereich mit NiMH und kleiner Solarzelle ausreichen kann.
    Ich habe mir dazu die ESP (PWR-ESP-87/12) besorgt und bin fasziniert !

    http://images.google.de/imgres?imgurl=http://cdn.instructables.com/FU3/4NE0/I8J9XYD4/FU34NE0I8J9XYD4.MEDIUM.jpg&imgrefurl=http://www.instructables.com/id/ESP8266-MPSM-v2-DevBoard-MAINS-WIFI-Web-Power-Swit/&h=465&w=620&tbnid=FqMjluXJw0oStM:&tbnh=98&tbnw=131&docid=Dk_4E0NdMH6EfM&usg=__BViWa5yDCe8kp6BNa8jny0sq-mA=&sa=X&ved=0ahUKEwi_9bDnqODKAhWLCCwKHV8-AqsQ9QEIOjAD

  9. WOW, auf der Suche nach günstiger Erweitereung von I/Os für Loxone bin auf deinen Blog gestoßen. Klasse, das scheint die Lösung zu sein.
    Und das Schöne, diverse Mega328p Boards hab ich noch, brauche also nur ein passendes EthernetShield.
    SUPER!!!

  10. Hallo,
    ein sehr interessanter Beitrag!
    Ich hätte eine Frage zum Miniserver.
    Wie viele virtuelle UDP Eingänge kann man anlegen, bzw. ist es begrenzt?

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert