Menu principal
- Bienvenue sur .
- Connexion
- Inscrivez-vous
Comment gérer au plus simple sa rampe LEDs à l’aide d’un Arduino?
Voici donc la suite du précédent tutoriel qui concernait la fabrication d’une rampe LED. Nous allons maintenant étudier la manière la plu simple de contrôler un driver dimmable en PWM, et ce, à l’aide d’un Arduino. Mais soyons claire, il faut tout de même avoir quelques notions de base en électronique et il sera nécessaire de passer du temps sur la programmation de l’Arduino (il faut donc coder, même si le code est simple pour notre utilisation son apprentissage demande d’y passer un peu de temps). Ce tuto est donc à considérer comme une aide mais ne sera pas toujours suffisant, en particulier en fonction du matériel choisi.
« Y’en a qui ont essayé … ils ont eu des problèmes, hein ! »
Chevalier et Laspalès
Dans l’exemple que je présente ici, l’Arduino est utilisé pour :
- gérer la durée d’éclairage
- gérer l’allumage et l’extinction progressive de la rampe LEDs
En complément de ces 2 fonctions de base, notre Arduino pourra également piloter un relai (facultatif). Ce dernier permet de gérer l’allumage et l’extinction de tout type d’appareil (en on/off). Dans mon cas je l’utilise pour programmer l’allumage d’un simple ventilateur (qui peut être nécessaire pour refroidir la rampe LEDs par exemple). Il est bien entendu qu’on pourra par la suite ajouter des fonctions complémentaires à notre Arduino : ajouter un afficheur LCD, ajouter un capteur température ou autre, … la limite étant le nombre de broches libres sur l’Arduino.
Un Arduino, c’est quoi ? Comment ça marche ?
Pour simplifier, l’Arduino est un appareil constitué d’un cerveau (le micro-contrôleur) capable de recevoir, traiter et envoyer des informations selon une certaine logique qu’on lui définit dans un programme. Les broches de l’Arduino peuvent fonctionner en « entrée » (pour recevoir les informations : capteurs températures, interrupteurs, …) et/ou en « sortie » (pour envoyer des informations : signal PWM pour notre driver LEDs, alimenter un relais ou une petite LED, …). L’Arduino que j’utilise est la version Uno. Pour programmer cet Arduino, il suffit de le brancher sur le port USB sur votre ordinateur.
Le matériel nécessaire pour contrôler sa rampe leds
Il faudra vous procurer le matériel suivant:
- Une carte Arduino, Uno par exemple - Une alimentation délivrant une tension comprise entre 7V et 12V (je conseille 10V (ou 12V) pour simplifier les montages suivants)
- Un « protoshield » : c’est une plaque électronique qui s’enfiche sur la carte Arduino. C’est sur cette plaque qu’on fera les soudures pour ajouter des composants par exemple.
- 2 résistances 1.5KΩ (pour montage d’un driver MeanWell)
- 2 transistors NPN 2N2222 (pour montage d’un driver MeanWell)
- Le petit matériel : fer à souder, fils électriques, pinces, tournevis, étain, …
En complément, vous aurez également besoin des modules suivants :
- Un module horloge RTC DS1307 : c’est un petit module externe qu’on branche sur notre Arduino. C’est tout simplement une horloge, nécessaire pour programmer nos périodes d’éclairage par exemple ! Car l’Arduino n’a pas d’horloge précise intégrée …
Si vous le souhaitez (facultatif), vous pourrez également vous procurer : Un relais : c’est une sorte d’interrupteur qui peut être contrôlé par l’Arduino pour gérer l’allumage et l’extinction d’un appareil fonctionnant jusqu’à 220V (ventilateur, pompe à eau, …). Le relais peut être nécessaire si l’on souhaite par exemple contrôler un ventilateur pour refroidir la rampe LEDs.
NB : Pour gérer nos drivers LEDs dimmables en PWM, on ne passera pas par un relais. Le driver sera directement branché sur une sortie PWM de notre Arduino.
Le montage!
Pour assurer les fonctions prévues (Cf §1), il faut réaliser un montage du type :
Je prends l’exemple de la gestion de 2 drivers car pour notre utilisation en récifal il peut être intéressant de gérer séparément les LEDs blanches et les LEDs bleues :
- pour allumer/éteindre progressivement le bac avec les LEDs bleues
- pour pouvoir régler l’intensité des bleues par rapport aux blanches afin d’obtenir le rendu que l’on souhaite (plus ou moins bleu).
Pour ce faire, il va falloir faire les branchements en utilisant les broches disponibles de notre Arduino.
Pour la majorité d’entre nous, on peut se retrouver perdu devant l’Arduino …
Voici les broches dont on dispose, numérotées de 0 à 13, de A0 à A5, ainsi que les broches « Power » :
Pas de panique!
Pour traduire un peu tout ça, voici ce qu’il faut savoir:
- A gauche (broches du haut): ce sont les broches pour l’alimentation. Les broches GND (= ground, la terre) correspondent à la masse. La broche Vin est utilisée pour alimenter l’Arduino (à connecter au + de l’alimentation). L’arduino est capable d’alimenter des modules externes (par exemple, un petit ventilo, un écran LCD, …) : on utilisera pour cela les broches +3V3 ou +5V (pour alimenter respectivement le module en 3V ou 5V).
- A gauche (broches du bas, A0 à A5) : les entrées analogiques (pour brancher le module RTC ou un capteur température par exemple).
- A droite : les entrées/sorties digitales. Seules les broches 3, 5, 6, 9, 10, 11 peuvent fournir un signal PWM. Nous utiliserons donc une de ces broches pour contrôler chacun de nos drivers leds dimmables. Mais attention ! Ces sorties PWM transmettent un signal en 5V. Or certains drivers comme les Meanwell nécessitent du 10V : il faut donc convertir le signal PWM 5V fournit par l’Arduino en 10V (CF § Branchement des drivers, ci-dessous).
Etape 1: Mise en place du protoshield
Le protoshield est très utile pour pouvoir bidouiller/souder notre montage sans risquer l’altérer l’Arduino.
Je trouve très pratique les protoshield avec borniers (ça évite de devoir dessouder en cas d’erreur de montage).
Etape 2: Branchement de l’alimentation de notre Arduino
L’Arduino doit être branché une alimentation fournissant une tension comprise entre 7V et 12V. Dans le cas de l’utilisation de driver MeanWell, je conseille l’utilisation d’une alimentation de 10V ou 12V pour faciliter la conversion du signal PWM 5V de l’Arduino en 10V (Cf étape 4).
L’alimentation doit être branchée aux broches GND (le -) et Vin (le +), ou à la prise jack prévue à cet effet. L’Arduino peut également être alimenté par le port USB, ce qui peut être pratique pour la phase de programmation.
Etape 3: Branchement du module RTC DS1307
Pour que votre Arduino connaisse l’heure, le jour, le mois, … il est nécessaire de le brancher à un module RTC DS1307 (par exemple).
Le branchement est assez simple sur celui que j’utilise :
- DS1307 -> Arduino- SDA -> Pin A4
- SCL -> Pin A5
- GND -> GND
- VCC+ -> +5V
Etape 4: Branchement des drivers
Ici ça se complique un peu. Comme indiqué plus haut, pour utiliser des drivers Meanwell (qui n’acceptent que les signaux PWM en 10V) il est nécessaire de convertir le signal PWM 5V de l’Arduino en signal PWM 10V. Pour ce faire, il va falloir sortir le fer à souder et reproduire le montage ci-dessous. On implantera les composants sur le protoshield (pratique !). On reproduit ce montage pour chacun des drivers.
NB: la partie du montage encadrée en rouge n’est nécessaire que si vous utilisez une alimentation de 12V. Si vous utilisez une alimentation de 10V vous devez simplifier le montage en supprimant les composants de l’encadré rouge.
Dans mon exemple qui servira de base pour la programmation (étape 6) :
- le driver qui pilote les LEDs blanches est branché sur le Digital Pin 9 (PWM)
- le driver qui pilote les LEDs bleues est branché sur le Digital Pin 11 (PWM)
Etape 5 (facultative): Branchement du relai
Sur le relais, il faut distinguer les broches à connecter à l’Arduino, et celles à brancher sur l’appareil qu’on veut contrôler (selon les caractéristiques du relai, on peut contrôler des appareils fonctionnant sous 220V).
Pour le branchement côté Arduino, rien de bien compliqué, il suffit de suivre les indications écrites sur le relai :
Relai -> Arduino
VCC -> +5V
GND -> GND
D -> Digital pin 3
Pour le branchement côté appareil à contrôler, le relai vient s’intercaler sur le fil (+) qui l’alimente. Dans mon cas, j’ai branché un ventilateur alimenté en 5V via l’Arduino.
Etape 6: La programmation de l’Arduino …
Maintenant que le montage électronique est terminé, passons à l’étape la plus redoutée: la programmation!
Autant être claire, pour les néophytes comme moi, à première vue vous n’y comprendrez rien! Mais en passant un peu de temps à décortiquer le programme, on s’aperçoit que tout est très logique, il faut juste se familiariser avec le langage utilisé.
Sous-étape 6.1 : Installation du logicielDans un premier temps, télécharger le logiciel Arduino et lancez-le. Il n’est pas nécessaire de brancher tout de suite l’Arduino … essayez d’abord de terminer le programme et de vérifier qu’il fonctionne bien (il y a un outil de vérification dans le logiciel, sous l’onglet File).
Sous-étape 6.2 : Installation des bibliothèques
L’Arduino n’est pas encore capable de comprendre toutes les commandes qu’on va utiliser. Pour cela, il faut installer des "libraries" pour lui apprendre de nouveaux langages.
Pour notre programme, vous aurez besoin des "libraries" suivantes :
- WProgram
- Time
- Wire
- DS1307RTC
Sous-étape 6.2 : Programmation du module RTC
Vous devez dans un premier temps régler l’heure de votre module RTC. Pour ça, vous devez installer sur l’Arduino le programme suivant (en remplaçant par les bonnes valeurs …) :
#include
#include
#include
#include
void setup() {
RTC.stop();
RTC.set(DS1307_SEC,00); //reglage secondes
RTC.set(DS1307_MIN,56); //reglage minutes
RTC.set(DS1307_HR,10); //reglage heures
RTC.set(DS1307_DOW,7); //reglage jour de la semaine
RTC.set(DS1307_DATE,27); //reglage date
RTC.set(DS1307_MTH,11); //reglage mois
RTC.set(DS1307_YR,11); //reglage annee
RTC.start();
}
void loop(){
}
Vous branchez ensuite le module RTC, vous allumez l’Arduino … et c’est bon !
Le RTC est à l’heure ! Vous pouvez maintenant faire un Reset (bouton poussoir) de votre Arduino et passer à l’étape suivante.
Sous-étape 6.3 : Programmation
Si vous avez utilisé les mêmes broches que moi pour le montage, vous pouvez copier/coller le programme ci-dessous, et cliquer sur vérifier pour vous assurer qu’il n’y a pas d’erreur.
J’ai inséré les explications dans le programme. Mais voici quelques éléments de compréhension supplémentaires :
- La première partie du programme rappelle les "libraries" utilisées dans le programme. Pour cela on utilise la fonction #include < >
- Les informations précédées de // ne font pas parties du programme, mais sont là pour se rappeler ce qu’on a fait … Idem pour les informations comprises entre /* et */ (les informations apparaissent alors en grisé dans le programme)
- Le signal PWM est défini par une variable comprise entre 0 (les LEDs sont éteintes) et 255 (les LEDs fonctionnent à 100%)
- Quelques éléments de langage :
- int : définit une variable
- Void setup() : initialise chacune des variables (nom de la variable et port utilisé)
- Void loop() : c’est ce que le programme va répéter en boucle (vérifier l’heure par exemple pour savoir quelle signal PWM envoyer)
- If : si …
- Else if : de plus, si …
- Else : sinon …
#include
#include
#include
#include
/*
Ports utilisés :
Analog Pin 4 = SDA pour ds1307
Analog Pin 5 = SCL pour ds1307
Digital Pin 9 = PWM Blanc
Digital Pin 11 = PWM Bleu
Digital pin 3 = relais pour le ventilo
Pour info :
PWM1 = intensité des blancs
PWM2 = intensité des bleus
relais = état du relais du ventilo des drivers
*/
int pwm1=9;
int pwm2=11;
int time;
int val_up=0;
int val_down=0;
int relais=3;
void setup() {
Serial.begin(9600); //initialise la communication pour le DS1307
analogWrite(pwm1,0); //initialise à 0 les leds blanches
analogWrite(pwm2,0); //initialise à 0 les leds bleues
setSyncProvider(RTC.get); //récupère les données du DS1307
pinMode(relais, OUTPUT); //initialise le port du relais en sortie
digitalWrite(relais, LOW); //le relais est éteint à l'initialisation
}
void loop() {
val_up = (map (minute(), 0, 59, 0, 255)); //permet d’attribuer une valeur d’intensitp des leds croissante sur 59 minutes, comprise entre 0 et
255 (valeur maximale du signal PWM)
val_down = (map (minute(), 0, 59, 255, 0)); //permet d’attribuer une valeur d’intensitp des leds dpcroissante sur 59 minutes, comprise entre
255 et 0 (valeur minimale du signal PWM)
//****************LEDS BLEUES***************************************************
if (hour() == 11) { // entre 11:00:00 et 11:59:59
analogWrite (pwm2, val_up); // allumage progressif sur 59 minutes
}
else if (hour() == 21) { // entre 21:00:00 et 21:59:59
analogWrite (pwm2, val_down); // extinction progressive sur 59 minutes
}
else if ((hour() > 11 ) && (hour() < 21)) { // entre 12:00:00 et 20:59:59
analogWrite(pwm2, 255); // allumage maximum
}
else {
analogWrite(pwm2, 0);//le reste du temps les leds bleues sont éteintes
}
//****************LEDS BLANCHES*************************************************
if (hour() == 12) { //entre 12:00:00 et 12:59:59
analogWrite (pwm1, val_up*0.8); //allumage progressif
}
else if (hour() == 20) { //entre 20:00:00 et 20:59:59
analogWrite (pwm1, val_down*0.8); // extinction progressive
}
else if ((hour() > 12 ) && (hour() < 20)) { //entre 13:00:00 et 19:59:59
analogWrite(pwm1, 255*0.8); //allumage max
}
else {
analogWrite(pwm1, 0);//le reste du temps les leds blanches sont éteintes
}
//****************Ventilateur ********************************************
if (pwm1 > 0) {//Si les leds blanches sont allumées
digitalWrite(relais, HIGH);//relais ventilo ON
}
else {//sinon
digitalWrite(relais, LOW);//relais ventilo OFF
}
if (pwm2 > 0) {//Si les leds bleues sont allumées
digitalWrite(relais, HIGH);//relais ventilo ON
}
else {//sinon
digitalWrite(relais, LOW);//relais ventilo OFF
}
}
Il s’agit là d’un programme assez simple à comprendre, qui en contrepartie peut être grandement amélioré, en particulier pour que la gradation de l’éclairage fasse moins apparaître de paliers … mais nous verrons ça dans un prochain épisode…
Et voilà à quoi ça ressemble au final !
J’ai pour ma part choisi de tout mettre dans un boîtier : je ne le conseille pas forcément car les drivers chauffent beaucoup (j’ai dû ajouter un petit ventilo)… et ça devient un peu fouilli à l’intérieur …
J’ai ajouté un petit interrupteur sur la face avant, pour pouvoir allumer faiblement les LEDs bleues pendant la nuit, histoire de pouvoir montrer mes dernières boutures aux copains de passage
.Mais combien ça coute tout ça?
Alors, pour donner une idée du coût total du contrôleur je vous donne de mémoire des prix approximatifs :
- Arduino Uno: 25€
- Protoshield à borniers: 10€
- Module RTC DS1307: 5€
- Relais (facultatif): 5€
- Alimentation 10 ou 12V: 10€
- Resistances, transistors: quelques 10n de centimes.
Quelques adresses utiles:
Vous trouverez les composants classiques dans n’importe quel magasin d’électronique. Certains vendent désormais des Arduino (Electronique-diffusion par exemple, dans le 8éme).
Pour ma part, pour avoir de biens meilleurs prix et plus de choix, j’ai commandé sur internet : je ne peux que vous recommander les 3 sites suivants, que j’ai testé, et qui sont top niveau prix et surtout communication SAV :
Pour le prochain épisode, nous verrons comment complexifier un peu le montage pour ajouter d’autres modules à notre Arduino (LCD, …) ou pour améliorer le programme en gérant le cycle lunaire ou pour avoir une gradation plus progressive à l’allumage, par exemple …
Bon bricolage les Atolliens !!!
Article transmis par Lionav69
Si vous souhaitez faire publier un article sur l'Atoll merci de contacter les webmasters du site.