Département GEII

Support de travaux pratiques

Automatisme et Informatique Industrielle
Classes : DUT2-AII

Enseignant : NYATTE STEYVE

Année universitaire :
 INTRODUCTION GENERALE

Les présentes notes constituent un support de travaux pratiques consacrés aux

architectures et systèmes 2 et destinés à des étudiants de deuxième année du
Parcours : Systèmes Embarqués et Mobiles (SEM) au Département Technologies
de l’Informatique.
Dans ce support, on propose les principales caractéristiques d'un microcontrôleur
de la famille pic de microchip (pic 16f877) et des outils de conception et de
simulation ( Proteus, mikroC ) via un ensemble de travaux pratiques.
Dans ce support, certaines figures sont directement tirées du document
constructeur à fin de familiariser les étudiants à leurs exploitation.
Ces manipulations pratiques occupent un semestre.
L’auteur remercie par avance tous les lecteurs qui lui fait part de leurs critiques
et de leurs remarques constructives.
 ELEME!T CO!STITUTIF (ECUE)
ATELIER ARCHITECTURES ET SYSTEMES 2
Volume horaire Coefficient Crédit
Cours TD TP
0 0 45 2 2

Plan :

Semaine TP
Prise en main de l’environnement du logiciel Proteus ISIS et
Séance 1 de compilateur MikroC PRO pour PIC.

Séance 2 Contrôle d’ un afficheur 7 Segments via le pic 16f877

Séance 3 Programmation d’un afficheur lcd 2*16 via un PIC 16F877.

Séance 4 Gestion d'un clavier matriciel via le pic 16f877.

Programmation du Conversion Analogique 3umérique (CA3,
Séance 5 ADC) du pic 16f877

Séance 6 Programmation d’une Communication Série du PIC.

Programmation de la modulation de largeur d’impulsion avec
Séance 7 le pic 16f877.

Séance 8 Gestion des interruptions via le pic 16f877

Pré-requis :
• Systèmes Microprocesseurs, Systèmes logiques, Architecture des Ordinateurs

Objectifs Spécifiques:

• Comprendre l’architecture logicielle d’un microcontrôleur.

• Apprendre à configurer et programmation un PIA pour la lecture et la commande des
périphériques

Moyens et Outils Pédagogiques

• Fascicule de travaux pratiques
• Logiciel porteuse
• Documentation constructeur.

Evaluations :
• Le mode de contrôle continue : chaque TP est noté.
• La note personnalisée (NP) : sur la présence, la réalisation des exercices à la maison.
• Note sur les compte rendu du TP.
 Département GEII
TP 31 : Prise en main de l’environnement du logiciel Proteus ISIS et de
compilateur MikroC PRO pour PIC.
Classes : DUT- GEII
ECUE: MICROCONTROLEUR Enseignant :STEYVE NYATTE.

Objectif : se familiariser avec l’environnement du logiciel Proteus et de

compilateur MikroC PRO pour programmer un PIC.

1- PROTEUS
Le «Proteus» est une suite de logicielle
permettant la CAO électronique éditée par
la société Labcenter Electronics. Proteus
est composé de deux logiciels principaux :
ISIS, qui est un très bon logiciel de
simulation en électronique. Il est un
éditeur de schémas qui intègre un
simulateur analogique, logique ou mixte.
ARES, dédié à la création de circuits
imprimés. Grâce à des modules
additionnels, ISIS est également capable
de simuler le comportement d'un
microcontrôleur (PIC, Atmel, 8051,
ARM, HC11...) et son interaction avec les
composants qui l'entourent.

1.1. INTERFACE UTILISATEUR

Fenêtre d’ensemble Fenêtre d’édition Barre de menu

Boite à outils

Sélecteur
d’objet

Zone de messages
Commande de simulation animée Coordonnées du curseur
2- MikroC PRO :
 Le « mikroC PRO » est un compilateur
pour PIC Conçu par la société «
Mikroelektronika », le compilateur C nouvelle
génération "MikroC PRO" pour
microcontrôleurs PIC bénéficie d'une prise en
main très facile. Il comporte plusieurs outils
intégrés (mode simulateur, terminal de
communication, gestionnaire 7 segments,...). Il a
une capacité à pouvoir gérer la plupart des
périphériques rencontrés dans l'industrie (Bus
I2C, 1Wire, SPI, RS485, Bus CAN, cartes
compact Flash, signaux PWM, afficheurs LCD
et 7 segments...), de ce fait il est un des outils de
développement incontournable et puissant.
Il contient un large ensemble de bibliothèques de
matériel, de composant et la documentation
complète.

2.1. Création d’un nouveau projet

Avec mikroC PRO, on crée un nouveau projet ( Project --> New Projet ) , on choisi le pic16f877 et un
quartz de 20Mhz.

On Saisit ensuite le programme puis on le compile :

!ote :
La simulation permet d'ajuster et de modifier le circuit comme si on manipulait un montage
réel. Ceci permet d'accélérer le prototypage et de réduire son coût.
Il faut toujours prendre en considération que les résultats obtenus de la simulation sont un peu
différents de celles du monde réel.

3. Travail demandé :
3.1. Installer Proteus et mikroC PRO.
3.2. Lancer ISIS et le Compilateur mikroC PRO.
3.3. Réaliser le circuit de test ci-dessous sous ISIS :

U1 D1
X1 R1
13 33
OSC1/CLKIN RB0/INT
14 34
1
OSC2/CLKOUT RB1
35
470 D2
VDD MCLR/Vpp/THV RB2
36
R2
20MHz RB3/PGM
2 37
RA0/AN0 RB4 470 D3
C1 C2 3
RA1/AN1 RB5
38 R3
33pF 33pF 4 39
RA2/AN2/VREF- RB6/PGC
5 40
6
RA3/AN3/VREF+ RB7/PGD 470 D4
7
RA4/T0CKI
15
R4
RA5/AN4/SS RC0/T1OSO/T1CKI
16
RC1/T1OSI/CCP2 470
8 17
RE0/AN5/RD RC2/CCP1
9 18
RE1/AN6/WR RC3/SCK/SCL
10 23
RE2/AN7/CS RC4/SDI/SDA
24
RC5/SDO
25
RC6/TX/CK
26
RC7/RX/DT
19
RD0/PSP0
20
RD1/PSP1
21
RD2/PSP2
22
RD3/PSP3
27
RD4/PSP4
28
RD5/PSP5
29
RD6/PSP6
30
RD7/PSP7
PIC16F877

3.4. Ouvrir un nouveau projet sous mikroC PRO, écrire le programme ci-dessous :
void main() {
trisb= 0b11110000 ; // direction du port b (1 : Entrée, 0 : Sortie)
while(1) // boucle infinie
{
portb = 0b00001111 ; //les 4 leds allumées
}
}
Après compilation et s'il n' y a pas d'erreurs le fichier TP1.hex est créé
Dans ISIS, on double clique sur le microcontrôleur et on spécifie le fichier TP1 .hex
qui se trouve dans le dossier TP puis OK.
Par la suite lancer la simulation ( le bouton play du panneau de contrôle de
l'animation) , les 4 leds seront allumées.
3.5. refaire 3.4. pour allumer 4 autres leds liées au port c du pic.
Maintenant on va transformer notre programme pour que les leds clignoteront .
3.6. refaire 3.4. pour le programme suivant :
void main() {
trisb= 0b11110000 ;
while(1)
{
portb = 0b11110000 ;
delay_ms(200) ;
portb = 0b11110001 ;
delay_ms(200) ;
portb= 0b11110010 ;
delay_ms(200) ;
portb = 0b11110100 ;
delay_ms(200) ;
portb = 0b11111000 ;
delay_ms(200) ;
}
}
3.7. Dans notre exemple on a allumé les leds on agissant sur le port en entier on peut
accéder individuellement à chaque bit en utilisant les identifiants
F0, ..., F7, c.-à-d. pour allumer la première led, on écrit Portb.F0 = 1.

void main() {
trisb= 0b11110000 ;
// 1 1 1 1 0 0 0 0
while(1)
{
portb = 0b11110000 ;
delay_ms(200) ;
portb.f0 = 1 ;
delay_ms(200) ;
portb.f0 =0 ;
portb.f1 = 1 ;
delay_ms(200) ;
portb.f1 = 0 ;
portb.f2 = 1 ;
delay_ms(200) ;
portb.f2 = 0 ;
portb.f3 = 1 ;
delay_ms(200) ;
}
}

3.8. Ecrire un programme qui permet de faire clignoter les diodes paires pendant une
seconde et les diodes impaires pendant une seconde en le testant avec ISIS.

.
TP 32 : Contrôle d’ un afficheur 7 Segments via le pic 16f877.

ECUE: MICROCONTROLEUR

Objectif : Dans cette expérience on va apprendre à contrôler un afficheur 7 segments.

1. Introduction :

il existe deux types d'afficheur, anode commune AC et cathode commune CC (

noter le sens des diodes et l'alimentation des afficheurs ).
Pour les AC les diodes sont allumés par la présence d'un
état 1 et pour les CC par un état 0. Donc pour afficher un
chiffre on doit présenter sur les broches du circuit le
code 7 segments correspondant

MikroC PRO vous permet de former ce code et ce en allant dans le menu: Tools --->
Seven Segment Editor
2. Travail demandé :

2.1. Lancer ISIS et le Compilateur mikroC PRO.

2.2. Réaliser un circuit sous ISIS liant le port b du PIC 16F877 avec un afficheur 7
segments (AC) via un buffer (UL+2803).

2.3. Ecrire le programme suivant sur mikroC PRO en commentant chaque ligne :

void main() {
trisb= 0b10000000 ;
while(1)
{
portb =0xB0 ;
delay_ms (1000) ;
portb = 0x99;
delay_ms(1000) ;
}
}

2.4. Expliquer le code portb =0xB0 et portb = 0x99.

2.5. Compiler et implémenter le fichier .hex disponible dans le PIC16F877 sous ISIS.

2.6. Jusqu’à présent on n' a pas utilisé les port en entrée, dans l'exemple suivant on va
utiliser deux boutons poussoirs bp1 et bp2 (qui seront liés aux broches 6 et 7 du port c).
Lorsqu’ on appui sur bp1 ou sur bp2 on affiche successivement 3 ou 4.

void main() {
PORTB =00 ;
TRISB = 0 ;
PORTC = 0 ;
TRISC = 0xC0;
while(1)
{ if ( portc.f6 == 0 )
portb = 0x4f ;
else if (portc.f7 == 0 )
portb = 0x66;
else portb = 0x3f;
}
}
 2.7. Compléter le programme ci-dessous qui permet d'afficher de 0 à 9 à une cadence
de 500ms. En déclarant un tableau tab[10] contenant les 10 codes 7 segments des
chiffres de 0 à 9 et avec une structure for repérer dans la table le code à envoyer sur le
port b tous les 500 ms.

int i ;
char tab[10] = { …,… }
void main()
{…
while(1) {
for ( … )
{ portb = tab[i] ;
… ;}}}

2.8. Ecrire un programme qui permet d’incrémenter le chiffre affiché en appuyant sur
un bouton poussoir

2.9. Ecrire un programme qui contrôle trois afficheurs, et ce en utilisant le phénomène

de la persistance rétinienne , on dispose de trois afficheurs branchés sur le même bus
du port b, puis on les sélectionne à tour de rôle à l'aide de trois transistors de
commutation qui seront liés au port d. Si la sélection se fait assez rapidement, l’œil a
l'impression que tous les afficheurs fonctionnent simultanément et affichent un nombre
choisi par exemple : 434.
33
OSC1/CLKIN RB0/INT
34
OSC2/CLKOUT RB1
35
RB2
36
RB3/PGM
37
RB4
38
RA2/AN2/VREF-/CVREF RB5
39
RA3/AN3/VREF+ RB6/PGC
40
RA4/T0CKI/C1OUT RB7/PGD
RA5/AN4/SS/C2OUT
15
RC0/T1OSO/T1CKI
16
RE0/AN5/RD RC1/T1OSI/CCP2
17
RE1/AN6/WR RC2/CCP1
18
RE2/AN7/CS RC3/SCK/SCL
23
RC4/SDI/SDA
24
MCLR/Vpp/THV RC5/SDO
25
RC6/TX/CK
26
RC7/RX/DT
19
RD0/PSP0
20
RD1/PSP1
21
RD2/PSP2
22
RD3/PSP3
27
RD4/PSP4
RD5/PSP5
28 R1 Q1 R2 Q2 R3 Q3
29 BC548 BC548 BC548
RD6/PSP6
30 10K 10K 10K
RD7/PSP7
TP 33 : Programmation d’un afficheur LCD 2*16 via un PIC 16F877.

Objectif : Cette manipulation a pour objectif de programmer un afficheur LCD 2* 16

via le pic 16f877.

1. Introduction :
Ce composant est spécialement fabriqué pour être
utilise avec des microcontrôleurs, ce qui signifie qu'il
ne peut pas être activé par des circuits standards. Il est
utilisé pour afficher différents messages. Il peut
afficher des messages sur deux ligne de 16 caractères
chacune. Le modèle décrit ici est le plus fréquemment utilisé dans la pratique en
utilisant le brochage suivant :

1. Masse (Vss)
2. Alimentation (VCC (5V))
3. Ajustement du contraste (utiliser un potentiomètre pour varier le contraste)
4. Sélection du registre (RS), 0 = écriture de commande, 1 = écriture de donnée
5. Read/Write (R/W), 0 = écriture (de PIC vers LCD), 1 = lecture (de LCD vers PIC)
6. Enable (EN) - utilisé pour cadencer les données
7. DB0 (n’est pas utilisé pour le mode 4-bit) - LSb
8. DB1 (n’est pas utilisé pour le mode 4-bit)
9. DB2 (n’est pas utilisé pour le mode 4-bit)
10. DB3 (n’est pas utilisé pour le mode 4-bit)
11. DB4 - LSb pour le mode 4-bit
12. DB5
13. DB6
14. DB7 - MSb
15. rétroéclairage + (5V)
16. rétroéclairage - (GND)
Toutes les données transférées à un écran LCD à travers les broches D0-D7 seront
interprétées comme une commande ou une donnée, qui dépend de l'état logique de la
broche RS.

Le compilateur MikroC PRO utilise des fonctions (bibliothèques) pour simplifier la

programmation de l’écran LCD aux utilisateurs.

Dans les versions précédentes, les compilateurs utilisent la fonction Lcd_Config qui
associe le port au broches du LCD (RS, EN, WR, D7......D4), par exemple
Lcd_Config(&PORTD, 0, 1, 5, 7, 3, 2, 4, 6)
Cependant, les nouvelles versions à savoir mikroC PRO (et les versions supérieures)
n’utilise pas cette fonction. On emploi l'instruction sbit pour attribuer chaque broche du
LCD à une broche du pic, C-A-D:
Association des broches du LCD au port b du pic définition du sens

sbit LCD_RS at RB4_bit; sbit LCD_RS_Direction at TRISB4_bit;

sbit LCD_EN at RB5_bit; sbit LCD_EN_Direction at TRISB5_bit;

sbit LCD_D7 at RB3_bit; sbit LCD_D7_Direction at TRISB3_bit;

sbit LCD_D6 at RB2_bit; sbit LCD_D6_Direction at TRISB2_bit;

sbit LCD_D5 at RB1_bit; sbit LCD_D5_Direction at TRISB1_bit;

sbit LCD_D4 at RB0_bit; sbit LCD_D4_Direction at TRISB0_bit;

Aussi, d’autres fonctions peuvent être utilisées à savoir :

Lcd_Out affiche un texte à la position spécifiée, exemple Lcd_Out (1, 1, ''TP1")

Lcd_Out_Cp affiche un texte à la position courante, exemple Lcd_Out (1, 1, ''ici")
Lcd_Chr affiche un caractère à la position spécifiée, exemple Lcd_Chr (1, 3, ''T")
Lcd_Cmd envoi une commande à LCD, exemple Lcd_Cmd(_LCD_CLEAR);

2. Travail demandé :
2.1. Lancer ISIS et le Compilateur mikroC PRO.
2.2. Réaliser le schéma et le programme ci-dessous:
LCD1
LM016L
D
VSS

VEE

W
VD

7
R

D
E
1

10

11

12

13

14
U1
13 33
OSC1/CLKIN RB0/INT
14 34
OSC2/CLKOUT RB1
1 35
MCLR/Vpp/THV RB2
36
RB3/PGM
2 37
RA0/AN0 RB4
3 38
RA1/AN1 RB5
4 39
RA2/AN2/VREF- RB6/PGC
5 40
RA3/AN3/VREF+ RB7/PGD
6
RA4/T0CKI
7 15
RA5/AN4/SS RC0/T1OSO/T1CKI
16
RC1/T1OSI/CCP2
8 17
RE0/AN5/RD RC2/CCP1
9 18
RE1/AN6/W R RC3/SCK/SCL
10 23
RE2/AN7/CS RC4/SDI/SDA
24
RC5/SDO
25
RC6/TX/CK
26
RC7/RX/DT
19
RD0/PSP0
20
RD1/PSP1
21
RD2/PSP2
22
RD3/PSP3
27
RD4/PSP4
28
RD5/PSP5
29
RD6/PSP6
30
RD7/PSP7
PIC16F877
 // les connections du module LCD
sbit LCD_RS at RB4_bit;
sbit LCD_E! at RB5_bit;
sbit LCD_D4 at RB0_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D7 at RB3_bit;
//les directions
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_E!_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;
// fin des connections du module LCD
void main(){
Lcd_Init(); // initialisation du LCD
Lcd_Cmd(_LCD_CLEAR); // effacer l’écran
Lcd_Out(1, 1, "TP:arch.et sys.2");
Lcd_Out(2, 1, "Par:SAADAOUI AK");
//Lcd_Out_Cp("Here!");
Lcd_Cmd(_LCD_CURSOR_OFF); // éliminer le curseur
}

2.3. Refaire 2.2. en liant le LCD avec le port D du pic 16f877.

 TP 34 : Gestion d'un clavier matriciel via le pic 16f877.

Classes : MECATRONIQUE
ECUE: ATELIER ARCHITECTURES ET SYSTEMES 2 Enseignant : STEYVE NYATTE.

Objectif : Cette manipulation a pour objectif de gérer un clavier matriciel via le pic
16f877.

Introduction :
Un clavier matriciel est composé de lignes ( L1 L2 L3 L4) et de colonnes ( C1 C2 C3), à
l'appui sur une touche une connexion entre une ligne et une colonne est établi, exemple si
on appui sur 2, L1 et C2 seront interconnectées
Le rôle du pic est de balayer les lignes et les colonnes en envoyant des codes appropriés
contenus dans un tableau, pour déterminer la touche appuyée sur un écran LCD.

2. Travail demandé :
2.1. Lancer ISIS et le Compilateur mikroC PRO.
2.2. Réaliser le schéma et le programme ci-dessous:

LCD1
LM016L
VDD
VSS

VEE

W
RS

D0
D1
D2
D3
D4
D5
D6
D7
R
E
1
2
3

4
5
6

7
8
9
10
11
12
13
14

33
OSC1/CLKIN RB0/INT
34
OSC2/CLKOUT RB1
35
RB2
36
RB3/PGM
37
RB4
38
RA2/AN2/VREF-/CVREF RB5
39
RA3/AN3/VREF+ RB6/PGC
40
RA4/T0CKI/C1OUT RB7/PGD
RA5/AN4/SS/C2OUT
15
RC0/T1OSO/T1CKI
16
RE0/AN5/RD RC1/T1OSI/CCP2
17
RE1/AN6/W R RC2/CCP1
18
RC3/SCK/SCL
23
RC4/SDI/SDA
24
MCLR/Vpp/THV RC5/SDO
25
RC6/TX/CK
26
RC7/RX/DT
1

19
RD0/PSP0
20
RD1/PSP1
21
RD2/PSP2
RD3/PSP3
22
A 1 2 3
27
RD4/PSP4
28
RD5/PSP5
29
RD6/PSP6
RD7/PSP7
30
B 4 5 6
C 7 8 9
D 0 #
 // connexions du module Keypad
char keypadPort at PORTC;
// connexions du module LCD
sbit LCD_RS at RB1_bit;
sbit LCD_E! at RB0_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_RS_Direction at TRISB1_bit;
sbit LCD_E!_Direction at TRISB0_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;

void main()
{
unsigned short kp = 0;
Keypad_Init(); // Initialisation du Keypad
Lcd_Init(); // Initialisation du Lcd
Lcd_Cmd(_LCD_CLEAR); // effacement de l’écran
Lcd_Cmd(_LCD_CURSOR_OFF); // Cursor off
Lcd_Out(1, 1, "Key :"); // écrire un message dans Lcd
do
{
kp = 0; // Reset la variable
// attendre que le bouton soit pressé et relâché
do
kp = Keypad_Key_Click(); // sauvegarder le code
while (!kp);
// transformation du code en valeur ASCII
switch (kp)
{
case 1: kp = 49; break; // 1
case 2: kp = 50; break; // 2
case 3: kp = 51; break; // 3
case 4: kp = 52; break; // 4
case 5: kp = 53; break; // 5
case 6: kp = 54; break; // 6
case 7: kp = 55; break; // 7
case 8: kp = 56; break; // 8
case 9: kp = 57; break; // 9
case 10: kp = 42; break; // *
case 11: kp = 48; break; // 0
case 12: kp = 35; break; // #
}
Lcd_Chr(1, 10, kp); // affichage de la valeur ASCII en Lcd
} while (1);
}
2.3. Refaire 2.2. avec un keypad 4x4, on vous demande d’écrire un programme pour
afficher la touche appuyée simultanément sur un LCD, un afficheur 7segments et 4diodes
leds (la valeur binaire de la touche appuyée).

A 7 8 9
B 4 5 6
C 1 2 3
D
ON
C 0 = +

4
 Département Technologies de l’Informatique
TP 35 : Programmation du Conversion Analogique 3umérique (CA3, ADC) du pic
16f877.
Classes : L2- SEM
ECUE: ATELIER ARCHITECTURES ET SYSTEMES 2 Enseignant : SAADAOUI AK.

Objectif : Cette manipulation a pour objectif de programmer le module CAN (Conversion

Analogique numérique) du pic 16f877. (Le signal à convertir peut être une tension d'un
capteur qui sera simulé par un potentiomètre.)

1. Introduction :
La conversion A/N consiste à lire une tension sur les entrées analogiques du pic et la
convertir en nombre entier situé entre 0 et 1023 (10 bits), les valeurs 0 et 1023
correspondent aux tensions de référence Vref+ et Vref-.

Le module CAN du pic 16f877 demande une configuration particulière:

• configuration de la broche analogique en liant le potentiomètre à l’entrée du port

A, (par exemple : TRISA.F0 = 1, (RA0/AN0 ))

• configuration des registres : ADCON0 et ADCON1 du pic 16f877.

le résultat de la conversion 10 bits est stocké dans les registres ADRESH et ADRESL
qu'on ne va pas utiliser car MikroC PRO a une fonction Adc_Read(0) qui nous retourne
directement le résultat.

2. Travail demandé :

2.1. Lancer ISIS et le Compilateur mikroC PRO.

2.2. Réaliser un circuit sous ISIS liant le port b du pic 16f877 avec 8 leds et un
potentiomètre à l’entrée du port A.

2.3. Ecrire le programme suivant sur mikroC PRO en commentant chaque ligne :

SAADAOUI Abdelkader
 unsigned long int val;
void main() {
PORTB = 0;
TRISB = 0 ;
TRISA =0X01 ;
ADCO!0 = 0 ;
ADCO!1 = 0x8E ;
while(1) {
Delay_us(20);
val = Adc_Read(0);
val = val/4
portb = val ;
}}

2.4. Ecrire un programme qui affiche la tension qui est sur le curseur du potentiomètre en
utilisant trois afficheurs 7segments sélectionnés par trois transistors de commutation.
Sachant que 5 V correspond à1024 on a besoin d'afficher 5,00 v

SAADAOUI Abdelkader
 Département Technologies de l’Informatique

TP 36 : Programmation d’une Communication Série du PIC.

Classes : L2- SEM

ECUE: ATELIER ARCHITECTURES ET SYSTEMES 2 Enseignant : SAADAOUI AK.

Objectif : Cette manipulation a pour objectif de programmer la Communication Série du

pic 16f877.

1. Introduction :
Dans une Communication Série, les données sont transmises en série bit après bit
les octets sont entourés de bits de start et bits de stop.
Avec la norme RS232, on a la possibilité de rajouter un bit de parité et un deuxième bit de
stop.
On peut facilement envoyer ou recevoir des données avec le pic 16f877, il suffit d'utiliser
les fonctions fournies par MikroC PRO:

Usart _init : choix du débit

Usart_Data_ready : vérifie si la donnée est reçue
Usart_Read : lecture de la donnée
Usart_Write : envoi de la donnée

Notre programme consiste à envoyer au terminal les textes : bas, haut, droit, gauche. selon
le bouton sélectionné

2. Travail demandé :

2.1. Lancer ISIS et le Compilateur mikroC PRO.

2.2. Réaliser un circuit sous ISIS liant le port d du pic 16f877 avec 4 boutons poussoirs.

2.3. Ecrire le programme suivant sur mikroC PRO:

SAADAOUI Abdelkader
int derect ;
int i ;
char mesG[] = {'g','a','u','c','h','e'} ;
char mesD[] = {'d','r','o','i','t','e'} ;
char mesH[] = {'h','a','u','t' } ;
char mesB[] = {'b','a','s'} ;
void main() {
TRISc = 0x00;
TRISD = 0xf0; // PORTC en entrée
Usart_init(9600);

while(1) {
derect = (PORTD & 0b11110000 ) ; // masquer
les bit non utilisés
switch (derect)
{ case 0b01110000 :
for (i=0 ;i<6 ;i++ )
Usart_Write(mesG[i]);
Usart_Write(13); //retour a la ligne
break ;
case 0b10110000 :
for (i=0 ;i<4 ;i++ )
Usart_Write(mesH[i]);

Usart_Write(13);
break ;
case 0b11010000:
for (i=0 ;i<3 ;i++ )
Usart_Write(mesB[i]);
Usart_Write(13);
break ;
case 0b011100000:
for (i=0 ;i<6 ;i++ )
Usart_Write(mesD[i]);
Usart_Write(13);
break ;
} delay_ms(200) ; //attente relachement
bouton
}}

2.4. Ecrire le programme suivant sur mikroC PRO en rajoutant à l'expérience précédente
quatre Leds qui indiquent le sens ( haut, bas, droite, gauche ) où chaque Led s'allume en
appuyant sur le bouton correspondant.

SAADAOUI Abdelkader
 Département Technologies de l’Informatique
TP 37 : Programmation de la modulation de largeur d’impulsion avec le pic
16f877.
Classes : L2- SEM
ECUE: ATELIER ARCHITECTURES ET SYSTEMES 2 Enseignant : SAADAOUI AK.

Objectif : Cette manipulation a pour objectif de programmer une modulation de largeur

d’impulsion via le pic 16f877.

1. Introduction :

PWM ou MLI (Pulse Width Modulation ) est un signal dont le rapport cyclique varie.

PWM est utilisé dans plusieurs applications (La commande des servomoteur, La variation
de vitesse des moteurs, La conversion numérique analogique).

Le PIC utilise le module CCP Capture/Compare/PWM en mode PWM la broche RC1

doit être configuré en sortie, la valeur de la période est chargé Dans le registre PR2 et la
valeur du rapport cyclique dans le registre CCPRL.
Le TIMER2 compte l'horloge interne après une pré division programmable par 1.4 ou 16
Quand Timer2 atteint la valeur dans PR2 : Timer2 passe a zéro, la broche PWM est mise
a1
Quant Timer2 atteint la valeur dans CCPR1L la sortie PWM est mise 0

PÉRIODE = (PR2+1) X Tosc X 4 X valeur du pré diviseur

DURÉE = CCPR1L X Tosc X valeur du pré diviseur

Tosc = 1/ fréquence horloge

pour générer le signal PWM on peut utiliser ce principe qui agit directement sur les
registres
ou peut utiliser les fonctions fournis par MikroC PRO :

SAADAOUI Abdelkader
Pwm_init(freq) :choix de la fréquence en Hz
PWM_change_duty(durée) : choix du rapport cyclique ( valeur entre 0 pour 0% et 255
pour 100% )
PWM_start () : démarrage du module PWM
Pmw_stop() : arrêt du module PWM

Notre programme consiste à générer un signal PWM de fréquence 2 Khz et dont le

rapport cyclique varie continuellement

U1 D1
X1 R1
13 33
OSC1/CLKIN RB0/INT
14 34
1
OSC2/CLKOUT RB1
35
470 D2
VDD MCLR/Vpp/THV RB2
36
R2
20MHz RB3/PGM
2 37
RA0/AN0 RB4 470 D3
C1 C2 3
RA1/AN1 RB5
38 R3
33pF 33pF 4 39
RA2/AN2/VREF- RB6/PGC
5 40
6
RA3/AN3/VREF+ RB7/PGD 470 D4
7
RA4/T0CKI
15
R4
RA5/AN4/SS RC0/T1OSO/T1CKI
16
RC1/T1OSI/CCP2 470
8 17
RE0/AN5/RD RC2/CCP1
9 18
RE1/AN6/WR RC3/SCK/SCL
10 23
RE2/AN7/CS RC4/SDI/SDA
24
RC5/SDO
25
RC6/TX/CK
26
RC7/RX/DT
19
RD0/PSP0
20
RD1/PSP1
21
RD2/PSP2
22
RD3/PSP3
27
RD4/PSP4
28
RD5/PSP5
29
RD6/PSP6
30
RD7/PSP7
PIC16F877

2. Travail demandé :

2.1. Lancer ISIS et le Compilateur mikroC PRO.

2.2. Réaliser le circuit ci-dessus sous ISIS..

2.3. Ecrire le programme suivant sur mikroC PRO:

SAADAOUI Abdelkader
 char i ;
void main() {

TRISB = 0; // PORTB en sortie

TRISC = 0; / PORTC en sortie

Pwm_Init(2000); // Initialise PWM a 2 Khz
i =0 ;
while (1)
{
Pwm_Start(); // Demarre PWM
i= i+10 ; // incrémentation par 10 du rapport cyclique
Pwm_Change_Duty(i); // changer le rapport cyclique

// ou PWM1_Set_Duty (i) ;

portb = i ; // on affiche la valeur sur le portb

delay_ms(1000) ; //on attend 1 sec
} }

2.4. Refaire 2.3. pour commander la variation de vitesse d’un moteur à courant continu.

SAADAOUI Abdelkader
 Département Technologies de l’Informatique

TP 38 : Gestion des interruptions via le pic 16f877

Classes : L2- SEM

ECUE: ATELIER ARCHITECTURES ET SYSTEMES 2 Enseignant : SAADAOUI AK.
Objectif : Cette manipulation a pour objectif de gérer Les interruptions via le pic 16f877.

1- Introduction :
le pic 16f877 possède 14 sources d'interruption qui peuvent être déclenché suite à un
événement matériel ou logiciel.
Dés l’apparition de l’événement le programme principale est suspendu et le contexte est
sauvegardé et le pic se branche à une routine particulière à la source d'interruption, à sa
sortie le pic reprend l'exécution du programme principale en restaurant le contexte
sauvegardé.

Pour gérer ce processus , il faut : activer dans le programme la ou les sources

d’interruption, et écrire une routine d’interruption appropriée.
Le contrôle des interruptions se fait grâce aux registres INTCON, PIE1, PIR1, PIE2,
PIR2. Le registre INTCON regroupe les bits de validation (= enable bit) et de
signalisation (= flag ou drapeau) des interruptions« de base ». Les interruptions des
modules périphériques sont gérées par les registres PIE et PIR. Sur le PIC 16F877
on a deux PIE et deux PIR, étant donné le nombre important de sources
d’interruptions possibles.

2. Travail demandé :

2.1. Lancer ISIS et le Compilateur mikroC PRO.

2.2. Réaliser le circuit ci-dessus sous ISIS :

SAADAOUI Abdelkader
 D8
R2
470
LED-GREEN

D1
U1 R3
13 33
OSC1/CLKIN RB0/INT 470
14 34 LED-GREEN
OSC2/CLKOUT RB1
35
RB2
2 36
RA0/AN0 RB3/PGM D2
3
RA1/AN1 RB4
37 R1 R4
4 38 10k
RA2/AN2/VREF-/CVREF RB5
5 39
RA3/AN3/VREF+ RB6/PGC 470
6 40 LED-GREEN
RA4/T0CKI/C1OUT RB7/PGD
7
RA5/AN4/SS/C2OUT
15
8
RC0/T1OSO/T1CKI
16 D3
9
RE0/AN5/RD RC1/T1OSI/CCP2
17
R5
RE1/AN6/WR RC2/CCP1
10 18
RE2/AN7/CS RC3/SCK/SCL 470
23 LED-GREEN
RC4/SDI/SDA
VDD1 24
MCLR/Vpp/THV RC5/SDO
25
RC6/TX/CK
26 D4
RC7/RX/DT R6
19 470
RD0/PSP0
20 LED-GREEN
RD1/PSP1
21
RD2/PSP2
22
RD3/PSP3
27
D5
RD4/PSP4 R7
28
RD5/PSP5
29
RD6/PSP6 470
30 LED-GREEN
RD7/PSP7
PIC16F877A
D6
R8
470
LED-GREEN

D7
R9
470
LED-GREEN

2.3. Ecrire un programme sur mikroC PRO, où, dans cette expérience on va utiliser une
interruption matériel générer par l'entrée RB0/INT, si un événement indésirable ou
dangereux survient qu'on va matérialiser par un bouton poussoir le processus s'arrête et
affichage sur port D, sachant que la routine d'interruption à mettre avant main ( ) est :

void Interrupt( ) {

if (INTCON.INTF) { // SI INTF =1
portc.f2 = 0; // Led off

portd = 0xAE ; // affichage sur port D

while (1)
{ asm { NOP ; } // boucle infini
}

Alors que l’initialisation à mettre dans main( ) est :

// setup interrupts

INTCON.INTE = 1; // interruption sur INT0 active

INTCON.INTF = 0; // drapeau à 0
INTCON.GIE = 1; // interruption générale GIE active

SAADAOUI Abdelkader

View publication stats