Après avoir étudié le montage d’un simple interrupteur, qui permet de commander le jeu, voyons désormais comment afficher des informations sur le pupitre : je parle bien sûr des voyants lumineux. L’objectif de cet article est de voir comment se pilote un voyant lumineux avec une carte Arduino, et en particulier comment relier un voyant à une carte.

Principe du montage

La carte Arduino dispose de nombreux pins digitaux qui peuvent être soit définis comme des entrées (INPUT, INPUT_PULLUP), soit comme des sorties (OUTPUT). Pour commander un voyant, nous allons donc ici définir nos pins Arduino comme des sorties. Pour cet article, on suppose que l’on souhaite commander notre voyant avec le pin 3.

void setup(){
       pinMode(3, OUTPUT);
}

Avant d’aller plus loin dans le code, intéressons nous à la façon de relier notre voyant à la carte.
La première chose à remarquer est qu’un voyant est un composant qui a une puissance électrique non négligeable : contrairement aux circuits électroniques de commande (par exemple un interrupteur) qui ne consomment pas (ou extrêmement peu en réalité) d’énergie pour fonctionner, une lampe dissipe de l’énergie électrique sous forme lumineuse pour briller. Il n’est donc pas possible de la relier directement à un pin Arduino qui n’est pas fait pour fournir de la puissance, et il va falloir utiliser une alimentation externe. Le choix de cette alimentation dépend des caractéristiques du voyant : tension d’alimentation et puissance consommée. Il faut une alimentation capable de fournir la tension demandée, et dont la puissance totale est supérieure à la somme de tous les voyants du pupitre. Je vous suggère pour cela d’utiliser une alimentation de PC ATX : ce sont des blocs d’alimentation fournissant des puissances de l’ordre de plusieurs centaines de Watts, avec plusieurs sorties aux tensions 3.3V, 5V et 12V.
Vous pouvez dans un premier temps tester votre voyant en le branchant directement à votre alimentation, éventuellement par l’intermédiaire d’un interrupteur. On prendra dans l’exemple ci-dessous un voyant à incandescence dont la tension nominale d’alimentation est de 12V.

Remarque : Dans le cas où votre voyant nécessite une tension inférieure à celle de votre alimentation, il est possible d’intercaler une résistance en série avec votre voyant. Attention cependant avec cette pratique : il est difficile de calculer la valeur de la résistance à ajouter, car la résistance de l’ampoule n’est pas constante (elle dépend de la température, qui augmente fortement lorsque l’ampoule est allumée). Par ailleurs, il est important de choisir une résistance capable de dissiper les puissance mises en jeu, au risque sinon de la voir chauffer excessivement voir se détériorer. N’ayant jamais expérimenté cette technique, je ne la détaillerai pas ici. J’utilise pour ma part des voyants 12V avec une alimentation de PC sous 12V.

Il est possible également d’utiliser une LED à la place de l’ampoule, celle-ci demandant beaucoup moins de puissance et des tensions plus faibles. Attention cependant, avec une LED il faut toujours intercaler une résistance en série compte tenue de sa tension nominale très faible. Je vous invite à consulter des sites externes sur la façon de procéder pour choisir votre résistance, compte tenu de la tension de fonctionnement indiquée dans les documents techniques de votre LED.

Par la suite nous ferons l’hypothèse d’utiliser un voyant à incandescence ayant une tension nominale de 12V.

Le problème qui se pose maintenant est le suivant : comment piloter notre voyant à l’aide d’une carte Arduino tout en continuant de l’alimenter en puissance avec une alimentation externe ?

Le transistor

La réponse à la question posée plus haut réside dans un composant que l’on pourrait qualifier de miraculeux : le transistor. Pour faire simple, il s’agit d’un interrupteur commandé électriquement, c’est à dire comme un relais, mais qui à la différence de ce dernier ne dispose pas de lame mobile. Il existe plusieurs technologies de transistor, tantôt commandés en courant (transistors bipolaires), tantôt commandés en tension (MOSFET, IGBT…).

Nous utiliserons ici un transistor MOSFET IRF540N : il s’agit d’un transistor commandé en tension, souvent présent dans les kit de démarrage Arduino car une tension de 2 à 4V suffit pour le commander.

Réalisation du montage

La résistance de 10k Oms (on peut prendre plus, comme 100k Oms par exemple) est une résistance de pull-down, déjà évoquée dans l’article sur les interrupteurs, permettant de bien bloquer le transistor lorsque l’on commande l’extinction du voyant. La résistance de 270 Oms permet de limiter le courant lorsque l’on passe d’un état haut à un état bas. Le montage fonctionne sans mais risque de détériorer l’Arduino à long terme. Je vous invite à consulter l’excellent site Locoduino.org et sa page sur l’utilisation des transistors MOSFET qui vous en apprendra plus (c’est d’ailleurs l’un des sites qui m’a été très utile pour la fabrication du premier simulateur).

Pour le câblage du transistor, on s’aide de la datasheet du composant qui indique le brochage :

Important : Il est nécessaire de relier ensemble le GND de l’Arduino et celui de l’alimentation de PC pour que le système fonctionne : cela permet d’avoir une référence commune des potentiels électriques. Oublier ce petit fil c’est risquer de s’arracher les cheveux pendant des heures pour trouver la panne (je parle évidemment de vécu !)

Comme je l’ai dit, le transistor MOSFET IRF540N est commandé en tension, avec un seuil compris entre 2 et 4V. Il suffit donc pour le débloquer (c’est à dire fermer l’interrupteur) de commander un état haut sur le pin Arduino correspondant :

digitalWrite(3, HIGH);

Vous l’aurez compris, pour bloquer le transistor (ouvrir le circuit), on commande un état bas :

digitalWrite(3, LOW);

Je vous propose ci-dessous un petit exemple pour faire simplement clignoter un voyant dès la mise sous tension du système (avec une fréquence de 0.5 Hz) :

void setup(){
       pinMode(3, OUTPUT);
}

void loop(){
       digitalWrite(3, HIGH);
       delay(1000);
       digitalWrite(3, LOW);
       delay(1000);
}

Vous noterez qu’on utilise ici des « delay » qui bloquent complètement le programme. L’exemple ci-dessous permet de s’en affranchir à l’aide de la fonction « millis », de la façon dont nous l’avons étudié dans l’article sur l’émulation de touches de claviers.

unsigned long timer_lampe = 0;
unsigned long duree_allumee = 1000;
unsigned long duree_eteinte = 1000;

void setup(){
       pinMode(3, OUTPUT);
}

void loop(){
       if( !digitalRead(3) and millis() > timer_lampe + duree_eteinte ){
        // si la lampe est éteinte et que la durée lampe éteinte est écoulée
              // on commande l'allumage de la lampe et on enregistre l'instant d'allumage
             digitalWrite(3, HIGH);
             timer_lampe = millis();
       }

       if( digitalRead(3) and millis() > timer_lampe + duree_allumee){
        // si la lampe est allumée et que la durée lampe alluméeest écoulée
              // on commande l'extinction de la lampe et on enregistre l'instant d'extinction
             digitalWrite(3, LOW);
             timer_lampe = millis();
       }
}

La gestion d’un voyant est une brique de base d’un pupitre de conduite de simulateur. N’hésitez pas à vous entrainer avec un montage très simple composé d’un unique voyant commandé par une carte Arduino, avant de commencer à en ajouter plusieurs. Vous pourrez également relier un voyant à la valeur d’une variable de simulation récupérée dans OpenRails et envoyée à votre carte Arduino, comme par exemple le voyant de patinage relié à la variable correspondante.