Agir sur le monde

Une lampe est une case que quelqu'un regarde

Le principe tient en une phrase. Le concepteur d'une carte décide qu'une certaine adresse ne correspond pas à de la mémoire ordinaire, mais à un circuit. Quand le processeur écrit à cette adresse, le circuit reçoit la valeur et fait ce pour quoi il a été fabriqué : fermer un relais, allumer une diode, envoyer un octet sur une liaison série. Pour le processeur, absolument rien ne change. Il exécute un sb, comme la veille sur une case de données.

Cette organisation porte un nom, l'entrée-sortie mappée en mémoire, et elle est très largement majoritaire aujourd'hui. Elle explique pourquoi un plan de mémoire n'est pas un espace uniforme : une zone est de la mémoire vive, une autre de la mémoire morte, une troisième est une fenêtre sur un contrôleur. La documentation d'un microcontrôleur consacre l'essentiel de ses pages à cette carte des adresses.

Dans ce cours, la ligne matériel: câble le périphérique.

La déclaration pose huit lampes à partir de 0x3000, chacune occupant un octet. Le programme est celui du chapitre précédent, au mot près : charger l'adresse, poser une valeur dans un registre, ranger cet octet. La seule nouveauté est visuelle, et elle est de taille : la figure montre une lampe s'allumer.

Éteindre, et faire clignoter

Si écrire une valeur non nulle allume, écrire zéro éteint. Le registre zero sert alors directement de source.

Quatre écritures à la même adresse, et le clignotement est là. Chaque sb remplace le contenu de la case, et la lampe suit. La figure signale d'ailleurs, à chaque écriture, la valeur qui se trouvait là avant : 0 puis 1 puis 0, en alternance.

Une remarque s'impose sur ce programme, parce qu'elle vaut pour tout pilotage réel. Le clignotement est ici instantané et invisible sur une carte véritable : quatre instructions s'exécutent en quelques nanosecondes, et aucun œil ne verrait la diode s'éteindre. Un vrai programme de clignotement passe l'essentiel de son temps à attendre, soit en comptant dans une boucle, soit en interrogeant une horloge matérielle, qui est elle aussi une case à une adresse connue. Le chapitre 6 donnera la boucle ; le principe de l'attente, lui, est déjà entier : lire une case jusqu'à ce qu'elle change.

Le décalage désigne la sortie

Les huit lampes occupent huit octets consécutifs. Leur atteindre ne demande rien de plus que le décalage déjà vu sur un tableau de données.

Une seule adresse a été chargée, et quatre sorties distinctes ont été commandées. Le décalage joue exactement le rôle qu'il jouait sur le tableau mesures du chapitre précédent : il désigne un élément à partir d'une base. Un contrôleur industriel qui commande seize vannes fonctionne ainsi, à ceci près que les vannes sont souvent regroupées dans les bits d'un même octet, ce qui est le sujet du chapitre suivant.

Le décalage n'est pas obligé d'être écrit dans l'instruction. Il peut venir d'un registre, et c'est là que le motif devient reconnaissable.

Ce programme mérite d'être lu deux fois, parce qu'il est la traduction d'une ligne que beaucoup ont déjà écrite. a0 contient un numéro de sortie, ici 5. Le programme ajoute ce numéro à l'adresse de base du périphérique, puis écrit 1 à l'adresse obtenue.

Le même raisonnement vaut au-delà de l'Arduino. Un pilote de périphérique, sous n'importe quel système, est un morceau de code qui connaît des adresses et écrit dedans. Le mot « pilote » évoque une machinerie complexe ; l'essentiel de son travail tient dans des sw et des lw à des adresses documentées, plus la discipline nécessaire pour les faire dans le bon ordre.

Un afficheur occupe un mot

Toutes les sorties ne tiennent pas dans un octet. Un afficheur numérique reçoit un nombre entier, et se commande donc par un mot de quatre octets.

La dernière observation est celle qui compte. addi t1, t1, 1 incrémente un registre, et l'afficheur ne bouge pas. Il ne bouge qu'au sw suivant. Le compteur vit dans t1, l'affichage vit dans la case 0x3010, et les deux ne sont reliés que par les instructions qui recopient l'un vers l'autre. C'est la distinction entre un état interne et une sortie, et c'est elle qui explique pourquoi une interface reste figée pendant qu'un calcul avance.

Rien n'empêche de commander plusieurs périphériques dans le même programme : ce ne sont que des adresses différentes.

Deux registres tiennent les deux adresses de base, et le reste du programme n'est qu'une suite d'écritures. Un système embarqué sérieux fait exactement cela, avec quelques dizaines de périphériques et des adresses moins rondes.

Écrire à la bonne largeur

La largeur de l'écriture n'est pas un détail de style. Elle décide du nombre d'octets touchés, donc du nombre de sorties affectées.

Les quatre premières lampes sont allumées une par une. La dernière instruction, sw t1, 0(t0), range la valeur 1 sur quatre octets : l'octet de poids faible vaut 1, les trois autres valent 0. Trois lampes s'éteignent donc, sans qu'aucune instruction n'ait prétendu les éteindre.

L'autre versant de la même discipline concerne l'alignement, déjà rencontré sur les données.

Un addi de trop sur l'adresse de base, et l'accès est refusé. Sur une carte réelle, l'issue est parfois pire qu'un refus : selon le composant, une écriture décalée atteint un registre voisin qui n'attendait rien de tel.

Le monde répond aussi

Écrire commande, lire renseigne. Un contrôleur dispose presque toujours d'un registre d'état, à une adresse documentée, dans lequel il dépose ce qu'il a à dire : la donnée est prête, le tampon est plein, un défaut est survenu. Chaque information tient dans un bit, parce qu'un bit suffit à dire oui ou non et qu'un contrôleur n'a pas de place à gaspiller.

La ligne données: etat @ 0x3100 tient lieu ici de ce qu'un contrôleur aurait déposé à cette adresse. Le point n'est pas de tricher : de la mémoire ordinaire et un registre matériel se lisent avec la même instruction, et c'est précisément ce que ce chapitre affirme depuis le début.

Le programme lit l'octet d'état, qui vaut 13. Reste à en extraire un seul bit, celui de rang 2. srli t2, t1, 2 décale le contenu de deux positions vers la droite, ce qui amène le bit voulu en dernière position : 13 devient 3. andi t3, t2, 1 ne garde que cette dernière position, et donne 1.

Ces deux instructions sont la matière du chapitre suivant, et elles sont données ici sans démonstration, parce qu'aucun dialogue avec du matériel ne se passe d'elles. Un pilote lit un octet d'état, isole un bit, et décide. La décision elle-même viendra au chapitre 5 ; l'isolement du bit vient tout de suite après.

La méthode

1. Chercher l'adresse dans la documentation du composant avant d'écrire la moindre instruction : une carte des adresses et une largeur d'accès sont les deux seules informations indispensables.
2. Charger l'adresse de base une fois, dans un registre réservé au périphérique, et désigner les sorties voisines par un décalage plutôt que par un nouveau calcul.
3. Choisir la largeur d'après le composant : sb pour une sortie d'un octet, sw pour un registre ou un afficheur d'un mot, et vérifier qu'aucun voisin ne se trouve dans les octets emportés.
4. Contrôler l'alignement de toute adresse obtenue par un calcul, avant l'accès plutôt qu'après la panne.
5. Séparer l'état interne de la sortie : garder le compteur, la consigne ou la mesure dans un registre, et ne recopier vers le périphérique qu'au moment voulu.
6. Lire le registre d'état avant de conclure qu'un périphérique ne répond pas, et isoler le bit qui renseigne plutôt que de comparer l'octet entier.
7. Se rappeler qu'une lecture peut avoir un effet sur un composant réel, et ne pas relire un registre d'état par confort.

Synthèse

• Une entrée-sortie mappée en mémoire est une adresse surveillée par un circuit. Écrire dedans agit sur le monde, et cela se fait avec les instructions déjà connues, sb et sw, sans aucun ajout au jeu d'instructions.
• Une lampe s'allume sur une valeur non nulle et s'éteint sur zéro : le registre zero sert directement de source à l'extinction, et l'état visible n'est rien d'autre que le contenu de la case.
• Le décalage désigne la sortie. Une seule adresse de base chargée avec la suffit à commander huit lampes, et un décalage venu d'un registre transforme un numéro de sortie en adresse.
• digitalWrite() n'est pas une primitive du monde : c'est une fonction qui traduit un numéro de broche en adresse, puis écrit. Tout pilote de périphérique est fait de cette matière.
• Un afficheur occupe un mot et se commande par sw, tandis qu'une lampe occupe un octet et se commande par sb. Une écriture trop large éteint les voisins en silence, et une adresse mal alignée fait échouer l'accès.
• Un registre d'état se lit, et chacun de ses bits porte une information indépendante. L'extraire demande un décalage et un masque, ce que srli et andi font en deux instructions.
• Un registre du processeur et une sortie physique sont deux choses distinctes : incrémenter le premier ne change rien au second tant qu'aucune écriture ne les relie.

Ces deux instructions employées à la fin, srli et andi, ont été admises sans justification. Masquer et filtrer les reprend depuis le début, avec tout ce qui permet d'isoler un champ, de forcer un drapeau et de basculer un bit sans toucher aux autres.