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

IM EINSATZ?

Dann schau dir UNSEREN LOXKURS an und profitiere von unserem Wissen!

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.

Fotowiderstand

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 (2063 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.

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

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.

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.

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

14 Kommentare
  1. Moin, moin,
    Danke für die ausführlichen Berichte. Auch wenn ich nicht alles verstehe, so finde ich es hoch interessant. Habe gerade erst angefangen mich in die Thematik PI einzuarbeiten. Installation ist aufgrund der vielseitigen Anleitungen problemlos gelungen.
    Eine Frage, möglich das sie dumm erscheint, oder ich habe die Antwort überlesen,
    warum “ARDUINO”? Könnte das nicht auch über einen PI mit FHEM laufen?
    Gruß Michael

    1. Hi Michael,
      deine Frage ist keineswegs unbegründet oder dumm. Die Gründe, warum ich den Arduino (nebem einem RPi mit FHEM) einsetzen möchte, habe ich augenscheinlich noch nicht genug herausgearbeitet. Vieles ist auch mit einem RPi über dessen Pins (GPIO) möglich, da hast du Recht. Der Arduino hat aber gerade für die hier beschriebenen Anwendungsfälle (Sensorik und Aktorik) einige Vorteile, wenn man ihn als Gateway einsetzen möchte.

      Ein Arduino-Board verbraucht aufgrund seines gering getakteten Microcontrollers viel weniger Strom als ein RPi, was gerade dann relevant sein kann, wenn man (wie ich) den Plan verfolgt, jeden Raum mit mindestens einem Arduino als Gateway zwischen den zu installierenden Sensoren/Aktoren und der Smart-Home-Zentrale (z.B. FHEM auf einem RPi oder Loxone) auszustatten. Dadurch sollte auch die Wärmeentwicklung ein Stück geringer ausfallen, was bei hohen Umgebungstemperaturen von entscheidendem Vorteil sein kann, um einer Überhitzung des Systems zu entgehen.

      Weiterhin gibt es durch die verschiedenen Arduino-Modelle mehr Handlungsspielraum. Der Arduino Nano (Affiliate-Link) – Kostenpunkt um die 6 Euro – ist bspw. wesentlich kompakter als ein RPi und kann damit auf kleinstem Raum (z.B. in einem Unterverteiler) verbaut werden. Arduino Mega (Affiliate-Link) – Kostenpunkt unter 20 Euro -, welcher größentechnisch auf dem Niveau einen RPi ist, hat hingegen mehrere Dutzend Pins, sodass eine Vielzahl von Sensoren und Aktoren (Temperatur, Luftfeuchte, CO2, Niederschlag, Anwesenheit, Helligkeit, Lautstärke, Infrarot, Relais, Displays…) gleichzeitig angebunden werden können.

      Ein weiterer Punkt ist die Software. Der gesamte Programmcode eines Arduino umfasst eine überschaubare Anzahl an Codezeilen und kann so mit vertretbarem Aufwand exakt auf die eigenen Bedürfnisse hin angepasst werden, wodurch auch langfristig die Wartung vereinfacht werden sollte. Dabei bringt ein Arduino seinen eigenen Programmspeicher mit und benötigt keine (auf lange Sicht) fehleranfälligere SD-Karte.

      Schließlich ist es auch so, dass der Arduino eine riesige Community besitzt, die sich mit ähnlichen Themen (wenn auch meist nicht im Smart-Home-Kontext) beschäftigen, sodass man eigentlich immer eine passende Lösung zu einem Problem im Netz findet.

      Sicherlich gibt es noch mehr Gründe einen Arduino einzusetzen, evtl. werde ich dazu auch noch einmal eigenen Blogpost aufsetzen. Hoffe das hilft dir aber erstmal etwas weiter, um meine Beweggründe nachvollziehen zu können und den Arduino in den Gesamtkontext des Smart Home einzuordnen. Wenn du weitere Fragen hast, zögere nicht sie zu stellen.

      Grüße
      Jörg

  2. Hallo,

    ich finde die Beiträge auf meintechblog SEHR GUT (1,0). Ich würde mich SEHR freuen wenn ein HowTo mit FHEM statt Loxone noch entstehen würde!?! Da ich schon länge auf der suche bin aber micht noch nicht getraut habe mir ein Arduino zu kaufen. (Liegt wohl an der großen Auswahl der Boards und der Pakete).

    Weiter so.

    1. Hi Frederic,
      freut mich, dass die Artikel insgesamt gut anzukommen scheinen. Da ich mich erst seit Kurzem in die Arduino-Materie einarbeite, wollte ich vorerst die Integration mit Loxone in Angriff nehmen, da ich damit bereits Erfahrungen mit UDP in Sende- und Empfangsrichtung gesammelt habe und gleichzeitig nicht noch mehrere Baustellen aufmachen wollte. FHEM steht aber definitiv auf meiner Liste, spätestens wenn andere Übertragungstechniken (z.B. RS485 Funk) zum Einsatz kommen. Auch Christoph wird künftig bestimmt darüber bloggen, da er sich jetzt ebenfalls verstärkt mit dem Thema Arduino beschäftigt und FHEM als primäre Smart-Home-Zentrale einsetzt.

      Grüße
      Jörg

  3. Hallo Jörg,

    kann man die Schaltungen auch kompakter gestalten? Das man die ganzen Komponeten verwenden kann, ist wirklich klasse! Nur möchte ich nicht immer so ein eher nicht so schönes Board dran haben. Gibt es da eine Lösung?

    Gruß

    Sebastian

    1. Hi Sebastian,
      gute Anmerkung. Diesen Punkt habe ich wohl noch nicht klar genug herausgestellt. Alle Aufbauten, die bisher beschrieben wurden, stellen lediglich eine temporäre Testumgebung dar, um die Funktionen zu testen und bei Bedarf schnell Änderungen am Hardwaresetup vornehmen zu können. Sobald der gesamte Aufbau einmal fertig ist, sollen die Komponenten dann permanent auf einer selbst gesignten Leiterplatte, auch PCB (printed circuit board) genannt, ihren Platz finden. Wie das dann aussehen kann, wird im nachfolgenden YouTube-Video ab Minute 01:55 deutlich: https://www.youtube.com/watch?v=durXAuJWGk4

      Bis ich jedoch an diesem Punkt angelangt bin, wird sicherlich noch einige Zeit vergehen, da ich mich erst noch tiefer in die Materie einarbeiten muss, um alle Funktionen nach meinen Wünschen umsetzen zu können. Aber hey, der Weg ist das Ziel und mit jeder neuen Erkenntnis wird das ganze Thema nur noch spannender. Den Weg dorthin möchte ich dabei eifrig dokumentieren und hier zur Verfügung stellen.

      Grüße
      Jörg

  4. Moin Jörg,
    Sehr interessant Deine Ausführung.
    Wenn ich Dich richtig verstehe ist diese Variante sehr gut für z. B. Temperaturen geeignet. Ein Vorhaben ist es eine Brennraumtemperatur Mittels Thermoelement zu messen und als Diagramm zu visualisieren.
    Frage: Ist das direkt mit dem PI machbar? ich denke eher nicht, da ein Meßumformer benötigt wird – oder?
    Mit einem Arduino in Verbindung eines MAX 6675 sollte es aber möglich sein.
    Kann ich das dann unter FHEM mit dem PI nutzen? Wenn ja wie.
    Gruß Michael

    1. Hi Michael,
      der RPi hat sechs Pins, die als analoge Eingänge für genau solche Zwecke genutzt werden können. Sowas habe ich zwar noch nicht selbst umgesetzt, dein Vorhaben sollte aber mit einem FHEM, dem Thermoelement und dem Messumformer am RPi zu realisieren sein. Wie genau, kann ich dir aktuell in einem Satz leider nicht beantworten. Als Einstieg kann dir aber vielleicht der Artikel Raspberry Pi: GPIOs schalten im FHEM-Wiki weiterhelfen.

      Grüße und viel Erfolg
      Jörg

  5. Sehr schöner und informativer Artikel !
    Dennoch habe ich eine Bitte.
    Empfehle bitte keine Multimeter dieser Qualität und Preisklasse.
    Diese Dinger sind für Bastler bis 9 Volt okay.
    Aber sie sind ebenso rausgeworfenes Geld.
    Wenn man sich mal den Spaß macht und durchaus etwas teurere Voltcraft, UniT oder ähnliche Geräte öffnet, friert einem auch hier noch oft das Blut in den Adern augenblicklich ein.
    Es sagt auch niemand, dass es gleich bei Fluke oder Keysight/Agilent enden muss.
    Bei Reviews kommen beispielsweise Extech und Amprobe relativ gut weg.

    Vernünftige Messleitungen, Eingangsschutz, 0,5% Grundgenauigkeit sind hier schon für 50 € zu haben!

    1. Hi Stephan,
      hast du einen konkreten Produktvorschlag für ein Messgerät, was deiner Meinung nach preislich noch erschwinglich ist?

      Grüße
      Jörg

  6. Hallo,

    Ich bin gerade über dieses HowTo gestolpert. Ich finde es sehr gut geschrieben und auch detailliert genug für Anfänger. Aber im ersten Teil steht dass die Spannung fließt. Ich will nicht kleinlich sein, aber das sollte unbedingt geändert werden. Spannung liegt an und Strom fließt. Ansonsten Daumen hoch für den Aufwand.

  7. Hallo Jörg,
    als Loxone User der gerade anfängt mit Arduinos zu experimentieren ist das eine perfekte Anleitung. Ich glaube das muss ich heute doch mal nachbauen!

  8. Moin Jörg,

    auf Grund deines Beitrages bin ich auf die Idee gekommen mit ein Arduino zu holen um hier mal etwas zu experimentieren. Ich selbst habe auch Loxone bei mir im Haus verbaut.
    Ein Super Blog hat du hier. Mach weiter so.
    Ich habe aber auch mal eine Frage, hättest du einen Ansatz für mich, wie ich Analogwerte mit dem Loxone Sende (z.B. Temperatur) und die mit dem Arduino empfange? Das würde mir für mein Projekt sehr weiter helfen.
    Gruß
    Stefan

Schreibe einen Kommentar

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

Das könnte dir auch gefallen