Arduino et afficheur 7 segments

12 sept. 2012

Deuxième article de la série sur Arduino. Au programme : opérations bit à bit.

Résultat attendu

Exemple de résultat

Il s’agit de contrôler un afficheur 7 segments en affichant les chiffres entrés dans la console série (en utilisant Serial).

Une fois cette base réalisée, il est facile de l’adapter à vos besoins. Par exemple, modifier l’affichage à l’aide d’un potentiomètre ou rajouter un deuxième afficheur 7 segments.

Matériel et logiciels utilisés

On utilisera un Arduino, un afficheur 7 segments (à cathodes communes) et 7 résistances de 220 ohms (plus un câble USB, des fils, plaque prototype…). À défaut, sept DEL peuvent remplacer l’afficheur, mais les chiffres seront bien moins lisibles (sauf si vous utilisez des DEL plates).

Avec sept DEL

Niveau logiciel, prenez la solution de votre choix qui marche, comme l’IDE officielle par exemple.

Squelette

Cette fois, partons d’un code de base où il reste des trous à remplir.

// segments :    A,  B,  C, D, E, F, G
byte pins[7] = {12, 11, 10, 9, 8, 7, 6};

byte chiffres[10] = {
//   ABCDEFG
    B1111110, // 0
    B0110000, // 1
    B0000001, // 2 TODO
    B0000001, // 3 TODO
    B0000001, // 4 TODO
    B0000001, // 5 TODO
    B0000001, // 6 TODO
    B0000001, // 7 TODO
    B0000001, // 8 TODO
    B0000001  // 9 TODO
};

void show(byte c) {
  // TODO
}

void setup() {
    // Initialisation
    for(int i = 0; i < 7; i++)
        pinMode(pins[i], OUTPUT);
    // On affiche un 4 pendant une seconde
    show(chiffres[4]);
    delay(1000);
    // On éteint l’affichage
    show(0);
}

void loop() {
  // TODO
}

Ressources utiles

Afficheur 7 segments

Positions des segments

D’un point de vue électrique, un afficheur 7 segments est simplement l’assemblage de sept DEL, dont les cathodes (ou plus rarement anodes) sont reliées ensembles. Chaque segments (nommés de A à G) se commande donc individuellement. Il suffit donc de décider pour chaque chiffre quels segments doivent êtres allumés, et le tour est joué ! C’est ce que fait le tableau chiffres.

La notation en binaire simplifie la lecture des valeurs de chiffres : pour le chiffre zéro, les segments A à F doivent êtres allumés, et G éteint. Pour le chiffre un, seuls les segments B et C doivent être allumés. Je vous laisse compléter les chiffres suivants dans le squelette.

Je n’ai pas pris en compte le point. Si vous souhaitez le contrôler également, il se comporte exactement comme les autres segments : une patte de l’afficheur lui est dédié. Il suffit donc d’une autre résistance pour le relier à une entrée de l’Arduino, de quelques lignes de code et l’affaire est pliée.

Opérations bit à bit

Maintenant que l’on a une représentation binaire du chiffre à afficher, il ne reste plus qu’à l’utiliser dans la fonction show, qui – comme son nom l’indique – affichera la représentation binaire d’un chiffre (par exemple) sur l’afficheur 7 segments.

Pour manipuler les représentations binaires de nombres, les opérations bit à bit sont les plus efficaces. On peut les séparer en deux catégories : les opérations logiques, et les opérations de décalage.

Opérations logiques

L’opérateur de négation ~ inverse chaque bit : les zéros deviennent des uns et vice-versa. À noter que le type de la variable à une importance ici : si on définit int x = B101; alors ~x vaudra B1111111111111010 et non B010.

Les autres opérateurs sont appliqués sur deux paramètres en même temps. Plus précisément, le premier bit du premier paramètre avec le premier bit du second paramètre, le deuxième bit du premier paramètre avec le deuxième bit du second paramètre, et ainsi de suite : c’est pour cette raison que l’on parle d’opérations bit à bit. Les opérations suivantes sont disponibles, avec les notations usuelles :

le « et » : B110 & B100 vaut B100
le « ou » : B110 | B100 vaut B110
le « ou exclusif » : B110 ^ B100 vaut B010

À noter que des formes compactes existent pour & et |. Par exemple, x &= y est équivalent à x = x&y. On peut donc forcer des bits à 0 (avec &=) ou à 1 (avec |=) de manière plus lisible (ce qui n’est que du sucre syntaxique).

Décalages

Comme son nom l’indique, une opération de décalage décale les bits vers la gauche ou vers la droite. Cependant, il faut préciser que faire des bits qui sont décalés en dehors de la zone allouée, et quel sont les valeurs des bits qui apparaissent ?

Pour le décalage à gauche, c’est facile : les bits qui « sortent » sont perdus, et les bits ajoutés sont des zéros. L’opérateur est << et le deuxième paramètre est le nombre de décalages à gauche qui seront effectués, donc le nombre de zéros ajoutés à droite. Ainsi, si int x = B101, x<<2 vaudra B10100 et x<<14 vaudra B0100000000000000¹.

Le décalage à droite est plus complexe. Si les bits qui « sortent » sont également perdus, les bits ajoutés ne sont pas toujours des zéros. Plus précisément, si la variable est signée (de type char, int ou long), ils auront la même valeur que le bit le plus à gauche : il y a extension du signe. Si la variable n’est pas signée, le comportement normal s’observe : des zéros sont systématiquement ajoutés. Ainsi, si int x = B1000000000001010 et unsigned int y = B1000000000001010 :

x>>2 vaudra B1110000000000010
y>>2 vaudra B0010000000000010

La solution pour retrouver le comportement « normal » est de transtyper x en unsigned int : (unsigned int)x>>2 vaudra B0010000000000010.

Utilisation

Armé des opérations bit à bit, vous pouvez écrire le contenu de la fonction show : il suffit de regarder la valeur des sept premiers bits de chaque représentation d’un chiffre, et d’allumer ou éteindre le segment correspondant suivant cette valeur.

À vous !

Maintenant que vous avez tous les éléments en main, il ne vous reste plus qu’à remplir le squelette. Vous devriez alors voir s’afficher un quatre pendant une seconde.

Pour continuer, vous pouvez écrire le contenu de la fonction loop de manière à pouvoir commander l’affichage 7 segments en rentrant directement le chiffre souhaité dans la console série. Si vous avez besoin d’aide, je vous laisse relire mon précédent tutoriel sur Serial.

Conclusion

Vous savez maintenant afficher les chiffres de votre choix sur un afficheur 7 segments, mais plus important, vous connaissez les opérations bit à bit.

Il ne devrait pas être difficile de trouver des améliorations au montage :

ajouter les lettres de « A » à « F » ;
contrôler l’affichage à l’aide d’un potentiomètre : je vous laisse aller voir du côté de la fonction AnalogRead() ;
ou toute autre idée que vous pourriez avoir !

La suite au prochain épisode où l’on apprendra à gagner des fils, ce qui permettra de contrôler deux afficheurs 7 segments sans monopoliser 14 broches sur l’Arduino.

↑ …et non B10100000000000000 puisque les int contiennent 16 bits.

L’image donnant la position des segments est de h2g2bob sous licence CC BY-SA.