TP4 : Utilisation de l’Interruption du
Timer0 avec PIC16F877
1. Introduction :
Le Timer0 est un composant clé des microcontrôleurs, utilisé pour générer des
interruptions à des intervalles réguliers. Ces interruptions servent à gérer des fonctions
de temporisation ou de contrôle périodique. Ce TP met en œuvre l’interruption du
Timer0 du PIC16F877 dans deux cas pratiques : faire clignoter une LED à une
fréquence fixe, et créer une horloge temps réel dont l’affichage se fait sur un écran
LCD.
2. Les Objectifs :
Les objectifs principaux de ce TP sont :
Savoir paramétrer le Timer0 pour produire des interruptions à des intervalles
constants.
Analyser le rôle du Timer0 et comprendre la configuration du registre de
contrôle OPTION_REG sur le PIC16F877.
Concevoir une routine d’interruption dédiée au traitement des signaux
générés par le Timer0.
Exploiter cette interruption pour piloter le clignotement d’une LED avec
une fréquence définie.
Utiliser le Timer0 comme référence temporelle afin de réaliser une horloge
affichant les millisecondes, secondes, minutes et heures sur un écran LCD.
Réaliser la conception et la simulation du montage à l’aide du logiciel
Proteus.
3. Matériels et Logiciels Utilisés :
Microcontrôleur : PIC16F877 (U1)
Composants électroniques :
o Diode Électroluminescente (LED)
o Afficheur LCD (LM016L ou équivalent)
o Résistance de limitation de courant pour la LED (R2)
o Résistance ajustable (RV2) pour le contraste de l'LCD
o Fils de connexion
o Oscillateur à quartz (X1) et condensateurs associés (C1, C2)
1
o Source d'alimentation (simulée)
Logiciel de Simulation : Proteus ISIS
Logiciel de Développement : Compilateur C pour PIC (tel que CCS C
Compiler).
4. Manipulation :
Deux projets indépendants ont été réalisés en s’appuyant sur l’interruption générée par le
Timer0.
Première Activité : Clignotement d'une LED via
l'Interruption du Timer0 :
Objectif :
Mettre en œuvre l’interruption du Timer0 pour commander le
clignotement d’une LED, en assurant un cycle d’environ 1 seconde :
500 ms allumée, suivie de 500 ms éteinte.
Schéma Réalisé :
Programme :
#include <16F877.h> // Inclusion du fichier en-tête pour le microcontrôleur PIC16F877
#use delay(clock=4M) // Définition de l’horloge système à 4 MHz
#fuses XT,NOWDT // Utilisation d’un oscillateur XT, désactivation du Watch dog Timer
#byte PORTC=0x07 // Adresse du port C
#bit LED=PORTC.0 // Définition du bit LED comme étant le bit 0 du port C (RC0)
#byte TRISC=0x87 // Registre de direction du port C (0 = sortie, 1 = entrée)
#byte INTCON=0x0B // Registre de contrôle des interruptions
2
#bit GIE=INTCON.7 // Bit d’activation globale des interruptions
#bit TOIE=INTCON.5 // Bit d’activation de l’interruption du Timer0
#byte OPTION_REG=0x81 // Registre de configuration du Timer0
#byte TMR0=0x01 // Registre du Timer0
int k=0; // Compteur d’interruptions pour temporiser le clignotement
#int_rtcc
void F_rtcc() {
TMR0 = 6; // Recharge le Timer0 à 6 pour ajuster la fréquence d’interruption
k++; // Incrémente le compteur à chaque interruption
if(k == 125) { // Si 125 interruptions ont eu lieu (~500ms)
k = 0; // Réinitialise le compteur
LED = !LED; }} // Inverse l’état de la LED (allumée <-> éteinte)
void main() {
TRISC = 0b00000000; // Configure tous les bits du port C comme sorties
LED = 0; // Initialise la LED à l’état éteint
option_reg = 0x03; // Configure le Timer0 :
// - Source d’horloge interne (bit T0CS = 0)
// - Prédiviseur 1:16 (bits PS2:PS0 = 011)
// ==> Fréquence d’interruption réduite
while(1) {
GIE = 1; // Active les interruptions globales
TOIE = 1; }} // Active les interruptions du Timer0
3
Explication de fonctionnement :
Le Timer0 est paramétré pour générer un débordement à des intervalles
constants. À chaque débordement, la routine d’interruption F_rtcc() est
exécutée. Un compteur nommé k est utilisé pour accumuler plusieurs
interruptions avant d’inverser l’état de la LED, permettant ainsi de prolonger la
durée entre deux changements. En ajustant le prédiviseur et la valeur initiale du
Timer0, on obtient une fréquence d’interruption adaptée, et l’utilisation du
compteur k permet de produire un clignotement proche de 1 Hz (500 ms allumé,
500 ms éteint).
4
Deuxième Activité : Affichage d'une Horloge (s:m:h) sur l'LCD :
Objectif :
Exploiter l’interruption du Timer0 comme référence temporelle pour
construire une horloge qui compte les secondes, les minutes et les heures,
et afficher l’heure en temps réel sur un écran LCD.
Schéma réalise :
Programme :
#include <16F877.h> // Inclusion du fichier d'en-tête du PIC16F877
#use delay(clock=4M) // Définition de la fréquence d’horloge à 4 MHz
#fuses XT,NOWDT // Oscillateur en mode XT, Watch dog Timer désactivé
// Déclaration des adresses et bits utiles pour la manipulation des registres
#byte PORTC=0x07 // Port C (sortie LED)
#bit LED=PORTC.0 // LED connectée à RC0
#byte TRISC=0x87 // Registre de direction du port C
#byte INTCON=0x0B // Registre des interruptions
#bit GIE=INTCON.7 // Bit d'autorisation globale des interruptions
#bit TOIE=INTCON.5 // Autorisation interruption Timer0
#byte OPTION_REG=0x081 // Registre d’option (configuration du Timer0)
#byte TMR0=0x01 // Registre Timer0 (compteur)
#include <LCD.c> // Inclusion de la bibliothèque LCD
5
// Déclarations des variables de temps
int s=0; // secondes
int m=0; // minutes
int h=0; // heures
int k=0; // compteur pour déterminer le passage du temps
#int_rtcc
void F_rtcc() {
TMR0 = 6; // Valeur de rechargement du Timer0 (pour ajuster le taux d’interruption)
k++; // Incrémente le compteur à chaque interruption
if(k==250) { // Lorsque 250 interruptions sont atteintes (~1 seconde)
k = 0;
s++; } // Incrémente les secondes
if(s == 60) { // Lorsque 60 secondes sont atteintes
m++; // Incrémente les minutes
s = 0;}
if(m == 60) { // Lorsque 60 minutes sont atteintes
h++; // Incrémente les heures
m = 0;
// Affiche l'heure courante sur le LCD en position (1,1)
Lcd_gotoxy(1,1);
printf(Lcd_putc, "%u:%u:%u", h, m, s);}
void main() {
TRISC = 0b00000000; // Configure tout le port C en sortie
LED = 0; // Initialise la LED à l’état bas
Lcd_init(); // Initialise l’afficheur LCD
option_reg = 0x03; // Configuration du prédiviseur de Timer0 (diviseur de fréquence)
while(1) {
GIE = 1; // Active les interruptions globales
TOIE = 1; }} // Active les interruptions du Timer0
6
Explication de fonctionnement :
Le Timer0 est configuré pour générer des interruptions périodiques. À chaque interruption, la routine
F_rtcc() est exécutée pour incrémenter les secondes. Lorsque le nombre de secondes atteint 60,
les minutes sont mises à jour, puis les heures selon le même principe. L'heure courante est ensuite
affichée sur l'écran LCD. Le pré diviseur et la valeur de rechargement (6) du Timer0 permettent de
régler la fréquence des interruptions, assurant ainsi une mesure temporelle précise pour simuler une
horloge en temps réel.
5. Conclusion :
Ce TP a montré comment utiliser efficacement l’interruption du Timer0 pour des fonctions de
temporisation. Une LED a été clignotée avec précision, et une horloge temps réel a été
implémentée et affichée sur un LCD. La configuration du registre OPTION_REG et la routine
d’interruption sont essentielles pour assurer un bon fonctionnement.
7
Elaboré par : BEN SLEMA TESNIM