Über eine zeitgesteuerte Schaltung kannst du Verbraucher zu einem bestimmten Zeitpunkt aktivieren/deaktivieren. Dieses kleine Projekt wird mit dem Arduino UNO R3, einem 2x20 Zeichen LCD-Display und Relais Shield umgesetzt. Der Arduino nutzt eine Echtzeituhr (RTC), um das Datum und die Uhrzeit genau zu erfassen, sodass Schaltvorgänge pünktlich ausgeführt werden können. Die aktuelle Uhrzeit wird auf dem LCD-Display dargestellt, während das Relaismodul externe Geräte wie Lampen oder Motoren steuert. Diese zeitgesteuerte Schaltung eignet sich ideal für Automatisierungsprojekte, bei denen Aktionen zu festgelegten Zeiten ablaufen sollen. Im Folgenden erkläre ich dir Schritt für Schritt, wie du die Komponenten anschließt und programmierst. https://www.youtube.com/watch?v=hZaCMxE3oEo Ein Follower auf TikTok hat mich auf die Idee für diesen Beitrag gebracht, daher möchte ich mich an dieser Stelle ganz besonders bei Armin F. für den inspirierenden Vorschlag bedanken.

LCD-Display mit Datum & Uhrzeit von einer RTC am Arduino UNO R3 Auf meinem TikTok Kanal habe ich dir bereits zu diesem Beitrag, mehrere Videos veröffentlicht, in welchen ich den Aufbau der Schaltung, das Programmieren in der Arduino IDE sowie das Einstellen von Zeitpunkten für das Schalten von Verbraucher erläutert habe. - Teil 1 - Aufbauen der Schaltung - Teil 2 - Programmieren eines LCD-Displays über die Arduino IDE am Arduino UNO R3

Wie soll das kleine Projekt funktionieren?

Der Arduino UNO R3 erhält die aktuelle Uhrzeit und das Datum von der RTC. Zu einem festgelegten Zeitpunkt schaltet er dann das Relais. So weit, so unkompliziert. Über die serielle Schnittstelle lässt sich einerseits der Zeitpunkt für eine Aktion einstellen und andererseits die RTC mit dem richtigen Datum und der Uhrzeit konfigurieren. In meinem Projekt verwende ich ein zweifaches Relaismodul, wodurch ich zwei verschiedene Schaltzeitpunkte festlegen kann.

Benötigte Ressourcen für dieses Projekt

Für den Aufbau des Projektes verwende ich nachfolgende Bauteile: - einen Arduino UNO R3* - ein USB-Datenkabel* - eine RTC DS3231* - ein I2C LCD-Display* - ein Relais Shield* - diverse Breadboardkabel*, 10 cm, männlich - weiblich

Module - zeitgesteuerte Schaltung am Arduino Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Aufbau der Schaltung

Der Aufbau am Arduino UNO R3 ist recht einfach, du schließt die RTC & das LCD-Display via I2C an und das 2fach Relaismodul über zwei digitale Pins.

zeitgesteuerte Schaltung mit dem Arduino UNO R3, RTC und LCD-Display Nachfolgend die Tabelle mit den Daten, wie die Bauteile an den Arduino angeschlossen wurden. BauteilArduino UNO R3Kabelfarbe2fach Relais ModulVCC5 VrotGNDGNDschwarzIN1D9braunIN2D8blauRealtimeClock (RTC DS3132)VCC5 VrotGNDGNDschwarzSDAA4gelbSCLA5grünLCD-DisplayVCC5 VrotGNDGNDschwarzSDAA4gelbSCLA5grün Statt dem betagten Arduino UNO R3 könntest du auch den neuen UNO R4 Minima oder UNO R4 WiFi nutzen, alle drei Mikrocontroller sind untereinander kompatibel. Oder wenn du noch platzsparender sein möchtest, dann den Arduino Nano V3.

Zeitgesteuerte Schaltung in der Arduino IDE programmieren

Beginnen wir nun und programmieren die Schaltung in der Arduino IDE. In meinem Fall nutze ich die Arduino IDE 2. Schritt 1 - programmieren des LCD-Displays Fangen wir zunächst im ersten Schritt mit dem LCD-Display an, dieses haben wir via I2C angeschlossen und daher benötigen zunächst auch eine spezielle Bibliothek. Diese Bibliothek können wir vom GitHub Repository johnrickman / LiquidCrystal_I2C als ZIP-Datei herunterladen. //Bibliothek zum ansteuern des LCD-Display via I2C #include //Das Display wird über //die I2C Adresse 0x27 angesteuert //es hat 20 Zeichen pro Zeile //es hat 2 Zeilen LiquidCrystal_I2C lcd(0x27, 20, 2); void setup() { //initialisieren des Displays lcd.init(); //aktivieren der Hintergrundbeleuchtung lcd.backlight(); //setzen des Cursors auf die erste Zelle im Display lcd.setCursor(0, 0); //schreiben eines Textes lcd.print("Fr. 20.10.2024"); //setzen des Cursors auf die zweite Zeile im Display lcd.setCursor(0, 1); //schreiben eines Textes lcd.print("18:35:23 Uhr"); } void loop() { //bleibt leer } Der Code bewirkt, dass auf dem LCD-Display in der ersten Zeile das Datum und in der zweiten Zeile die Uhrzeit angezeigt wird. Solltest du keinen Text sehen, so empfehle ich dir zunächst den Drehpoti für die Helligkeit auf der Rückseite zu drehen.

Schritt 2 - programmieren der RealtimeClock Die Realtimeclock wird via I2C angesteuert und liefert uns einen Zeitstempel aus Datum & Uhrzeit. Jedoch müssen wir dieser initial einen solchen Zeitstempel setzen. Programm - setzen und auslesen eines Zeitstempels an einer RTCHerunterladen Schritt 2.1 - setzen eines Zeitstempels Den Zeitstempel im Format TT.MM.YYY SS:MM:SS also zum Beispiel "20.09.2024 18:35:34" (ohne Anführungszeichen) senden wir via seriellen Monitor an den Mikrocontroller. Über die Funktion readDataFromSerial() werden diese Daten empfangen und ausgewertet. Die Bestandteile des Zeitstempels werden anschließend an die Funktion rtcWriteTimestamp übergeben. // I2C Adresse des RTC DS3231 #define RTC_I2C_ADDRESS 0x68 struct Zeitstempel { String datum; String zeit; }; char linebuf = {}; bool readData = false; void setup() { Serial.begin(9600); ... } void loop() { readDataFromSerial(); if (readData) { String timestamp = linebuf; //Das Datum muss inkl. den Punkten 10 Zeichen lang sein String datum = timestamp.substring(0,10); String tag = datum.substring(0,2); String monat = datum.substring(3,5); String jahr = datum.substring(6,10); //Die Uhrzeit beginnt ab dem 11 Zeichen aus dem Zeitstempel String uhrzeit = timestamp.substring(11); String stunde = uhrzeit.substring(0,2); String minute = uhrzeit.substring(3,5); String sekunde = uhrzeit.substring(6); rtcWriteTimestamp(stunde.toInt(), minute.toInt(), stunde.toInt(), tag.toInt(), monat.toInt(), jahr.toInt()); } ... } void readDataFromSerial() { //Zähler für die Zeichen byte counter = 0; readData = false; //Wenn Daten verfügbar sind dann... if (Serial.available() > 0) { delay(250); readData = true; //solange Daten von der seriellen Schnittstelle //empfangen werden... while (Serial.available()) { //speichern der Zeichen in dem Char Array char c = Serial.read(); if (c != 'n') { linebuf = c; if (counter < sizeof(linebuf) - 1) { counter++; } } } Serial.println(linebuf); } else { readData = false; } } void rtcWriteTimestamp(int stunde, int minute, int sekunde, int tag, int monat, int jahr){ Wire.beginTransmission(RTC_I2C_ADDRESS); Wire.write(0); // Der Wert 0 aktiviert das RTC Modul. Wire.write(decToBcd(sekunde)); Wire.write(decToBcd(minute)); Wire.write(decToBcd(stunde)); Wire.write(decToBcd(0)); // Wochentag unberücksichtigt Wire.write(decToBcd(tag)); Wire.write(decToBcd(monat)); Wire.write(decToBcd(jahr-2000)); Wire.endTransmission(); } Schritt 2.2 - auslesen eines Zeitstempels Wenn wir den Zeitstempel gesetzt haben, dann können wir diesen wieder auslesen. void loop() { ... //bleibt leer Zeitstempel zeitstempel = readRtc(); lcd.setCursor(0, 0); lcd.print(zeitstempel.datum); lcd.setCursor(0, 1); lcd.print(zeitstempel.zeit); delay(500); } //auslesen der Daten von der RealtimeClock Zeitstempel readRtc() { //Aufbau der Verbindung zur Adresse 0x68 Wire.beginTransmission(RTC_I2C_ADDRESS); Wire.write(0); Wire.endTransmission(); Wire.requestFrom(RTC_I2C_ADDRESS, 7); int sekunde = bcdToDec(Wire.read() & 0x7f); int minute = bcdToDec(Wire.read()); int stunde = bcdToDec(Wire.read() & 0x3f); int wochentag = bcdToDec(Wire.read()); int tag = bcdToDec(Wire.read()); int monat = bcdToDec(Wire.read()); int jahr = bcdToDec(Wire.read()) + 2000; char datum; sprintf(datum, "d.d.", tag, monat, jahr); char zeit; sprintf(zeit, "d:d:d Uhr", stunde, minute, sekunde); return { datum, zeit }; } Schritt 3 - aktivieren der Relais via Zeitstempel In meinem Fall habe ich ein 2fach Relais Shield in die Schaltung integriert, du kannst auch Shields mit deutlich mehr Relais erwerben und integrieren, die nachfolgend gezeigt Funktion bleibt dieselbe. struct Relais { int digitalPin; String desc; Zeitstempel actionON; Zeitstempel actionOFF; }; Relais relais1 = { 9, "Relais #1", { "20.09.2024", "22:21:00" }, { "20.09.2024", "22:21:10" } }; Relais relais2 = { 8, "Relais #2", { "20.09.2024", "22:21:10" }, { "20.09.2024", "22:21:15" } }; void setup() { ... pinMode(relais1.digitalPin, OUTPUT); pinMode(relais2.digitalPin, OUTPUT); digitalWrite(relais1.digitalPin, HIGH); digitalWrite(relais2.digitalPin, HIGH); } void loop() { ... checkCurrentTimestamp(relais1, zeitstempel); checkCurrentTimestamp(relais2, zeitstempel); } void checkCurrentTimestamp(Relais relais, Zeitstempel zeitstempel) { if (zeitstempel.datum == relais.actionON.datum && zeitstempel.zeit == relais.actionON.zeit) { Serial.println("aktivieren"); digitalWrite(relais.digitalPin, LOW); } else if (zeitstempel.datum == relais.actionOFF.datum && zeitstempel.zeit == relais.actionOFF.zeit) { Serial.println("deaktivieren"); digitalWrite(relais.digitalPin, HIGH); } }

Fazit und Ausblick

Auf dieses Projekt bin ich von einem Leser meines Blogs aufmerksam geworden. Dieser möchte gerne eine kleine Webseite mit einer Schaltfläche haben, um dort per Tastendruck ein Relais (oder mehrere) zu schalten. Dieses Relais soll dann nach 5 Sekunden wieder abfallen.

Teileliste

Für dieses Projekt benötigen wir folgende Teile: Wemos D1 mini Relaisshield (für den Wemos D1 mini) Zusätzlich benötigen wir ein WLAN Netzwerk zu welchem wir uns verbinden können (SSID & Passwort müssen bekannt sein). Es gibt den Microcontroller Wemos D1 auch als größere Bauform (im Format des Arduino UNOs) dieser bietet dann mehr digitale Pins.

Wemos D1 mini & R3 mit Relaisshields

Aufbau & Schaltung

Wenn man den Wemos D1 mini und das passende Relaisshield sein eigen nennt so ist der Aufbau relativ simple, denn diese beiden Bauelemente werden einfach aufeinander gesteckt.

Relais Shield für den Wemos D1 mini Beachte dabei aber die korrekte Pinbelegung da sonst der Microcontroler und-/oder das Shield beschädigt werden kann. Möchte man die nachfolgenden Schaltungen jedoch mit einer größeren Relaisplatine betreiben, so reicht der Wemos D1 mini & Wemos D1 R3 nicht mehr aus.

Relaisshield 4fach & 1fach Hier empfehle ich den Arduino Mega mit einem ESP8266 Chip.

Arduino Mega mit ESP8266 Chip Dieser Microcontroller besitzt 54 digitale Ein/Ausgänge und dieses reicht für 3x 16 Relais (48Stck.) Jedoch würde ich empfehlen die Spannungsversorgung für die Relaisplatinen über ein externes 5V Netzteil zu realisieren.

Aufbau der Schaltung mit dem Wemos D1 mini

Nun möchte ich beschreiben wie man das Relaisshield am Wemos D1 mini mit Hilfe einer kleinen Webseite betreibt. Der Wemos D1 mini hat genügend Speicherplatz um einen Sketch (inkl. Bibliotheken) und eine Webseite zu speichern.  Die Webseite wird hier als String im Sketch abgelegt und bei einem Aufruf (Request) ausgeliefert. Hier nun der Sketch wie man eine Verbindung zu einem bestehenden WiFi Netzwerk aufbaut. #include const char* ssid = ""; //SSID aus dem Router const char* password = ""; //Passwort für den Zugang zum WLAN WiFiServer server(80); //Port auf welchem der Server laufen soll. void setup() { Serial.begin(115200); //Baudrate für die Serielle Geschwindigkeit. delay(10); Serial.print("Aufbau der Verbindung zu: "); //Ausgabe der SSID auf der Seriellen Schnittstelle. Serial.println(ssid); WiFi.begin(ssid, password); //Initialisieren der Wifi Verbindung. while (WiFi.status() != WL_CONNECTED) { //Warten bis die Verbindung aufgebaut wurde. delay(500); //Einen Punkt auf der Seriellen Schnittstelle ausgeben so das der Benutzer erkennt dass, das Sketch noch läuft. Serial.print("."); } //Bei erfolgreicher Verbindung wird der folgende Text ausgeben. Serial.println(""); Serial.print("Mit "); Serial.print(ssid); Serial.print(" erfolgreich verbunden!"); server.begin(); // Starten des Servers. Serial.println(""); Serial.println("Server gestartet"); //Ausgabe auf der Seriellen Schnittstelle das der Server gestartet wurde. Serial.println(""); // Ausgabe der IP Adresse Serial.print("Adresse : http://"); Serial.print(WiFi.localIP()); Serial.println("/"); } void loop() { //Prüfen ob sich ein Client verbunden hat, wenn nicht die Loop "verlassen" WiFiClient client = server.available(); if (!client) { return; } // Wenn sich ein Client verbunden hat solange warten bis Daten gesendet werden. Serial.println("Neuer Client verbunden."); while(!client.available()){ delay(1); } delay(1); //1ms. Pause } Auf dem seriellen Monitor der Arduino IDE wird dann bei einer erfolgreichen Verbindung die zugeteilte IP-Adresse ausgegeben: Aufbau der Verbindung zu: FRITZ!Box 7590 KV . Mit FRITZ!Box 7590 KV erfolgreich verbunden! Server gestartet Adresse : http://192.168.178.26/ Schreiben wir nun das Sketch für das Relaisshield, wir könnten nun fest das Relaisshield für den Wemos D1 mini im Quellcode verdrahten. Diese vorgehensweise ist jedoch nicht gut da es so einige Relaisshields (1fach, 2fach, 4fach, 8fach, 16fach) auf den Markt gibt.  Wir benötigen somit eine kleine Konfiguration, hier verwende ich ein Array von einem eigenen Typ Relais. Dieser neue Typ enthält ein Feld für eine Bezeichnung sowie für den Pin welcher angesprochen werden soll. erzeugen der Klasse "Relais" Um einen neue Klasse anzulegen erzeugen wir zunächst die HEADER Datei, diese Datei beschreibt die spätere Klasse. Datei "relais.h" #include "Arduino.h" class Relais { public: Relais(String bezeichnung, int pin); String getBezeichnung(); int getPin(); long getStartTime(); void setStartTime(long startTime); private: String _bezeichnung; int _pin; long _startTime; }; Die eigentliche logik der Klasse kommt dann in die CPP Datei. Datei "relais.cpp" Zunächst müssen wir die HEADER Datei einbinden. Als nächstes folgt nun die Programmierung des zuvor definierten Konstruktors der Klasse sowie die Funktionen für die Felder "_bezeichnung" & "_pin" sowie "_startTime" zum speichern der Zeit wann das Relais aktiviert wurde. #include "Arduino.h" #include "relais.h" Relais::Relais(String bezeichnung, int pin){ _bezeichnung = bezeichnung; _pin = pin; _startTime = -1; } String Relais::getBezeichnung(){ return _bezeichnung; } int Relais::getPin(){ return _pin; } long Relais::getStartTime(){ return _startTime; } void Relais::setStartTime(long startTime){ _startTime = startTime; } Nun können wir ein Relais Objekt erzeugen und auf die Felder zugreifen: Relais * relais = new Relais("Test", 1); Serial.println(relais -> getBezeichnung()); Serial.println(relais -> getPin()); Da wir jedoch Relaisshields / Relaismodule verwenden wollen wo mehr als eines verbaut wurde, erzeugen wir ein Array mit Relais. Für eine bessere Organisation könnte man nun für jedes Relaisshield ein extra Array anlegen und dann alle Arrays zu einem Array verbinden (wir hätten dann ein Mehrdimensionales Array). Dieses erhöht jedoch nicht die Lesbarkeit des Quellcodes. Array mit Relais erzeugen Nun wollen wir die neue Klasse verwenden um unsere Relaisshields zu definieren.  Ein Array erzeugt man in dem man an den Variablennamen eine eckige Klammer anfügt.  Relais * relais = {new Relais("Test", 1)}; Wir haben nun ein Array mit einem Wert erzeugt.  Arrays beginnen immer mit dem Index "0"! Wenn wir nun auf dieses Element in dem Array zugreifen wollen müssen wir wieder unser Array verwenden und in den eckigen Klammern ein Index setzen. Serial.println(relais -> getBezeichnung()); Mit dem Pfeil spricht man das Element an und kann dann Operationen mit dem durchführen. Es würde auch funktionieren: Relais * currentRelais = relais; Serial.println(currentRelais -> getBezeichnung()); Zähler Damit wir später mit dem Array arbeiten können benötigen wir eine Zählvariable, mit dieser können wir zbsp. in der Funktion "setup" den pinMode über eine For-Schleife setzen. Es gibt an dem Array eine Funktion um die Länge zu ermitteln jedoch ist dieses die Länge des Speichers. Man müsste dann das maximum der definierten Felder ("bezeichnung", "pin") berechnen und dann kann man die Länge des Array verwenden. Dieses wäre jedoch viel zu kompliziert und daher bevorzuge ich eine einfache Variable: const unsigned int RELAIS_COUNTER = 1; Nehmen wir die Zeile auseinander: const - definiert den Wert als Konstante, d.h. dieser Wert kann später nicht mehr verändert werden, unsigned - dieser Operator besagt das nur positive Zahlen erlaubt sind, int - ganze Zahlen RELAIS_COUNTER - der Name der Variable = - damit beginnt eine Zuweisung 1 - die anzahl der Elemente in dem Array. Konstanten schreibe ich immer groß, dieses hat den Vorteil das man später im Code erkennt das es sich um eine Konstante handelt. setup - Funktion Erweitern wir nun die setup Funktion um eine For-Schleife damit wir die Relais und damit die Pins als Ausgänge  (OUTPUT) setzen. for(int i=0;i getPin(),OUTPUT); } Des Weiteren wird in der Funktion definiert was passieren soll wenn eine Bestimmte Adresse auf dem ESP8266 aufgerufen wird. Es gibt in unserem Fall 2 Adressen einmal die ohne Parameter "http://192.168.178.26/" und einmal zum setzen eines Status für ein Relais "http://192.168.178.26/set?btn=0". server.on("/", callHome); server.on("/set", callSet); loop - Funktion Die Funktion "loop" wird sehr übersichtlich denn, es wird nur dem Server "gesagt" das dieser auf Clients reagieren soll.  Zusätzlich wird in der Funktion noch geprüft ob gesetzte Relais nach einer definierten Zeit x wieder zurück gesetzt werden soll. void loop() { server.handleClient(); for(int i=0;i getStartTime(); if(startTime > -1){ long currentTime = millis(); if((currentTime - MAX_ACTIVE_RELAY_TIME)> startTime){ digitalWrite(currentRelais -> getPin(),LOW); currentRelais -> setStartTime(-1); } } } } HTML Dokument erstellen Wenn der Benutzer die Adresse "http://192.168.178.26/" aufruft so soll eine kleine Webseite angezeigt werden.

Webseite mit Schaltfläche für ein Relais In meinem Test habe ich den Wemos D1 mini mit dem Relaisshield verwendet, daher ist auf dieser Seite "nur" 1 Relais mit der Bezeichnung "R1" eingerichtet. Für jedes Relais wird eine Schaltfläche angeboten. Die Schaltflächen werden dabei ähnlich einer Tabelle positioniert. Da hier ja mehr als nur 1 Relais dargestellt werden kann, möchte ich nach einer definierbaren Zahl x einen Zeilenumbruch erzeugen. Hier lege ich zunächst eine Konstante an. const unsigned int MAX_TABLE_COLUMNS = 3;  Die Webseite selber wird in einem String gespeichert, hier emphielt es sich zunächst diese in einem Editor wie Notepad++ oder PSPad zu schreiben und dann in die Arduino IDE zu integrieren. void callHome(){ String content = ""; content += ""; content += ""; content += ""; content += ""; content += ".wrapper {max-width:90%;margin:0 auto;text-align:center;}"; content += ".btn {margin:15px;}"; content += ""; content += ""; content += ""; content += ""; content += "

Pyro - Entferno

"; content += "

v3.0

"; content += " "; content += ""; for(int i=0;i getBezeichnung()+"' onClick='sendRequest("+i+")'/>"; int value = (i+1) % MAX_TABLE_COLUMNS; if(value == 0){ content += ""; } } String ipAddress = WiFi.localIP().toString(); content += ""; content += ""; content += ""; content += "const url='http://"+ipAddress+"/set?';"; content += "function sendRequest(button){"; content += " const Http = new XMLHttpRequest();"; content += " reqUrl=url+'btn='+button;"; content += " console.log(reqUrl);"; content += " Http.open('GET', reqUrl);"; content += " Http.send();"; content += "}"; content += ""; content += ""; content += ""; sendResult(content); } Setzen eines Relais Status Die Schaltfläche aus der Webseite erzeugt einen Request an die Adresse "http://192.168.178.26/set?btn=0" dieses bewirkt dass, das Relais aus dem Array am Index "0" auf HIGH (aktiv) gesetzt wird. Da wir den Index als Parameter an der URL übergeben müssen wir zunächste alle gelieferten Parameter durchlaufen um dann unseren Key "btn" zu finden und auszuwerten. void callSet(){ int buttonIndex = -1; for (int i = 0; i String parameterName = server.argName(i); String parameterValue = server.arg(i); if(parameterName == "btn"){ buttonIndex = parameterValue.toInt(); } } if(buttonIndex > -1){ Relais * currentRelais = relais; currentRelais -> setStartTime(millis()); digitalWrite(currentRelais -> getPin(),HIGH); sendResult("{\"msg\": \"Das Relais mit der Bezeichnung "+currentRelais -> getBezeichnung()+" ist aktiv!\"}"); } } Wurde kein Index übergeben so passiert nichts, es würde dann ein Timeout auf der JavaScript Console ausgegeben werden.

Schaltung & Aufbau mit Relaisshields

Wie eingangs erwähnt kann man größere Relaisshields erwerben. Diese Relaisshields gibt es in 1fach, 2fach, 4fach, 8fach sowie 16fach. Je nach größe muss man beachten das ein geeigneter Microcontroller gewählt wird. Für die nachfolgende Schaltung verwende ich einen Wemos D1 R3 welchen ich bereits im Tutorial WEMOS D1 – Arduino UNO kompatibles Board mit ESP8266 Chip vorgestellt habe. Schaltung In der nachfolgenden Schaltung habe ich einen Arduino UNO verwendet, dieser Unterscheidet sich etwas zum Wemos D1 R3 jedoch sind die verwendeten Anschlüße an den gleichen stellen zu finden.

Schaltung 4fach & 1fach Relais am Arduino UNO Aufbau Für den Aufbau der Schaltung benötigst du: 9 Steckbrettkabel, männlich - weiblich, 20cm 2 Steckbrettkabel, männlich - männlich, 10cm 1x Steckbrett 170 Pin 1x 1fach Relaisshield 1x 4fach Relaisshield 1x Wemos D1 R3

Aufbau - Wemos D1 R3 mit 4fach & 1fach Relaisshield An den Relaisshields sind die Pins mit jeweils GND für Ground IN1 - Relais 1 IN2 - Relais 2 IN3 - Relais 3 IN4 - Relais 4 VCC - Spannungsversorgung 5V  gekennzeichnet. Relaishield Wemos D1 R3 4fach Relaishield   GND GND IN1 D11 IN2 D10 IN3 D9 IN4 D8 VCC 5V 1fach Relaisshield   VCC 5V IN1 D12 GND GND Der Microcontroller besitzt "leider" nur einen Pin für 5V daher verwende ich zusätzlich ein kleines, 170 Pin Steckbrett um dort die 5V zu verteilen. Quellcode Im Quellcode müssen wir nur die verwendeten Pins und die Bezeichnungen anpassen: const unsigned int RELAIS_COUNTER = 5; Relais * relais = { new Relais("R1", D12), new Relais("R2", D11), new Relais("R3", D10), new Relais("R4", D9), new Relais("R5", D8), };

Video

In diesem Video verwende ich das Relaisshield vom Wemos D1 mini da ich leider feststellen musste dass, das 1fach Relaisshield defekt ist.  

Download