Registres

Une des choses les moins évidentes à comprendre dans le fonctionnement d'un microcontrôleur est typiquement un registre. Il est impossible d'utiliser les micro-contrôleurs sans savoir ce qu'ils sont. Ce livre n'est nullement différent, on cherche alors à ce que le lecteur familiarise lui/elle même avec le concept du registre et donc le texte suivant essayera de l'expliquer en termes assez simples, pour que même un débutant puisse saisir l'idée d'un registre.

Les boutons d'un lecteur de cassettes

Un registre ressemble à un panneau de boutons de n'importe quel appareil domestique. On trouve des interrupteurs, qui peuvent être allumés ou éteints. Le meilleur exemple est un lecteur de cassette simple. Pour ceux qui ne se souviennent pas, le lecteur de cassette a 6 boutons, de gauche à droite :

• Enregistrement
• Rembobinage
• Play
• Avance rapide
• Arrêt
• Pause

Chaque bouton à une fonction, mais seulement quand il est utilisé correctement. Par exemple, le bouton d'arrêt n'a pas de fonction à moins que la cassette fonctionne - only then will it do something apparent et arrête la lecture. Les boutons avance rapide et rembobinage, d'autre part, peuvent être utilisés à tout moment, parce que la bande peut être orientée dans les deux directions, peu importe si elle fonctionne ou s'est arrêtée. L'enregistrement commence seulement quand les boutons play et enregistrement sont appuyés simultanément. Certains peuvent avoir essayé d'appuyer sur plusieurs ou tous les boutons à la fois - dans ce cas, le lecteur de cassette pourrait faire quelque chose d'inattendu ou mettre tout en pause.

Les registres du micro-contrôleur se comportent comme des boutons d'un lecteur de cassette - chaque bouton à une fonction, lorsqu'il est utilisé correctement. En appuyant les mauvais boutons, un micro-contrôleur ne se détériorera pas, mais il ne fonctionnera pas non plus. En réalité, il n'y a aucun bouton dans les registres, au lieu de cela il y a une série de transistors, qui s'allument et s'éteignent. Des micro-contrôleurs plus simples ont 8 interrupteurs basés sur des transistors dans un registre simple. Un registre peut être imaginé comme un nombre de 8 bits, où chaque bit marque l'état d'un de ces interrupteur. Par exemple, la valeur 1 signifie que l'interrupteur est branché et 0 que l'interrupteur est débranché.

Les “boutons” du registre et la valeur des bits

Puisque l'état des interrupteurs du registre peut facilement être traité comme un nombre et vice versa, un registre peut être comparé à une mémoire, qui peut contenir des données de la taille d'un nombre. Par cette comparaison, nous voyons que les registres sont en réalité des créneaux de mémoire. La différence entre un registre et un slot de mémoire est qu’un slot de mémoire stocke seulement les informations, alors que dans un registre ces informations contrôlent en réalité quelque chose. Par exemple, si une valeur binaire de 01100001 est écrite à un registre, cela signifie que trois boutons imaginaires sont appuyés et quelque chose arrive.

Avec un lecteur de cassette il est possible d'appuyer sur chaque bouton séparément, mais dans un registre il est plus difficile de changer la valeur d'un “interrupteur” ou le bit. Concrètement il est nécessaire de changer le contenu entier du registre. Avant le changement de la valeur d'un bit, il faut savoir qu'il y a beaucoup de registres dans un micro-contrôleur. Certaines parties du micro-contrôleur utilisent des dizaines de registres pour les contrôler. La variété des registres signifie qu'il y doit avoir une façon de distinguer les différents des registres ce que l'on réalise en les nommant. Un registre, par exemple, est appelé PORTB. En réalité, ces noms doivent juste rendre les choses plus faciles pour le développeur et chaque nom correspond à une adresse numérique.

Pour écrire sur un registre ou en lire une valeur, il doit être adressé comme une variable dans C. L'exemple suivant montre l'écriture d'une valeur binaire sur un registre imaginaire REG et ensuite sa lecture dans la variable Reg . Des valeurs binaires sont distinguées par 0b (zéro), pour que le compilateur comprenne le système numérique.

  REG = 0b01100001;
  unsigned char reg = REG;

Il n'y a rien de difficile à écrire et lire les valeurs d'un registre, mais il devient un peu délicat si on doit modifier seulement un bit. Pour modifier des bits, on a besoin d'avoir des connaissances en mathématiques binaires et utiliser des systèmes numériques différents. Il ne serait pas impossible de ne traiter que des nombres binaires, mais ils peuvent être un peu ennuyeux, parce que des nombres binaires sont assez longs et c'est pourquoi la plupart des personnes utilisent des nombres hexadécimaux plus courts.

Nombres hexadécimaux

En hexadécimal, les nombres ne sont pas seulement des 0 et des 1 comme dans le fichier binaire ou de 0 à 9 en décimale, mais au lieu de cela de 0 à F. Un nombre hexadécimal est composé de quatre bits. La table à droite montre les nombres binaires et leurs équivalents hexadécimaux. Des nombres binaires sont convertis en hexadécimal en lisant des bits quatre à la fois, en commençant par le rang le plus bas. Les rangs sont lus de droite à gauche en commençant par 0. Par exemple, le bit le plus bas classé (au rang 0) est 0 et le plus haut (au rang 3) est 1. Dans l'exemple précédent, la valeur binaire du registre est 01100001, qui correspond au 61 en hexadécimal et est écrit 0x61 (zéro) en langage C.

Pour changer un bit seul dans un nombre (le registre, la variable ou n'importe où autrement à cet égard) il est nécessaire d'utiliser des opérations binaires. L'opération binaire est une opération entre deux nombres binaires, où chaque bit des nombres sont soumis à leur propre opération logique. Typiquement un micro-contrôleur supporte quatre opérations binaires, chacune ayant plusieurs noms. La section suivante décrit l'opération logique derrière chacune de ces quatre opérations binaires avec un bit seul ou des bits multiples.

Négation, multiplication logique, addition logique et séparation exclusive

• Négation / Inversion
  Le négation inverse la valeur du bit, un 0 devient 1 et vice et versa. En C, la négation correspond au symbole “~”.
• Multiplication logique/ Conjonction
  Lorsqu'on multiplie deux bits, le résultat est 1 lorsque les deux valeurs sont à 1. En C, la multiplication logique correspond au symbole “&”.
• Addition logique / Disjonction
  Lorsqu'on additionne deux bits, le résultat est 1 lorsqu'au moins une des deux valeurs est à 1, quelle que soit la valeur de l'autre. La valeur est 0 quand les deux bits sont à 0. En C, l'addition logique correspond au symbole “|”.
• Disjonction exclusive / OU Exclusif / XOR
  L'opération du OU Exclusif renvoi 1 lorsque les deux bits on des valeurs différentes (le premier est à 1, le second à 0), sinon l'opération renvoi 0. En C, le OU Exclusif correspond au symbole “^”.

C'est tout ce qu'il y a à savoir pour modifier les bits seuls. La théorie seule n'est probablement pas suffisante, c'est pourquoi il y a quelques exemples typiques avec des registres dans les paragraphes suivants.

Mettre un bit en haut

Pour mettre un ou plusieurs bits dans un registre en valeur haute (1) une opération d'addition logique est nécessaire. Un des opérandes de l'opération doit être le registre et l'autre un nombre binaire, où seul le bit haut est celui qui doit être mis haut dans le registre. Ce nombre binaire est appelé un bitmask. Ci-dessous le code de C correspondant à l'opération montrée à droite :

  // Let's suppose REG = 0x0F
  REG = REG | 0x11; // First method
  REG |= 0x11;      // Second method
  // Now REG = 0x1F

Mettre un bit en bas

Pour mettre un ou plusieurs bits dans un registre en valeur basse (0) une opération de multiplication logique est nécessaire. Un des opérandes de l'opération doit être le registre et l'autre un bitmask, où seul le bit bas est celui qui doit être mis bas dans le registre. Ci-dessous le code de C correspondant à l'opération montrée à droite :

  // Let's suppose REG = 0x0F
  REG = REG & 0xFE; // First method
  REG &= 0xFE;      // Second method
  // Now REG = 0x0E

Inverser la valeur d'un bit

Pour inverser un ou plusieurs bits dans un registre une opération de disjonction exclusive est nécessaire. Un des opérandes de l'opération doit être le registre et l'autre un bitmask, où seul le bit bas est celui qui doit être inversé dans le registre. Ci-dessous le code de C correspondant à l'opération montrée à droite :

  // Let's suppose REG = 0x0F
  REG = REG ^ 0x11; // First method
  REG ^= 0x11;      // Second method (use only one per inversion)
  // Now REG = 0x1E

Inverser tous les bits

Pour inverser tous les bits d'un registre on utilise l'opération de négation. Cette opération est unaire, ce qui signifie qu'elle ne nécessite qu'un seul opérande. Ci-dessous le code de C correspondant à l'opération montrée à droite :

  // Let's suppose REG = 0x0F
  REG = ~REG;
  // Now REG = 0xF0

Lire la valeur d'un bit

Pour lire une ou plusieurs valeurs d'un bit d'un registre la même opération que pour mettre un bit en position basse est nécessaire - la multiplication logique. L'un des opérants doit être le registre et l'autre le bitmask, où le seul bit en position haute est celui que l'on doit lire sur le registre. Ci-dessous le code de C correspondant à l'opération montrée à droite :

  // Let's suppose REG = 0x0F
  unsigned char x = REG & 0x01;
  // Now x = 0x01

Beaucoup de langages de programmation ont en réalité quelques opérations bitwise supplémentaires, qui le rendent plus facile pour les programmeurs. Celles-ci sont des opérations de déplacement de bits qui les déplacent vers la gauche ou vers la droite dans un nombre binaire. La valeur principale de l'opération de déplacement traitant avec des registres est sa capacité à convertir des rangs de bits en bitmasks et vice versa.

Déplacement à gauche

L'image à droite montre une opération de déplacement à gauche. Bien que le déplacement de bit ne soit pas une opération logique et n'ait aucun symbole correspondant, en C il est marqué par “«”. Le déplacement à gauche est utilisé pour transformer le rang d'un bit en un bitmask. Par exemple, pour obtenir le masque pour le 6ème bit (NB! Au rang 5), le chiffre 1 doit être déplacé de 5 fois vers la gauche. L'opération en C ressemble à ça:

REG = 0x01 << 5;
// Now REG = 0x20

Déplacement à droite

L'opération de déplacement à droite fonctionne de la même manière que celle à gauche. Elle est représentée par le symbole “»” en langage C. Le déplacement à droite est utilisé pour récupérer la valeur logique d'un bit à partir d'un bitmask. Un exemple principal montre comment lire la valeur d'un bit simple. Ce qui suppose que le bit qui doit être lu n'est pas à son rang le plus bas, mais par exemple au rang 5. Dans ce cas le résultat pourrait à la fois être 0x20 ou 0x00, mais parfois il est nécessaire d'avoir ou 0 ou 1 comme résultat, c'est dans ce cas que l'on utilise le décalage à droite. L'opération en C ressemble à ça:

// Let's suppose REG = 0x20
unsigned char x = REG >> 5;
// Now x = 0x01 (or simply 1)

Si un bit est déplacé vers la droite à partir du rang le plus bas ou vers la gauche à partir du rang le plus haut, alors il disparaît. Certains langages de programmation contiennent des opérations de déplacement de bits rotatives, avec lesquelles le bit ne disparaît pas, mais se déplace du rang le plus haut vers le rang le plus bas et vice versa. Le langage C ne prévoit pas ce type d'opération, mais rien n'empêche le programmeur de l'écrire si nécessaire.

Toutes les opérations sur les bits ne fonctionne pas seulement avec les registres, mais aussi avec les variables ou les constantes. Ce dernier peut bien sur être utilisé comme opérande et non comme résultat

Pour faire quoi que ce soit avec les registres du micro-contrôleur, il est nécessaire de connaître l'utilisation de ce micro-contrôleur en particulier. Chaque micro-contrôleur est accompagné d'une ou plusieurs fiches techniques, qui décrivent la structure entière et les fonctionnalités du micro-contrôleur. La fiche technique décrit aussi les registres. L'exemple suivant permettra de comprendre les descriptions des registres dans les fiches techniques AVR.

L'un des registres AVR dans sa fiche technique

L'image montre le registre UCSRnA du micro-contrôleur ATmega128, qui supporte “le contrôle USART et le statut du registre A”. Ce registre est utilisé pour configurer le module USART de l'AVR afin d'en lire ses statuts. Tous les noms de registres de l'AVR sont écrits en lettre capitales, mais le lecteur notera que le nom du registre contient la lettre minuscule n. On utilise un n minuscule pour identifier l'index du module; Certains ATmega128 contiennent deux modules USART identiques, qui ne sont décrit qu'une seule fois, l'utilisateur remplacera alors le n par un 0 ou 1. ATmega128 contient donc les deux registres UCSR0A et UCSR1A.

Le contenu d'un registre est représenté par une boîte à 8 slots avec une ligne en gras. Chaque slot représente un bit. Les rangs des bits sont marqués au-dessus de la boîte - en croissant de droite à gauche. Puisque AVR est un micro-contrôleur de 8 bits, la plupart des registres sont de 8 bits aussi. Il y a quelques exceptions, quelques registres sont de 16 bits, mais ils consistent en réalité en deux registres de 8 bits. Comme chaque registre a un nom, chaque bit dans le registre a aussi un nom - comme les boutons sur un lecteur de cassette. Chaque bit est décrit dans la fiche technique. Les noms de bit sont des abréviations et la lettre n minuscule peut être remplacée par l'index du module, comme avec les noms de registre. Quelques registres n'utilisent pas tous les 8 bits, dans ce cas le slot du bit est marquée avec un trait d'union.

Au-dessous des bits du registre on trouve deux lignes, qui définissent si le bit est en lecture (R), en écriture (W) ou les deux (R/W). Par exemple, les bits de statut ne peuvent pas être écrasés et même s'il est essayé dans le programme, le bit restera inchangé. Si le bit est marqué en écriture, la lecture aboutira toujours à une valeur spécifique définie dans la fiche technique. La deuxième ligne spécifie la valeur par défaut du bit, valeur prise après chaque remise à zéro du micro-contrôleur.

Tandis que le de noms des registres de l'AVR pointent vers une adresse de slot de mémoire réelle, les noms de bits gardent le numéro du rang du bit correspondant. Donc il est nécessaire de transformer les noms en bitmasks en utilisation d'une opération de déplacement, pour manipuler les bits dans un registre. Le code suivant contient quelques lignes d'exemple pour utiliser le registre du module USART 0.

  // Set TXC0 bit high
  UCSR0A |= (1 << TXC0);
 
  // Set U2X0 bit low
  UCSR0A &= ~(1 << U2X0);
 
  // Read the value of UDRE0 bit(mask)
  unsigned char u = (UCSR0A & (1 << UDRE0));
 
  // At this point u value is either 0 or 32,
  // which enables using it in a logical operation
  if (u)
  {
     // Invert MPCM0 bit
     UCSR0A ^= (1 << MPCM0);
  }
 
  // Sometimes it is necessary to acquire a specific 0 or 1 value,
  // so the read bit needs to be shifted right
  u >>= UDRE0;
 
  // Now the value of u is either 0 or 1