7 Segments
Sommaire
Afficheur 7 segments avec Arduino
Ce tutoriel est un premier essai. Il est donc perfectible :) !
Il a été écrit à partir de l'Atelier Arduino qui a eu lieu le 17 Juillet 2013 hébergé gracieusement par Jeff de MVSolutions.
objectif
Affichage de chiffres avec un registre et un afficheur 7 segments.
La base de cette démo est le tutorial Arduino « ShiftOut » disponible, en anglais, ici : Serial to Parallel Shifting-Out with a 74HC595
Le but de cette démo est de faire défiler les chiffres 0 à 9 sur un afficheur 7 segments à l'aide d'un Arduino Uno et d'un registre (« Shift register »).
Pour cela nous allons brancher le registre sur l'arduino comme dans le tutoriel ShiftOut, puis nous allons remplacer les leds du tutoriel par l'afficheur 7 segments (simple non ? :) ).
Câblage
1) Branchement du registre
Connecter l'Arduino et le registre comme décrit dans le tutoriel. On doit obtenir ce résultat :
http://arduino.cc/en/uploads/Tutorial/ShftOutExmp1_2.gif
2) Branchement du registre sur l'afficheur 7 segments
Connecter les pattes du registre et de l'afficheur de la façon suivante :
Connecter toutes les pattes du haut au registre ainsi : Q6 Q5 C Q4 Q3
Et toutes les pattes du bas ainsi : (La patte en bas à droite correspond à la diode du point décimal que nous n'allons pas utiliser ici.) Q0 Q1 C Q2
Les diodes de l'afficheur correspondront alors au sorties suivantes du registre :
Les deux pattes Cathode (C) doivent être branchées sur des résistances reliées à la terre (GND).
le code
3) Création et chargement du programme dans le microcontrôleur
Ouvrir un croquis (sketch) dans le logiciel Arduino et entrer le code suivant :
RegistreDecalage74HC595.ino
//**************************************************************//
// Name : shiftOutCode, Hello World
// Author : Carlyn Maw,Tom Igoe, David A. Mellis
// Date : 25 Oct, 2006
// Modified: 23 Mar 2010
// Version : 2.0
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255
//****************************************************************
//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
// valeurs envoyées au registre pour afficher les leds
int mesValeurs[] = {12, 91, 94, 108, 118, 119, 28, 127, 126, 63};
void setup() {
//set pins to output so you can control the shift register
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
//
void loop() {
for (int i=0; i<10; i++) {
affDigit(mesValeurs[i]);
}
}
void affDigit(int nombre) {
// take the latchPin low so
// the LEDs don't change while you're sending in bits:
digitalWrite(latchPin, LOW);// on peut mettre HIGH et LOW plus bas
// shift out the bits:
shiftOut(dataPin, clockPin, MSBFIRST, nombre);
//take the latch pin high so the LEDs will light up:
digitalWrite(latchPin, HIGH);// on peut mettre LOW et HIGH plus haut
// pause before next value:
delay(500);
}
Ce code permet d'envoyer un signal différent toutes les demi-secondes au registre avec un code compris entre 0 et 255 correspondant au chiffre qu'on veut afficher.
La correspondance est obtenue grâce au tableau suivant :
Les valeurs calculées sont des puissances de 2.
Par exemple pour le chiffre 1 on veut afficher les segments correspondant à Q2 et Q3 uniquement, il faut donc envoyer une valeur égale à :
2^4 + 2^8 = 12
4) Explication du code
Chaque chiffre de l'afficheur correspond à un int envoyé au registre : 0->63, 1->12,...9->126
Pour faire cette correspondance on peut mettre ces valeurs ordonnées dans un tableau :
int mesValeurs[] = {63, 12, 91, 94, 108, 118, 119, 28, 127, 126};
Ainsi quand on écrit mesValeurs[2] on obtient la valeur 91, qui sera celle à envoyer au registre.
La fonction affDigit permet d'afficher un chiffre sur le 7 segments en envoyant la valeur passée en paramètre.
Donc pour afficher 2 sur le 7 segments on peut écrire : affDigit(mesValeurs[2]);
Le programme se contente de parcourir un tableau d'entiers qu'on a rempli avec les valeurs correspondant aux chiffres :
int mesValeurs[] = {63, 12, 91, 94, 108, 118, 119, 28, 127, 126};
… à l'aide d'une boucle for :
for (int i=0; i<10; i++) { affDigit(mesValeurs[i]); }
La méthode affDigit prend en paramètre un entier qui est la valeur à envoyer au registre :
void affDigit(int nombre) {
et elle l'envoie au registre grâce à shiftOut :
shiftOut(dataPin, clockPin, MSBFIRST, nombre);
L'appel de digitalWrite(latchPin, LOW) permet d'éteindre le pin (« Latch ») pendant l'envoi des bits et digitalWrite(latchPin, HIGH) permet d'allumer la diode.
Delay(500)
permet d'attendre une demi-seconde avant de passer à l'itération suivante.
Questions
Si vous avez des questions, posez-les ici!