7 Segments

De FunLab Documentation
Révision datée du 2 juin 2018 à 02:43 par Tuxun (discussion | contributions)
(diff) ← Version précédente | Voir la version actuelle (diff) | Version suivante → (diff)
Aller à : navigation, rechercher

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

Shift register 09 lrg.jpg

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 : Tuto1 branchement 7segments.png7-seg-disp-cc.png


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 :


Tuto1 tableau valeurs.png


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!