TP5 : Programmation C avancée des PIC

Afficheur 7 segments
et interruption (TIMER0)

Objectifs pédagogiques :
Maîtriser les notions avancées de la programmation C des PIC :
o Opérations sur les Entrées/Sorties avec accès direct aux
registres et masquage
o Utilisation des fonctions (appel, déclaration et passage de
variables).
o Création & Utilisation des bibliothèques pour
périphériques

Préalables :
Notions élémentaires sur la programmation C, sur les
interruptions, maitrise de l’environnement PICC et la
plateforme EasyPIC v7.

Durée : 1.5 séance de 3H

ISTMT TP5 26
TP Architecture des systèmes à processeurs GBM3

1. Description du travail

Le TP consiste à écrire un programme C pour PIC 16F877a permettant de commander les

4 afficheurs 7 segments de la platine EasyPIC v7. Dans un premier temps, il faut mettre en
œuvre un seul afficheur afin de maitriser uniquement la gestion des segments et l'utilisation
d'un fichier de définition (.h). Ensuite, il faut multiplexer deux afficheurs selon 2 approches
différentes, sans et avec gestion d'interruption.

2. Fonctionnement
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 correspondant au port x, une valeur hexadécimale (mais on pourrait
également donner une valeur binaire ou octale).
En vous aidant du schéma de l'afficheur, complétez le tableau 1.
Tableau 1
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 1000)b est remplacé par le mot binaire (0111 1111)b.
Mais on pourrait s’y prendre autrement et utiliser un tableau de 10 cases pour mémoriser les
valeurs hexadécimales.

Le schéma des connexions des afficheurs est donné sur la figure 1.

ISTMT TP5 27
TP Architecture des systèmes à processeurs GBM3

Figure 1

Questions préliminaires :
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. Travail demandé
Exercice 1 : Gestion de l'afficheur DIS0 seul

Le projet sera 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. En utilisant le tableau 1, compléter le fichier "Display_utils.h" (fonction "mask") et

l’enregistrer dans votre répertoire de travail.

ISTMT TP5 28
TP Architecture des systèmes à processeurs GBM3

// Fichier Display_utils.h
unsigned int mask(unsigned int 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 int, sur 8 bits (de 0 à 255), ce qui est largement suffisant.
- Il est également possible de n'indiquer que le prototype de la fonction dans le fichier .h
(càd. seulement la ligne " unsigned int mask(unsigned int num); ") et de coder la fonction dans
un autre fichier .c.

2. En se basant sur les commentaires, compléter le programme principal ci-après :

// indiquer la bibliothèque du pic utilisé et la fréquence de l’oscillateur.
#include Display_utils.h"
void main () {
unsigned int i;
disable_interrupts(global);
// Configurer Portx comme sortie x désigne le port qui commande les 7 segments
// Turn off all 7seg displays
// Configurer Porty comme sortie y désigne le port qui sélectionne les afficheurs.
// Mise à 0 zéro du port y
while (1) {
for (i = 0; i <= 9; i++){
// Turn off all 7seg displays
// Affecter au portx mask(i).
// Activer l’afficheur 7seg approprié.
Delay_ms (1000);
}
}
}

➔Avant d’aller plus loin, analyser le code. Que va faire l’afficheur DIS0 ?
3. Configurer le switch SW4 pour permettre l'activation de l'afficheur DIS0 (SW4.1
on).
4. Compiler le programme et vérifier son bon fonctionnement sur la carte.
5. Modifier le programme afin d’utiliser l’afficheur DIS1, puis DIS2 et finalement DIS3.

ISTMT TP5 29
TP Architecture des systèmes à processeurs GBM3

Exercice 2 : Gestion de 2 afficheurs – Multiplexage

A présent il s’agit de 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 TP5/DISO1/
3. Coller le fichier Display_utils.h dans ce répertoire
4. En s’appuyant sur l’algorithme donné, écrire et tester un programme qui affiche un
compteur de 00 à 99 sur les deux afficheurs.
Utiliser les opérateurs / (division) et % (modulo – reste de la division) :
- Pour extraire le chiffre des dizaines d’un nombre « number » :
digit = (number / 10u) % 10u;
- Pour extraire le chiffre des unités : digit = number % 10u;
5. Modifier la valeur des temporisations (100 ms)
6. Que constatez-vous ? Donnez une explication
7. Même si la valeur de la temporisation est faible (10 ms ou moins), cette manière de
programmer est-elle viable ?

ISTMT TP5 30
TP Architecture des systèmes à processeurs GBM3

Exercice 3 : Gestion des 4 afficheurs - Interruption

Nous allons à présent 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 Disp4affich.c permet d’afficher
un compteur sur les 4 afficheurs 7 segments de la carte Easypic7.

#include "Display_utils.h"
unsigned int shifter, portd_index;
unsigned int16 digit, number;
unsigned int portd_array[4];

#int_rtcc
void interrupt() {
// Turn off all 7seg displays
// bring appropriate value to PORTD
// turn on appropriate 7seg. display
// Décaler shifter vers le prochain digit

if (shifter > 8u)

shifter = 1;

// increment portd_index de 1
portd_index++ ;
if (portd_index > 3)
portd_index = 0; // turn on 1st, turn off 2nd 7seg.
set_timer0(0); // reset TIMER0 value
}
void main() {
// Set TMR0 in 8bit mode, assign prescaler to TMR0
// clear TMR0L
//configurer les ports d'E/S
digit = 0;
portd_index = 0;
shifter = 1;
number = 9981; // Initial number value
//Activer les interruptions
//Activer l’interruption sur débordement Timer0

While(1){
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)

ISTMT TP5 31
TP Architecture des systèmes à processeurs GBM3

number++ ; // increment number

if (number > 9999)
number = 0;

}
}

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

2) Compléter le programme précédent selon les commentaires indiqués.

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 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.2. Timer0 et interruption par débordement

T0CON est le registre associé au Timer0 (cf. annexe2). Dans le programme, il prend la
valeur 0xC4.
Convertissez cette valeur en binaire et la reporter dans le tableau de l’annexe2
1.
2.
Surligner les lignes valides en fonction des bits individuels
3.
En particulier, déterminez la valeur du prescaleur (prédiviseur) ?
Sachant que la fréquence d’entrée du préscaleur est de Fosc/4 (soit 8/4),
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 ?
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].

ISTMT TP5 32
TP Architecture des systèmes à processeurs GBM3

Annexe : Le Timer0 et le registre T0CON

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

bit7 bit6 bit5 bit4 bit3 bit2 Bit1 bit0

ISTMT TP5 33