Hardcoding

L’assignation d’un état LOW/HIGH sur une pin de votre Arduino, se fait couramment à l’aide de la méthode digitalWrite(pin, state). RazorConcepts nous présentait il y a quelques semaines une nouvelle méthode pour assigner des états aux pins de votre Arduino. Jugeant cette méthode très intéressante, j’ai décider d’aller aujourd’hui un peu plus loin dans l’explication de cette technique.

La méthode consiste en effet à assigner directement des valeurs (binaires ou hexadécimal) aux variables PORTB PORTC et PORTD, correspondant au trois encarts ci-dessous.

Chacun de ces ports du micro-contrôleur utilisé par l’Arduino possède de 6 à 8 entrées/sorties. Ainsi, à chaque pins de la platine correspond un couple PORT / numéro d’entrée/sortie.

// sortie 543210
//        ↓↓↓↓↓↓
PORTC = 0b110110;

• Notation explicite
• Passer une sortie spécifique à l’état HIGH
• Passer une sortie à l’état LOW
• Notation groupée, basculement simultané
• Inverser l’état d’une sortie
• Gain de poids, gain de perfs
• Conclusion

Notation explicite

Si vous souhaitez modifier l’ensemble des états de plusieurs sorties d’un même PORT, il est possible d’écrire explicitement la valeur (complète) de ce dernier. On souhaite par exemple définir les états des pins digitales 7, 5 et 2 de l’Arduino à HIGH, et les pins 6, 4, 3, 1 et 0 à LOW. Les pins digitales 0 à 7 de l’Arduino correspondent aux sorties 0 à 7 du PORTD.

// sortie 76543210
//        ↓↓↓↓↓↓↓↓
PORTD = 0b10100100;
PORTD = 0xA4; // notation hexadécimale

L’état 1, symbolise l’état HIGH, l’état 0, l’état LOW. Le numéro de sortie commence à zéro et part de la droite vers la gauche (du LSB au MSB). Pour la conversion binaire, hexadécimale, rien de plus simple qu’une requête Google

Les assignations explicites peuvent s’avérer utile dans la méthode setup() visant à initialiser l’état de votre circuit. Il permet également de rendre votre code source plus pro, et plus légé

Passer une sortie spécifique à l’état HIGH

Prenons comme exemple le passage de la pin digitale 3 à HIGH. Le schéma nous montre que la pin digital 3 se trouve sur le PORT D3.

//  sortie 76543210
//         ↓↓↓↓↓↓↓↓
PORTD |= 0b00001000 (PORT PD3)

ou encore avec l’une des notations suivantes

PORTD |= 0b1000
PORTD |= 1 << 3;
PORTD |= _BV(3);

Le shortcut _BV est définit dans ./hardware/tools/avr/avr/include/avr/sfr_defs.h de l’IDE Arduino. Contrairement à l’assignation explicite, ces opérations, utilisant la porte logique OR, ne modifie que l’état de la ou des sorties souhaitées.

Passer une sortie à l’état LOW

Nous souhaitons, définir l’état de la pin digitale 11 à LOW, soit le PORT B, sortie 3. C’est à l’aide des portes logiques AND et NOT que nous pouvons écrire :

PORTB &= ~0b00001000

Ou l’une de ces notations équivalentes :

PORTB &=  0b11110111
PORTB &=  B11110111 // constante
PORTB &= ~(1<<3)
PORTB &= ~_BV(PB3);
PORTB &= ~_BV(3);
// Ou enfin, en hexadécimal
PORTB &= ~0x8;
PORTB &= 0xF7;

Les constantes B* sont définies de B0 à B11111111

Notation groupée

Si les sorties, dont on souhaite modifier l’état, se trouvent sur le même port, il est possible de grouper l’ensemble des instructions en une seule. Nous souhaitons dans notre exemple passer les pins 6, 2 et 1 à LOW. Commençons par écrire chacune des trois instructions nécessaires à cet exemple.

PORTD &= ~B01000000  // sortie 6, port D
PORTD &= ~B00000100  // sortie 2, port D
PORTD &= ~B00000010  // sortie 1, port D

L’opération étant la même (passage à LOW) et concernant les sorties d’un même port (le D), il est donc possible les additionner

pin D6 => PD6  0b01000000
pin D2 => PD2  0b00000100
pin D1 => PD1  0b00000010
               __________
on additionne  0b01000110

L’opération “groupée” à effectuer est donc

PORTD &= ~0b01000110
//           ↑   ↑↑
//           6   21  fixe les sorties 6,2 et 1 du PORT D à LOW
//                   sans modifier l'état des autres sorties

Ce type de programmation permet donc un basculement simultané (en un cycle processeur) de plusieurs sorties. Dans le meilleur des cas, 9 cycles processeurs sont nécessaires avec la méthode classique digitalWrite.

Explication sur l’opération AND NOT &=~..

gardons notre exemple du triple passage à LOW (sorties 6, 2 et 1).

~ est l’opérateur NOT qui permet “d’inverser” la valeur des bits
~..000001000110  =  ..111110111001

le nombre de 1 devant la notation binaire dépends de l’architecture du microprocesseur (ici 8 bits)

On peut donc écrire,

  //       7 543  0
  //       ↓ ↓↓↓  ↓    keep on if on
PORTD &= 0b10111001
  //        ↑   ↑↑
  //        6   21     switch off if on

On renseigne enfaite ici les bits à maintenir allumé, si ils le sont déjà.

Ainsi, dans ce même exemple (mettre pin 6,2, et 1 à LOW) supposons, au hasard, un état du port D initial à 0b01011101

Nous appliquons l’opération PORTD &= ~B01000110 vu précédemment, qui peut également s’écrire :

PORTD &= 0b10111001
PORTD = PORTD & 0b10111001
PORTD = 0b01011101 & 0b10111001 

//      0b01011101
//  &   0b10111001
//      ----------
//      0b00011001
//        ↑↑↑↑↑↑↑↑
// sortie 76543210

On applique l’opération AND sur chaque bit, (rappel : 0b1 & 0b1 = 0b1)

l’état final, 0b00011001, montre donc bien une modification de l’état des sorties 6 et 2 à LOW (la pin 1 étant déjà à LOW). Cette opération n’a eu aucune incidence sur l’état des autres pins, comme souhaité ; le tout en un seul cycle.

Inverser l’état d’une sortie

Exemple : nous souhaitons inverser l’état de la sortie 5 et 7 du PORTD. Dans un cas concret, deux LED clignotant en alternance l’une de l’autre sur les pins digitales 5 et 7.

int state = 1;

void setup() {}
void loop() {
  if(state==1) { // on réalise l'alternance à l'aide d'une variable
    state = 0;
    digitalWrite(5, LOW);
    digitalWrite(7, HIGH);
  }
  else {
    state = 1;
    digitalWrite(5, HIGH);
    digitalWrite(7, LOW);
  }
  delay(1000); // on attend 1 seconde
}

Avec les opérations binaires, la fonction XOR nous permet d’écrire

void setup() {
  PORTD = B10000000; // on définit l'état initial
}
void loop() {
  //sorties 7 5
  //        ↓ ↓
  PORTD ^= B10100000; // ou PORTD ^= 0xA0;
  delay(1000);
}

Une fois compilée, on obtient une ROM de 550 bytes en opération binaire contre 846 bytes en écriture standard.

Autre avantage, si l’on souhaite modifier l’état initial (pour par exemple faire clignoter les LEDs ensembles), une seule modification suffit, l’état initial de PORTD.

Gain de poids, gain de performances

Voici un exemple simple mettant en œuvre un chenillard à 8 LEDs. En écriture “binaire”

int lednum = 0;

void setup(){}
void loop() {
  PORTD = 1 << lednum; // un seul cycle processeur
  delay(1000);
  lednum++;
  if(lednum==8) lednum = 0;
}

Le même algorithme en écriture standard

int lednum = 0;

void setup(){}
void loop() {
  digitalWrite(0, LOW); // on éteint l'ensemble des LED
  digitalWrite(1, LOW);
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  digitalWrite(6, LOW);
  digitalWrite(7, LOW);
  digitalWrite(lednum, HIGH);
  delay(1000);
  lednum++;
  if(lednum==8) lednum = 0;
}

Une fois compilé on obtient ici un programme 588 bytes contre 886 bytes avec le premier code source.

Sur ces quelques exemples concrets, le gain en poids est de l’ordre de 35 %. Toutefois, si l’on soustrait à ces tailles de programme les 436 bytes occupés par un programme vide (afin de ne retenir uniquement la taille de l’espace occupé par les instructions propres au programme). On obtient une taille de 152 bytes contre 450 bytes, soit une réduction de 66% du code.

Conclusion

Outre le gain de taille, crucial sur un microprocesseur de ce type, le gain en performances. Un benchmark réalisé par RazorConcepts montre des temps de réponse 10 fois supérieurs à la fonction standard digitalWrite() proposée par l’IDE Arduino.

Bien entendu, je vous ai présenté ici les exemples “qui vont bien” (même PORT, opérations simples,.. ). Il y a fort à parier que dans d’autre cas, plus spécifiques, les instructions binaires ne soit pas nécessairement un choix très judicieux.

Ainsi, à moins de frôler dangereusement la limite imposée par votre micro-contrôleur (16 ou 32K), l’utilisation de cette technique reste dédiée aux librairies, aux montages nécessitant une réactivité accrue, ou ceux nécessitant des changements d’état simultanés.

Trois opérations à retenir :

• le OR (|=) qui permet de modifier la valeur des bits choisi à 1, et donc de passer les sorties à l’état HIGH.
• le AND NOT (différent de NAND !) (&=~) qui permettra de “soustraire 1″ aux bits choisis, et permet donc de mettre des sorties à l’état LOW
• le XOR (^=) qui permettra d’inverser l’état des sorties renseignées pas un bit positif