La grande centrale

1. Ça se complique un peu

La petite centrale ne permet de piloter qu’une seule locomotive à la fois. Ce n’est pas la finalité du protocole DCC, qui dispose d’une capacité d’adressage de 9 998 locomotives. Après avoir construit un panneau de contrôle permettant la commande simultanée de nombreuses locomotives, il est tout à fait légitime de vouloir en tirer pleinement parti.

Un Arduino Uno ne suffira pas pour une telle tâche. Il n’y a pas assez de mémoire, que ce soit de la RAM pour les données ou de la mémoire flash pour le programme. En outre, on est limité au niveau des entrées-sorties.

L’utilisation d’un Arduino Mega2560 s’impose donc comme une évidence. Son prix n’étant guère plus élevé que celui d’un Uno, il serait dommage de s’en priver. Le fait de faire passer la RAM de 2 ko à 8 ko est vraiment un indéniable confort, et cela justifie pleinement ce choix. De surcroît, la taille de l’EEPROM augmente aussi de façon conséquente, passant de 1 ko à 4 ko, ce qui est bien pratique, car les paramètres des locomotives sont stockés dans cette mémoire.

Sur le schéma qui suit, les circuits sont tous reliés à l’Arduino au moyen de labels, ce qui permet d’éviter de dessiner des fils dans tous les sens et permet de présenter le schéma sur trois pages différentes. Sur ce premier schéma, outre l’Arduino proprement dit, on trouve également l’alimentation, l’écran...

1. Les boutons

La centrale DCC est dotée de boutons de contrôle disposés tout autour de l’écran à la façon d’une console de jeu.

Ce qui lui donnera à peu près l’aspect suivant :

Ces boutons permettent de naviguer dans l’interface utilisateur, ils sont directement reliés aux entrées D42 à D53 d’un côté, et à la masse de l’autre. Il suffit donc de configurer les entrées en INPUT_PULLUP, ce qui ajoute une résistance de tirage (pull-up) au +5 V sur chaque entrée. Si un bouton n’est pas activé, l’entrée n’est pas reliée et la valeur lue est donc 1. Lorsque l’on appuie sur un bouton, l’entrée est mise à la masse et on lit alors zéro.

La lecture des touches autour de l’écran est assez simple puisqu’elles ne sont pas matricées. Il suffit donc de définir l’affectation de chaque touche pour pouvoir y accéder.

#define SW_H 42  
#define SW_B 43  
#define SW_G 44  
#define SW_D 45  
#define SW_P1 46  
#define SW_P2 47  
#define SW_P3 48  
#define SW_P4 49  
#define SW_ESC 50  
#define SW_DEL 51  
#define SW_NO 52  
#define SW_OK 53 

2. Le pavé numérique

Quant au connecteur J7, il permet la connexion d’un pavé numérique optionnel. Celui-ci est relié aux entrées D32 à D39. Il n’est pas obligatoire, mais permet de gagner du temps lorsqu’il s’agit de saisir une valeur numérique.

Les rangées sont reliées sur D32 à D35, qui sont configurées en sorties, les colonnes étant reliées sur D36 à D39, qui, quant à elles, sont configurées en entrées de type INPUT_PULLUP.

Le câblage est vraiment très simple, l’essentiel étant déjà effectué à l’intérieur du clavier. Les huit connexions disponibles à l’extérieur correspondent aux quatre lignes et aux quatre colonnes....

1. L’écran

Il est possible de connecter diverses technologies d’écran sur un Arduino : affichage monochrome ou couleur, en mode texte ou graphique, de dimensions très variées. Cependant, si l’on veut rester raisonnable, on évitera de choisir un écran qui consommerait trop de puissance ou trop de mémoire, la centrale deviendrait pénible à utiliser. Afin de rester raisonnable tout en rendant l’interface attractive, un écran monochrome de 128 par 64 pixels avec rétro-éclairage a été choisi pour la réalisation de la centrale.

Il existe trois principales normes de communication avec un tel type d’écran : parallèle, I²C et SPI. Dans le cas des écrans LCD de 128 par 64 pixels, ce sont les circuits communiquant en mode parallèle qui sont les plus répandus, c’est donc un tel modèle qui a été retenu pour la conception de la centrale. On en trouve sur Internet en recherchant « LCD12864 PARALLEL ».

Voici l’écran qui a servi de modèle pour le dessin du circuit imprimé. La zone d’affichage fait environ 68 par 36 mm, soit 77 mm de diagonale (ce qui correspond à 3 pouces).

L’interface parallèle se base sur des signaux compatibles avec le circuit HD44780 de chez Hitachi, ce qui permet aux différents fabricants d’afficheurs LCD de proposer des circuits qui disposent du même brochage. Les signaux permettant le contrôle du circuit sont les suivants :

En pratique, on peut directement relier le signal R/W à la masse, la librairie graphique ne fait qu’écrire dans le circuit. Les 10 signaux nécessaires sont reliés aux sorties D22 à D31 de l’Arduino Mega.

Les sorties D12 et D13 sont également utilisées pour régler le contraste et la luminosité de l’afficheur. Elles sont utilisées en mode PWM, ce qui permet d’envoyer des signaux analogiques à l’afficheur....

1. Le circuit imprimé

Il est assez imposant, mais il contient peu de composants, l’écran et les touches du clavier nécessitent un certain espace qui ne peut pas être réduit et tout l’arrière est occupé par des connecteurs.

Téléchargement depuis la page Informations générales : at-dcc.

Il est nécessaire de préciser quelques points importants qui doivent être pris en compte lors de la réalisation de ce circuit.

L’Arduino Méga est sérigraphié sur la face supérieure du circuit imprimé mais en réalité ses connecteurs doivent être implantés sur la face inférieure, donc du côté où l’Arduino Méga n’est pas représenté. Cette implantation curieuse est due au fait qu’elle est issue d’une des librairies de KiCad et qu’il s’agit d’une implantation destinée à un shield Arduino.

Il faut aussi choisir avec précaution les boutons-poussoirs, en particulier au niveau de la longueur de la tige qui sert à les actionner. Pour être utilisables, les boutons doivent dépasser de la face avant, par contre l’écran doit être placé derrière la face avant. Donc, les boutons, munis de leurs capuchons, doivent être au moins 5 mm plus hauts que l’écran. On peut y parvenir en soudant l’écran directement sur le circuit imprimé, mais c’est toujours un peu risqué en cas de problème. Sinon, il faut envisager de prolonger les tiges des boutons. Faute de trouver des « prolongateurs » de boutons, on peut y parvenir en utilisant des entretoises plastiques M3 collées sur les boutons.

La liste des composants peut varier quelque peu en fonction des options choisies.

1. Le stockage et les priorités

La petite centrale ne permettant de ne piloter qu’une seule locomotive à la fois, un petit tableau suffit largement pour stocker tous les paquets émis. Pour gérer plusieurs locomotives, une liste un peu plus sophistiquée doit être mise en œuvre.

Cette liste doit permettre le stockage de trois types de paquets différents : la consigne de vitesse, l’état des fonctions et la programmation des variables de configuration. Les données y sont stockées, prêtes à être envoyées, la somme de contrôle est déjà calculée. L’interruption n’a plus qu’à lire le contenu des paquets et à les envoyer vers la sortie. Mais ce n’est pas si facile. Pour envoyer les données dans le bon ordre et savoir ce qu’il faut en faire, toute une logique de séquencement doit être mise en place. Les différents types de paquets n’ont pas tous les mêmes priorités, ni la même durabilité. Par exemple, les données de pilotage des locomotives doivent être régulièrement émises sur le réseau, sinon les locomotives finissent par s’arrêter ; c’est une sécurité.

En pratique, si l’on ne fait pas tourner trop de trains, on peut envoyer la liste des paquets telle quelle. Mais si l’on augmente le nombre de locomotives, cela se corse rapidement. On peut calculer le taux de répétition du cas le plus défavorable.

Le préambule consomme déjà 20 bits. Une adresse longue prend 2 octets. Un contrôle de vitesse à 128 crans, encore 2 octets. Avec la somme de contrôle, ce sont déjà 5 octets, soit 46 bits en comptant les START et le STOP. La commande de vitesse prend donc 66 bits au total.

Les commandes de fonction se contentent de 1 octet, mais il faut y ajouter l’adressage long et la somme de contrôle, soit 4 octets en tout, donc 37 bits. En y ajoutant le préambule, on atteint 57 bits. Si l’on veut tirer parti des 12 fonctions de base, ce sont trois paquets qu’il faut émettre, soit 171 bits.

Au total, le contrôle d’une seule locomotive avec 12 fonctions consomme 66 + 171 = 237 bits. Le débit...