Le panneau de contrôle

1. Un loisir à partager

Si l’on équipe les trains de décodeurs numériques, c’est non seulement pour avoir un meilleur contrôle de la vitesse ou un éclairage réversible, mais c’est surtout pour faire circuler plusieurs trains à la fois. Même s’il est toujours possible de contrôler tous les trains avec une seule commande, cela devient rapidement compliqué. Le plus simple, et aussi le plus ludique, consiste à disposer d’une commande pour chaque convoi. C’est plus convivial, puisque l’on peut s’y mettre à plusieurs et commander tous les trains simultanément.

Les centrales DCC du commerce sont généralement fournies avec un ou deux contrôleurs. Pour piloter plus de locomotives, et donc augmenter le côté ludique du système, il faut soit jongler entre les adresses des décodeurs, ce qui est assez fastidieux, soit acheter des commandes supplémentaires, qui sont assez onéreuses. Pourtant, un contrôleur ne contient qu’un potentiomètre, quelques boutons et un minimum de câblage électronique. Un amateur éclairé peut donc parfaitement y parvenir.

Le contrôleur permet donc de commander les locomotives, qu’il s’agisse de régler la vitesse, de choisir le sens de marche du convoi, voire de piloter directement les fonctions du décodeur. Il y a deux façons d’envisager un tel système de pilotage :

La grande centrale DCC, celle qui sera créée par la suite, étant conçue pour accepter indifféremment l’un ou l’autre système...

1. Le principe

Dans le code de la centrale, une structure est prévue pour définir d’état d’un contrôleur. En créant un tableau à partir de cette structure, on dispose de l’état de chaque contrôleur, qu’il soit géré par le panneau de contrôle présenté dans ce chapitre ou par un des contrôleurs indépendants présentés dans le prochain chapitre. On y trouve l’identifiant de la locomotive, ce qui permet de retrouver ses caractéristiques dans la liste des locomotives, mais aussi la consigne de vitesse, le sens de marche et l’état des touches de fonction.

typedef struct _command_  
{  
 byte loco;  
 char F0;  
 word speed;  
 word F1;  
 word F2;  
} CONTROL ;  
 
CONTROL ControlList[CONTROL_LIST_SIZE]; 

Avant d’effectuer la moindre lecture, il est nécessaire de configurer les entrées. La fonction controlInit est appelée depuis setup. Elle se charge de paramétrer correctement les signaux de commande des contrôleurs, puis on initialise le contenu de la liste des contrôleurs.

void controlInit(void)  
{  
 pinMode(CTRL_MUXEN,OUTPUT);  
 digitalWrite(CTRL_MUXEN,LOW);  
 pinMode(CTRL_MUXA0,OUTPUT);  
 pinMode(CTRL_MUXA1,OUTPUT);  
 pinMode(CTRL_MUXA2,OUTPUT);  
 pinMode(CTRL_MUXA3,OUTPUT);  
for(int i=0; i<sizeof(ControlList)/sizeof(CONTROL); i++)  
 {  
   ControlList[i].loco=0xFF;  
   ControlList[i].F0=MODE_STOP;  
 }  
} 

2. Le décodage

Lire la vitesse est une chose aisée. Il suffit d’utiliser la fonction analogRead.

      word speed=analogRead(CTRL_SPEED); 

La lecture du sens de marche nécessite un peu plus de travail, car il va falloir convertir la valeur analogique lue avant de la stocker sous une forme utilisable pour le pilotage des locomotives. Faire sept décalages à droite revient à faire la division par 128 qui a été effectuée dans la section Les signaux analogiques.

      char F0=((analogRead(CTRL_F0)>>7 ; 

On obtient donc...

1. De multiples possibilités

Avant de clore ce chapitre, voici la présentation d’un circuit qui va être utilisé à plusieurs reprises dans la suite de cet ouvrage. Ce circuit particulièrement versatile intègre un support pour un Arduino Nano ainsi que de nombreux connecteurs permettant une grande variété d’utilisations.

Il ne sera pas possible de disposer de toutes ces fonctionnalités en même temps, donc les connecteurs ne seront jamais toujours soudés à la fois. Dans ces conditions, quel est donc l’intérêt de faire un seul circuit alors que l’on pourrait en faire plusieurs, chacun dédié à une tâche ? La réponse est simple : la plupart des producteurs de circuits imprimés ne permettent pas de faire réaliser moins de cinq exemplaires, alors quitte à avoir trop de circuits, autant les utiliser plusieurs fois.

Le schéma présenté ici est donc assez simple : un Arduino et plein de connecteurs, rien de plus. On peut constater que de nombreuses entrées-sorties sont utilisées deux fois, mais ce n’est pas un problème puisque les connecteurs ne sont pas censés être utilisés simultanément.

J1 est un bus I²C. Il est relié à A4 et A5, qui sont le bus I²C physique de l’Arduino Nano. À l’inverse, les connecteurs J5 et J6 sont aussi des bus I²C, mais des bus logiciels. Ils ne sont utilisables qu’au moyen d’une librairie additionnelle. Un bus I²C Logiciel est, comme son nom l’indique, entièrement géré par le programme, il est donc inévitablement...