Arduino mit NeoPixel-Optokopplern, die viele Relais steuern

Notwendige Werkzeuge und Maschinen

	Lötkolben (generisch)
	Allgemeine Tools wie in einem normalen Haushalt/Werkstatt

Apps und Onlinedienste

Über dieses Projekt

Bei diesem Projekt geht es darum, mehrere Relais oder andere Aktoren von einem einzigen Arduino-Ausgangspin aus zu steuern.

Diese Lösung kann für typische Situationen verwendet werden, in denen die Anzahl der verfügbaren Arduino-Ausgangspins nicht ausreicht und mehr Aktoren wie Relais parallel von einem einzigen Ausgangspin gesteuert werden müssen.

Das Funktionsprinzip basiert auf der Verwendung eines LED-Streifens aus mehreren NeoPixeln (SMD5050-LEDs mit WS2812B-Controller-Chips). Jedes Pixel wird mit einem LDR (Light Dependent Resistor) zusammengestellt, wodurch ein DIY-Optokoppler entsteht (beliebig viele, nur begrenzt durch die LED-Streifenlänge, z. B. 300 Pixel, und verfügbare 5V-Stromversorgung). Auf diese Weise wird eine Seriell-Parallel-Konvertierung erstellt (von 1 auf viele)

Jede einzelne LED wird von ein und demselben Arduino-Ausgangspin angesprochen. Jeder LDR (in Reihe mit einem 27kOhm-Widerstand) ist an ein 5V-Relais angeschlossen. Auf diese Weise können viele NeoPixel/LDR-Kombinationen von 1 Arduino-Ausgangs-PIN mit der Adafruit NeoPixel-Bibliothek gesteuert werden. Anstelle von Relais können auch andere Aktuatorgeräte angeschlossen werden, die die LDRs als Eingang für einen beliebigen Schaltkreis verwenden.

Für dieses Projekt, das Teil eines größeren Plans ist, wird ein ESP32 (NodeMCU) verwendet; ein normales Arduino Uno (oder fast jedes andere Modell) wird jedoch die Arbeit erledigen.

Schritt 1:Herstellung der NeoPixel-Optokoppler

Der DIY-Optokoppler wird aus den folgenden Materialien hergestellt:

• ein Stück LED-Streifen bestehend aus 10 WS2812 LEDs (aus einem längeren Streifen geschnitten) nur 4 werden tatsächlich im Projekt verwendet
• ein Stück dunkelgrauer Schaumstoff
• ein Streifen Steckbrett
• schwarzes Entenband

Hinweis:Der Abstand der Punkte entspricht dem Abstand der LEDs.

Es ist wichtig, das Licht jeder einzelnen LED von den LDRs der anderen zu trennen, um ein "Lichtübersprechen zu vermeiden ." Es stellte sich heraus, dass dies in der Praxis fast unmöglich ist und daher wurde die Lichtmenge, die von jeder LED im "Ein"-Zustand emittiert wird, in der Software auf niedrige Werte eingestellt.

Der verwendete LED-Streifen ist 10 LEDs lang, aber in diesem Projekt werden nur 4 Pixel in Kombination mit 4 LDRs verwendet (um es einfach zu halten)

Schritt 2:Das elektronische Setup

Im Steckbrett-Setup habe ich ein ESP32s (NodeMCU) verwendet, aber jeder Arduino kann die Arbeit erledigen.

Der Schaltplan (erstellt mit Fritzing) sieht wie folgt aus:

In der Praxis sieht dies wie folgt aus:

Wie Sie sehen, wird nur 1 Ausgangspin verwendet, um 4 Relais parallel zu steuern. Diese Zahl kann bis auf 300 steigen! (so viele LEDs wie in einem 5 m langen Streifen verfügbar).

Das ESP32-Gerät arbeitet mit 3,3 Volt (ein integrierter 3,3-V-Spannungsregler), während der LED-Streifen mit 5050 LEDs mit 5 V läuft. Der ESP32 wird mit 5 V-Strom versorgt (über den USB-Anschluss von einem 5V-Adapter oder 5V Powerbank). Die NeoPixel LEDs beziehen die 5V Versorgung direkt vom 5 Volt Pin des ESP32 und die verwendeten Relais sind ebenfalls 5V Typen.

In diesem Beispiel werden 4 Optokopplerkreise verwendet, die 4 Relais steuern, die an jeweils eine 230V-Lampe angeschlossen sind.

Der verwendete Ausgangspin ist GPIO PIN 21 und die Relais werden über die Pixelnummern 1, 2, 3, 4 gesteuert.

Schritt 3:Erstellen der Software

Die Schleifenfunktion im Arduino Sketch ist einfach und besteht aus einer Reihe von "for"-Schleifen, um verschiedene Muster des Schaltens der Lampen durch die Steuerung jedes der Relais anzuzeigen.

Um ein bestimmtes Relais zu steuern, wird die folgende Funktion innerhalb des Schleifencodes aufgerufen:

void ControlRelais (int RelaisNo, bool RelaisState) { strip.setPixelColor(RelaisNo, RelaisState*15, RelaisState*15, RelaisState*15); // Schalten Sie die LED ein / aus, die zu RelaisNo strip.show () gehört; Serial.print ("RelaisNr"); Serial.print (RelaisNr); Serial.print(" ="); Serial.println (RelaisState); } 

Tatsächlich schaltet diese Funktion nur eine bestimmte LED ein oder aus.

Eine LED-Adresse entspricht der jeweiligen Relaisnummer. Die LEDs leuchten bei geringer Lichtstärke, gerade genug, um das Relais über den LDR auszulösen und somit Lichtverschmutzung zu vermeiden (oben auch als "Lichtübersprechen" bezeichnet.

Das Ergebnis all der Mühe und der jeweiligen Skizze, zeigt der folgende Film:

Code

• Skizze zur Steuerung mehrerer Relais über selbstgebaute NeoPixel-Optokoppler

Skizze zur Steuerung mehrerer Relais über selbstgebaute NeoPixel-OptokopplerArduino

/* Dieser Code zur Steuerung mehrerer Relais oder anderer Aktoren von einem einzigen Arduino-Ausgangspin wurde von Pierre . entwickelt und produziert Pennings (Dezember 2018) Diese Lösung kann für typische Situationen verwendet werden, in denen die Anzahl der verfügbaren Arduino-Ausgangspins nicht ausreicht und mehr Aktoren wie Relais parallel gesteuert werden müssen Das Funktionsprinzip basiert auf der Verwendung eines Streifens aus mehreren Neopixeln (SMD5050 LEDs mit WS2812B Controllerchips) Jedes Pixel wird mit einem LDR (Light Dependent Resistor) zusammengefügt, wodurch ein DIY Optokoppler entsteht ), wird an ein 5V Relais angeschlossen. Auf diese Weise können viele Neopixel/LDR-Kombinationen von 1 Arduino-Ausgangs-PIN mit der Adafruit Neopixel-Bibliothek gesteuert werden. Für dieses Projekt, das Teil eines größeren Plans ist, wird ein ESP 32 (NodeMCU) verwendet, jedoch wird ein normales ARDUINO UNO (oder fast jedes andere Modell) die Arbeit erledigen (natürlich müssen die Einstellungen im Code angepasst werden .) , zB aufgrund unterschiedlicher Pinbelegung) Das ESP 32 Gerät arbeitet mit 3,3 Volt (ein On-Board 3,3V Spannungsregler), während der LED Streifen mit 5050 LEDs mit 5V läuft Der ESP 32 wird mit 5V Strom gespeist (via der USB-Port von einem 5V-Adapter oder einer 5V-Powerbank) Die Neopixel-LEDs beziehen die 5V-Versorgung direkt vom 5V-Pin des ESP 32 und die verwendeten Relais sind ebenfalls 5V-Typen. In diesem Beispiel wird ein LED-Streifen mit 10 LEDs verwendet, der Einfachheit halber werden nur 4 Optokoppler-Schaltungen verwendet, die 4 Relais steuern, die an jeweils eine 230V LED-Lampe angeschlossen sind. Der verwendete Ausgangspin ist GPIO PIN 21 und die RELAIS werden über Pixelnummern 1,2,3,4 gesteuert Dieser Code ist unter der GPL3+ Lizenz lizenziert.*/#include #define NUM_LEDS 10////// ////////////////////////////////////////// Initialisieren der GPIO-Pinconst int RelaisPin =21; // Pin 21 sendet Steuerdaten (0 -3,3 V) an das Relaisint RelaisNo =0; // Variable für das zu steuernde Relaisbool RelaisState =false;int r =0;Adafruit_NeoPixel strip =Adafruit_NeoPixel(NUM_LEDS, RelaisPin, NEO_RGB + NEO_KHZ800);///////////////// ///////////////////////////////// der folgende Setup-Code wird einmal nach "Power On" oder danach ausgeführt ein RESETvoid-Setup () { Serial.begin (115200); pinMode (RelaisPin, AUSGANG); // Initialisiert den RelaisPin als Ausgabe strip.begin(); // Alle LEDs auf "aus" initialisieren für (int t =0; t <10; t++) { strip.setPixelColor (t, 15, 15, 15); // Nach dem Einschalten werden alle LEDs des Streifens einmal getestet strip.show(); // Beachten Sie, dass die Reihenfolge der Farben des WS2812 LED-Streifens R, G, B Verzögerung (500) ist; strip.setPixelColor (t, 0, 0, 0); // Und wieder aus }}///////////////////////////////////////// ///////// der folgende Schleifencode wird wiederholt bis "Power Off" oder ein RESETvoid loop(){ for (int r =1; r <5; r++) // die 4 Relais einschalten nacheinander von 1 bis 4 zählen { Verzögerung (500); ControlRelais (r , wahr); Verzögerung (500); ControlRelais (r, falsch); } for (int k =4; k> 0; k--) // die 4 Relais nacheinander einschalten Zählen von 4 bis 1 { delay (500); ControlRelais (k, wahr); Verzögerung (500); ControlRelais (k, false); } for (int r =1; r <5; r++) // schalte die 4 Relais in einem Muster ein { for (int k =4; k> 0; k--) { delay (500); ControlRelais (r , wahr); ControlRelais (k, wahr); Verzögerung (500); ControlRelais (r, falsch); ControlRelais (k, false); } }}//////////////////SCHLEIFENENDE ///////////////////////// ///////////////////////////////// //////////////// ////////////////////////////////// Nachfolgend die Funktion zur Steuerung des Relais (aufgerufen aus der Schleife) void ControlRelais (int RelaisNo, bool RelaisState) { strip.setPixelColor(RelaisNo, RelaisState*15, RelaisState*15, RelaisState*15); // Schalten Sie die LED ein / aus, die zu RelaisNo strip.show () gehört; Serial.print ("RelaisNr"); Serial.print (RelaisNr); Serial.print(" ="); Serial.println (RelaisState); }

Schaltpläne