Un premier programme

1. Une librairie

Les données DCC sont envoyées sur les voies en modulant des signaux électriques toutes les 58 µs. Un bit à 1 correspondant à un signal positif de 58 µs, suivi d’un signal négatif de la même durée. Un bit à 0 est un signal positif de 116 µs, donc deux signaux de 58 µs, suivi d’un signal négatif de la même durée. Tout est donc multiple de 58 µs. Il suffit d’une interruption calée sur cette durée pour que le signal DCC soit généré avec toute la précision nécessaire.

Dans le monde de l’Arduino, programmer des interruptions n’a rien de compliqué. Il existe plusieurs librairies pour les gérer. La librairie msTimer, proposée par défaut, utilise une base de temps de 1 ms, ce n’est pas assez précis pour générer un signal DCC. C’est donc la librairie FlexiTimer2, qui est mise à contribution, car elle offre une résolution de 1 µs.

Cette bibliothèque n’est pas disponible dans le gestionnaire de l’Arduino. Il faut donc télécharger séparément le fichier, puis utiliser l’option Inclure une bibiothèque ZIP. Le fichier est disponible à l’adresse suivante : https://playground.arduino.cc/Main/FlexiTimer2/...

1. La théorie

Entre le bouton que l’on tourne pour régler la vitesse du train et le signal envoyé sur les voies, plusieurs transformations sont nécessaires. Cela commence par le formatage des données. Elles sont d’abord lues, il peut s’agir d’une entrée analogique sur laquelle est branché un potentiomètre, un clavier ou des interrupteurs. Ces données sont formatées, puis converties sous la forme d’un paquet DCC, constitué d’un nombre variable d’octets :

Ce paquet DCC peut donc faire entre 3 et 6 octets selon les cas. Les paquets ne sont créés et stockés qu’en cas de changement de vitesse ou de changement des touches de fonction, il est inutile de le refaire systématiquement si rien n’a changé.

Ce paquet est ensuite stocké en mémoire, car les données DCC doivent être réémises régulièrement, même si elles ne changent pas, sinon les locomotives finissent par s’arrêter d’elles-mêmes. C’est une question de sécurité. Ce stockage prend l’aspect d’un tableau qui liste tous les paquets à émettre. Lorsqu’un paquet doit être stocké, il faut d’abord vérifier s’il doit remplacer un paquet existant ou s’il s’agit d’un nouveau paquet.

Pour finir, l’envoi est effectué par une routine sous interruption appelée toutes les 56 µs. Il faut deux appels pour envoyer un bit à 1 et quatre appels pour envoyer un bit à 0. Outre les données constituant le paquet proprement dit, il faut aussi envoyer le préambule et ajouter les bits de séparation et de STOP.

2. La création des bits

À chaque appel de l’interruption, toutes les 58 µs, il n’y a qu’un signal émis. Celui-ci correspond, selon les cas, à un demi-bit (dans le cas d’un bit à 1), ou à un quart de bit (dans le cas d’un bit à 0). Il est donc nécessaire de mémoriser l’état courant pour savoir vers quel état il faudra évoluer lors de l’appel...

1. L’interface utilisateur

La mémoire disponible dans un Arduino Uno étant assez limitée, il est nécessaire de créer une interface utilisateur la plus légère possible. Heureusement, il y a peu d’interactions à gérer. Essentiellement, la navigation dans les menus et la saisie de valeurs texte ou numériques. La programmation de l’interface utilisateur a déjà été succinctement détaillée dans le chapitre Les autres circuits, elle ne sera pas expliquée plus en détail, car ce n’est pas le but de cet ouvrage.

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

Il faut gérer les points suivants :

La consigne de vitesse est obtenue à partir de la lecture d’une entrée analogique sur laquelle on a branché un potentiomètre.

Ce programme étant prévu pour ne piloter qu’une seule locomotive,  on peut se contenter d’une interface utilisateur très épurée, qui est basée sur seulement deux écrans.

Tout d’abord l’écran d’accueil, qui permet de choisir les paramètres de pilotage de la locomotive. On change de paramètre en utilisant les touches gauche et droite, le curseur clignotant indiquant le paramètre sélectionné. On peut ensuite faire varier le paramètre choisi en utilisant les touches haut et bas.

Quand les paramètres sont choisis, on peut passer à l’écran suivant en appuyant sur le bouton OK. Il s’agit de l’écran de pilotage. Si on appuie sur [Echap], on retourne au menu principal.

Le choix de la vitesse se fait avec le potentiomètre. Les touches gauche et droite permettent de changer le sens de marche. Si l’on est en marche avant, appuyer une fois sur la touche gauche arrête le train, appuyer une deuxième fois sur la touche gauche le fait passer en marche arrière. Si l’on...

1. Le problème

La mémoire libre part assez vite, et ce pour une raison assez surprenante : même si le programme et les données sont stockés dans la mémoire flash, ces dernières doivent être recopiées en RAM au démarrage, ce qui consomme inutilement de la mémoire dans le cas de constantes (par exemple, les chaînes de caractères affichées à l’écran).

Cette problématique est due à l’architecture mémoire des microprocesseurs Atmel qui équipent les circuits Arduino, qui est de type Harvard. Dans ce cas, les zones mémoire de programme et de données sont séparées. La zone de programme pointe vers la mémoire flash, tandis que la zone de données pointe vers la RAM.

2. L’usage de la mémoire

C’est un point qui est couramment omis, car il y a souvent assez de mémoire pour que tout se passe bien. Mais il faut en parler, car cela explique certains plantages qui surviennent avec des croquis un peu chargés.

Il est important d’optimiser l’usage de la mémoire RAM, et ce d’autant plus qu’elle stocke énormément de données, et de façon assez variée. En pratique, cela se répartit entre trois blocs distincts, mais néanmoins adjacents, chacun étant dédié à certains types de variables :

Entre ces deux derniers blocs de mémoire, il y a la zone de mémoire libre, qui évolue lors de l’exécution du programme.

La zone statique ne bouge pas ; son contenu peut varier, mais sa taille ne change pas. Par contre, pile et tas varient, et cela peut poser problème.

Quand on fait appel à une sous-fonction, on consomme de la pile. S’il y a de nombreux paramètres et beaucoup de variables locales, on consomme encore plus de pile. Si une sous-fonction en appelle une autre, qui en appelle encore d’autres, on en consomme davantage encore. La taille de la pile peut...