Contrôleur de LED simple utilisant un TIP120

Dans le cadre du projet Domochevsky, nous cherchons à implémenter un système d’éclairage intelligent, tel que nous en avons discuté dans ce précédent billet. Nous n’implémenterons pas toutes les fonctionnalités décrites immédiatement, mais nous allons créer une base simple et extensible sur laquelle nous pourrons construire la suite du projet. Nous décrirons ici une version minimale, facile à mettre en oeuvre, mais malgré tout apte à recevoir des ajouts ultérieurs, présentés dans les billets suivants.

Contrôleur de LED simple : description de la version minimale

Dans la version minimale, nous souhaitons créer un contrôleur de LED simple afin de pouvoir allumer ou éteindre notre système lumineux par une pression sur un bouton. Nous utiliserons ici des bandes de LED en 12v continu. C’est très basique, mais nous décrirons ce circuit élémentaire avant de l’améliorer avec un détecteur de présence dans un prochain billet. Nous utiliserons un Arduino Nano, car cette carte est compacte, tout en fournissant toutes les fonctionnalités d’un Arduino uno.  Dans ce cas précis, il s’agit d’un clone chinois de l’Arduino Nano, que j’ai déjà testé ici. Ce choix se justifie par le coût faible (2€) de cette carte, ce qui est parfait pour un système d’éclairage. Une alternative serait d’utiliser directement une puce ATMega328p, mais vu le prix du clone, on peut se simplifier la vie en s’en servant.

Un transistor Darlington : le TIP 120

La carte Arduino fonctionne en 5V, alors que les LED sélectionnées fonctionnent en 12V. Même si les LED étaient en 5V, le Arduino ne pourrait pas fournir assez de courant pour alimenter une bande de LED conséquente. Il nous faut donc un moyen de commuter un courant élevé (aux alentours d’une ampère). Pour cela il est possible d’utiliser des transistors. Dans le cas précis, nous utiliserons un transistor Darlington. Il est possible d’utiliser d’autres technologies, telles que les FET, mais dans notre cas, le Darlington conviendra très bien. Nous utiliserons le TIP120, très utilisé par les électroniciens amateurs, car simple et performant. Il peut commuter jusqu’a 4 ampères, avec tes tensions allant jusqu’à 60V. Suivez ce lien pour accéder à la documentation officielle du TIP120 pour plus d’informations (pas nécessaire pour réaliser ce projet).

En pratique, on connectera une sortie du Arduino à ce transistor. Quand la sortie (disons D11) sera à l’état logique haut, le transisror autorisera le passage du courant à travers notre bande de LED. De cette façon, on peut commuter un courant important depuis une broche du Arduino (cela fonctionne également pour un Raspberry pi), à une tension quelconque, fournie par une alimentation externe.

Liste des composants requis

Voyons maintenant le montage sur une breadboard. Il nous faut tout d’abord les composants suivants :

• Un arduino nano (mais on peut reproduire la même chose avec un uno, leonardo, n’importe quel arduino en fait)
• une breadboard;
• un transistor TIP120;
• un jack d’alimentation femelle pour breadboard;
• une résistance entre 2 et 10K ohms;
• une résistance de 1K ohms;
• un bouton poussoir;
• quelques connecteurs mâle-mâle pour breadboard;
• une bande de LED;
• un transfo fournissant la tension requise pour les LED (et l’ampérage nécessaire).

Le montage minimal sur breadboard

Passons maintenant à l’assemblage de notre contrôleur de led simple. Nous plaçons la carte Arduino et les composants sur la breadboard, en connectant le tout comme sur ce schema :

contrôleur de LED simple sur arduino via un TIP120

Nous plaçons le Arduino sur le bord gauche de la breadboard, et connectons la broche 5V au rail 5v sur le côté (fils rouges), de même pour la masse (GND, fils noirs). On relie également les rails 5v et de masse des deux côtés de la breadboard pour simplifier le câblage.

On peut maintenant placer notre jack d’alimentation (l’élément avec un éclair sur le schéma) sur la breadboard. La broche connectée au plot central du jack est le + dans la plupart des cas, c’est à vérifier sur votre transfo. Dans notre implémentation, c’est le cas. Ici, cela correspond à la broche de droite de la petite carte. La broche de gauche, connectée à la lamelle sur le côté long du jack est la masse. Vous pouvez vérifier le tout avec un voltmètre, ou en branchant votre bande de LED. Les LED ne bloquent le courant si la polarité est inversée, et s’allument lorsqu’on est dans le bon sens. Vérifiez toutefois s’il n’y a pas un circuit sensible à la polarité sur votre bande de LED (il ne faut surtout pas essayer avec des LED adressables). Ici, le jack apportera du 12V. On connecte la masse du jack à la masse du circuit, et le +12V à la broche VIN du Arduino (et surtout pas une autre!). Vérifiez bien le branchement, car le 12V sur une autre broche pourrait griller la carte. La broche VIN permet d’amener le courant au régulateur de tension de la carte, qui va produire du 5V pour alimenter le reste de la carte.

On connecte ensuite le bouton poussoir à une entrée (la 12 ici, via le fil vert) sur l’une des pattes du bouton. A cette même patte, on connecte une résistance entre 1 et 10 kilo-Ohms (prenez ce que vous avez dans cette plage), qui est la résistance de tirage (ici pull-down), qui garantit que la valeur par défaut est 0V, soit un signal logique bas. L’autre patte de la résistance sera connectée à la masse (ce qui en fait une pull-down). L’autre broche du switch sera quand à elle connectée au rail +5V. Ainsi, quand on appuie sur le bouton, le 5V passe, et ressort par l’entrée D12, ou l’on lira alors un signal haut.

Il est maintenant temps de connecter le transistor. J’ai choisi de placer la partie métallique vers l’extérieur de la breadboard, de façon a pouvoir fixer facilement un dissipateur si nécessaire. La partie noire étant face à nous, on connecte la broche la plus à droite à la masse du circuit. On connecte la broche la plus à gauche à une résistance de 1K, puis l’autre côté de la résistance à la broche D11 du Arduino. C’est par cette broche que l’on enverra le signal commandant le transistor. La résistance sert à limiter le courant. Nous sommes en 5V, et sachant que U=R*I, donc I=U/R=5/1000A, soit 5 mA. C’est tout à fait dans les capacités d’une sortie d’un arduino. Nous avons choisi la broche D11, car celle ci est capable de PWM, ce qui nous servira ultérieurement, par exemple pour changer la luminosité de nos LED. La broche centrale du transistor sera connectée à la masse de la bande de LED.

Pour la bande de LED justement, c’est très simple, puisqu’il suffit de connecter le + de la bande au + du jack d’alimentation (le 12V dans notre cas), et le – à la borne centrale du transistor.

Voici à peu près ce que cela donne (il s’agit d’une version un peu plus ancienne, donc les branchements et la disposition sont légèrement différents) :

contrôleur de LED simple sur breadboard, version beta

Version perfboard

Notre contrôleur de LED simple peut également être réalisé de façon plus durable, en utilisant une plaque de prototypage type perfboard. Ici, il faudra souder les composants afin d’assurer le contact, ce qui rendra l’ensemble plus solide et résistant aux débranchements intempestifs. Voici le schéma d’une telle version :

Contrôleur de LED simple sur perfboard à souder

Cependant, même si ça n’apparait pas ici, certains composants ne sont pas soudés. En effet, la carte Arduino et le transistor ne sont pas soudés. Au lieu de cela, ce sont des broches femelles qui sont soudées sur la carte, et on enfiche le Arduino et le transistor dans ces broches femelles. Pour le Arduino ça permet de le reprogrammer plus facilement, en l’enlevant (et aussi de le changer en cas de problème), et donc sans avoir à tout démonter, et pour le transistor, cela permet de pouvoir le placer plus loin, pour pouvoir le visser sur les parois d’un boitier en métal si nécessaire pour la dissipation thermique. D’autre part on pourra changer de modèle de transistor pourvu que le brochage soit le même.

Le programme

Pour l’instant notre contrôleur de LED simple l’est tellement qu’il ne fait rien. Il manque pour cela un programme! Le code est relativement simple, puisque nous reprendrons ici l’exemple dans 02.Digital/Debounce de Arduino, et nous changerons les broches : buttonPin devient 12 au lieu de 2 et ledPin devient 11 au lieu de 13. Le programme changera l’état des LED à chaque appui sur le bouton, avec un debounce pour éviter des effets de clignotement indésirables.

Voici le code source modifié, compacté et avec des commentaires en français :

//contrôleur de LED simple - version basique
const int buttonPin = 12; // le bouton est sur D12
const int ledPin = 11; // les LED sur D11
int ledState = LOW; // au départ les LED sont eteintes
int buttonState; // l'etat courant du bouton
int lastButtonState = LOW; // l'etat precedent du bouton

long lastDebounceTime = 0; // la derniere fois qu'on a analyse l'etat du bouton
long debounceDelay = 50; // 

void setup() 
{
 pinMode(buttonPin, INPUT); // la broche du bouton est mise en entree
 pinMode(ledPin, OUTPUT); // la broche des LED est mise en sortie
 digitalWrite(ledPin, ledState); // on initialise les LED 
}

void loop() 
{
 int reading = digitalRead(buttonPin);//on lit l'etat du bouton
 if (reading != lastButtonState) //si il a change
 {lastDebounceTime = millis();} //on met a jour le timer de debounce
 if ((millis() - lastDebounceTime) > debounceDelay) //si le temps ecoule depuis la derniere lecture est suffisant
 {
 if (reading != buttonState) //si la lecture est differente de la précédente
 {
 buttonState = reading; //alors on met à jour
 if (buttonState == HIGH) //si le bouton est enfonce
 {ledState = !ledState;} //on inverse l'etat de la LED
 }
 }
 digitalWrite(ledPin, ledState); //on change l'etat de la LED
 lastButtonState = reading; //on met a jour l'etat precedent du bouton
}

Dès cet instant, nous disposons d’un contrôleur de LED simple, voire assez basique, mais fonctionnel. Chaque appui sur le bouton allumera ou éteindra les LED, selon l’état précédent. Bien entendu, nous ne nous contenterons pas de cela, mais nous construirons sur cette base. Dans le prochain billet, nous ajouterons un capteur infrarouge pour automatiser l’allumage/extinction des LED tout en conservant la possibilité d’un contrôle manuel total. Nous nous intéresserons pour cela à la façon de programmer le système en gardant un seul bouton tout en pouvant changer de mode simplement.

Il est à noter qu’au niveau de fonctionnalités actuel, puisque nous n’envoyons pas de signaux PWM, il aurait été possible d’utiliser un relais pour commander un éclairage 220V de façon similaire.