Informatique Industrielle

TP 3 – Microcontrôleur

Afficheur 7 segments
et interruption (TIMER0)

Thomas Quiniou et Albert Ranaivosoloarimanana

Licence SPI-2

Année 2014

1
1. Objectifs
Manipuler les 4 afficheurs 7 segments de la platine EasyPic7. Dans un premier temps,
vous mettrez en œuvre un seul afficheur afin de maitriser uniquement la gestion des
segments et l'utilisation d'un fichier de définition (.h1). Ensuite, vous devrez multiplexer
deux afficheurs selon 2 approches différentes, sans et avec gestion d'interruption.

2. Les afficheurs 7 segments de la carte Easypic7

Un afficheur est constitué de 7 segments identifiés par les lettres de A à G et du point
décimal DP. Chaque segment est rattaché à l'une des broches du µC. Pour les activer,
vous écrirez dans le registre LATx correspondant au port x, une valeur hexadécimale
(mais on pourrait également donner une valeur binaire ou octale) à l'instar de ce que
vous aviez fait avec les LEDs au TP précédent. En vous aidant du schéma de l'afficheur,
complétez le tableau suivant :

bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0

Affichage Hexa
DP G F E D C B A
0 0 0 1 1 1 1 1 1 0x3F
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0

Ce tableau représente une opération de masquage qui sera mise en œuvre dans un
fichier de définition (.h). Autrement dit, chaque symbole (0, 1, 2 etc.) est remplacé par
un mot binaire. Par exemple, le symbole 8 (0000 1000b) est remplacé par le mot binaire
0111 1111b. Mais on pourrait s’y prendre autrement et utiliser un tableau de 10 cases
pour mémoriser les valeurs hexadécimales.

Vous pouvez facilement contrôler les valeurs hexadécimales obtenues grâce à l’un des
utilitaires de mikroC. Pour l’afficher : Tools > Seven Segment Editor.

1
h pour header file ou fichier d'en tête en français

2
Le schéma des connections des afficheurs est rappelé ci-dessous :

Questions :
1. Quel port permet de sélectionner l'afficheur actif?

2. Quelles valeurs faut-il envoyer pour sélectionner :

a. l'afficheur DIS0? .................................................

b. L'afficheur DIS1?.................................................

c. L'afficheur DIS2?................................................

d. L'afficheur DIS3?................................................

3. Quel port permet d'afficher les segments?

4. Est-il possible d'activer 2 segments en même temps?

5. Est-il possible d'afficher 2 symboles en même temps?

6. Quelle est l'utilité du multiplexage?

3
3. Exercice 1 : Gestion de l'afficheur DIS0 seul

Votre projet sera ici constitué de 2 fichiers, un fichier principal (.c) et un fichier de
définition opérant le masquage (.h). Afin que le compilateur puisse lier le fichier .h au
fichier .c, la directive #include sera utilisée.

1. Grâce au tableau que vous avez rempli en page 2, compléter le fichier suivant
(fonction mask):

// Fichier Display_utils.h
unsigned short mask(unsigned short num) {
switch (num) {
case 0 : return 0x3F;
case 1 : return ..... ;
case 2 : return ... ;
case 3 : return ... ;
case 4 : return ... ;
case 5 : return ... ;
case 6 : return ... ;
case 7 : return ... ;
case 8 : return ... ;
case 9 : return ... ;
}
}

Remarques :
- Utilisation du format unsigned short, sur 8 bits (de 0 à 255), ce qui est
largement suffisant ici
- il est également possible de n'indiquer que le prototype de la fonction
dans le fichier .h (càd. seulement la ligne " unsigned short mask(unsigned
short num); ") et de coder la fonction dans un autre fichier .c.
2. Remplacer les lettres x et y par les bons ports dans fichier principal suivant :
// Fichier principal (DIS0.c)
#include "Display_utils.h"
void main () {
unsigned short i;
RCON. IPEN = 0; // Disable priority levels on interrupts
INTCON.GIE = 0; // Disable all interrupts
TRISx = 0; // Configure Portx as output
LATx = 0; // Turn off all 7seg displays
TRISy = 0; // Configure Porty as output
LATy = 0; // Clear port y
while (1) {
for (i = 0; i <= 9u; i++){

4
 LATx = 0; // Turn off all 7seg displays
LATy = mask(i); // bring appropriate value to PORTy
LATx = 1; // turn on appropriate 7seg. display
Delay_ms (1000);
}
}
}
Remarque : dans la boucle for, la lettre u accolée au chiffre 9 signifie unsigned

Avant d’aller plus loin, analyser le code. Selon vous, que va faire l’afficheur DIS0?

3. Configurer le switch SW4 pour permettre l'activation de l'afficheur DIS0

(SW4.1 on).
4. Créer un nouveau projet (TP3/DIS0), fréquence 32 MHz
5. Dans le Project > Edit Project, ne pas oublier d’activer la PLL (8×4 = 32 MHz)
6. Recopier le contenu du fichier DIS0.c et enregistrer
7. Ouvrir une page blanche : File > New > New Unit
8. Recopiez le contenu du fichier Display_utils.h
9. Sauvegarder ce fichier : File > Save As. Sélectionner le type Header File (*.h)
10. Allumer la platine EasyPic7
11. Compiler et programmer (built+Program) le µC
12. Vérifier le bon fonctionnement de votre code

Modifier le programme afin d’utiliser l’afficheur DIS1, puis DIS2 et finalement DIS3.

4. Exercice 2 : Gestion de 2 afficheurs - Multiplexage

Vous allez maintenant mettre en œuvre 2 afficheurs (DIS0 et DIS1) afin d’afficher une
valeur qui s’incrémentera de 00 à 99. Etant donné qu’il n’est pas possible de valider
simultanément plusieurs afficheurs (en raison du câblage de la carte EasyPic7), il vous
faudra basculer de l’un à l’autre (multiplexage). Si le multiplexage fonctionne bien, le
basculement ne doit pas être visible. Dans cet exercice, il sera indispensable de
basculer entre les 2 afficheurs en passant par l’algorithme suivant :

Faire plusieurs fois ( boucle for : for (j = 1; j <= 50; j++) { )

• activer DIS0
• afficher le chiffre de poids faible
• tempo (10 ms par exemple)
• activer DIS1
• afficher le chiffre de poids fort
• tempo (10 ms par exemple)

1. Autoriser l’utilisation des afficheurs DIS0 et DIS1 (switch SW4.1 et .2 on)

2. Créer un répertoire TP3/DISO1/
3. Coller le fichier Display_utils.h dans ce répertoire

5
 4. Créer un nouveau projet (TP3/DIS01), fréquence 32 MHz
5. Dans la seconde fenêtre du New Project Wizard, ajouter le fichier
Display_utils.h
6. Ne pas oublier dans Project > Edit Project de valider la PLL
7. En s’appuyant sur l’algorithme donné, écrire et tester un programme qui affiche
un compteur de 00 à 99 sur les deux afficheurs. Vous utiliserez les opérateurs
/ (division) et % (modulo – reste de la division) :
a. Pour extraire le chiffre des dizaines d’un nombre « number » :
digit = (number / 10u) % 10u.
b. Pour extraire le chiffre des unités : digit = number % 10u;
8. Modifier la valeur des temporisations (100 ms)
9. Que constatez-vous ? Donnez une explication.
10. Même si la valeur de la temporisation est faible (10 ms ou moins), cette manière
de programmer est-elle viable ?

5. Exercice 3 : Gestion des 4 afficheurs - Interruption

Vous allez maintenant utiliser une autre méthode pour réaliser le multiplexage. Il s’agit
ici d’utiliser l’interruption généré par le Timer0. Le programme suivant (DIS0123.c), que
vous pourrez télécharger à l’adresse http://pages.univ-nc.nc/~quiniou, permet d’afficher
un compteur sur les 4 afficheurs 7 segments de la carte Easypic7.

#include "Display_utils.h"

unsigned short shifter, portd_index;

unsigned int digit, number;
unsigned short portd_array[4];

void interrupt() {
LATA = 0; // Turn off all 7seg displays
LATD = portd_array[portd_index]; // bring appropriate value to PORTD
LATA = shifter; // turn on appropriate 7seg. display

// move shifter to next digit

shifter <<= 1;
if (shifter > 8u)
shifter = 1;

// increment portd_index
portd_index++ ;
if (portd_index > 3u)
portd_index = 0; // turn on 1st, turn off 2nd 7seg.
TMR0L = 0; // reset TIMER0 value
TMR0IF_bit = 0; // Clear TMR0IF
}

6
void main() {
ANSELA = 0; // Configure PORTA pins as digital
ANSELD = 0; // Configure PORTD pins as digital

TRISA = 0; // Configure PORTA as output

LATA = 0; // Clear PORTA
TRISD = 0; // Configure PORTD as output
LATD = 0; // Clear PORTD

T0CON = 0xC4; // Set TMR0 in 8bit mode, assign prescaler to TMR0

TMR0L = 0; // clear TMROL
digit = 0;
portd_index = 0;
shifter = 1;

number = 9981; // Initial number value

GIE_bit = 1;
TMR0IE_bit = 1;

do {
digit = number / 1000u ; // extract thousands digit
portd_array[3] = mask(digit); // and store it to PORTD array
digit = (number / 100u) % 10u; // extract hundreds digit
portd_array[2] = mask(digit); // and store it to PORTD array
digit = (number / 10u) % 10u; // extract tens digit
portd_array[1] = mask(digit); // and store it to PORTD array
digit = number % 10u; // extract ones digit
portd_array[0] = mask(digit); // and store it to PORTD array

Delay_ms(1000); // one second delay (Temporisation Prog. Principal)

number++ ; // increment number

if (number > 9999u)
number = 0;

} while(1); // endless loop

}

1. Autoriser l’utilisation des 4 afficheurs (SW4.1, SW4.2, SW4.3, SW4.4 on)

2. Créer un répertoire TP3/DISO123/
3. Coller les fichiers DIS0123.c et Display_utils.h dans ce répertoire
4. Créer un nouveau projet DIS0123, fréquence 32 MHz
5. Dans la seconde fenêtre du New Project Wizard, ajouter les 2 fichiers
DIS0123.c et Display_utils.h
6. Ne pas oublier dans Project > Edit Project de valider la PLL
7. Compiler et programmer le µC

7
I. Test du programme

Vérifier que le compteur démarre bien à 9981 et bascule à 0000 après 9999. Vous
pouvez à tout moment « reseter » la carte en appuyant sur le bouton « reset » situé en
haut à droite de la carte Easypic7.

II. Analyse du programme

Après les déclarations de différentes variables, de type unsigned short ou int, le

programme est scindé en 2 partie (void). La première (void interrupt) concerne le code
qui sera exécuté lorsque l’interruption sera activée (débordement du Timer0). La
seconde (void main) concerne le programme principal.

En parcourant rapidement le code, il est visible que l’interruption est générée par le
Timer0 - les bits GIE et TMR0IE sont mis à 1.

II.1. Boucle do-while() du programme principal

Cette partie du programme permet d’incrémenter le compteur toutes les secondes.
portd_array est un tableau de 4 éléments qui contient les 4 digits du compteur. Chaque
digit est extrait grâce aux opérateurs / et %.

II.1. Timer0 et interruption par débordement

TOCON est le registre associé au Timer0 (cf. annexe2). Dans le programme, il prend la
valeur 0xC4.
1. Convertissez cette valeur en binaire et la reporter dans le tableau de l’annexe2
2. Surligner les lignes valides en fonction des bits individuels
3. En particulier, déterminez la valeur du prescaleur (prédiviseur) ?
4. Sachant que la fréquence d’entrée du préscaleur est de Fosc/4 (soit 32/4),
quelle est la période de comptage du Timer0 ?
5. Sachant que le timer0 est configuré sur 8 bits et qu’il est initialisé à 0, quelle est
la période de génération d’une interruption ?
6. Comparer avec la temporisation du programme principal, qu’en déduisez-vous ?
7. Pour le reste, il s’agit de sélectionner chaque afficheur tour à tour (grâce à
shifter) et d’afficher le bon digit (portd_array[portd_index]).

8
Annexe 1 : rappel sur les Interruptions

9
10
 Annexe 2 : Le Timer0 et le registre T0CON

Valeur du registre T0CON : 0xC4 (à convertir en binaire)

bit7 bit6 bit5 bit4 bit3 bit2 Bit1 bit0

11