Voir la source de 7 Segments

== 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 : [http://www.arduino.cc/en/Tutorial/ShiftOut 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 (« [https://fr.wikipedia.org/wiki/Registre_à_décalage 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

[[File:shift_register_09_lrg.jpg|200px]]

=== 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 :
[[File:tuto1_branchement_7segments.png|400px]][[File:7-seg-disp-cc.png|400px]]


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 :

<code lang=cpp name="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);

}
</code>

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 :


[[File:tuto1_tableau_valeurs.png|400px]]


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!



















[[Category:Tutos]]