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

IM EINSATZ?

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

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 (Gleichspannung) ü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:

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

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

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.

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.

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

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

6 Kommentare
  1. Hallo Jörg, ich muss zwar noch einen Monat warten bevor ich mir den Adurino und Zubehör bestelle (Dreambox 7080hd spinnt, als Ersatz ne vu duo2 bestellt), aber weiter so! Tip Top sagt man hier dazu!
    Ich freue mich schon es selber auzuprobieren

  2. Hallo, gefallen mir sehr gut deine Arduino Ausführungen.
    Werde jetzt auch endlich mal mit ein paar Testaufbauten Loxone-Arduino beginnen.

    Hast du schon wieder was erweitert? Wie läuft es bis jetzt?

    Wie schaut es mit POE beim Arduino aus, vielleicht schon ausprobiert?

    Hast du schon mal mit einem Taster betrieben? Gibt es einen merklichen Zeitversatz von Tasterbetätigung – Arduino – Loxone – Licht.

    Werde das natürlich selbst versuchen jedoch wollt ich mal fragen.

    Weiter so.

    Lg
    Michael

    1. Hi Michael,
      ich habe in der Zwischenzeit Einiges getestet und versuche bald mal weitere Artikel zu veröffentlichen. Möchte bspw. im Bad (testweise) einen LED-Stripe per Arudino ansteuern und dimmen inkl. Bewegungsmelder, Temperatursensor und Co.
      Mein Arduino im Flur funktioniert bisher im Echtbetrieb seit einigen Monaten 1a. Er erkennt Bewegungen und überträgt diese Information per WLan als UDP-Nachricht an Loxone, welches wiederum das Licht per Loxone-Air-Unterputzaktor schaltet. Das funktioniert ohne merkbare Verzögerung, womit ich eigentlich nicht gerechnet hätte. Außerdem möchte ich die Live-Besucherzahlen des Blogs über ein analoges Voltmeter visualisieren und habe da schon einige Komponenten bestellt. Weitere Informationen dazu dann in Kürze per Blogpost.

      Grüße
      Jörg

      PS: Was möchtest du als Erstes mit dem Arduino umsetzen?

Schreibe einen Kommentar

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

Das könnte dir auch gefallen