LES MICROCONTRÔLEURS

Chapitre N°3
Mise en œuvre d’une application à base
d’un microcontrôleur

Objectifs à atteindre :
 Rappeler les structures algorithmiques fondamentales
 Réaliser des applications à base des microcontrôleurs
 Elaborer un programme spécifique à une application à base de microcontrôleur.

1 Parcours à suivre pour la mise en œuvre d’une application à base de microcontrôleur :

La résolution et la conception par la méthode graphique des problèmes en logiques

combinatoires, séquentielle ou système embarqué dont la commande met en œuvre des structures
microprogrammes à base de microcontrôleurs, nécessite le passage par les étapes suivantes,
quelques soit le type et la famille de microcontrôleur.

Organigramme
Assembleur et
Algorithme Simulateur
CDCF
compilateur
GRAFCET
4
1 2 3 C

Analyse du Programmation Test Code Objet

Transcription
système
5

Transfert

Le schéma synoptique ci-dessous comprend trois phases distinctes.

(1) Le développement matériel : s'appuie sur un cahier des charges, c.à.d. la définition des
fonctionnalités et des performances du système. Cette phase doit permettre de spécifier les
caractéristiques du microcontrôleur, de ses périphériques et de l'électronique associée.
(2) Le développement logiciel : s'appuie sur la phase précédente pour construire un
algorigramme, puis le code qui va être testé. Cette phase requiert que vous choisissiez le langage

24
(assembleur et/ou évolué) que nous utiliserons sur des bases objectives, par exemple de manière
à optimiser le temps de développement, la facilité de maintenance, le nombre d'opérations, etc.
(3) La phase de test doit être menée pour vérifier que le cahier des charges initial est bien
rempli. Cette phase de test « finale » n'empêche pas d'avoir mené des tests séparés lors des
phases de développement matériel et logiciel.

2 Langage C : MikroC
2.1 Filière de développement :

On désigne par filière de développement figure N°1 l’ensemble des outils qui rendre en œuvre
pour passer du fichier texte (source codé en C) au code objet (code machine) téléchargé dans le
microcontrôleur.

Figure N°1 : Schéma synoptique de

la filière de développement

Le tableau suivant présente les différentes extensions générées par la filière de développement

Fichiers Description du contenu du Fichiers Description du contenu

(Extensions) fichier (Extensions) du fichier
Fichier source en langage C. Code objet (exécutable)
.C .HEX
téléchargé dans le μC
Entête de définition des broches, Montre l’organisation du
.H Registres, Bits de Registres, .TRE programme sous forme
Fonctions, et directives de pré- d’arbre (découpages en

25
 compilation. fonction) et l’utilisation de la
mémoire pour chaque
fonction.
Fichier de projet (pas obligatoire). Code machine plus
.PJT .COF
Informations de débogage
Fichier qui montre chaque ligne Erreurs éventuelles
.LST du code C et son code assembleur .ERR rencontrées durant la
associé généré compilation.
Indique la correspondance entre le Fichier statistique sur
nom des symboles (variables, bits, l’espace mémoire occupé.
.SYM registres) et .STA etc.
leur adresse hexadécimale en
mémoire.
.ASM Fichier en langage assembleur.

2.2 Les variables :

Il existe différents types de variables reconnus par le compilateur du MikroC: Par défaut, tous
ces types de données sont non signés, ils peuvent être signé en rajoutant le mot clé signed devant
le type.

Type Description taille domaine signé domaine non

signé
bit Défini un nombre de 1 bit 1 bit X 0 ou 1
sbit Défini un nombre de 1 bit 1 bit X 0 ou 1
int Défini un nombre de 16 16 bits -32768 à + 32767 0 à 65535
bits
long (int) Défini un nombre de 32 bits [ -2 147 483 648 à 0 à 4 294 967 295
32bits 2 147 483 647]
char un caractère (codé en 8 bits 128 à + 127 0 à 255
interne comme un octet)
float Nombre à virgule (réel) 32 bits -1.5 * 1045 .. +3.4 X
38
sur 32 bits * 10
short (int) Défini un nombre de 8 bits 8 bits 128 à + 127 0 à 255
void type non spécifié

26
2.3 Les opérateurs du langage C : MikroC

Lors de son exécution, un programme est amené à effectuer des opérations qui peuvent être
purement arithmétiques, de comparaison, d’affectation, etc…
Type Description
Type Symbole Exemple
Opérateur d’affectation
Affectation = x=11 ; y=a+b
Opérateurs arithmétiques
addition + a = a+b ; x= 7 + a
soustraction - a= a-b ; y= c-13
moins unitaire - a = -b
multiplication * a=a*a;b=y*9
division / c=8/b;d=a/b
Reste de la division
entière (modulo) % r=a%b

Type Symbole Exemple

Opérateurs logiques de comparaison
=> Le résultat de la comparaison peut prendre deux valeurs vrai ou faux
c = a $$ b // c est vrai si a et b sont vrais,
ET logique &&
sinon c est faux
c = a || b // c = 1 si a ou b sont non nuls,
OU logique ||
sinon c=0
c = !c ; a=!b // c prend le complément de ce
Non logique !
qu’il valait
Opérateurs de comparaison
=> Le résultat de la comparaison peut prendre deux valeurs vrai ou faux
égalité == if a==b ; if c==9
différent != if c!=a
supérieur > if a>b ; if 8 >a
supérieur ou égal >= if a>=b
inférieur < if a>b ; if 8 >a
inférieur ou égal <= if a>=b
Opérateurs binaires de comparaison bit à bit

27
 => Le résultat de la comparaison peut prendre deux valeurs vrai ou faux
ET binaire x = a $ b // c est vrai bit à bit si bit à bit a et
&
b sont vrais
OU binaire x= a | b // c est vrai bit à bit si bit à bit a ou
|
b sont vrais
OU exclusif binaire x = a ^ b // c est vrai bit à bit si bit à bit a
^
ou exclu b sont vrais
complément à 1 ~ a=~b
décalage de n bits
>> x = y >> n // y = x décalé de n bits à droite
à droite
décalage de n bits
<< x = y << n // y = x décalé de n bits à gauche
à gauche
Exemples (a et b deux entiers) tel que :
a = 1100 0111 0101 0011 (0xC753) a ^ b = 1101 1110 1111 1101 (0xDEFD)
b = 0001 1001 1010 1110 (0x19AE) ~ a = 0011 1000 1010 1100 (0x38AC)
~ b = 1110 0110 0101 0001 (0xE651)
a & b = 0000 0001 0000 0010 (0x0102)
a<<2 = 0001 1101 0100 1100 (0x1D4C)
a | b = 1101 1111 1111 1111 (0xDFFF)

2.4 Les tableaux :

2.4.1 Définition :
Un tableau est un ensemble d’éléments de même type désignés par un identificateur unique,
chaque élément contenu dans le tableau est repéré par un “indice” précisant sa position au sein
de l’ensemble. On peut effectuer différents traitements (consulter, modifier, ajouter …) sur un
élément ou l’ensemble des éléments du tableau.
 Un tableau à une dimension correspond à la notion de vecteur en mathématiques. C’est
un tableau d’une seule ligne et plusieurs colonnes. Voici un tableau à 8 éléments :
17 0 33 108 41 13 56 92

 Un tableau à deux dimensions est défini par l’intersection du nombre des lignes par celui
des colonnes. Un tableau bidimensionnel correspond à la notion de matrice en
mathématiques. Voici une matrice de 3*3 éléments : (3 lignes et 3 colonnes)
19 22 31 90 47
26,8 15 0 74 6
…

28
2.4.2 Tableau à une dimension
Tableau à une dimension

Déclaration : L’utilisation de la notion de vecteur en algorithmique ou en C nécessite une

déclaration auparavant

Syntaxe nomtableau : Tableau [tailletab] <typeéléments>

algorithmique : Exemples :
tab0 : tableau [0..19] entier => tableau de 20 entier
tab1 : tableau [20] réel => tableau de 20 éléments réels
tab2 : tableau [] entier = [1,2,3,4,5] => tableau de 5 entiers initialisé
tab3 : tableau [10] entier = [1,2,3,4,5]; => tableau de 10 entier initialisé
type Tab tableau[24] entier => déclaration d’un type tableau de 24 entiers
tab4 : Tab => tab4 est un tableau de 24 entiers
=> Ces deux dernières écritures permettent d’éviter l’écriture de la même
déclaration pour des tableaux de même type et de mêmes structures
Syntaxe dans le <typeélément> nomtableau[tailletab] ;
langage C : Exemples :
int tab1[20]; /* tableau de 20 entiers non initialisé */
tab2 = {1,2,3,4,5}; /* tableau de 5 entiers même si le type n’a pas été spécifié */
int tab3[] = {1,2,3,4,5}; /* tableau de 5 entiers même si la taille n’a pas été
spécifiée*/
float tab4[20]= {10,2,47,9,5}; /* tableau de 20 réels partiellement initialisé */
typedef int Tab[5]; /* déclaration d’un type tableau Tab*/
Tab tab5; /*tab5 est un tableau de 5 éléments entier*/
Tab tab6= {1,2,3,4,5}; /*tab5 est un tableau de 5 éléments entier initialisé*/
Char alphabet[12] ; /*déclaration d’une chaîne de caractère de 12 caractère
maximum*/
Accès : En algorithmique ou en C, pour accéder à un élément du tableau, il suffit de
connaître la position : <nomtableau>[n°position]
Exemple :
pour accéder au 6ème élément de tab4 déclaré ci-dessus, on utilise l’expression
tab4[6].
En général, pour accéder au ième élément d’un tableau T déjà déclaré, on utilise
T[i] avec i dans la taille du tableau T.

29
Affectation : L’affectation permet de modifier le contenu d’une case du tableau et ainsi
changer sa valeur par une autre valeur de même type ou la valeur d’une
expression.
En algorithmique : <nomtableau>[n°position]  valeur
Exemple : tab3[3]  34
La valeur de tab3[3] ne vaut plus 3 mais 34
Ou tab3[3]  5 + tab3[1]
La valeur de tab3[3] ne vaut plus 34 mais 35 car tab3[1] vaut 1 d’après la
déclaration
En langage C : <nomtableau>[n°position] = valeur ;
Exemple : tab3[3] = 34 ;
tab3[3]  5 + tab3[1] ;

2.4.3 Tableau à deux dimensions :

Tableau à deux dimensions

Syntaxe nomtableau : Tableau [tailleligne, taillecolonne] <typeéléments>

algorithmique : Exemples :
Image1 : tableau[1..5,1..4] entier => déclaration de 20 éléments entier dans un
tableau Image1
Image2 : tableau[15,3] réel => déclaration de 15*3 éléments réels dans un
tableau Image2
Image3 : tableau [3,4] caractère = [‘A’,’B’,’C’,’D’] => déclaration d’une matrice
de 1é caractères dans les quatre premiers sont initialisées
Syntaxe dans le <typeélément> nomtableau[tailleligne][taillecolonne] ;
langage C : Exemples :
int Image1 [20][20]; /* tableau de 40 entiers non initialisé */
float Image2 [1..4][1..6] = {7,5,12 ,69,90,44,77} ; /* déclaration d’une matrice
de 24 éléments réels initialisés */

Accès : En algorithmique, pour consulter le contenu d’une case, il faut avoir, à la fois, le
numéro de ligne et le numéro de la colonne :
<nomtableau>[n°ligne, n°colonne]
Exemple :

30
 Mat3[1,2] permet de connaitre la valeur ‘B’ ‘après la déclaration faite ci-dessus
Par contre en C, la syntaxe de la consultation est la suivante :
<nomtableau>[n°ligne][ n°colonne]
Exemple :
mat2[2][1] permet de connaitre la valeur 90 après la déclaration faite ci-dessus
Affectation : Il est possible de changer le contenu d’une case déjà rempli par une nouvelle
valeur de même type ou par le résultat d’une expression (qui doit être de type
compatible avec celui de l’élément correspondant), la syntaxe utilisée est :
En algorithmique :
<nomtableau>[n°ligne, n°colonne]  valeur
Exemple :
Mat3[1,2]  ‘G’
La valeur de Mat3[1,2] ne vaut plus ‘B’ mais ‘G’ (voir la déclaration de Mat3
faite ci-dessus)
En C : <nomtableau>[n°ligne][n°colonne] = valeur ;
Exemple : mat2[2][1] = 41 ;
La valeur de mat2[2,1] ne vaut plus 90 mais 41
Ou mat2[2][1] = 3 * mat2[2][1];
La valeur de mat2[2][1] sera 123 au lieu de 41

2.5 Les fonctions et procédures :

2.5.1 Définition
On appelle procédure ou fonction, un sous-programme qui est appelé depuis le programme
principal. Une fonction (ou procédure) est une série d'instructions. Une fonction peut être
appelée par une autre fonction et doit retourner une valeur sauf si elle est du type void. Elle peut
prendre des arguments dont les noms et types sont définis entre les parenthèses. Si la fonction
n'attend aucun paramètre, on l'indique par le mot réservé void entre parenthèses.
Un paramètre d’entrée est la référence à une variable manipulée par la procédure ou la fonction.
Un paramètre de sortie est une valeur renvoyée par une fonction.
Les fonctions permettent :
 Meilleure lisibilité
 Diminution du risque d'erreurs
 Possibilité de tests sélectifs.

31
  Dissimulation des méthodes : Lors de l'utilisation d'une fonction il faut seulement
connaître son effet, sans devoir s'occuper des détails de sa réalisation.
 Réutilisation d'une fonction déjà existante : Il est facile d'utiliser des fonctions que l'on a
écrites soi-même ou qui ont été développées par d'autres personnes.
 Simplicité de l'entretien

2.5.2 Syntaxe
La syntaxe d’une fonction est la suivante:
Type_de_la_valeur_de_retour Nom_de_la_fonction (type noms_des_paramètres)
{
liste d’instructions; // Une ou plusieurs instructions séparées par des ;
return (valeur) // Valeur à renvoyer à la fin de la fonction
}
Remarque :
 Si la fonction ne renvoi pas de valeur (type de la valeur de retour = VOID), la ligne return
(valeur) est inutile.
Tous les paramètres d’entrées deviennent des variables locales de la fonction.
 Exemple de fonction sans paramètre d’entrée et de sortie :
Pour appeler la fonction dans un programme :
initialisation();
Déclaration de la fonction :
void initialisation()
{
TrisB=0;
TrisA=0;
TrisC=0x8F;
Adcon1=7; // Toutes les broches du PortA en numérique
}
 Exemple de fonction avec des paramètres d’entrée et pas de valeur retournée en
sortie :

Pour appeler la fonction dans un programme :

Tempo_Sec(10);
Déclaration de la fonction :
void Tempo_Sec(int duree)
{
delay_ms(1000*duree); /* Appel d’une autre fonction Delay_ms
(avec comme paramètres 1000 * duree) */
}

 Exemple de fonction avec des paramètres d’entrée et une valeur retournée en sortie :

Pour appeler la fonction dans un programme :

c=Max(10,30);
Déclaration de la fonction :
int Max(int a, int b)

32
{
if(a>b) //si 'a' est supérieur à 'b'
return a; //on retourne 'a'
else //sinon
return b; //on retourne 'b'
}

2.6 Les bibliothèques standards :

Il existe un ensemble de fonctions déjà existantes que l’on peut utiliser dans nos programmes.
Ces fonctions sont stockées dans des librairies (tel que stdio.h par exemple) que l’on doit faire
référence en début de programme.
Exemple : #include <stdio.h>

Fonctions de temporisation
Le compilateur de MikroC intègre des fonctions très pratiques pour gérer les délais, à savoir:
delay_cycles(valeur) ; // temporisation en NB de cycles
delay_us(valeur) ; // temporisation en μS
delay_ms(valeur) ; // temporisation en mS

2.7 Les bases du MikroC :

On a la possibilité d’écrire les chiffres de cette manière :

Le décimal : A = 10 ;
L’octal : A = 012 ;
L’hexadécimal A = 0x0A ;
Le binaire A = 0b00001010 ;
Pour les caractères : Exemple la lettre A code ASCII 65(Décimal) ou $41(Hexadécimal), peut
s’écrire :
LETTRE = 65 ;
LETTRE = 0x41 ;
LETTRE = ‘A’ ;

2.8 Quelques informations et règles d’écritures :

Un programme en MikroC utilise deux zones mémoires principales :

 La zone des variables est un bloc de RAM où sont stockées des données manipulées par le
programme.
 la zone des fonctions est un bloc de ROM qui reçoit le code exécutable du programme et les
constantes.
Chaque ligne d’instruction se termine par un « ; ».
Le début d’une séquence est précédé du symbole « { ».
33
La fin d’un séquence est suivie du symbole « } ».
Déclarer une variable ou une fonction, c’est informer le compilateur de son existence.
Les noms des variables que l’on utilise (variables, fonctions) sont des identificateurs. Leur
écriture doit respecter les critères suivants :
Utiliser les caractères de l’alphabet, de a à z et de A à Z, les chiffres de 0 à 9 .
 Ne doit pas contenir d’espaces ou de caractères accentués. Ne doit pas dépasser 32 caractères.
Être représentatif de leur rôle dans le programme (pour une meilleure lecture et
compréhension du programme).
Voici exemple de programme que nous allons commenter pour en dégager quelques règles.
void main( )
{ // début
TRISA = 0xff ; TRISB = 0b10100011 ; TRISC = 15 ;
PORTB.F3 = 1 ; PORTB.F4 = 0 ;}
Règle N°1 : Les instructions propres au langage C doivent être écrites en minuscule void main( )
Règle N°2 : Les instructions particulières aux microcontrôleurs être écrites en majuscule TRISB
Règle N°3 : Les retours à la ligne et les espaces servent uniquement à aérer le code. Ils peuvent
ne pas être utilisés.
Règle N°4 : Les accolades délimitent un groupement d’instruction.
Règle N°5 : Le signe // indique un commentaire.
Règle N°6 : Le point virgule indique la fin d’une instruction.
Règle N°7 : Le mot clé 0b indique que la suite est écrite en binaire.
Règle N°8 : Le mot clé 0x indique que la suite est écrite en hexadécimal.
Règle N°9 : L’absence de mot clé indique que la suite est écrite en décimal.

2.9 Choix de la direction de communication :

Les registres de direction figure N° 2 TRISA, TRISB, … permet de configurer les PORTA,
PORTB,…. soit en entrée ou en sortie selon l’utilisation.
L’état du bit i de TRISx ( TRISx<i> ) contrôle la direction du bit i de PORTx (PORTx<i> ):
TRISx<i> = 0  PORTx<i> en sortie (écriture)
TRISx<i> = 1  PORTx<i> en entrée (lecture)
Exemple : TRISB = 0xFF  les 8 bits du PORTB en entrées
TRISC = 0x0F  RC7 à RC4 en sorties, RC3 à RC0 en entrées
Les bits i 7 6 5 4 3 2 1 0
Le nom de bit RC7 RC6 RC5 RC4 RC3 RC2 RC1 RC0
0 0 0 0 1 1 1 1
TRISC = 0x0F
Sortie Sortie Sortie Sortie Entrée Entrée Entrée Entrée

34
 Figure N° 2 : choix de la direction de communication

3 Notion d’algorithme

3.1 Définition :

Un algorithme est un ensemble de règles opératoires rigoureuses, ordonnant à un processeur

d’exécuter dans un ordre déterminé une succession d’opérations élémentaires, pour résoudre un
problème donné. C’est un outil méthodologique général qui ne doit pas être confondu avec le
programme proprement dit.

Un algorithme peut être :

� Représenté graphiquement par un organigramme (ou ordinogramme).
� Écrit sous forme littérale avec un langage algorithmique.

3.2 Organigramme :

L’organigramme est une représentation graphique normalisée utilisée pour analyser ou

décoder un problème. Il utilise des symboles représentant des traitements, des liaisons, des
données… Un organigramme bien représenté doit être fléché et fermé, compris entre un début et
une fin

35
 SYMBOLE DÉSIGNATION
Traitement
Opération ou groupe d’opération sur des données, instructions, etc.

Sous-programme
Portion de programme considérée comme une simple opération.

Entrée-Sortie
Mise à disposition d’une information à traiter ou enregistrement
d’une information traitée.
Embranchement
Test, exploitation de conditions variables impliquant le choix
d’une parmi deux. Symbole utilisé pour représenter une décision.

Début, fin ou interruption

Début, fin ou interruption d’un organigramme
Symbole auxiliaires de renvoi
Symbole utilisé deux fois pour assurer la continuité lorsque une
partie de liaison n’est pas représentée
Sens conventionnel des liaisons. Le sens général de liaison doit être :
� De haut en bas,
� De gauche à droite.

3.3 Structures algorithmiques fondamentales :

Les opérations relatives à la résolution d’un problème peuvent en fonction de leur enchaînement,
être organisées selon trois familles de structures :
� Structures linéaires,
� Structures alternatives,
� Structures répétitives.

3.3.1 La structure linéaire ou séquence

La structure linéaire se caractérise par une suite d’actions à exécuter successivement dans l’ordre
de leur énoncé.

Organigramme Langage algorithmique Exemple en langage C

void main( )
Début algorithme :
{
FAIRE opération 1
fonction_1( ) ;
FAIRE opération 2
fonction_2( ) ;
FAIRE opération 3
fonction_3( ) ;
Fin algorithme.
}

36
3.3.2 La structure alternative ou sélection :
La structure alternative n’offre que deux issues possibles s’excluant mutuellement. Les structures
alternatives définissent une fonction de choix ou de sélection entre l’exécution de l’un ou de
l’autre des deux traitements. Également désignées par structures conditionnelles, elles sont
représentatives de saut ou rupture de séquence.
 La structure alternative complète :

Organigramme Langage algorithmique Exemple en langage C

if( condition = = VRAI )

SI condition VRAIE {
fonction_1( ) ;
ALORS action 1 }
SINON action 2 else
{
FIN SI fonction_2( ) ;
}

 La structure alternative réduite :

Organigramme Langage algorithmique Exemple en langage C

SI condition VRAIE
if( condition = = VRAI )
{
ALORS action
fonction( ) ;
}
FIN SI

3.3.3 Les structures répétitives :

Une structure répétitive ou itérative répète l’exécution d’un traitement.

 Faire… Tant que…

Dans cette structure, le traitement est exécuté une première fois puis sa répétition se poursuit
jusqu’à ce que la condition soit vérifiée.

37
 Organigramme Langage algorithmique Exemple en langage C

do
FAIRE {
action fonction( ) ;
TANT QUE condition VRAIE }
while(condition = = VRAI) ;

 Tant que… Faire…

Dans cette structure on commence par tester la condition, si elle est vraie alors le traitement est
exécuté.

Organigramme Langage algorithmique Exemple en langage C

TANT QUE condition VRAIE while(condition = = VRAI) ;

{
FAIRE action fonction( ) ;
}
FIN TANT QUE

3.3.4 La structure répétition contrôlée :

Dans cette structure la sortie de la boucle d’itération s’effectue lorsque le nombre souhaité de
répétition est atteint. D’où l’emploi d’une variable de boucle (indice I) caractérisée par :
� Sa valeur initiale.
� Sa valeur finale.
� Son pas de variation.

Organigramme Langage algorithmique Exemple en langage C

for( I = Vi ; I > 0 ; I = I – 1 )
{
fonction( ) ;
POUR I = Vi à I = 0 et par pas de 1
}
Équivalent à :
FAIRE action
I=Vi;
while(I>0)
FIN POUR
{
fonction( );
I=I-1; }

38
4 Applications N°1 :
Exercice N°1 : On donne l’algorigramme suivant :

1- Trouver l’équation de S
2- On déduire la (les) fonction(s) réalisée(s) par S
3- Traduire l’algorigramme par le langage algorithmique
4- Ecrire le programme de l’application en langage MikroC
Exercice N° 2:
1- Trouver l’équation de de l’exercice N°1.
On donne l’équation suivante :
2- Tracer l’algorigramme correspondant
Exercice N° 3:
On veut commander une lampe L suivant le montage ci-dessous :
a L

b
1- Donner l’équation de L.
2- Proposer une solution en logique programmée utilisant un microcontrôleur 16F628A
3- Créer l’organigramme de l’équation L.
4- Ecrire le programme relatif à cette solution en langage MikroC

39
 Exercice N°4 :
Créer un organigramme et écrire un programme qui incrémente une variable à chaque appui sur
un bouton poussoir L. le nombre d’appui sera égale à 5, la LED raccordée au montage changera
d’état. (Proposer d’abord un schéma de simulation)

Exercice N°5 : Schéma électrique du circuit de commande du moteur Pas à Pas :

Ce circuit de commande est basé sur l’utilisation d’un microcontrôleur 16F84A.

MOTOR pas à pas

PIC 16F84A
ULN2003

1°/ Compléter la structure micro programmée par ce qui convient:

--------------------- ---------------------
-----------
--------------------- --------------------- -------------------
--------------------- ---------------------
-- -------------- μC

-----------------
---------------
-----------------
------- ---------------------- -----------------------
--

2°/ Préciser au moins trois critères pour choisir un microcontrôleur :

3°/ La référence du microcontrôleur est PIC16F84A : Que signifie la lettre F et A.
40
4°/ Donner le nom du circuit d’horloge utilisé.

5°/ Préciser le rôle de MCLR .

6°/ Indiquer la signification des pattes suivantes concernant le brochage du microcontrôleur (PIC
16F84A),
VSS, VDD : ----------, RA0-RA4 : ---------, RB0-RB7 : --------, OSC1 et OSC2 : ---------
3°/ Comme une solution technologique, pour la commande du moteur pas à pas, on utilise un
microcontrôleur 16F84A
Compléter l’algorigramme correspondant au cahier de charge suivante.
 Entrée : Port RA0 Fonctionnement :
Si RA0 = 0 Sens ANTI HORAIRE
Sens HORAIRE Sens ANTI HORAIRE
Si RA0 = 1 Sens HORAIRE
RB3 RB2 RB1 RB0 RB3 RB2 RB1 RB0
 Sorties : 1 0 0 1 1 0 0 1
 Port RB0 – RB1 – RB2 et RB3 0 1 0 1 1 0 1 0
Nota : La duré du chaque position du 0 1 1 0 0 1 1 0
moteur Pas à Pas est de 1s. 1 0 1 0 0 1 0 1

Start 16f84A

2
8 16

3
9 17

4
….. 10 18
Si Port A
=D’1'

….. 11 Port B = 19
5 13 D’10’

12 20
6 Tempo 14
T-1-1000000µs
13 Saut vers 21 Saut vers
7 15 module N°..... module N°.....

Algorigramme de moteur pas à pas

41
Exercice N°6: Etude d’une carte de commande à base d’un microcontrôleur 16F877A :
En se référant à la carte de commande :
1- La référence du microcontrôleur est PIC16F877A : Que signifie la lettre F et A.
2- Donner le nom du circuit d’horloge utilisé.
3- Le PIC16F877A possède plusieurs ports, on demande de compléter le tableau suivant :
Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0
Port A

4- Sur quel port sont connectés les deux moteurs pas à pas
5- Mettre une croix dans la case correspondante :
RB2, RB3, RB4, RB5 sont affectés aux : variables des entrées
variables des sorties
6- Mettre une croix dans la case correspondante :
Sens 1 Sens 2
Le moteur Mb tourne dans le : Si RB0 =1
Si RB1 =1

7- Mettre une croix dans la case correspondante : Si RB0=1 et RB1=1

Le moteur Mb en marche
Le moteur Mb à l’arrêt
8- Déduire l’état du moteur Mb si RB0=0 et RB1=0

9- Une partie du
programme pour la
commande du
moteur Mb est
représenté en
algorigramme
suivant. On
demande de
trouver l’équation
de X.

42
10- Réaliser un algorigramme qui décrit cette équation ; X=a.(m+x)
11- Donner un nom aux équations de la question 9 et 10.

Figure N° 1 : Carte de commande à base d’un microcontrôleur 16F877A

43
Exercice N°7: Système de perçage

Soit le système de perçage suivant : Le moteur est commandé par un contacteur KM1 et le
vérin est Commandé par le distributeur M.

a) Déterminer le GRAFCET PC
b) Remplir le tableau d’affectation
Entrées Sorties
Broches Broches
Capteurs Préactionneurs
du µC du µC

c) Compléter l’algorithme puis le transformer en programme MikroC.

Algorithme Programme

Algorithme grafcet
Variables X0, X1, X2 : octet ; ----------------------------------------------------------
DEBUT ----------------------------------------------------------
TrisA ← ………….. ----------------------------------------------------------
TrisB ← ………….. ----------------------------------------------------------
PortA ← 0; ----------------------------------------------------------
X0 ← 1; ----------------------------------------------------------
X1 ← 0; ----------------------------------------------------------
X2 ← 0; ----------------------------------------------------------
Tanque (1=1) Faire ----------------------------------------------------------
DEBUT ----------------------------------------------------------
SI ((X0=1) ET (Port….=1)) ALORS ----------------------------------------------------------

DEBUT ----------------------------------------------------------

X0 ← 0; ----------------------------------------------------------

X1 ← 1; ----------------------------------------------------------

FINSI ; ----------------------------------------------------------

SI ((X1=1) ET (Port….=1)) ALORS ----------------------------------------------------------

DEBUT ----------------------------------------------------------

44
 X1 ← 0; ----------------------------------------------------------
X2 ← 1; ----------------------------------------------------------
FINSI ; ----------------------------------------------------------
SI ((X2=1) ET (Port…. =1)) ALORS ----------------------------------------------------------

DEBUT ----------------------------------------------------------

X2 ← 0; ----------------------------------------------------------

X0 ← 1; ----------------------------------------------------------

FINSI ; ----------------------------------------------------------

SI (X1=1)ALORS Port………SINON ----------------------------------------------------------

Port…..... ; ----------------------------------------------------------

FINSI ;
SI (X1=1)ALORS Port………SINON
Port…..... ;
FINSI ;
SI (X1=1)ALORS Port………SINON
Port…..... ;
FINSI ;
FINFAIRE ; FIN.

Exercice N°8: Gestion de la commande du moteur Mt1

GRAFCET PC relatif au moteur Mt1 Carte de commande de moteur Mt1

En se référant au schéma structurel de la carte de commande de moteur et son GRAFCET PC :

1- Compléter la table d’affectation.
2- Compléter le GRAFCET codé microcontrôleur.
3- Ecrire le programme en MikroC.
45
 Système - - -

Entrées
Microcontrôleur RA0 RA1 RA2 RA3 RA4 - - -
TRISA =
(------------)H
Système

Sorties
Microcontrôleur RB0 RB1 RB2 RB3 RB4 RB5 RB6 RB7
TRISB =
(------------)H

Exercice N°9 : Testeur de batterie

Le potentiomètre P, en réglant la tension u appliquée sur l’entrée RA1 du pic, permet de simuler
l’état de charge d’une batterie.

Si 3,4 < u < 5 allumer la diode LED verte, Dv

Si 2,5 < u < 3,4 allumer la diode LED orange, Do
Si 0 < u < 2,5 allumer la diode LED rouge, Dr

a- Proposer un schéma structurel à base d’un PIC (16f877A).

b- Donner l’algorigramme correspondant.
c- Ecrire le programme en MicroC permettant au PIC de réaliser la fonction décrite ci-
dessus.

Schéma structurel à base d’un PIC.

46
 Algorigramme (organigramme) Programme

---------------------------------------------------------------
---------------------------------------------------------------
---------------------------------------------------------------
---------------------------------------------------------------
---------------------------------------------------------------
---------------------------------------------------------------
---------------------------------------------------------------
---------------------------------------------------------------
---------------------------------------------------------------
------------------------------------------------------

Exercice N°10 : Système de remplissage et de bouchage des bouteilles

On présente un système qui s’inscrit dans une chaîne d’embouteillage, il correspond à

l’isolement de la partie assurant les fonctions de remplissage et bouchage.

Le remplissage se fait par soutirage. Un capteur « bouteille remplie » permet de contrôler le

niveau de remplissage de façon satisfaisante. Le bouchage est assuré par un vérin presseur. Les
prises d’information sur la partie opérative sont représentées par commodité par des galets
mécaniques.

47
 On donne le GRAFCET
au point de vue système
et au point de vue
commande

a- Compléter le tableau suivant :

Système
Entrées

Microcontrôleur RC0 RC1 RC2 RC3 RC4 RC5 RC6 RC7

TRISC =
(------------)H
Système
Sorties

Microcontrôleur RD0 RD1 RD2 RD3 RD4 RD5 RD6 RD7

TRISD =
(------------)H

b- Compléter le GRAFCET codé microcontrôleur.

48
c- Compléter le schéma structurel du système.

49
 d- Compléter le programme suivant :

int x0,x1,x2,x3,x4,x5; //Activation/Désactivation de X2

void main() ------------------------------------------------------

{ ------------------------------------------------------

TRISC = -----------; ------------------------------------------------------

TRISD = ---------; //Activation /Désactivation de X3

x0=----;x1=-----;x2=-------- x3=0 ;x4=0 ; ------------------------------------------------------

x5=--------; ------------------------------------------------------

while (1) ------------------------------------------------------

{ //Activation/Désactivation de X4

//Activation/Désactivation de X0 ------------------------------------------------------

if (x3&x5&portc.f4&portc.f6) ------------------------------------------------------

{x0=1;} ------------------------------------------------------

--------------------------------------------------- //Activation/Désactivation de X5

//Activation/Désactivation de X1 if (x4&portc.f7)

if ((x0&portc.f0&portc.f1&portc.f2) {x5=1;portd.f7=1}

---------------------------------------------------- -----------------------------------------------------

if (x1){ x0=0; } }

5 Applications N°2 :

Exercice N°1 :
On donne la référence du microcontrôleur est PIC16f628A : que signifie les lettres F et A
Indiquer la signification des broches :
VSS, VDD, OSC1 OSC2, RA0 à RA7, MCLR
Exercice N°2 :
Pour le cas du PIC 16F84, Quelles le rôle :
- TRISB

50
 - WATCHDOG :
- PORTA :
- Cycle machine :

Exercice N°3 :
On veut réaliser un compteur/décompteur modulo 10 à l’aide du PIC 16F84A.
a) Proposer un montage électronique : Il faut utiliser un afficheur 7segments pour
l’affichage et un interrupteur pour le choix entre le comptage et le décomptage.
b) Ecrire l’organigramme de fonctionnement.
c) Ecrire le programme correspondant.

Exercice N°4 :
On propose de réaliser une partie de la carte de commande d’une voiture en utilisant le circuit
PIC 16F84, dans ce cas on utilise:
- Un Interrupteur K de validation du fonctionnement de cette partie de la carte.
- Trois commutateurs à deux positions: K1 pour le choix entre clignotant à droite/ gauche,
K2 « Code /Far » et K3 essuie-glass Marche/Arrêt.
1- Proposer un montage électronique sans oublier que la source de l’alimentation est une
batterie 12V.

6 Applications N°3 :

Exercice N°1 :
On veut réaliser le montage électronique, à base de PIC16F877, d’un testeur de batterie de
voiture qui permet d’allumer les LEDs D1 à D5 selon la tension mesurée de la batterie
- Vb>12v : Batterie chargée D1=1, D2=1, D3=1, D4=1 et D5 éteinte.
- Vb< 12v et Vb>10.4v : Batterie moyennement chargée D1=1, D2=1, D3=1, (D4 et D5)
éteintes.
- Vb<10.4 et Vb>9.1v : Batterie faible D1=1, D2=1, (D3, D4 et D5) éteintes.
- Vb<9.1v : état Batterie déchargée D1=1, (D2, D3 et D4) éteintes et D5 clignotantes.
a) Proposer un montage de réalisation électronique.
b) Donner l’expression de la tension Va en fonction de Vb .
c) Ajouter un interrupteur sur la ligne RA4 du PIC 16F877, qui permet de valider le
fonctionnement de votre préposition.
d) Donner l’organigramme correspondant à ce fonctionnement puis le programme.

51
Exercice N°2 :
On propose de réaliser, pour un Hôtel, une carte pour la commande du parking de voitures.

Le directeur de l’hôtel propose :

- L’utilisation d’un afficheur, à l’entrée du parking, qui affiche le nombre de positions

libres.
- Un système de détection de présence de nouvelle voiture à l’entrée du parking.
- Un système de détection de sortie de voiture
- Une carte de commande qui permet de contrôler l’ouverture et la fermeture du parking et
l’afficheur automatiquement.
-
Pour cela et en se basant sur le brochage du PIC 16F877.

a) Donner un montage de réalisation

électronique : Il faut utiliser des afficheurs
7segments pour l’affichage et des
interrupteurs pour la détection de présence
de nouvelle voiture ou sortie d’une autre du
parking.
b) Ecrire l’organigramme de fonctionnement.
c) Ecrire le programme correspondant.

52
Exercice N°3 :

Soit une installation de traitement de surface comprenant un chariot automoteur constitué de

deux bacs, un poste de chargement et un poste de déchargement. Des informations S1 à S4
permettent le positionnement au dessus des différents postes.

Figure 1
Le diagramme du cycle est le suivant :

Figure 2
Cycle de fonctionnement :
L’opérateur, après avoir accroché les pièces à traiter sur le cadre situé au point de chargement, en
position basse, donne l’information de départ cycle (dcy). Le chariot automoteur (CM) élève le
châssis en position haute (S5), effectue une translation à droite (TD) et se positionne au dessus
de la première cuve (S2). Le chariot descend (CD) alors le châssis dans le bac de décapage, le
laisse pendant 20 secondes et remonte le châssis pour aller ensuite au bac suivant. Il
recommencera les mêmes opérations jusqu’au poste de déchargement où l’opérateur décrochera
les pièces avant de renvoyer (r). Le chariot remonte puis effectue une translation à gauche (TG).
Rq : On supposera que le processus se trouve dans les conditions initiales au départ cycle :
- Le châssis se trouve en position basse (S6)
- Le chariot se trouve en S1
- Le châssis est vide.

53
Ce système sera commandé par un PIC 16f877.
a) Selon la description précédente, donner dans un tableau les entrées et les sorties du
système à commander.

Entrées Sorties

* ………………………………………… * ………………………………………

* ………………………………………… * ………………………………………

* ………………………………………… * ………………………………………

b) Proposer un schéma électronique (les actions seront représentées par des diodes LEDs) .
c) Donner un organigramme de fonctionnement du système.
d) Ecrire le programme correspondant, en MickroC Pro, permettant de gérer ce système

54