Arduino (index)
Index Site principal
Arduino (page 1)
Page publiée le : 24/01/2013
La carte en elle-même :
les afficheurs 7 segments :
la doc de ces afficheurs est ici :
Cet afficheur possède 18 broches soit 9 pour chaque afficheur.
Sa mise en service est du mode anode commune.
Il faut donc relier les bornes 13 et 14 au +5 V.
Pour allumer les segments A à G et DP, il faut les relier chacun à une patte d’une résistance de 470 ohms, l’autre patte de cette résistance étant à la masse.
Le DP (Digital Point, le point ou virgule), n'est pas câblé dans ce montage, mais rien ne vous empêche de le rajouter et de modifier le programme pour vous entraîner.
Ici, la masse sera en fait un « zéro » (0V) ou un « un » (+5V) issu des broches I/O_0 à I/O_6.
le schéma :
Bien sur, pour réaliser ce petit projet il vous faudra :
- Le logiciel libre, pour écrire, éditer, compiler et programmer la carte Arduino.
- une plaque d’essai,
- 7 résistances de 470 Ω
- un afficheur double à 7 segments en anodes communes.
Structure du programme
Il se décompose en 4 parties :
- les déclarations
- une routine « affichage »
- une routine configuration (setup) exécutée une seule fois,
- le cœur du programme contenu dans la boucle « loop ».
Les déclarations
- affectation de nom aux broches de commande des afficheurs.
- Déclaration des variables globales
- Attention, pour les besoins d’écriture, ici, le tableau aff[70] à été scindé en 2 lignes. Mais dans le programme il est écrit sur une seule ligne.
- On peut remarquer que les broches I/O 0 à 6 n’ont pas été renommées, de façon à pouvoir utiliser une boucle de comptage des identifiants au cours du programme.
La routine Affichage()
La fonction "setup()" :
Enfin la fonction "loop()":
- on démarre par un retard de 0.5 seconde durant lequel les afficheurs restent éteints,
- puis une boucle (for…) compte de 0 à 15,
- cette boucle identifie et mémorise la valeur des unités et des dizaines issues de la valeur du compteur « cpt »,
- selon que « cpt » est inférieur ou égal à 15 l’appel de la routine Affichage() se fera 50 ou 100 fois. Ceci permet d’afficher la valeur 15 deux fois plus longtemps avant de revenir à 0,
- puis on trouve la boucle d’appel de la routine Affichage() qui est donc fonction de la valeur de « raz »,
- lorsque le nombre d’affichage est consommé (valeur « raz »), on revient au début de la fonction loop() pour un nouveau cycle.
Fonctionnement :
- Au démarrage du programme, les afficheurs restent éteints durant 0.5 seconde.
- Puis le compteur part de 0 et compte jusqu’à 15.
- A chaque valeur la routine d’affichage est appelée 50 fois si le compteur est inférieur à 15.
- La routine « Affichage » :
- identifie la valeur des unités et des dizaines du compteur,
- prépare l’afficheur concerné en positionnant les ports I/O alimentant les segments,
- sélectionne l’afficheur qui doit être allumé,
- chaque afficheur est allumé durant 10ms (variable « multiplex »).
- Arrivé à 15, la routine « Affichage » est appelée 100 fois, ce qui laisse la valeur « 15 » affichée plus longtemps, avant d’éteindre les afficheurs et de revenir au début de la boucle « loop() » pour un nouveau cycle.
Une vidéo brut de fonderie :
(si j'ai le courage, je la peaufinerai...)
Le programme complet en langage C pour Arduino :
* * * * *
Ce genre d'afficheur est très gourmand en courant. Aussi, afin de réduire la consommation, il est nécessaire de n'allumer qu'un afficheur à la fois. C'est là qu'entre en jeu le multiplexage.
Pour ce faire nous utiliserons 2 sorties de l'arduino (broches 12 et 13) qui seront mises, l'une au niveau "1" (+5V) et l'autre au niveau "0" (0V) chacune à leur tour. Notre paire d'afficheurs sera câblée comme sur le schéma ci dessous.
Ainsi, physiquement, il n'y aura qu'un seul afficheur alimenté à la fois.
#define aff1 12 // doit être à 1 pour alimenter l'afficheur des dizaines
#define aff2 13 // doit être à 1 pour alimenter l'afficheur des unités
int multiplex = 10; // durée de l'affichage en ms
// tableaux de data pour chaque chiffre de 0 à 9 de l'afficheur 7 segments.
int aff[70]={0,0,0,0,0,0,1,1,0,0,1,1,1,1,0,0,1,0,0,1,0,0,0,0,0,1,1,0,1,0,0,1,1,0,0,
0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0};
int unite; // valeur des unités
int dizaine; // valeur des dizaines
int debut; // debut de la data à lire dans aff[70]
int fin; // fin de la data à lire dans aff[70]
int i; // variable de boucle de lecture de la data
int j; // numéro de la broche I/O
int cpt; // variable de boucle pour le compteur (ici de 0 à 15)
int nbaff; // variable de boucle pour le nombre d'affichages avant de remettre le cpt à 0
int raz; // variable de nombre d'affichages avant changement ou RAZ.
// identification de l'emplacement de la valeur des unités
// dans le tableau aff[70]
debut = unite * 7; // début de l'emplacement
fin = debut + 6; // fin de l'emplacement
j = 0; // initialisation de j (broche IO_0)
// boucle de récupération de la valeur de chaque segment
// pour positionner chaque broche I/O correspondante.
for (i=debut; i<=fin; i++){
if (aff[i] == 1) // si la valeur est à 1
{
digitalWrite(j, HIGH); // IO_J = 1 pour éteindre le segment
}
else // si non
{
digitalWrite(j, LOW); // IO_J = 0 pour allumer le segment
}
j=j+1; // et on passe à la broche I/O suivante
}
// fin de la boucle de préparation à l’affichage des unités.
digitalWrite(aff2, HIGH); // allumage de l'afficheur des unités
delay(multiplex); // durée d'affichage (en ms)
digitalWrite(aff2, LOW); // extinction de l'afficheur.
//--- Même chose pour l'afficheur des dizaines
debut = dizaine * 7;
fin = debut + 6;
j = 0;
for (i=debut; i<=fin; i++){
if (aff[i] == 1)
{
digitalWrite(j, HIGH);
}
else
{
digitalWrite(j, LOW);
}
j=j+1;
}
digitalWrite(aff1, HIGH);
delay(multiplex);
digitalWrite(aff1, LOW);
pinMode(aff2, OUTPUT); // active/désactive l'afficheur des unités pinMode(aff1, OUTPUT); // active/désactive l'afficheur des dizaines
pinMode(0, OUTPUT); // segment A
pinMode(1, OUTPUT); // segment B
pinMode(2, OUTPUT); // segment C
pinMode(3, OUTPUT); // segment D
pinMode(4, OUTPUT); // segment E
pinMode(5, OUTPUT); // segment F
pinMode(6, OUTPUT); // "point" non utilisée dans le programme
digitalWrite(aff2, LOW); // unité OFF
digitalWrite(aff1, LOW); // dizaine OFF
delay(500); // retard avant début de cycle
// compteur pour afficher de 0 à 15
for (cpt=0; cpt<=15; cpt++)
{
dizaine = int(cpt/10); // identification de la dizaine à afficher
unite = cpt - (dizaine * 10); // identification de l'unité à afficher
// condition d'affichage
if (cpt==15)
{
raz=100; // affichera 100 fois les dizaines et les unités avant RAZ.
}
else
{
raz=50; // affichera 50 fois les dizaines et les unités avant de passer
// à la valeur suivante du compteur « cpt ».
}
for (nbaff=0; nbaff<raz; nbaff++)
{
Affichage(); // boucle d'affichage fonction de la valeur "raz"
}
}
A copier/coller directement dans l'éditeur Arduino
ATTENTION :
la suite de 0 et de 1 de la variable tableau aff[70]
doit se trouver sur une seule ligne.
Multiplexage de deux afficheurs 7 segments.
Les modules Arduino ne sont pas prévus pour alimenter de tels afficheurs. Mais on peut contourner le problème en utilisant le multiplexage. De ce fait on ne fait travailler q’un digit à la fois. De plus, en choisissant des digits à anodes communes, notre arduino draine le courant au lieu de le fournir.