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 aux sorties préfixées par PB, PC, et PD du schéma 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
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
Arduino Mega
Voici le mapping des 70 sorties de l'ATmega1280 de l'Arduino Mega pour les 54 sorties "digitales" :
// sortie 7 6 5 4 3 2 1 0
// ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
PORTL 42 43 44 45 46 47 48 49
PORTG 4 39 40 41
PORTD 38 18 19 20 21
PORTC 30 31 32 33 34 35 36 37
PORTA 22 23 24 25 26 27 28 29
PORTH 9 8 7 6 16 17
PORTJ 14 15
PORTB 13 12 11 10 50 51 52 53
PORTE 3 2 5 1 0
pour les 16 sorties analogiques :
// sortie 7 6 5 4 3 2 1 0
// ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
PORTF 7 6 5 4 3 2 1 0
PORTK 15 14 13 12 11 10 9 8
