Arduino avec optocoupleurs NeoPixel contrôlant de nombreux relais

Outils et machines nécessaires

	Fer à souder (générique)
	Outils communs comme disponible dans un foyer/atelier normal

Applications et services en ligne

À propos de ce projet

Ce projet concerne le contrôle de plusieurs relais ou autres actionneurs à partir d'une seule broche de sortie Arduino.

Cette solution peut être utilisée pour des situations typiques où la quantité de broches de sortie Arduino disponibles est insuffisante et où davantage d'actionneurs tels que des relais doivent être contrôlés en parallèle à partir d'une seule broche de sortie.

Le principe de fonctionnement est basé sur l'utilisation d'une bande LED d'un certain nombre de NeoPixels (LED SMD5050 avec des puces de contrôleur WS2812B). Chaque pixel est associé à une LDR (Light Dependent Resistor), créant ainsi un optocoupleur DIY (autant que vous le souhaitez, uniquement limité par la longueur de la bande LED, par exemple 300 pixels, et l'alimentation 5V disponible). De cette façon, une conversion série vers parallèle est créée (de 1 à plusieurs)

Chaque LED individuelle est adressée à partir d'une seule et même broche de sortie Arduino. Chaque LDR (en série avec une résistance de 27kOhm), est connecté à un relais 5V. De cette façon, de nombreuses combinaisons NeoPixel/LDR peuvent être contrôlées à partir d'un code PIN de sortie Arduino à l'aide de la bibliothèque Adafruit NeoPixel. Au lieu de relais, d'autres dispositifs d'actionnement pourraient également être connectés, en utilisant les LDR comme entrée à n'importe quel circuit.

Pour ce projet, qui fait partie d'un plan plus vaste, un ESP32 (NodeMCU) est utilisé; Cependant, un Arduino Uno normal (ou presque n'importe quel autre modèle) fera l'affaire.

Étape 1 :fabrication des optocoupleurs NeoPixel

L'optocoupleur DIY est fabriqué avec les matériaux suivants :

• un morceau de bande LED composé de 10 LED WS2812 (coupées dans une bande plus longue) seulement 4 sont réellement utilisées dans le projet
• un morceau de mousse gris foncé
• une bande de planche à pain
• ruban de canard noir

Remarque :la séparation des points est égale à la séparation des LED.

Il est important de séparer la lumière de chaque LED individuelle des LDR des autres pour éviter la "diaphonie de lumière ." Il s'est avéré qu'en pratique, cela est presque impossible et, par conséquent, la quantité de lumière émise par chaque LED à l'état "allumé" a été réglée à des niveaux bas dans le logiciel.

La bande LED utilisée est longue de 10 LED mais seuls 4 pixels sont utilisés en combinaison avec 4 LDR dans ce projet (pour rester simple)

Étape 2 :La configuration électronique

Dans la configuration de la maquette, j'ai utilisé un ESP32 (NodeMCU), mais n'importe quel Arduino peut faire le travail.

Le schéma du circuit (réalisé avec Fritzing) est le suivant :

En pratique, cela ressemble à ceci :

Comme vous pouvez le voir, une seule broche de sortie est utilisée pour contrôler 4 relais en parallèle. Ce nombre peut aller jusqu'à 300 ! (autant de LED que disponibles dans une bande de 5 m de long).

L'appareil ESP32 fonctionne à des niveaux de 3,3 volts (un régulateur de tension de 3,3 V embarqué), tandis que la bande LED avec 5050 leds fonctionne sur 5 V. L'ESP32 est alimenté en 5 V (via le port USB d'un adaptateur 5V ou 5V batterie externe). Les LED NeoPixel reçoivent l'alimentation 5V directement à partir de la broche 5 volts de l'ESP32 et les relais utilisés sont également de type 5V.

Dans cet exemple, 4 circuits optocoupleurs sont utilisés pour contrôler 4 relais connectés chacun à une lampe 230 V.

La broche de sortie utilisée est GPIO PIN 21 et les relais sont contrôlés via les numéros de pixels 1, 2, 3, 4.

Étape 3 :Création du logiciel

La fonction de boucle dans l'Arduino Sketch est simple et se compose d'un certain nombre de boucles "for" pour montrer différents modèles de commutation des lampes en contrôlant chacun des relais.

Pour contrôler un relais particulier, la fonction suivante est appelée à partir du code de boucle :

void ControlRelais (int RelaisNo, bool RelaisState) { strip.setPixelColor(RelaisNo, RelaisState*15, RelaisState*15, RelaisState*15); // allume/éteint la LED qui appartient à RelaisNo strip.show(); Serial.print(" RelaisNo "); Serial.print(RelaisNo); Serial.print(" ="); Serial.println(RelaisState); } 

En fait, tout ce que fait cette fonction est soit d'allumer une LED particulière, soit de l'éteindre.

Une adresse LED correspond au numéro de relais respectif. Les LEDs sont allumées à un faible niveau de luminosité, juste assez pour déclencher le relais via le LDR, et ainsi éviter la pollution lumineuse (appelée aussi ci-dessus "light cross talk".

Le résultat de tous les efforts et du croquis particulier, est montré dans le film suivant :

Code

• Esquisse pour contrôler plusieurs relais via des optocoupleurs NeoPixel faits maison

Esquisse pour contrôler plusieurs relais via des optocoupleurs NeoPixel faits maisonArduino

/* Ce code pour contrôler plusieurs relais ou autres actionneurs à partir d'une seule broche de sortie Arduino, a été développé et produit par Pierre Pennings (décembre 2018) Cette solution peut être utilisée pour des situations typiques où la quantité de broches de sortie Arduino disponibles est insuffisante et où plusieurs actionneurs tels que Relais doivent être contrôlés en parallèle Le principe de fonctionnement est basé sur l'utilisation d'une bande de plusieurs néopixels (LED SMD5050 avec puces de contrôleur WS2812B) Chaque pixel est associé à une LDR (Light Dependent Resistor), créant ainsi un optocoupleur DIY. ), est connecté à un relais 5V De cette manière, de nombreuses combinaisons Neopixel/LDR peuvent être contrôlées à partir d'un PIN de sortie Arduino à l'aide de la bibliothèque Adafruit Neopixel. Pour ce projet, qui fait partie d'un plan plus vaste, un ESP 32 (NodeMCU) est utilisé, cependant un ARDUINO UNO normal (ou presque n'importe quel autre modèle) fera le travail (bien sûr les paramètres dans le code devront être ajustés , p. le port USB d'un adaptateur 5V ou powerbank 5v) Les LED Neopixel sont alimentées en 5V directement par la broche 5 volts de l'ESP 32 et les relais utilisés sont également de type 5V. Dans cet exemple, une bande LED de 10 LED est utilisée, pour des raisons de simplicité, seuls 4 circuits optocoupleurs sont réalisés contrôlant 4 relais connectés à une LEDLamp 230V chacun. La broche de sortie utilisée est GPIO PIN 21 et les RELAIS sont contrôlés via les numéros de Pixel 1,2,3,4 Ce code est sous licence GPL3+.*/#include #define NUM_LEDS 10////// //////////////////////////////////////// initialise le GPIO pinconst int RelaisPin =21 ; // la broche 21 envoie les données de contrôle (0 -3,3 V) au Relaisint RelaisNo =0; // Variable pour le Relais applicable à contrôlerbool RelaisState =false;int r =0;Adafruit_NeoPixel strip =Adafruit_NeoPixel(NUM_LEDS, RelaisPin, NEO_RGB + NEO_KHZ800);///////////////// ///////////////////////////////// le code de configuration qui suit s'exécutera une fois après "Power On" ou après un RESETvoid setup() { Serial.begin(115200); pinMode(RelaisPin, SORTIE); // Initialise le RelaisPin comme sortie strip.begin(); // Initialise toutes les LED sur "off" pour (int t =0; t <10; t++) { strip.setPixelColor(t, 15, 15, 15); // Après la mise sous tension, toutes les LED de la bande sont testées une fois strip.show(); // notez que l'ordre des couleurs de la bande LED WS2812 est le délai R,V,B (500); strip.setPixelColor(t, 0, 0, 0); // Et retour à off }}//////////////////////////////////////// ///////// le code de boucle qui suit, s'exécutera de façon répétée jusqu'à "Power Off" ou un RESETvoid loop(){ for (int r =1; r <5; r++) // allumer les 4 Relais l'un après l'autre comptage forme 1 à 4 { délai (500); ControlRelais (r , vrai); retard (500); ControlRelais (r , false); }for (int k =4; k> 0; k--) // enclenche les 4 relais les uns après les autres en comptant la forme 4 à 1 { délai (500); ControlRelais (k , vrai); retard (500); ControlRelais (k , false); } for (int r =1; r <5; r++) // enclencher les 4 relais dans un patern { for (int k =4; k> 0; k--) { delay (500); ControlRelais (r , vrai); ControlRelais (k , vrai); retard (500); ControlRelais (r , false); ControlRelais (k , false); } }}/////////////////FIN DE BOUCLE///////////////////////// //////////////////////////////// //////////////// ///////////////////////////////// Ci-après la Fonction de pilotage du Relais (appelée depuis l'intérieur de la boucle) void ControlRelais (int RelaisNo, bool RelaisState) { strip.setPixelColor(RelaisNo, RelaisState*15, RelaisState*15, RelaisState*15); // allume/éteint la LED qui appartient à RelaisNo strip.show(); Serial.print(" RelaisNo "); Serial.print(RelaisNo); Serial.print(" ="); Serial.println(RelaisState); }

Schémas