Maquette: La table de commande

Quand j’ai commencé le modélisme que vous avez pu voir sur le projet « train des alpes », je ne pensais pas nécessairement créer de table de commande.
C’est une idée qui m’est venue par la suite. Voici les étapes de création de cette table.

L’idée de base

Comme pour beaucoup de chose, tout commence par une idée un peu floue, et un petit dessin sur un bout de papier. Il fallait créer un support sur lequel on pourrait faire accélérer et ralentir le train, et choisir son sens de circulation. La maquette dispose aussi de 3 petites zones de rails qui sont isolées. Il faut donc trouver un moyen de les alimenter selon les besoins.
Enfin, j’ai ajouté des lampadaires, des lumières dans les maisons, et des lumières sur les véhicules. Il serait intéressant de pouvoir commander tout cela depuis la table de commande.

Méthode utilisée

La solution la plus simple consisterait à utiliser des interrupteurs. Le câblage serait facilité, mais en contrepartie, chaque interrupteur ne pourrait avoir qu’une seule utilité.
Impossible donc d’affecter un interrupteur à l’allumage des maisons, puis ensuite à celui de l’éclairage public car cela nécessiterait de modifier le câblage, ce serait rapidement ingérable.

La seconde solution est de tout relier à un micro ordinateur, et tout commander depuis cet appareil.

Ainsi, selon les besoins, l’ordinateur pourrait ré-affecter des bouton pour leur donner de nouvelles fonctions, ou bien encore permettre de programmer des « scénarios », des scènes, des ambiances sur la maquette.
Bien que cette seconde solution nécessite un travail de câblage et de programmation très important au départ, il offrira, en plus d’un gain de temps, une flexibilité à l’utilisation non négligeable par la suite.

C’est donc cette solution qui a été retenue.

Les besoins matériels

La maquette sera donc commandée par un Arduino. En raison des nombreuses connectiques, le modèle MEGA est retenu.
L’utilisation d’un Arduino permet aussi d’avoir en temps réel un retour visuel sur les ordres donnés, et l’état des différents systèmes. J’ai donc ajouté un écran à deux lignes et de nombreuses leds, indicatrices d’état sur la table.

Les interrupteurs ne permettent que deux états : allumé, ou éteint. J’ai donc opté pour des boutons poussoirs. Certes, ils n’ont que deux états également, mais on peut leur assigner un comportement différent selon le nombre de pressions que l’on fait dessus.

L’arduino est alimenté par du 5V. Or, les locomotives sur la maquette acceptent une tension de 0 à 14V pour se déplacer.
J’avais dans mes vieilleries un transformateur qui délivrait deux tensions de sortie : 5V et 12V, avec une masse commune. Ceci est parfait pour mes besoins.
Toutes les masses devront en effet être communes afin que le montage fonctionne.

La réalisation de la table
Pour créer la table, tout commence par un dessin. Le modèle est reconstitué en 3D sur ordinateur, puis imprimé avec une imprimante 3D.
L’imprimante que j’ai a la maison est limitée dans la taille des objets qu’elle peut créer. Elle ne peut en effet pas créer plus grand que des objets de dimensions 200x200x200 mm.

Vue de face

Aussi, la table est constituée de 4 parties :

• La partie gauche de la table
• La partie droite
• La section qui contient les éléments de commande (Arduino, relais, puce)
• Des support pour la table et pour les composants internes.

Vue avec le système de commande

Ces éléments sont ensuite assemblés. Il ne reste qu’à disposer les composants, et les connecter.
Au total, ce sont près de 72 heures d’impression qui sont nécessaires pour modéliser la table. Ce n’est qu’un début, le temps d’assemblage et de câblage sera quasiment aussi long, et on pourra ajouter aisément 5 jours de programmation

La problématique des leds

L’arduino commandera les leds et les relais selon les ordres qui lui seront donnés. Même si leur consommation est moindre, les leds de la table de commande ne peuvent être directement reliées à l’Arduino, au risque d’atteindre le seuil haut du courant acceptable dans ses circuits.
J’ai donc opté pour des transistors.
En fonction du signal qui leur est envoyé, ils laissent ou non passer l’électricité.

Ainsi, ce n’est pas l’Arduino qui alimente électriquement les leds, il se contente de dire aux transistors de laisser passer le courant, ou non.
Cela implique un transistor pour chaque leds. Il y en a 36 sur la table… Les leds fonctionnent sous une tension de 3V. Je leur ai donc ajouté une résistance à chacune pour ne pas les faire griller.

A la place des transistors, j’aurais pu utiliser une puce électronique. Le modèle SN74HC959N de chez Texas Instruments permet de commander jusqu’à 8 leds avec un nombre très réduit de connexions à l’Arduino. Ce sera une évolution pour une prochaine maquette 🙂
Pour l’heure, j’ai donc un cable par led, et un cable par bouton poussoir qui se retrouve relié à l’Arduino. Ce n’est pas tout : l’Arduino donne les ordres pour mettre en marche les trains, les diverses lumières de la maquette.

Au total, ce sont 66 câbles qui sont connectés à l’Arduino.

Les boutons poussoirs sont équipés de leds internes qui définira s’ils sont programmés ou non. A coté de chacun d’entre eux, une autre leds indiquera si la fonction qu’ils commandent est activée ou pas.
La vitesse de déplacement des trains sera indiquée à l’écran par un pourcentage, mais aussi grâce à 17 leds bleues, vertes et rouges, qui s’allumeront en fonction de la vitesse.

La table disposera également de deux systèmes de mesure de courant et de tension. Le premier indiquera la tension de 5V et le courant lié à cette tension.
Le second indiquera la tension de 12V et le courant lié à cette tension.

Ainsi, j’aurais un retour immédiat sur les énergies consommées par la maquette, et pourrait déceler tout pic anormal de courant dans la maquette (qui pourrait suggérer un court circuit).

Il serait dommage de créer quelque chose d’aussi évolutif sans en profiter au mieux. Aussi, je vais créer un mode manuel, où tous les boutons seront actifs et contrôlables, mais aussi un mode autonome, qui permettra à l’arduino de gérer lui même tous les effets et les trains de la maquette, sans intervention humaine.
J’ai donc ajouté un sélecteur de mode à 3 positions : mode neutre (aucune action de la part de l’Arduino), mode manuel et mode autonome.

Les relais

Les divers éléments de la maquette, comme l’éclairage public, les lumières des bâtiments, et des voitures, sont commandés par des relais.
Ces 3 systèmes utilisent du 12V, et sont donc alimentés par l’arrivée 12V de mon transformateur. Dans l’absolu, j’aurais pu user de transistors, comme pour les leds, ça aurait tout aussi bien fonctionné.
Toutefois, j’ai préféré laisser les transistors pour les éléments de la table de commande, et les relais pour les éléments de la maquette.
Sachez toutefois que les deux solutions auraient été viables.

Les relais commandent également l’alimentation de certaines sections de rails. Il y a au total 3 sections isolées, qui constituent une voie de garage, et deux voies auxiliaires de circulation.
Depuis la table, il est donc possible de relier ces sections électriquement au réseau ferroviaire principal, ou de les isoler.

Le principe de fonctionnement du relai est simple : il reçoit un signal qui lui permet de fermer un contact. Le contact et le signal sont isolés électriquement. Ainsi, un signal de 5V envoyé au relai lui permettra de fermer un contact dans lequel circule 220V, sans risque.
La table dispose de 8 relais, 6 sont, à ce jour, utilisés. Il n’est pas impossible que les relais restants soient utilisés ultérieurement.

La puce de contrôle des trains

La table commande une puce électronique qui permet de gérer la vitesse de déplacement des trains, ainsi que leur sens de circulation. C’est le modèle L293DNE.
Elle reçoit en réalité une tension continue de 12V. En fonction des ordres qui lui sont envoyés par l’Arduino, la puce va moduler une tension de sortie, comprise entre 0 et 12V, et le sens de circulation du courant. Parfait donc pour commander une locomotive.
Il faut savoir que la locomotive est sensée recevoir une tension entre 0 et 14V. Cependant, à pleine tension (14V, donc), la locomotive va si vite que le risque de déraillement est très élevé.
Il n’y a donc aucun inconvénient à ce que le seuil de la tension soit descendu à 12V. D’autant qu’avec cette méthode, la puce chauffera moins. Elle est sensée supporter une tension jusqu’à 30V, mais vu à quel point elle chauffe déjà sur mon montage, cette tension de seuil me paraît très (trop) élevée…

Le code

L’arduino va switch entre les programme, selon l’état du sélecteur de mode.
A ce jour, je me suis contenté de créer le programme pour le mode manuel. Le mode automatique nécessitera des composants qu’il me faut encore acheter, et la programmation sera plus complexe.

Sachez avant tout que je ne suis pas un expert en programmation, et que mon code est tout à fait perfectible. Je l’améliore au fur et à mesure, car il est déjà assez conséquent, et je compte l’optimiser avec le temps.
Après avoir déclaré la totalité des boutons poussoirs, des leds, des éléments contrôlés, il faut définir si l’information est entrante ou sortante (INPUT ou OUTPUT). En somme : est ce que l’information est reçue par l’arduino (exemple : un bouton poussoir qui est appuyé ou non), ou bien est ce que l’information est envoyée par l’arduino (exemple : donner l’ordre d’allumer une led)

Tout le but du code est d’établir le lien entre ces informations que l’Arduino reçoit, et ce qu’il en fait.
Etant donné que l’Arduino fonctionne avec un boucle qu’il répète indéfiniment, en mode manuel, il doit être en mesure de se trouver « en attente » d’un ordre, et agir selon qu’on appuie sur un bouton ou non.
L’avantage du code de l’Arduino est qu’il est très proche du langage C, lui même assez intuitif.

Par exemple,

« Si le bouton poussoir BP1 est pressé, allumer la led LED1 »

Se traduit par :

If (BP1==0) {<br />
digitalWrite(LED1,HIGH);<br />
}

Optimiser le code permettra de consommer moins de mémoire, et améliorera les boucles du programme afin d’utiliser au mieux les ressources et le calcul de l’Arduino.
Pour ce faire, on peut déjà commencer par revoir les variables. Il y en a de très nombreuses que j’ai déclaré sous la forme « INT ». Une variable déclarée en « int » consomme 2 octets.
Or les variables n’ont pas nécessairement besoin d’autant d’espace mémoire, et on peut réduire cet espace alloué en utilisant un autre type de variable (boolean, char, …) afin de mieux coller au besoin.

On libère ainsi de la mémoire, qui pourra être utilisée pour d’autres variables, temporaires ou non.

L’utilisation des boucles peut également être optimisée. Utiliser plusieurs fonctions externes à la boucle principale n’affectera pas la disponibilité de calcul du processeur, ni l’allocation mémoire, donc on peut externaliser des fonctions sans soucis.

Certains ordres peuvent être également extraits des boucles, car ils ne nécessitent pas d’être exécutés plusieurs fois. C’est autant de ressources qui seront libérées, et qui pourront être mises à profit pour d’autres fonctions, sans que l’Arduino ne souffre de ralentissements ni de problèmes de calcul (je vous rappelle que l’Arduino ne peut pas exécuter plusieurs fonctions simultanément, il les exécute les unes après les autres).

Si vous souhaitez vous lancer dans la programmation pour votre maquette, le code source est disponible au téléchargement à la fin de cet article.

Voici une vidéo où je vous présente le fonctionnement de l’ensemble.