Document Formation Mikroc Finale

RÉPUBLIQUE TUNISIENNE
MINISTÈRE DE L’ÉDUCATION
D.R.E. SFAX1
FORMATION DES ENSEIGNANTS DE GÉNIE ÉLECTRIQUE
Programmation en MikroC PRO
Application pour les microcontrôleurs
de la famille PIC
Préparée et animée par : Hichem BORCHANI
Encadrée par l’inspecteur : Abdelhakim MANOUBI
CREFOC SFAX AS : 2021 – 2022

PRESENTATION ET REMERCIEMENTS
Le présent rapport est un résumé de plusieurs articles concernant la
programmation en langage mikroC. Il présente différents exemples d’activités
et d’exercices corrigés traitant en particulier l’exploitation des afficheurs LCD
et des claviers 4x4, la conversion analogique numérique, la génération de
signaux MLI, les interruptions par RB0 et RB4 à RB7, l’exploitation du
TIMER0 … Ce document est donc un outil pour se familiariser avec la
programmation en langage mikroC. Ainsi, il peut être utilisé comme support
pour préparer le cours de microcontrôleur destiné aux élèves de la 3ème et
4ème années Sciences Techniques.
Je tiens à remercier Monsieur Mourad HAMMAMI et Madame Hiyem FRIKHA
pour leurs soutiens, leurs remarques visées et leur contribution à l’élaboration
de présent manuscrit.
CREFOC SFAX Formation 2021-2022 en GE page : 2

I- INTRODUCTION
La programmation des microcontrôleurs est basée sur le code machine connu comme code assembleur.
Ce code contient les instructions du programme. Il est bien détaillé et difficile à écrire. Le programme en
code assembleur est très long et difficile à comprendre.
La création des compilateurs de haut niveau a rendu facile la création et l’édition des programmes, bien
entendu les microcontrôleurs ne font pas exception. Il y a plusieurs variétés de compilateurs des différents
fabriquants et avec différents langages de haut niveau (PICC,CCS,PIC Basic…). Cette formation traite le
compilateur MikroC PRO, qui est un compilateur de langage C pour les microcontrôleurs PIC micro famille
12F,16F,18F,etc…
MikroC PRO est un logiciel avec une grande variété des helps, de supports et d’outils, qui facilite la
création des projets et des applications pour les microcontrôleurs PIC micro.
L’étude de cet environnement de développement est possible, parce que l’élève peut télécharger une démo
ou version free, qui a les mêmes caractéristiques que la version complète. La seule limite est la taille du
code machine qui ne peut pas excéder 2K octets, une capacité suffisante pour un premier apprentissage. La
version de démonstration peut être téléchargée à partir du site Web : www.mikroc.com
II- LANGAGE ET COMPILATEUR mikroC POUR PIC
Le langage mikroC pour PIC a trouvé une large application pour le développement de systèmes embarqués
sur la base de microcontrôleur. Il assure une combinaison de l'environnement de programmation avancée
IDE (Integrated Development Environment) et d’un vaste ensemble de bibliothèques pour le matériel, de la
documentation complète et d’un grand nombre d’exemples. Le compilateur mikroC pour PIC bénéficie
d'une prise en main très intuitive et d'une ergonomie sans faille. Ses très nombreux outils intégrés
(mode simulateur, terminal de communication Ethernet, terminal de communication USB, gestionnaire
pour afficheurs 7 segments, analyseur statistique, correcteur d'erreur, explorateur de code, mode Débug
ICD...) associé à sa capacité à pouvoir gérer la plupart des périphériques rencontrés dans l'industrie
(Bus I2C™, 1Wire™, SPI™, RS485, Bus CAN™, USB, gestion de cartes compact Flash et SD™/MMC™,
génération de signaux PWM, afficheurs LCD alphanumériques et graphiques, afficheurs LEDs à 7
segments, etc...) en font un outil de développement incontournable pour les systèmes embarqués,
sans aucun compromis entre la performance et la facilité de débogage.
1. Compilateur mikroC PRO pour PIC
La nouvelle version appelée mikroC PRO dispose de très nombreuses améliorations du compilateur
mikroC : nouvelles variables utilisables, nouvelle interface IDE, amélioration des performances du
linker et de l'optimisateur, cycle de compilation plus rapide, code machine généré plus compact
(jusqu'à 40 % suivant les cas), nouveaux PIC supportés, environnement de développement encore plus
ergonomique, nouveaux exemples d'applications, etc...

2. Installation du compilateur mikroC PRO v. 6.6.2
Pas 1 : Cliquer sur l’icône mikroC_PRO_6.6.2.exe (Si la fenêtre du Contrôle de compte d’utilisateur
s’ouvre, cliquer sur oui), et attendre que les données de l’installation se décompressent.
Pas 2 : Cliquer sur Next
Pas 3 : Cocher la case : I accept the terms in the License Agreement et cliquer sur Next

Pas 4 : Avant de cliquer sur Next, il est recommandé de laisser la case Install For All Users
coché. Cliquer sur Next
Pas 5 : Cliquer sur Next
Pas 6 : Cliquer sur Install (Noter bien l’endroit d’installation)
Ou "C:\Users\Public\Documents\Mikroelektronika\mikroC PRO for PIC\"

Pas 7 : Cliquer sur OUI pour l’association du format de fichier .c avec le logiciel mikroC PRO
Pas 8 : Cliquer sur Finish
Pas 9 : Aller dans le répertoire KeyGen et copier le fichier qui s’y trouve.
Pas 10 : Coller ce fichier au directory
"C:\Users\Public\Documents\Mikroelektronika\mikroC PRO for PIC\" ou
"C:\Program Files\Mikroelektronika\mikroC PRO for PIC\"
Pas 11: Cliquer deux fois sur le fichier KeyGen.exe pour enregistrer ses informations sur le registre de
votre ordinateur.
Pas 12 : Après exécution KeyGen ,un fichier est produit (mikroC_PRO_PIC.key).
Pas 13 : Supprimer le fichier keygen
Pas 14:Lancer le compilateur mickroC en cliquant sur l’icône
3. Construction d’un exécutable :
C, est un langage compilé, cela signifie qu’un programme C est décrit par un fichier texte appelé fichier
source. Ce fichier n’est pas exécutable par le microprocesseur. Il faut le traduire en langage machine. Cette
opération est effectuée par un programme appelé compilateur (compilateur mikroC par exemple)
Comment passer du code source au code exécutable ?
Tout à bord, pour écrire un programme, on doit faire appel à des bibliothèques (ce sont des morceaux de
codes déjà empaquetés prés à l’emploi), définir des variables et des constantes pour stoker des résultats
sous forme de chiffres, de lettres ou de chaines de caractères puis écrire le programme dans la fonction
main .Si votre projet commence à prendre un peu de volume, vous allez le scinder en fonctions qui
remplacent des tâches simples et élémentaires. Si votre projet commence à prendre plus d’ampleur, dans
ce cas, vous devrez effectuer un découpage sous forme de fichiers. Cela rend votre projet plus lisible et
flexible c'est-à-dire si vous voulez à faire une amélioration (extension) de votre projet, ça sera toujours plus
simple si vous avez des briques élémentaires.
Le compilateur passe par deux phases pour transformer le code source en code machine : phase
d’analyse et phase de production.
Phase d’analyse : Dans la phase d’analyse, le compilateur s’assure que le code source respecte la
syntaxe de grammaire du langage haut niveau (langage C).
La phase d’analyse est réalisée en trois étapes :
• Analyse lexicale : pour s’assurer que tous les mots du code source appartiennent au vocabulaire
du langage haut niveau.
Exemple pour une variable on écrit int 1a=5 ; erreur la variable ne doit pas débuter par un chiffre

• Analyse syntaxique : pour s’assurer que les mots construisent des phrases correctes
syntaxiquement et respectent la grammaire du langage haut niveau :
Exemple : if x==0 erreur on doit écrire If (x==0). On ne doit pas oublier les parenthèses
• Analyse sémantique : pour s’assurer que chaque phrase a du sens.
Exemple : Affecter une chaine de caractères à une variable de type entier :
int a[ ]="bon"; erreur ,on doit écrire char a[ ]="bon";
Phase de production : La phase de production est réalisée en quatre étapes successives :
• Le traitement par le préprocesseur : Le fichier source est analysé par un programme appelé
préprocesseur qui effectue des transformations purement textuelles, inclut d’autres fichiers sources etc…
• La compilation : Au cours de cette étape, le fichier engendré par le préprocesseur est traduit en
assembleur (fichier .asm).
• L’assemblage : Cette opération transforme le code assembleur en fichier binaire c'est-à-dire en
instructions directement compréhensibles par le processeur. Le fichier produit par l’assemblage est
appelé fichier objet .o .
• L’édition de liens : Un programme est souvent formé par plusieurs fichiers sources. Ceci permet
d’utiliser des bibliothèques de fonction standard déjà écrite, une fois le code source est assemblé. Il faut
donc lier entre les différents fichiers objets. L’éditeur de lien permet de faire le lien entre les différents
fichiers objets. En effet, chacun de ces fichiers partage certaines variables, certaines constantes, des
fonctions l’une vers l’autre et dans ce cas l’éditeur de lien permet de rendre exécutable le tout en faisant le
lien entre les différents objets. Il produit alors un fichier exécutable .hex
Précompilation Compilation Assemblage Edition de lien
Fichier source .C Fichier .asm Fichier .obj Fichier .hex
Organisation générale d’un compilateur C

4. Développement d’un projet :
Le développement d’un projet est

décrit par l’algorigramme ci-contre :
5. Création d’un nouveau projet

Le mikroC PRO pour PIC organise des applications dans des projets, composé d'un seul fichier de projet
(extension. mcppi) et un ou plusieurs fichiers sources (extension .c)
Les fichiers sources ne peuvent être compilés que s’ils font partie d'un projet.
Le fichier projet contient les informations suivantes :
- Nom du projet,
- Chemin d’enregistrement,
- Composant cible,
- Fréquence d’horloge du composant.
Une fois cette première étape est terminée, saisissez votre programme, compilez, corrigez les erreurs et
exécutez.
Si la compilation est réussie, le compilateur mikroC PRO pour PIC génère des fichiers de sortie dans le
dossier du projet (dossier qui contient le fichier projet. mcppi). Les fichiers de sortie sont résumés dans le
tableau ci-dessous:
Format Description Type de fichier
Code hexadécimal .Ce fichier est utilisé pour
Intel HEX .hex
programmer le PIC
Binary Fichier compilé pour la bibliothèque mikroC. .mcl
L’image globale de l’allocation de mémoire du PIC
List File pour les adresses d’instruction, les registres et les .lst
étiquettes du programme
Assembler File Le fichier en assembleur .asm

6. Introduction au langage de programmation mikroC
6.1 Structure d'un programme en mikroC

Un programme sous MikroC PRO peut être décomposé en deux grandes parties ou zones : une zone
réservée aux différentes déclarations et une autre zone réservée au programme principale void main ()
Main : Fonction principale et point d’entrée du programme.
Void : Indique que cette fonction ne retournera aucune valeur
Les types de variables utilisées en MikroC:
Type Taille en octet Longueur en bit Rang

Bit x 1bit 0 ou 1
sbit x 1bit 0 ou 1
char 1 8bits -128 à127
Unsigned char 1 8bits 0 - 255
Signed char 1 8bits -128 à127
int 2 16bits -32768 à +32767
Unsigned int 2 16bits 0 - 65535
Long 4 32bits -2147483648 à +214783647
Unsigned long 4 32bits 0- 4294967295
float 4 32bits ±1.17549435082 * 10-38 à ±6.80564774407 * 1038
double 4 32bits ±1.17549435082 * 10-38 à ±6.80564774407 * 1038
Afin de connaitre la taille en octet d’une variable, on utilise la fonction sizeof() :

Syntaxe de la déclaration d’une variable : Type Nom_variable =valeur initiale ;
la valeur est facultative,
Les identificateurs peuvent contenir les lettres a à z et A à Z, le caractère de soulignement «_» et les chiffres
de 0 à 9. La seule restriction est que le premier caractère doit être une lettre ou un trait de soulignement.
Exemples : char a =10 ; // variable de type caractère nommée a initialisée à 10
int _b,c=1,f ; // trois variables de type entier dont une est initialisés (c=1)
Les noms des variables dans mikroC n’est pas sensible à la casse de sorte que Sum, sum et suM
représente le même identifiant.
Voici quelques identificateurs valides :

temperature_V1
Pressure
no_hit
dat2string
SUM3
_vtext
Mais voici quelques identificateurs incorrects :

7temp // ne peut pas commencer par un chiffre
% Superieur // ne peut pas contenir de caractères spéciaux
int // ne peut pas répéter un mot-clé (nom réservé)
j23.07.04 // ne peut pas contenir de caractères spéciaux
Certains noms sont réservés pour le compilateur lui-même et ne peut pas être utilisés comme
noms de variables dans un programme.
On donne une liste alphabétique de ces noms réservés.
Noms réservés en mikroC ( Vous êtes appelés à respecter la casse)
asm enum signed auto extern sizeof break float static case for struct char goto switch const if
typedef continue int union default long unsigned do register void double return volatile else short while
Les letters c,f,w et z ne sont pas acceptés par le compilateur mikroC .On peut utiliser c1 par exemple
N.B : Les variables sont rangées dans la RAM
Syntaxe de la déclaration dune constante : const Nom_constante =valeur

Exemple : const b=200 ; //une constante nommée b vaut 200
Une constante de caractère est un caractère renfermé dans des guillemets simples.
Exemple : Const first_alpha=’A’ ; //une constante nommée First_Alpha est déclarée comme ayant la
valeur du caractère ‘A’
N.B : Les constantes sont rangées dans la ROM
N.B : le type de donnée d’une constante est déterminé automatiquement par le compilateur à partir de sa
valeur.
Syntaxe de la déclaration d’un tableau :
Un tableau est déclaré en spécifiant son type, le nom, et le nombre d’éléments à stocker.
La déclaration d’un tableau est similaire à la déclaration de variable, avec les crochets ajoutés après
Identificateur. Exemple : int Total [5] ; // tableau de 5 entiers nommé Total
Le premier élément d'un tableau est indexé à 0. Ainsi, dans cet exemple, Total [0] se réfère au premier
élément du tableau et Total [4] se réfère au dernier élément.
Un tableau peut être également déclaré sans spécifier sa taille.
Exemple : unsigned char mois[ ] = {31,28,31,30,31,30,31,31,30,31,30,31};
Des tableaux de caractères peuvent être déclarés de manière similaire.
Exemple : unsigned char Hex_Letters[ ] ={‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’}; //un tableau de caractères nommés
Hex_Letters est déclarée avec 6 éléments

Les chaînes sont des tableaux de caractères avec un terminateur nul. Les chaînes peuvent être déclarées
soit par enfermant la chaîne entre guillemets, ou en spécifiant chaque caractère du tableau au sein des
apostrophes et puis en terminant la chaîne avec un caractère nul. La chaîne de deux déclarations dans
l'exemple suivant est identique :
unsigned char Mystring[ ] = “COMP”; ou unsigned char Mystring[ ] = {‘C’, ‘O’, ‘M’, ‘P’, ‘\0’};
Utilisation de la fonction sizeof() :
On donne ci-dessous un exemple simple d'un programme en mikroC. Ce programme assure le

clignotement une LED connectée au PORTB (par exemple bit 0 du PORTB) du microcontrôleur PIC avec
une période de 2 secondes (1 seconde allumée et une seconde éteinte).

Les bases utilisées en C sont :
Le binaire commence par 0b… ou 0B … Exemple : a= 0b1100100
Le décimale Exemple : a= 197754
L’hexadécimale commence par 0x…. ou 0X… Exemple : a= 0xAF123B
L’octale commence par 0… Exemple : a= 034765
% Pour le binaire n’est pas accepté par le compilateur

$ pour l’hexadécimale n’est pas accepté par le compilateur
Pour la boucle infinie while true do n’est pas accepté
Affectation en mikroC = et non := comme en mikropascal
Remarque :
Il est possible d’accéder individuellement à 1 seul bit du PORT. A titre d’exemple, on écrit :
TRISB.F0 = 0 ; ou TRISB.B0=0 ;ou TRISB.RB0
PORTB.F0 = 1 ; ou PORTB.B0=1 ; ou PORTB.RB0=1 ; ou RB0_bit=1 ;
PORTB.0 : n’est pas accepté par le compilateur
/****************************************************************************
LED clignotante
==============
Ce programme fait clignoter une LED connectée au PORTB (broche RB0) avec une période de deux
secondes.
Les commentaires sont utilisés pour préciser le fonctionnement du
Microcontrôleur : 16F84A
programme.
Oscillateur : HS, 4.0000 Mhz Les lignes de commentaires sont ignorées et non compilé par le
Fichier : LED_1 compilateur.
Long commentaire commence par /* et se termine par */
Date : Mars 2021
Court commentaire sur une ligne commence par le caractère « // »
****************************************************************************/
void main() En langage C, un programme
{ commence avec les mots
clés : Void main ()
TRISB = 0; // Configuration du PORTB en sortie
PORTB=0 ; // Initialisation du PORTB
for(;;) // Boucle sans fin
{ Après cela, une accolade
ouvrante est utilisée pour
PORTB.B0 = 0; // RB0 = 0 indiquer le début du corps de
Delay_ms(1000); // Pause d’une seconde programme au lieu de begin
PORTB.B0 = 1; // RB0 = 1
Delay_ms(1000); // Pause d’une seconde
Le programme se termine par
} // Fin de la boucle une accolade fermante
} Au lieu de end.

6.2 Règles générales d’écriture en microC
Les instructions propres au langage mikroC doivent être écrites en minuscule (exemple : void main)
Les instructions relatives aux microcontrôleurs sont généralement écrites en majuscule (exemple : TRISB)
mais le compilateur les accepte même s’elles sont écrites en minuscule.
Les retours à la ligne et les espaces servent uniquement à aérer le code.
Toutes instructions ou actions se terminent par un point virgule « ; ».
Un bloc d’instruction commence par une accolade ouverte { et se termine par accolade fermée }
Autres méthodes :
• Utilisation du caractère
Négation logique !
• Utilisation de la variable sbit : 0n nomme la variable LED_1 de type sbit

La diode LED_1 est toujours branchée à la broche RB0. Syntaxe : sbit LED_1 at PORTB.B0 ;
Ou sbit LED_1 at RB0_bit ;
la syntaxe : sbit LED_1 at PORTB.F0 ; n’est pas acceptée par le compilateur microC
la syntaxe : sbit LED_1 at PORTB.RB0 ; n’est pas acceptée par le compilateur microC
la syntaxe : sbit LED_1 at PORTB.0 ; n’est pas acceptée par le compilateur microC
la syntaxe : Var LED_1 : sbit at PORTB.0 ; n’est pas acceptée par le compilateur microC (ce n’est pas
comme en mikropasal)
N.B : Attention à la façon d’écrire les commandes de MikroC PRO
(sbit n’est pas équivalent à Sbit. Vous êtes appelés à respecter la casse)

• Utilisation des équivalences
Directive # define
Dans la phase de précompilation le préprocesseur
remplace LED_1 par PORTB.B0
Assignation du nom LED_1 à PORTB.B0
N.B Respecter la casse on écrit #define minuscule. Exemple : si on écrit # Define on aura ce message d’erreur
Activité1 : Ecrire un programme en MikroC permettant de clignoter tout le PORTB avec une période 2s
On constate que seule la broche RB0 clignote puisque l’opérateur ! (not) utilisé réalise la fonction non juste
pour un seul bit elle nous renvoie une valeur booléenne. Pour que tout le PORTB clignote on utilise
l’opérateur tilde « ~ » ( Alt Gr 2 puis espace pour un clavier azerty) l’opérateur ~ complémente tout le mot
binaire bit à bit

Autre méthode en utilisant l’opérateur conditionnel
Opérateur ternaire (le seul dans C à requérir trois opérandes : une condition et deux expressions) :
Opérateur Equivalent Notation Priorité Ordre
?: opérateur conditionnel e? x:y 3 droite-gauche
Cette expression est une sorte de si alors sinon sous forme d'expression : si la condition e est vraie alors
cette expression vaut x sinon elle vaut y .
Exemple : a = (v == 2) ? 1 : 5 ; //Affecte la variable a à la valeur 1 si v vaut 2, sinon affecte la
variable a à la valeur 5. Si v=2 alors a=1 sinon a=5
Reprenons l’exemple de l’activité 1 mais en utilisant l’opérateur conditionnel
Activité2 : On désire commander la LED D1 en utilisant le bouton poussoir BP : une impulsion sur le
bouton poussoir BP allume la LED D1 durant 3s puis elle s’éteint.
Ecrire un programme mikroC qui répond au cahier de charges.
Utilisation de la structure conditionnelle
Si ( condition ) alors action 1 sinon action 2
Condition du test :
== « Test d’égalité » non
>,<,>=,<=, condition
oui
!= « test de différence»
&& ET logique Action1 Action2
|| Ou logique etc …
NB : le test d’égalité se fait avec == et non pas avec un seule = comme en mikropascal
Ne pas confondre == (test d'égalité) et = (affectation)
non
Si BP==1
oui
Led=1 Led=0
pause 3s

N.B : la condition doit être mise entre parenthèse sinon le compilateur indique une erreur
If BP==1 n’est pas accepté par le compilateur ce qu’on doit écrire c’est if (BP==1)
Même remarque pour la boucle : while 1 sans parenthèse n’est pas acceptée par le compilateur ce qu’on
doit écrire c’est while (1)
Instruction sélective if :( Branchements conditionnels)
L’ instruction conditionnelle if permet d’exécuter des instructions de manière sélective en fonction du

résultat d’un test. La déclaration du format général de l'instruction if est la suivante :
If (expression) instruction1; else instruction2;
Si l’expression est vraie (valeur non nulle), l’instruction1 s’exécute sinon, dans le deuxième cas, c’est
l’istruction2 qui s’exécute.
Dans l'exemple suivant, si la valeur de x est supérieure à MAX alors la variable P est incrémentée de
1, sinon elle est décrémenté de 1:
if (x > MAX)
P++;
else
P--;
Nous pouvons avoir plus d'une instruction en joignant les instructions entres accolades.
Par exemple:
if (x> MAX)
P++;
Cnt = P;
Sum = Sum + Cnt ;
else
P--;
Dans cet exemple, si x est supérieur à MAX, alors les trois instructions qui sont entres accolades sont
exécutées, sinon l’instruction P-- est exécutée.
Un autre exemple en utilisant l'instruction if :
if (x> 0 && x <10)
{Total + = Sum; Sum++;}
else
{Total = 0;Sum = 0;}

Les opérateurs de comparaison :
Opérateur Nom Notation Priorité Ordre

== Test d’égalité x==y 9 gauche -droite
!= Test de non égalité x !=y 9 gauche -droite
<= Test inférieur ou égal x<=y 10 gauche -droite
Test supérieur ou
>= x>=y 10 gauche -droite
égal
< Test inférieur strict x<y 10 gauche -droite
> Test supérieur strict x>y 10 gauche -droite
Théoriquement, le résultat d'une comparaison est une valeur booléenne (vraie ou fausse).
En C, le résultat d'une comparaison est 1 ( != 0) ou 0 selon que cette comparaison est vraie ou fausse.
Les opérateurs logiques
Une variable booléenne est une variable pouvant prendre la valeur vrai ou faux.
La valeur d'une expression booléenne est, comme le résultat des comparaisons, une valeur entière.

&& ET X&&y 5 gauche -droite
|| OU x ||y 4 gauche -droite
! (unaire) Non !x 14 droite -gauche
Activité3 : Même cahier de charges que l’activité 2, on change seulement la condition sur le bouton
poussoir BP
3000
Activité4 : On désire commander une LED D1 en utilisant

deux boutons poussoirs BP1 et BP2 .Une impulsion sur le
bouton poussoir BP1 allume la LED D1 et une impulsion
sur le bouton poussoir BP2 éteint la LED D1.

Activité5 : Les sorties d’un système
combinatoire sont régies par les
équations logiques ci dessous :
S1= A+B+C
S2=B.D
S3= A⊕B
S4=A.B+D
S5=A B
S6=A.B
S7=A+B
Ecrire un programme en mikroC qui

permet d’implanter le système
combinatoire correspondant.
N.B :la variable C n’est pas acceptée par le compilateur

| Opérateur avec Alt Gr 6
Les opérateurs de manipulation de bits
~ Opérateur avec Alt Gr 2 puis espace

& ET bit à bit x&y 8 gauche -droite
| OU bit à bit x |y 6 gauche -droite
^ OU exclusif bit à bit X^y 7 gauche -droite
~ (unaire) NON bit à bit ~x 14 droite -gauche
>> Décalage à droite x>>b 11 droite -gauche
<< Décalage à gauche X<<b 11 droite -gauche
Activité6 : Même cahier de x est décalé b fois à droite
charges que l’activité 5 mais x est décalé b fois à gauche
en utilisant les équivalences

Activité6-bis (Autre méthode)
// Zone de déclaration des variables d'affectation de procédures des fonctions
#define A RA0_bit
#define B RA1_bit
#define C1 RA2_bit
#define D RA3_bit
#define S1 RB0_bit
#define S2 RB1_bit
#define S3 RB2_bit
# define S4 RB3_bit
#define S5 RB4_bit
#define S6 RB5_bit
#define S7 RB6_bit
void main()
TRISA=0x1F; // configuration du portA en entrée
TRISB=0b00000000; // configuration du portB en sortie
PORTB=0;
while (1) // Boucle infinie
S1= A ||B|| C1;
S2= B&&D;
S3= A^B;
S4= D||B&&!A;
S5 =!S3;
S6= !(A&&B);
S7= !(A||B);

Activité7 : Un circuit à base de 16F84A, comporte 3 boutons poussoirs (S0,S1 et S2 reliés respectivement
à RA0,RA1 et RA2) et trois LED (D0,D1 et D2 reliées respectivement à RB0,RB1 et RB2) .
L’action sur l’un des boutons poussoirs entraine l’allumage de la diode de même indice et l’extinction des
autres. Si aucun des boutons n’est actionné, une LED (D7) branchée sur la broche RB7 s’allume. Ecrire un
programme mikroC qui répond à ce cahier de charges.
Instruction switch ….case : (Au cas ou) « (en pascal case expression of) »
Pour éviter les tractions de l’imbrication des if, on fait appel à une instruction plus élégante appelée switch
et dont la syntaxe est la suivante :
break
switch (condition) Case1 instruction1 Case1 instruction1
{
Case condition1 : instruction1 ;break ;
break
Case condition2 : instruction1 ;break ; Case2 Instruction2 Case2 Instruction2
…………………………………………..
Case3 Instruction3 Case3 Instruction3

Case conditionN : instruction N ;break ;
Default : instruction N+1;
}
Sans break Avec break
N.B La condition doit être de type char ou int et non pas de type float par exemple
Activité8 : Même cahier de charges que l’activité 7 mais on utilise l’instruction switch au lieu des tests
imbriqués
Dans le schéma relatif à l’instruction switch, les liaisons effectuées sur les broches RA3 et RA4 à travers
deux résistors sont nécessaires pour éviter de laisser des broches à l’air libre ce qui peut influer les valeurs
prises par ces broches à un moment donné puisqu’ on va tester sur tout le PORTA
Donc si PORTA=1 D01 sauter
si PORTA=2 D11 sauter
si PORTA=4 D21 sauter
Autrement D71

On ne doit pas oublier les break
Instruction d’itération for , while, do

Les instructions d’itération nous permettent d’effectuer des boucles dans un programme, où une partie d’un
code doit être répétée un certain nombre de fois. Dans mickroC, l’itération peut être effectuée de quatre
façons :
• Utilisation de for
• Utilisation de while
• Utilisation de do
• Utilisation de goto, continu et break
Instruction for « (en pascal for … to … ) » Instructions

La syntaxe d’une instruction for est :
for (expression initiale ; expression de condition ; expression incrément) I=i+1
instructions
{
Instructions ;
Ce type de boucle nécessite l’utilisation d’une variable qui doit être
}
déclaré auparavant dans la zone de déclaration des variables.
Exemple 1 :
for (i=0 ;i<10 ;i++) Trois paramètres :
1°) Initialisation : une instruction qui s’exécute une seule fois au début de la boucle
{ 2°) La condition : la condition pour que la boucle continu
Instructions; 3°) l’incrémentation : une instruction qui s’exécut e à chaque itération, i++ →i=i+1
}

N.B : La boucle « for » est généralement utilisée lorsqu’on connait d’avance le nombre d’itération
d’une boucle.
Exemple 2 :
Les paramètres d’une boucle for sont toujours optionnelles et peuvent être omises.
char j=0,i=20 ;
for ( ;i<100 ;i++) j=j+1 ; // pas de condition de départ et pas d’accolade puisque on exécute une instruction
Exemple 3 :
for ( ; ;) // Boucle sans fin

Exemple 4 : Boucles imbriquées
Les boucles imbriquées peuvent également être utilisées. Dans une boucle for imbriquée, la boucle
intérieure est exécutée pour chaque itération de la boucle externe. Dans l'exemple suivant la boucle
interne est exécutée 5 fois et la boucle extérieure est exécutée 10 fois. Le nombre d’itérations totales est de
cinquante :
// Exemple de deux boucles imbriquées
for (i = 0; i < 10; i++)
{
for (j = 0; j < 5; j++)
{
Instructions;
}
}
Activité 9 : On désire faire clignoter une diode D branchée sur la broche RA0 d’un PIC 16 F84A
Condition de départ
Condition de fin
Quizz :
Combien de fois la LED va s’allumer dans ce programme ?
• 4 fois
• 5 fois
• 6 fois La réponse est évidemment 5 fois

Activité 10 : Même cahier de charges que l’activité 9 mais avec l’option décrémentation.
Quizz :
Combien de fois la LED va s’allumer par ce programme ?
• 6 fois
• 5 fois
• 4 fois La réponse est évidemment 5 fois
Les opérateurs arithmétiques

Opérateurs arithmétiques en mikroC En mikropascal
Opérateur opération Notation Priorité ordre
+ Addition x+y 12 Gauche-droite + Addition
- Soustraction x-y 12 Gauche-droite - Soustraction
* Multiplication x*y 13 Gauche-droite * Multiplication
/ Division x/y 13 Gauche-droite / Division
div Division entière
% modulo x%y 13 Gauche-droite mod Reste de la division
N.B :L’opérateur « / » (division) se comporte de manière différente selon que les opérandes sont des
entiers ou des nombres flottants :
• Nombres flottants : le résultat est un nombre flottant obtenu en divisant les deux nombres ;
• Nombres entiers : le résultat est un nombre entier obtenu en calculant la division entière ou division
euclidienne
L’opérateur % (modulo) n’est défini que pour les entiers et le résultat est le reste de la division
entière des opérandes
Comment identifier les chiffres unité, dizaine,

Exemple :
centaine et millier d’un nombre ?
int a=20,b=3,d
Exemple :N=9573
d=a / b // résultat d= 6 c’est la division entière N=9573
d=a % b // résultat d= 2 c’est le reste de la division Unité de N N % 10 3
entière Dizaine de N (N / 10) % 10 7
Centaine de N (N / 100) % 10 5
Millier de N N / 1000 9

Activité 11 : Compteur modulo1000 avec affichage multiplexé (utilisation du boucles for imbriquées)
Instruction while
La syntaxe d’une instruction while est la suivante
Tant que la condition est vraie

while (condition)
( !=0) la boucle est effectuée,
{ La boucle peut ne jamais être
Instructions ; effectuée si la condition est fausse
}

Exemple1 : Quizz :
Int K=0; Combien de fois la LED va s’allumer par ce programme ?

• 9fois
while (K<10) • 10fois
{ • 11fois
La réponse est évidemment 10 fois
RA0_bit=1; // Allumer LED
Delay_ms(500);
Quizz :
RA0_bit=0; //Eteindre LED;
Donner la valeur de K lorsque on sort du boucle ?
Delay_ms(500); • 9
K++; • 10
• 11 La réponse est évidemment 10
}
Exemple2 :
while (1) // boucle sans fin puisque la condition est toujours vraie
{
Instructions;
}
N.B : Il est possible d’avoir une déclaration while sans corps. Une telle déclaration est utile.
Voici un exemple où le programme va attendre aussi longtemps que le bit 0 de PORTA est au niveau
logique 0. Le programme se poursuivra jusqu'au changement à la valeur 1 sur la broche RA0
while (PORTA.B0==0); ou while ( !PORTA.B0);

Activité 12 :
Le fonctionnement consiste à faire clignoter une LED branchée sur la broche RB0 toutes les 500ms, tant
que le bouton branché sur la broche RA0 est actionné. Autrement, la LED branchée sur la broche RB1
s’allume en continu.
Ecrire un programme en mikroC qui traduit ce cahier de charges.
Activité 13 :
On se propose de clignoter un nombre de fois une LED en fonction de la durée de pression sur un bouton
poussoir : si on presse rapidement la LED clignote une fois, si on presse très longuement la LED clignote
plusieurs fois. Tant qu’on presse sur le bouton poussoir on va incrémenter un compteur qui augmente
toutes les 20ms , une fois on a relâché le bouton poussoir on va décompter.
Ecrire un programme en mikroC qui traduit ce cahier de charges.
Nombre de clignotements
selon durée poussoir
Bouton
Compteur
LED
On déclare une variable de type entier nommée C_time

Instruction do while (condition)
La boucle finie do while (condition) est identique à while(), à la seule différence que la condition est
évaluée à la fin de la boucle. Donc dans ce cas les instructions entre accolades sont au moins
exécutées une seule fois.
La syntaxe d’une instruction do while est la suivante :
do
{
instruction_1 ;
instruction_2 ;
etc….
instrcuction_n ;
}
while (condition) ;

Activité 14 :
Reprenons l’activité 12 mais au lieu d’utiliser la structure while on utilise la structure do
Les instructions de branchement non conditionnel :

Instruction go to
Une instruction go to peut être utilisée pour modifier le flux normal de contrôle dans un programme. Elle
provoque le saut de programme jusqu'à l’instruction étiquette correspondant.
Une étiquette peut être n’importe quel jeu de caractères alphanumériques commençant par une lettre et se
termine par le caractère « : »
Exemple :
Utilisation de l’instruction if et l’instruction go to pour créer un programme en itération.
K=0; Quizz :
Étiquette
boucle: Combien de fois les instructions vont se répéter :
Instructions; • 9 fois
• 10 fois
K++ ; • 11 fois
La réponse est évidemment 10 fois
If (K<10) go to boucle;
Quizz :
Donner la valeur de K lorsque on sort du boucle ?
• 9
• 10
Instruction break
On a vu le rôle de l’instruction break au sein d’une instruction de branchement multiple switch. L’instruction
break peut être plus généralement employée à l’intérieur de n’importe quelle boucle. Elle permet
d’interrompre le déroulement de la boucle et passe à la première instruction qui suit la boucle. En cas de
boucles imbriquées, break fait sortir de la boucle plus interne.

Exemple :
Calculer la somme des nombres 1,2,3,4,5 Quizz :
Sum=0 ; Donner la valeur de Sum lorsqu’on sort du boucle for :
i=1 ; • 14
• 15
for (i=1 ;i<=10 ;i++) • 16 La réponse est évidemment 15
{
If (i>5) break; // si i>5 on sort de la boucle
Sum=sum+i;
}
Instruction continue
L’instruction continue permet de passer directement au tour de boucle suivant, sans exécuter les autres
instructions de la boucle.
Exemple :
Calculer la somme des nombres 1, 2, 3, 4, 6, 7, 8, 9,10
Sum=0 ; Quizz :
i=1 ; Donner la valeur de Sum lorsqu’on sort du boucle for :
• 50
for (i=1 ;i<=10 ;i++)
{ • 55
If (i==5) continue; // si i=5 on passe à l’itération suivante sans exécuter l’instruction
Sum=sum+i;
}
Activité 15 : (Grafcet1)
Objectif : L'objectif de cette activité est de traduire un grafcet d’un point de vue de la partie commande en
un en programme en MikroC. On donne le tableau d’affectation des entrées /sorties
pour le microcontrôleur PIC 16F84A :
GRAFCET P.C
Entrées Sorties
0 Broche du Broche du
Capteurs Préactionneurs
microcontrôleur microcontrôleur
Dcy Dcy RB0 KM1 RA0
1 KM1 L11 RB1 KM2 RA1
L11 a RB2 KM3 RA2
L10 RB3
2 KM2
a
3 KM3
L10

Activité 16 : (Grafcet2)
On donne le tableau d’affectation des entrées /sorties
0 pour le microcontrôleur PIC 16F876A :
m Entrées Sorties
1 KM1 KM2 AV Broche du Broche du
Capteurs Préactionneurs
a microcontrôleur microcontrôleur
m RA0 KM1 RB0
2 T a RA1 KM2 RB1
t / 2 / 5s b RA2 AV RB2
3 KM1 KM2 AR AR RB3
b
KM1 KM2 AV AR
?
? ? ?
U1
+5V
9 21
OSC1/CLKIN RB0/INT
10 22
OSC2/CLKOUT RB1
23
RB2
2 24
RA0/AN0 RB3/PGM
3 25
RA1/AN1 RB4
4 26
m 5
RA2/AN2/VREF-/CVREF
RA3/AN3/VREF+
RB5
RB6/PGC
27
6 28
RA4/T0CKI/C1OUT RB7/PGD
7
RA5/AN4/SS/C2OUT
11
a 1
MCLR/Vpp/THV
RC0/T1OSO/T1CKI
RC1/T1OSI/CCP2
12
13
RC2/CCP1
14
RC3/SCK/SCL
15
b 10k 10k 10k
RC4/SDI/SDA
RC5/SDO
16
17
RC6/TX/CK
18
RC7/RX/DT
PIC16F876A
Activité 17 : (Grafcet3 : séquences multiples)
0 CT=0
10k +5V
m
m
1 KM1 KM2 AV
a1 a1
2 KM1 AR a0
U2
a0 16
15
OSC1/CLKIN RA0
17
18
OSC2/CLKOUT RA1
1
3 CT= CT + 1 4
MCLR
RA2
RA3
2
3
RA4/T0CKI ? KM1
6
RB0/INT
7
RB1
8
CT=4 CT<4 RB2
RB3
9 ? KM2
10
RB4
11
RB5
12
RB6
RB7
13 ? AV
PIC16F84A
? AR

Activite_16

Activite_17

Mise en œuvre d’une interruption en C
En mikroC la routine interruption est déclarée en tant que fonction avec le nom spécial Interrupt
void interrupt()
{
Instructions;
}
Rappel : sur le registre INTCON et OPTION_REG
Configurer le registre INTCON en vue d’activer l’interruption externe sur RB0
GIE EEIE T0IE INTE RBIE T0IF INTF RBIF Valeur INTCON
INTCON
… … … … … ... ... ... ............
AVANT L’INTERRUPTION : Au cours du déroulement normal du programme principal :
Le bit7 (GIE=…) Le bit4 (INTE=…) Le bit (INTF=…)
Lorsque l’interruption a eu lieu le registre INTCON = ……
INTCON
… … … … … ... ... ... ..............
AU COURS DE L’INTERRUPTION : Le microcontrôleur exécute la routine d’interruption :

Le bit7 (GIE=…) Le bit4 (INTE=1) Le bit (INTF=…)
Il faut impérativement mettre à 1 le bit GIE et mettre à zéro l’indicateur INTF à la fin du sous-programme
d’interruption pour pouvoir revenir au programme principal et autoriser de nouvelles interruptions sur la
broche RBO/INT. A la sortie de la routine d’interruption on écrit la valeur ( ….)16 dans le registre INTCON.
INTCON
… … … … … ... ... ...
CONCLUSION :
Déroulement normal du programme principal Au cours d’une interruption A la fin de l’interruption
INTCON=0x……. INTCON=0x…. INTCON=0x………..
Il faut toujours remettre le registre INTCON à 0x….. à la fin de la routine d'interruption pour autoriser une
autre interruption ou bien mettre les bits :
INTCON.INTF=0 et INTCON.GIE =1 ou INTCON.b1=0 et INTCON.b7 =1 (en respectant l’ordre)
N.B si on veut produire l’interruption sur le front descendant d’une impulsion appliquée sur RB0 on doit
mettre un 0 au bit INTEDG du registre POTION_REG
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0

RBPU INTEDG TOCS TOSE PSA PS2 PS1 PSO
Si INTEDG = 1, l’interruption s’effectuera si le niveau sur RB0 passe de 0 vers1 (front montant de RB0).
Si INTEDG = 0, l’interruption s’effectuera si RB0 passe de 1 vers 0 (front descendant de RB0).
À l'issue d’un Reset, tous les bits du registre OPTION_REG sont à 1.
Activité 18 : Interruption externe avec RB0↑ ↑
Ecrire un programme en mikroC qui déclenche une interruption sur RB0 (front montant) et à chaque
impulsion sur le bouton poussoir BP relié à la broche RB0 inverse l’état de la diode LED D reliée à la
broche RA0.

↓
Activité 19 : Interruption avec RB0↓
Si vous l’avez remarqué, dans le programme principal, on a aucune action à réaliser. Le programme attend
tout simplement l’interruption pour inverser l’état de la diode. Malgré cette attente en apparence passive, le
PIC consomme de l’énergie pour ne rien faire. Pour remédier à cet inconvénient, on peut assurer la même
fonction globale du circuit en basculant le PIC en mode sleep (mode veille).
Cette possibilité est accessible par le biais de la commande assembleur suivante : asm sleep ;
(Commande ou instruction à ajouter à la fin du programme principal)
Reprenons donc l’activité 18 et ajoutons cette commande tout en modifiant l’interruption pour la rendre
active sur front descendant

Activité 20 : Interruption avec RB0
On va reprendre l’activité précédente, avec la modification suivante : la diode LED changera d’état toutes
les 3 impulsions sur le bouton poussoir (3 interruptions)
Analyse : Pour chaque interruption on va incrémenter une variable nommé i de type char et on test la
variable si elle est égale à 3 on change l’état de la diode et on initialise la variable i , sinon on sort de
l’interruption.
Activité 21 : Interruption avec RBI (RB4 à RB7)
Quatre LED dont chacune signale l’entrée en mode interruption par inversion de leur état .Ces diodes sont
associées aux boutons de la façon suivante :
D1 pour le bouton BP1 branché sur RB4,
D4 pour le bouton BP4 branché sur RB7.

Activité 22 : Deux interruptions dans un même projet (avec RB0 et RB4)
Si on actionne le bouton poussoir a on inverse l’état de la diode LED D1 (interruption sur RB0)
Si on actionne le bouton poussoir b on inverse l’état de la diode LED D2 (interruption sur RB4)
Compléter la configuration du registre intcon :
INTCON
… 0 0 … … 0 0 0 0x...

Activité 23 : Afficheur LCD
Soit le schéma de simulation d’un afficheur LCD ci-dessous.
Ecrire un programme qui permet d’afficher sur la première ligne votre « Nom » et sur la deuxième ligne le
texte « Admis(e) »
Animer l’affichage avec un défilement à droite puis à gauche
LCD_CMD(_LCD_SHIFT_RIGHT ) Décalage de l’affichage à gauche
LCD_CMD(_LCD_SHIFT_LEFT) Décalage de l’affichage à droite

Activité 24 : Afficheur LCD et écriture des lettres en arabe
Cette activité montre comment écrire des lettres en arabe :
Soit à réaliser l’affichage suivant sur un afficheur LCD 16x2
4 S T 1 π = 180 ° 1 4
c o m p t e u r : 3 5
Menu Tools - LCD custom character
Taper la lettre et générer le code en C

Programme :

Activité 25 : Afficheur LCD et conversion des variables en chaine de caractères
Dans cette activité on va écrire un programme qui réalise la conversion de données vers le string (chaine
de caractères), afin de vous faciliter les mécanismes de conversions mis en jeu pour chaque type de
variable.

Activité 26 : Signalisation lumineuse d’un robot
La signalisation lumineuse d’un robot est assurée par une série de 8 diodes LED de couleur rouge. Ces
diodes permettent à l’utilisateur de connaitre l’état du robot :
Le fonctionnement des diodes est le suivant :
À l’arrêt, les diodes sont toutes éteintes.
En fonctionnement, le robot allume les diodes l’une après l’autre (chenillard).
Lorsque sa batterie est à la limite de la décharge, le robot effectue un clignotement des diodes.
Durant la charge de la batterie toutes les diodes sont constamment allumées.
On peut mettre en œuvre la fonction signalisation lumineuse du robot en utilisant un microcontrôleur
comme suit :
0
U1
16 17
RA7/OSC1/CLKIN RA0/AN0
15 18
RA6/OSC2/CLKOUT RA1/AN1
1
RA2/AN2/VREF
4 2
RA5/MCLR RA3/AN3/CMP1
3
RA4/T0CKI/CMP2 D1
R1
6
RB0/INT
7
RB1/RX/DT
8
RB2/TX/CK D2
RB3/CCP1
9 R2
10
RB4
11
RB5
12
RB6/T1OSO/T1CKI D3
RB7/T1OSI
13 R3
PIC16F628A D4
R4
D5
R5
D6
R6
D7
R7
D8
R8
Tableau résumant le fonctionnement des diodes
PORTA RA1 RA0 Etat du robot Etat des diodes

0 0 0 Arrêt Eteintes
1 0 1 Batterie à la limite de décharge Clignotent
2 1 0 Fonctionne chenillard
3 1 1 Charge de la batterie Allumées

Activité 26 : signalisation lumineuse d’un robot (Utilisation des fonctions)
Fonctions dans mikroC
Une fonction est un sous programme qui est composé d’un ensemble d’instructions permettant de réaliser
un traitement spécifique. L’objectif est de pouvoir réutiliser cet ensemble d’instructions sans avoir à les
réécrire à chaque fois où on va en avoir besoin. En effet, dans certaines situations on a besoin de répéter
un traitement à différents endroits d’un même programme. Au lieu de dupliquer le code à chaque fois, il
suffit de la déclarer à l’intérieure d’une fonction et de l’appeler en cas de besoin.
Chaque fonction doit être déclarée de manière à être correctement interprétée au cours du processus du
compilation. La déclaration contient les éléments suivants :
• Nom de la fonction,
• Liste des paramètres,
• Déclaration des paramètres,
• Corps de la fonction,
• Type de résultat de la fonction.
La syntaxe générale de la déclaration d’une fonction est montrée ci-dessous :

type nom_fonction(type parameter1, type parameter2, .....)
{
.............
// corps de la fonction
Une fonction nommé Mult, reçoit deux arguments de
.............
type entiers a et b, et renvoie leur produit
}
Exemple : int Mult (int a, int b)
{
return (a*b)
}

Quand une fonction est appelée, elle s'attend généralement à donner le nombre d'arguments exprimés en
liste d'arguments de la fonction. Par exemple, la fonction précédente peut être appelée :
z = Mult (x, y); où la variable z est le type de donnée int. // z=x*y
Certaines fonctions ne renvoient pas de valeur, on les spécifie par le mot clé void
Exemple :
void LED(unsigned char D)
Une fonction LED, reçoit un argument de type char, et ne renvoie rien.
{
PORTB = D;
}
Exemple d’appel de la fonction : LED(45) ; // PORTB=45 ;
En outre, certaines fonctions ne renvoient pas de valeur et ne possèdent pas d'arguments.

Exemple :
void Compl() Dans l'exemple suivant, la fonction, nommée Compl, complémente le
{ PORTC du microcontrôleur, ne renvoie pas de données et n'a pas
PORTC = ~PORTC; d'arguments
}
Cette fonction peut être appelée en tant que : Compl ();
Programme :

Activité 27
On désire réaliser un chenillard de 8 leds branchées sur le PORTB, le sens est choisi suivant un bouton BP
relié à la broche RA0 :
Si BP=0 : chenillard à gauche.
Si BP=1 : chenillard à droite.
Utiliser deux fonctions :
Void decalage_droite()
Void decalage_gauche()

Activité 28 :TMR0 (compteur modulo 10 et affichage avec un afficheur à 7 segments)
On désire réaliser un compteur modulo10 en utilisant le timer TMR0, en mode compteur « entrée de
comptage sur RA4 »↑ avec un coefficient de prédivision =1 (sortie sur le port B)
1°) Configurer le registre « OPTION_REG »
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0

RBPU INTEDG TOCS TOSE PSA PS2 PS1 PSO
1 1 1 0 1 0 0 0
2°) Saisir le programme ci-contre puis simuler et vérifier le fonctionnement :
U1
16 17
OSC1/CLKIN RA0
15 18
OSC2/CLKOUT RA1
RA2
1 0
4 2
MCLR RA3
3
RA4/T0CKI
6
RB0/INT
7
RB1
8
RB2
9
RB3
10
RB4
11
RB5
12
RB6
13
RB7
PIC16F84A
Activité 29: TMR0 (compteur modulo 25 et affichage avec afficheurs à 7 segments)

On désire réaliser un compteur modulo 25 en utilisant le timer TMR0, en mode compteur « entrée de
comptage sur RA4 »↓ avec un coefficient de prédivision =1 (sortie sur le port B)

Activité 30 :TMR0 (compteur modulo 21et affichage avec un afficheur LCD)
On désire réaliser un compteur modulo 21 en utilisant le timer TMR0, en mode compteur « entrée de
comptage sur RA4 »↓ avec un coefficient de prédivision =1 (sortie sur le port B), et sur un afficheur LCD
(PIC 16F876A)

Activité 31 : Convertisseur sortie sur LCD
Pour lire et afficher la température de la lampe « ultraviolet » d’un robot aspirateur on utilise un
microcontrôleur PIC 16F876A, un afficheur LCD 16x2 et un capteur de température LM35. Ce dernier
fournit à sa sortie une tension proportionnelle à la température (10mV /10°C) .
V
En appliquant la règle de trois T = avec T en °C et V en mV
10
Le convertisseur CAN du microcontrôleur convertit toute tension comprise entre 0 et 5V (0 à 5000mV) en
un nombre sur 10 bits (de 0 à 1023) . En appliquant encore la règle de trois on obtient :
V Canal 0 A.D.C N
N × 5000 N × 500
V = avec V en (mV) → T = avec T en °C
1023 1023
V N
5000 mV 1023

Conversion de type (cast)
Une conversion de type intervient lorsqu’ un opérateur doit agir sur des opérandes de types différents. En
général, les opérandes sont alors convertis selon la règle suivante :
L’opérande la plus petite est convertit dans le type de l’opérande la plus grande.
Char → int → long → float → double (conversion implicite çad faite automatiquement par le compilateur).
Exemple :
char nombre_1=45 ;
Int nombre_2 ;
Nombre_2=nombre1 ;// nombre_2=45
Il est aussi possible de forcer une conversion de type (conversion explicite),
Syntaxe : (type) objet ;
Exemple :
float nombre_1 =10.23 ;
int nombre_2 ;
nombre_2 = (int) nombre_1 ; // nombre_2= 10

GESTION D’UN CLAVIER
Le mikroC PRO pour PIC fournit une bibliothèque pour travailler avec des claviers « en bloc de touches
4x4 ». Les routines de bibliothèque peuvent également être employées avec le bloc de touches 4x1, 4x2,
ou 4x3.
L’utilisation de ce clavier nécessite un port obligatoirement bidirectionnel 8 bits.
Instructions spécifique au compilateur « MikroC pro » pour le Clavier
char keypadPort at PORTD; // Pour la connexion du clavier au PORTD considéré (8 bits)
char kp; //on définit une variable de type octet
Keypad_Init();// Initialisation du clavier
kp = Keypad_Key_Press();// lecture de code de la touche « touche enfoncée » de 1 à 16.
kp = Keypad_Key_Click();// lecture de code de la touche « touche enfoncée puis libérée »de 1 à 16.
Activité N°33 (Clavier_1)
Saisir le programme suivant puis simuler le fonctionnement de chaque circuit et remplir les tableaux
correspondants :
Code en
Touche
décimal
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10
11 11
12 12
13 13
14 14
15 15
16 16

Code en
Touche
décimal
1 1
?
?
?
?
?
R9
Circuit 2
16
U1
OSC1/CLKIN RA0
10k
17
2 5
15 18
4
OSC2/CLKOUT
MCLR
RA1
RA2
RA3
RA4/T0CKI
1
2
3
1 2 3 4
3 9
L1
RB0/INT
RB1
RB2
6
7
8
L1 R1
10k
4 13
9
7 8
RB3
RB4
RB5
RB6
10
11
12
5 6
5 2
13 L2 R2
PIC16F84A
RB7
10k 6 6
lecture 10 11 12
L3
9
R3
7 10
15 16
10k
8 14
13 14
L4 R4
9 3
Colonne1
10k
10 7
Colonne2 11 11
Colonne3 12 15
Colonne4
13 4
On fait une balayage sur les colonnes et on lit sur les lignes
R8
10k
R7
10k
R6
10k
R5
10k 14 8
15 12
Le balayage se fait avec RB4 RB5 RB6 RB7
16 16
Lecture sur RB0 RB1 RB2 RB3 RB4
Activité N°34 (Clavier 2)

Ecrire un programme qui permet d’afficher sur la
première ligne et la première colonne La touche
est :
et en 2éme ligne et 1ére colonne Touche : le code de
la touche appuyé du clavier à la colonne 10
char keypadPORT at PORTC;

sbit LCD_RS at RB2_bit;
sbit LCD_EN at RB3_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_RS_direction at TRISB2_bit; if (kp==1) kp='7';
sbit LCD_EN_direction at TRISB3_bit; if (kp==2) kp='4';
sbit LCD_D4_direction at TRISB4_bit; if (kp==3) kp='1';
sbit LCD_D5_direction at TRISB5_bit; if (kp==4) kp='C';
sbit LCD_D6_direction at TRISB6_bit; if (kp==5) kp='8';
sbit LCD_D7_direction at TRISB7_bit;
if (kp==6) kp='5';
char kp;
void main() if (kp==7) kp='2';
{ if (kp==8) kp='0';
lcd_init(); if (kp==9) kp='9';
Keypad_Init(); if (kp==10) kp='6';
lcd_cmd(_lcd_clear); if (kp==11) kp='3';
lcd_cmd(_lcd_cursor_off); if (kp==12) kp='=';
lcd_out(1,1,"La touche est:");
if (kp==13) kp='/';
lcd_out(2,1,"Touche:");
while (1) if (kp==14) kp='*';
{ if (kp==15) kp='-';
kp=0; if (kp==16) kp='+';
while (kp==0) lcd_chr(2,10,kp);
{ }
kp=keypad_key_click(); }
}

Activité N°35 (Clavier 3)
On reprend l’activité N°34 juste on change la boucl e while avec do while et la structure conditionnelle
switch au lieu de if. Le programme devient :
char keypadPORT at PORTC; while (kp==0) ; /* ne quitter pas ce boucle

sbit LCD_RS at RB2_bit; que lorsque la condition devient
sbit LCD_EN at RB3_bit; fausse çad une touche actionnée*/
sbit LCD_D4 at RB4_bit; switch(kp)
sbit LCD_D5 at RB5_bit; {
sbit LCD_D6 at RB6_bit; case 1: kp='7'; break;
case 2: kp='4'; break;
sbit LCD_RS_direction at TRISB2_bit;
sbit LCD_EN_direction at TRISB3_bit; case 3: kp='1'; break;
sbit LCD_D4_direction at TRISB4_bit; case 4: kp='C'; break;
sbit LCD_D5_direction at TRISB5_bit; case 5: kp='8'; break;
char kp; case 8: kp='0'; break;
void main() case 9: kp='9'; break;
{ case 10: kp='6'; break;
lcd_init(); case 11: kp='3'; break;
Keypad_Init();
case 12: kp='='; break;
lcd_cmd(_lcd_clear); case 13: kp='/'; break;
lcd_cmd(_lcd_cursor_off); case 14: kp='*'; break;
lcd_out(1,1,"La touche est:");
case 15: kp='-'; break;
lcd_out(2,1,"Touche:");
while (1) case 16: kp='+';
{ }
kp=0; lcd_chr(2,10,kp);
do }
{ }
kp=keypad_key_click();
}
Activité N°36 (Clavier_4) « serrure codé »

Pour accéder à un immeuble, l’utilisateur doit saisir un mot de passe à l’aide d’un
clavier matriciel 12 touches installé à l’entrée. Si le mot de passe est correct, l’ouverture
de la porte est assurée par un relais qui doit rester alimenté avec le témoin vert pendant
2 secondes. Si le mot de passe est LEDR
R1
incorrect, un témoin rouge s’allume 220R
? RA3
? RA2
? RA1
? RA0
durant une seconde, la porte reste R2

220R RL1
fermée et l’utilisateur doit saisir à LEDV
D3
1N4148
5V
nouveau le mot de passe. U1

L’appui sur la touche * valide le mot de 16
15
RA7/OSC1/CLKIN
RA6/OSC2/CLKOUT
RA0/AN0
RA1/AN1
17
18
1
R3 Q1 KM1
RA2/AN2/VREF 2N2222
passe saisi, l’appui sur la touche #

4 2
RA5/MCLR RA3/AN3/CMP1 2k2
3
RA4/T0CKI/CMP2
6 R4
RB0/INT
permet d’initialiser le système pour une RB1/RX/DT
RB2/TX/CK
7
8
9
220R
RB3/CCP1
nouvelle lecture du code d’accès. RB4

RB5
10
11
12
LS1
RB6/T1OSO/T1CKI
13
La serrure est munie d’un haut-parleur PIC16F628A
RB7/T1OSI
1
SOUNDER
piézoélectrique «Sounder» qui émet un A 1 2 3

bip sonore à chaque appui sur une B 4 5 6
touche du clavier. C 7 8 9
Schéma du montage :
D 0 #

Programme :
char keypadPort at PORTB; // Clavier est relié au PORTB
char kp,a ;
unsigned code_serrure ;
void main ()
{
trisa=0 ; // PORTA sortie
porta=0 ; // Initialiser le PORTA
CMCON=0X07 ; // désactiver les comparateurs PORTA numérique
code_serrure =0 ;
a=0; // Initialiser les variables
kp=0;
Keypad_Init(); // Initialiser le port pour travailler avec le clavier
sound_init(&porta,3); // Initialiser le module " piezo-haut-parleur " qui est affecté à la broche RA3
tttttttttttj hhhhhhhhhhhhhhhhhhhhhhhhttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt
while (1) // boucle infinie

{
kp = Keypad_Key_Click(); // lecture du code de la touche
if (kp != 0) // si une touche est enfoncée
{
sound_play(1000,100); // produire un son de fréquence 1000hz qui dure 100ms
switch (kp) // selon la valeur de kp " selon la touche enfoncée " la variable a reçoit…. :
{
case 1: a = 1 ; break;
case 5: a= 4 ; break;
case 9: a= 7 ; break;
case 13: a = '*' ; break; // a reçoit le code ASCII du caractère *
case 15: a = '#' ; // a reçoit le code ASCII du caractère #
}
if (a != '*') code_serrure = code_serrure *10 + a ; // s'il n'ya pas d'action sur la touche * alors :
if (a == '#') code_serrure =0; // si on actionne la touche # on initialise le code à 0
if (a == '*') // si on actionne la touche * on valide le code
{
if (code_serrure == 1978) // si le code est correcte ici code=1978 alors
{
porta.RA1=1; // on allume le témoin verte
porta.RA2=1; // on ouvre la porte
delay_ms(2000); // temporisation de 2 secondes
}
else // si non
{
porta.RA0=1; // on allume le témoin rouge
delay_ms(1000); // temporisation de 1seconde
}
code_serrure =0; // initialiser le code à 0
}
porta=0; // Initialiser le porta
}
}
}

Le mikroC PRO pour PIC fournit une bibliothèque de sons pour fournir aux utilisateurs les routines
nécessaires à la signalisation sonore dans leurs applications. La génération de son nécessite du
matériel supplémentaire, tel qu'un piézo-haut-parleur
Instructions spécifique au compilateur « MikroC pro » pour le module Sound
- Sound_Init exemple : Sound_Init (& PORTD, 3); // Initialise la broche RD3 pour jouer le son
- Sound_Play exemple : Sound_Play (1000, 100); // Lecture d'un son de 1 KHz d'une durée de 100 ms
• Déduire à chaque fois la valeur de la variable code_serrure lorsque l’utilisateur appuie sur les
touches données dans le tableau suivant :
Valeur en décimal de la variable Porte Témoin Témoin
Touche appuyé
code_serrure= code_serrure *10 + a ouverte rouge verte
# 0 non non non
4 0+4=4 non non non
7 4*10 + 7 = 47 non non non
8 47*10+8 = 478 non non non
1 478*10 +1= 4781 non non non
* Validation 4781 ≠ 1978 après 1seconde 0 Non Oui (1s) non
1 1 non non non
9 19 non non non
7 197 non non non
8 1978 non non non
* Validation 1978 =1978 après 2seconde 0 oui (2s) non oui (2s)
# 0 non non non
5 5 non non non
4 54 non non non
* Validation 54 ≠ 1978 après 1seconde 0 non Oui (1s) non
Activité N°37 (Clavier_5 :serrure codé amélioré )

Activité N°38 ;Modulation de largeur d’impulsion
Ecrire un programme en MikroC PRO qui permet la génération d’un signal PWM de fréquence 5 KHz, dont
le rapport cyclique est modifié a l’aide de 2 boutons (augmentation + et diminution -). , on dispose aussi
d’un bouton arrêt qui arrête le moteur : la valeur X à placer sur le module set Duty est affichée sur le portB
et portA Vérifier le fonctionnement avec Proteus ISIS ?
• Utilisation de la fonction Button (&port,bit,temps d’appui en ms ,état logique actif)

Exemple :
if Button (&portA,3,50,1) then « action1 »//On teste l’appui sur un bouton poussoir relié à la
broche RA3 pendant 50ms pour faire l’action 1
Instructions spécifique au compilateur « MikroC pro » pour le module PWM
- PWM1_Init exemple : PWM1_Init (5000); // Initialisez le module PWM1 à 5 KHz
- PWM1_Set_Duty exemple:PWM1_Set_Duty (192); //Réglez le rapport cyclique à 75%
- PWM1_Start PWM1_Start (); // démarrer le module
- PWM1_Stop PWM1_Stop (); // arrêter le module

Activité N°39
Réaliser un compteur et décompteur modulo10
• Compteur incrémenté par le bouton RA2.
• Décompteur décrémenté par le bouton RA1.
Utilisation de la fonction Button (&port,bit,temps d’appui en ms ,état logique actif)

Activité N°40 : Comment programmer un front montant ou un front descendant ?
Réaliser un compteur modulo10 sortie sur le PORTA, le compteur est incrémenté par un front
montant « ↑ » sur RB1
Programme :
bit EA,EP; // déclaration de deux variables de type bit
void main()
{
TRISA=0; // tout le PORTA est configuré comme sortie
TRISB.RB1=1; // la broche RB1 est configuré comme entrée
PORTA=0; // Initialisation du PORTA à 0
EA=0;EP=0; // Initialisation des deux variables à 0
while (1)
{
EA : état actuel while (PORTA<10) // tant que PORTA<10
EP : état précédent {
EA=1 EA=PORTB.RB1; // mise à jour de EA
if (EA&&!EP) PORTA++; // incrémentation sur front montant
EP=0
EP=EA; // mise à jour de EP
}
PORTA=0;
On appui sur le bouton }
}
RB1 0 0
0 0
EA
EP 0
On relâche sur le bouton
Mise à jour de l’état précédent Mise à jour de l’état précédent
Résultat du test 0 On appui sur le bouton EA=0 // EA= PORTB.RB1
Pas d’incrémentation EP=EA =1 EP=EA =0
EA=1 // EA= PORTB.RB1 Résultat du test faux EA=0 et EP=1
du PORTA Résultat du test faux Résultat du test faux
Résultat du test vraie EA=1 et EP=0 Pas d’ incrémentation du PORTA
Pas d’incrémentation Pas d’incrémentation
On aura incrémentation du PORTA du PORTA du PORTA

Si on veut changer le front montant en descendant
Programme :
EP=1
bit EA,EP; // déclaration de deux variables de type bit
EA=0 void main()
{
TRISA=0; // tout le PORTA est configuré comme sortie
On relâche sur le bouton
TRISB.RB1=1; // la broche RB1 est configuré comme entrée
PORTA=0; // Initialisation du PORTA à 0
EA=0;EP=0; // Initialisation des deux variables à 0
while (1)
{
while (PORTA<10) // tant que PORTA<10
{
EA=PORTB.RB1; // mise à jour de EA
if ( !EA&&EP) PORTA++; // incrémentation sur front descendant
EP=EA; // mise à jour de EP
}
PORTA=0;
}
}
Activité N°40 bis même cahier de charge mais on uti lise une seule variable de type char
Etat
Etat.f1 Etat.f0
Programme : État précédente État actuel
unsigned char etat=0; // variable nommé etat de 8 bits
void main()
{
TRISA=0;
TRISB.RB1=1;
PORTA=0;
etat=0;
while (1)
{
while (PORTA<10)
{
etat.f0=PORTB.RB1;
if (ETAT.F0&&!ETAT.F1) PORTA++;
ETAT.F1=ETAT.F0;
}
PORTA=0;
}
}

Opérateurs binaires d'affectation composés
La syntaxe des opérateurs d'affectation composés est: expression1 op = expression2
où op peut être l'un des opérateurs binaires +, -, *, /,%, &, |, ^, <<, ou >>. (Sans espace entre op et =)
Opérateur Notation Équivalent Priorité Ordre

+= x+= y x=x+y 2 droite-gauche
–= x– = y x=x–y 2 droite-gauche
*= x*=y x=x*y 2 droite-gauche
/= x/=y x=x/y 2 droite-gauche
%= x%=y x=x%y 2 droite-gauche
>>= x>>=y x=x>>y 2 droite-gauche
<<= x<<=y x=x<<y 2 droite-gauche
&= x&=y x=x&y 2 droite-gauche
|= x|=y x=x|y 2 droite-gauche
^= X^=y x=x^y 2 droite-gauche
Espaces séparant les opérateurs composés (par exemple + = ) générera une erreur.
Opérateurs unaires d’incrémentation ou de décrémentation
Opérateur Notation Équivalent Priorité Ordre

++ x++ ou ++x x=x+1 14 droite-gauche
–– x– – ou – –x x=x–1 14 droite-gauche
y = x++; est le raccourci pour y = x; x = x + 1; (post-incrémentation)

y = ++ x ; est le raccourci pour x = x + 1; y = x; (pré-incrémentation)
L'opérateur séquentiel
Cet opérateur permet de regrouper plusieurs expressions en une seule
, Opérateur séquentiel e1,e2 Priorité 1 Ordre droite gauche

Notion sur la programmation modulaire
Jusqu’ici nous n’avons travaillé que dans un seul fichier appelé main.c .Pour le moment c’est acceptable
car nos programmes étaient tous petits. Si le programme est composé de plusieurs fonctions se trouvant
toutes dans un même fichier, on obtient alors un programme trop long.
Dès que l’on écrit un programme de taille importante ou destiné à être utilisé et maintenu par d’autres
personnes, il est nécessaire de fractionner le programme en plusieurs fichiers sources. L’objectif est de
rendre le programme lisible, portable facile à maintenir et à modifier.
Projet composé d’un seul fichier source .c (main) Projet composé de 2 fichiers sources .c et un
fichier Header (entête) .H
Comme vous le voyez, il ya deux types de fichiers :
Les fichiers .h appelés headers. Ces fichiers contiennent les prototypes des fonctions : déclaration
des fonctions indiquant au processeur qu’il existe une fonction appelé ... et qui prend tels paramètres
en entrées etc. Cela permet au processeur de s’organiser.
Les fichiers .c : ce sont des fichiers sources qui contiennent les fonctions elles – mêmes.
Pour chaque fichier .c, il ya son équivalent .h sauf la fonction main n’a pas de prototype parce que le
processeur la connait, c’est toujours la même pour tous les programmes.
Il faut inclure le fichier .h grâce à une directive de préprocesseur qui s’appelle # include avec des
guillemets sans espaces (exemple : # include ‘’fichier_1.h‘’) .
La commande # include demande d’insérer le contenu du fichier _1.h dans le fichier .c, et dans le fichier .h
on trouve seulement les prototypes des fonctions du fichier fichier_1.c
Exemple d’application :
Activité N°41
Prenons un exemple simple : Soit à clignoter deux PORTs (PORTA et PORTB d’un microcontrôleur
PIC 16F84A) en même temps à période de 1s. On va diviser le programme en deux fichiers source .c et un
fichier .h. Le clignotement du PORTA est fait avec la fonction main, (premier fichier source nommé
fichier_0), et le clignotement du PORTB est fait avec une autre fonction Clignote_PORTB (2ème fichier
source nommé fichier_1). Le prototype de cette fonction se trouve sur un fichier header nommé fichier_1.h
Comment ajouter des fichiers .c et .h à un projet ?
Commencer par créer un nouveau projet nommé par exemple Projet_1 modulaire, attribuer à ce projet un
fichier .c nommé par exemple fichier_0.c (qui contient la fonction main)

Création d’un autre fichier
Fonction clignote_PORTB qu’on va la

programmer dans un autre fichier source

Nommer ce fichier fichier _1 par exemple et préciser le type ici .c puisque c’est un fichier source
Dans ce fichier écrire le programme (le corps de la fonction clignote_PORTB)

Ajouter un autre fichier
Donner le même nom à ce fichier (fichier _1) et préciser le type ici .h (fichier header)
2 fichiers sources
Contient la fonction principale main
1 fichier d’entête

Dans le fichier .h, écrire seulement le prototype de la fonction clignote_PORTB c'est-à-dire la
première ligne de la fonction avec un point virgule à la fin.
Dans la fonction main fichier_0.c, ajouter la directive de préprocesseur # include ‘’fichier_1.h’’

pour insérer le prototype de la fonction clignote_PORTB au programme principale.
Compiler puis simuler.

QUELQUES PIEGES CLASSIQUES
• Erreurs sur l'affectation
Ce que le programmeur a écrit a == b;
Ce qu'il aurait dû écrire a = b;
• Erreurs avec les macros
#define n'est pas une déclaration
Ce que le programmeur a écrit : #define MAX 10;
Ce qu'il aurait dû écrire : #define MAX 10
Cette erreur peut provoquer ou non une erreur de compilation à l'utilisation de la macro :
L'utilisation x = MAX; aura pour expansion x = 10;;
Ce qui est licite : il y a une instruction nulle derrière x = 10; // pas d’erreur dans la compilation mais erreur
pour le fonctionnement.
L'utilisation int t[MAX]; aura pour expansion int t[10;]; //Ce qui génèrera un message d'erreur.
#define n'est pas une initialisation
Ce que le programmeur a écrit #define MAX = 10
Ce qu'il aurait dû écrire #define MAX 10
• Erreurs avec l'instruction if
Ce que le programmeur a écrit if ( a > b) ; a = b;
Ce qu'il aurait dû écrire if ( a > b) a = b;
• Erreurs avec les commentaires
Il y a deux erreurs avec les commentaires :
1. Le programmeur oublie la séquence fermante /*. Le compilateur ignore donc tout
le texte jusqu'à la séquence fermante du prochain commentaire.
2. On veut enlever (en le mettant en commentaire) un gros bloc d'instructions sans prendre garde au fait
qu'il comporte des commentaires.
• Erreurs avec les priorités des opérateurs
Les priorités des opérateurs sont parfois surprenantes. Les cas les plus gênants sont les suivants :
La priorité des opérateurs bit à bit est inférieure à celle des opérateurs de comparaison.
Le programmeur a écrit il désirait il a obtenu

x & 0xff == 0xac (x & 0xff) == 0xac x & (0xff == 0xac)
La priorité des opérateurs de décalage est inférieure à celle des opérateurs arithmétiques.
Le programmeur a écrit il désirait il a obtenu

x << 4 + 0xf (x << 4) + 0xf x << (4 + 0xf)

La priorité de l'opérateur d'affectation est inférieure à celle des opérateurs de comparaison.
Dans la séquence ci-dessous, très souvent utilisée, toutes les parenthèses sont nécessaires :
while ((c = getchar()) != EOF) {
...
}
• Erreurs avec l'instruction switch
Oubli du break
Erreurs sur le default
L'alternative à exécuter par défaut est introduite par l'étiquette default. Si une faute de frappe est commise
sur cette étiquette, l'alternative par défaut ne sera plus reconnue : l'étiquette sera prise pour une étiquette
d'instruction sur laquelle ne sera fait aucun goto.
switch(a){
case 1 : a = b;
defult : return(1); /* erreur non détectée */
Quelques raccourcis clavier très utile :
Ctrl +A Sélectionner tout

Ctrl +C Copier
Ctrl +F Trouver
Ctrl +R Remplacer
Ctrl+V Coller
Ctrl+X Couper
Ctrl+Y Supprimer la ligne
Ctrl+Z Annuler
Ctrl+G Aller à la ligne
Ctrl+Alt+L Convertir la sélection en minuscule
Ctrl+Alt+U Convertir la sélection en majuscule

TRAVAUX DIRIGÉS
Exercice N°1 :
On désire clignoter une LED à l’aide d’un microcontrôleur 16F84A comme donné par la figure suivante :
Le fonctionnement normal est décrit par le chronogramme suivant :
TB=500ms
LED D1 Période
TH=1000ms
TH TB t(ms)
Ecrire un programme en MikroC qui permet de traduire le cahier de charges.
.............................................................
……………………………………….
Exercice N°2 :
On désire automatiser la gestion des LEDs tricolores à l’aide d’un microcontrôleur 16F84A comme le
montre la figure ci-contre.
1) Ecrire un programme MikroC qui permet de faire clignoter les 3 LEDs tricolores simultanément. Le
fonctionnement normal est décrit par le chronogramme suivant :
TB=1000ms
LED :D1,D2,D3 Période TH=1000ms
TH TB t(ms)
.............................................................
……………………………………….
Exercice N°3 :
On propose de faire clignoter des LEDS branchées au PORTB du microcontrôleur de deux façons
différentes :
• 1ère façon :
- Si RA0=0, toutes les LEDS clignotent avec une période d’une seconde (0,5s allumées, 0,5s éteintes)
- Si RA0=1, les LEDS doivent clignoter chaque 500ms comme indiqué dans la figure ci-dessous.
RB7 RB6 RB5 RB4 RB3 RB2 RB1 RB0

Ecrire un programme en mikroC permettant de commander les diodes LEDs
.............................................................
……………………………………….
• 2éme façon :
- Si RA0=0, toutes les LEDS clignotent avec une période de deux secondes
- Si RA0=1 on obtient le cycle répétitif suivant :
Diodes LED allumées Durées (en seconde)
D0D1 1
D2D3 2
D4D5 3
D6D7 4
Aucune diode 1
Ecrire un programme en miKroC permettant de commander les diodes LEDs
.............................................................
……………………………………….
Exercice N°4 :
On veut maintenant réaliser plusieurs animation sur les LEDS commandées par les boutons poussoirs B1
et B2 selon le tableau suivant :
N°
B2 B1 Séquence Durée de défilement
séquence
0 0 0 D0etD1 -D2etD3 –D4etD5 -D6etD7 200ms
Chenillard à droite
1 0 1 100ms
D7-D6-D5-D4–D3-D2-D1-D0
2 1 0 D0etD7 –D1etD6 –D2etD5 –D3etD4 200ms
Chenillard à gauche
3 1 1 100ms
D0-D1-D2-D3–D4-D5-D6-D7

Ecrire un programme en mikroC permettant de commander les diodes LEDs
…………….
Exercice N°5 :
On désire commander deux LEDs à l’aide d’un interrupteur via un microcontrôleur
PIC 16F84A comme donnée par la figure ci-contre.
1°) Ecrire un programme en MikroC qui permet de fai re
allumer et éteindre les deux LEDS par l’interrupteur BP
……..

2°) Ecrire un programme MikroC qui permet d’indique r l’état ouvert ou fermé de l’interrupteur BP :
– LED rouge allumée : interrupteur ouvert.
– LED jaune allumée : interrupteur fermé.
……..
Exercice N°6 :
On désire commander deux LEDs à l’aide de deux boutons poussoirs via un microcontrôleur
16 F84A comme donnée par la figure ci-contre.
Ecrire un programme en MikroC qui permet de faire
allumer la LED bleu pour une durée de 3s et la LED
verte pour une durée de 5s suite à l’action de l’un de
deux boutons poussoirs.
……..
Exercice N°7:
On désire automatiser la gestion de feux tricolores, réglant la circulation d’un carrefour à deux voies.
L’étude se limitera à un seul feu et le fonctionnement normal est décrit par le chronogramme donné par la
figure ci-dessous.

Ecrire le programme en MikroC correspondant à ce cahier de charges.
……..
Exercice N°8:
Gestion de deux feux tricolores de circulation (carrefour)
Ecrire un programme en MikroC qui permet de piloter deux feux tricolores de carrefour. Vérifier le bon
fonctionnement du programme réalisé en utilisant Proteus ISIS.
Le chronogramme de fonctionnement est le suivant :
Pour faciliter la tache on programme par PORT entier

1°) compléter le tableau :
Voie 2 Voie1
Vert2 Orangé2 Rouge2 Vert1 Orangé1 Rouge1
RB5 RB4 RB3 RB2 RB1 RB0
PORTB=… … … … … … …
Duréé …
PORTB=… … … … … … …
Durée …
PORTB=… … … … … … …
Durée 32secondes
PORTB=… … … … … … …
Durée …
2°) Ecrire le programme en MikroC
……..

Exercice N°9:
Gestion de deux feux tricolores de circulation et deux passages piétons
Ecrire un programme en MikroC qui permet de piloter un carrefour avec passage piétons. Vérifier le bon
fonctionnement du programme réalisé en utilisant Proteus ISIS.
« PP » piétons de la route principale

« FP » Feux de la route principale
« PS » piétons de la route secondaire
« FP » Feux de la route secondaire
Le chronogramme de fonctionnement est le suivant :
Pour faciliter la tache, on programme par PORT entier, les feux tricolores sont connectés au PORTB et les
feux des piétons sont connectés au PORTA
Feux route secondaire Feux route principale
Feux piéton route secondaire Feux piéton route principale
Vert Rouge Vert Rouge
RA3 RA2 RA1 RA0

1°) Compléter le tableau :
Voie 2 secondaire Voie1 principale
Feux Piétons Feux Piétons
Vert2 Orangé2 Rouge2 V R Vert1 Orangé1 Rouge1 V R
RB5 RB4 RB3 RA3 RA2 RB2 RB1 RB0 RA1 RA0
PORTB=12
0 0 1 1 0 0
PORTA= 9 1 0 0 1
Duréé 32secondes
PORTB= …
PORTA=…
Durée
PORTB=…
PORTA=…
Durée
PORTB=…
PORTA=…
Durée
……..
Exercice N°10:
On désire commander une LED par plusieurs endroits à l’aide d’un microcontrôleur
16F84A via des boutons poussoir BPi (BP1, BP2 et BP3).
Le principe de fonctionnement est le suivant : une impulsion sur l’un des boutons poussoir BPi, la LED D
s’allume, une deuxième impulsion la LED s’éteint.
……..
Ecrire un programme MikroC qui répond au cahier de charges

(Utilisation de la fonction Button (&port,bit,temps d’appui en ms ,état logique actif) pour éliminer les
rebonds des boutons poussoirs).

Exercice N°10: (autre méthode sans utiliser la fonc tion button)
……..
Exercice N°10: bis

Refaire le même travail mais en changeant le câblage comme suit :
……..

Exercice N°11:
On désire réaliser une minuterie d’escalier à 3 temps réglable (1min, 3min, 5min) à l’aide d’un
microcontrôleur 16F84A selon la figure suivante :
Le principe de fonctionnement est le suivant :

• Une impulsion sur l’un des boutons poussoirs BPi (BP1, BP2, BP3), la LED s’allume pendant une ou
3 ou 5minutes puis elle s’éteint.
• Le temps est réglable par un commutateur C à 3 positions
Ecrire un programme MikroC qui répond au cahier de charges
……..

Exercice N°12:
Soit les équations suivantes d’un système logique combinatoire :
S1 = A + B + C1.B S2 = A.B + C1.B +C S3 = A + B + C.B S4 = A ⊕ B S5 = B.C1.A
On propose le schéma de simulation suivant :
Écrire un programme en MikroC qui permet d’implanter le système

combinatoire précédant.
……..
Exercice N°13: (UAL)

Pour réaliser des opérations arithmétiques et logiques, on s’adresse aux PORTS E/S du microcontrôleur
16F877A tels que les PORTC et PORTD désignent les PORTS d’entrées binaires à 4 bits
A (a3,a2,a1,a0) et B(b3,b2,b1,b0) et le PORTB représente le PORT de la sortie S(S4,S3,S2,S1,S0)
permettant un affichage des résultats de sortie en binaire S4 étant la retenue.
Les entrée de sélection des opérations à réaliser sont affectées aux bits RE0, RE1, RE2 du PORTE
Le tableau ci-dessous résume le fonctionnement de L’UAL
Bits de sélection
Opérations
RE2 RE1 RE0
001 AND
010 OR
011 XOR
100 +
101 -
110 *
111 /

Établir un programme en mikroC permettant de réaliser les différentes opérations désignées par le tableau
selon le schéma ci-dessous :
N.B Penser à utiliser l’appel des fonctions spécifiques pour chaque opération.
……..

Exercice N°14: (Comparateur)
On se propose d’écrire un programme assurant la comparaison entre deux mots A et B à 4 bits et afficher
le résultat sur un afficheur 7 segments (à cathodes communes) tant que la broche RE0 est active (Entrée
de validation)
Remarque : MikroC vous permet de déterminer le code 7 segments ; en allant dans : Tools Seven Segment Editor.
Si A>B Si A=B Si A<B
……..

Exercice N°15:
On désire commander un afficheur à 7 segments (à cathode commune)
sans décodeur à fin de réaliser un compteur modulo 10 à l’aide d’un
microcontrôleur 16F84A.
La cadence d’affichage des chiffres de 0 à 9 est de 500ms ,déclarer un
tableau tab[10] contenant les codes 7segments des chiffres de 0 à 9 et
A
avec une boucle for repérer le code à envoyer
F B
G
1°) Remplir la table de vérité suivant de l’affiche ur à 7 segments. E C
D
Chiffre 0 Chiffre 1 Chiffre 2 Chiffre 3 Chiffre 4
63 6 91 79 102
Chiffre 5 Chiffre 6 Chiffre 7 Chiffre 8 Chiffre 9

109 125 7 127 111
Segment G F E D C B A
PORTB=
Chiffre RB6 RB5 RB4 RB3 RB2 RB1 RB0
0 0 1 1 1 1 1 1 63
1
2
3
4
5
6
7
8
9
2°) Écrire un programme en MikroC qui permet de rép ondre au cahier des charges.
……..

Exercice N°16:
Écrire un programme en mikroC qui permet de réaliser

le fonctionnement suivant :
• Compteur modulo 10 commandé par la
position 1 du switcher RA0
• Décompteur modulo 10 commandé par la
position 2 du switcher (RA1)
Programme :
……..
Exercice N°17:
Écrire un programme en mikroC qui permet de réaliser le

fonctionnement suivant :
• Compteur des nombres pairs commandé par la
position 1 du switcher RA0
• Compteur des nombres impairs commandé par la
position 2 du switcher (RA1)

Programme :
……..
Exercice N°18:
Écrire un programme en mikroC qui permet d’incrémenter les chiffres

en appuyant sur le bouton poussoir relié à la broche RA3
Programme :
……..

Refaire le même programme mais en utilisant la fonction button.
Programme :
……..
Exercice N°19:
Écrire un programme en mikroC qui permet de contrôler l’affichage de deux chiffres (2 digits)
7 segments de 0 à 99 avec une cadence de 500ms. (déclarer un tableau tab[10] contenant les 10 codes 7
segments des chiffres de 0 à 9 et avec des boucles for repérer le code à envoyer)
Programme :
……..
Exercice N°20:
On désire réaliser un compteur modulo 100 par deux afficheurs 7 segments sans décodeur. On utilise le
principe de l’affichage multiplexé à l’aide d’un microcontrôleur 16F84A.
Ecrire un programme en mikroC qui permet de réaliser le compteur modulo100, les deux broches RA0 et
RA1 permettent de sélectionner l’un des deux afficheurs 7 segment à cathodes communes.

Programme :
……..

Exercice N°21:
On désire réaliser un compteur modulo 100 par deux afficheurs 7 segments avec décodeur. On utilise le
principe de l’affichage multiplexé à l’aide d’un microcontrôleur 16F84A.
Écrire un programme en mikroC qui permet de réaliser le compteur modulo100, les deux broches RA0 et
RA1 permettent de sélectionner l’un des deux afficheurs 7 segment à anodes communes.
Programme :
……..

Exercice N°22: (Commande d’un moteur pas à pas)
On désire commander un moteur pas à pas à l’aide d’un PIC 16F84A conformément au chronogramme
illustré par la figure 1 :
AV
A D
AV
B C
ROTOR Phase A
BC D
S
C
STATOR
Chronogramme de fonctionnement du moteur pas à pas commandé par un PIC16F84A.
1 2 3 4 5 1 2 3 4 5
Cycle
1seconde Arrêt
Figure 1
1°) Selon le schéma du circuit logique, déterminer la valeur du registre TRISA et TRISB sachant que les
broches non utilisées sont configurées comme entrées :
TRISA=0X ………. TRISB=0B ………………..
2°) A partir du chronogramme du moteur pas à pas, r emplir sa table de vérité suivante :
RA2 RA1 RA0 cycle RB3 RB2 RB1 RB0 PORTB=…

… … … 1 1 0 0 1 …
Marche avant 2
3
(AV) PORTA=…
4
5
RA2 RA1 RA0
Arrêt … … …
PORTA=….
RA2 RA1 RA0 1
.. … … 2
Marche arrière
3
(AR) PORTA=… 4
5

3°) Écrire un programme en mikroC qui répond au cah ier de charges.
Programme :
……..
Exercice N°23
On ajoute à l’exercice précédente un bouton relié à la broche RA3 qui sélectionne le mode de fonctionnent
de telle sorte que :
Si RA3=1 : mode de fonctionnement asymétrique et vitesse double
Si RA3=0 : mode de fonctionnement symétrique et vitesse normale
AV
ROTOR Phase A
N
BC D
S
STATOR

Écrire un programme en mikroC qui répond au cahier de charges.
……..

Exercice N°24
Même cahier de charges que l’exercice N°23 mais on utilise un tableau et les boucles for.
Programme :
……..

Exercice N°25 ( Afficheur LCD)
Soit le montage ci-dessous
Écrire un programme en mikroC qui répond au fonctionnement suivant :
• Un appui sur le bouton B1 seul, l’afficheur affiche ‘BONJOUR’ et la diode D1 clignote (1hz)
• Un appui sur le bouton B2 seul, l’afficheur affiche ‘BONSOIR’ et la diode D2 clignote (1hz)
• Un appui sur le bouton B3 seul, l’afficheur affiche ‘SALAM’ et la diode D3 clignote (1hz)
• Pour les autres cas, rien ne se passe
D1 : diode verte, D2 : diode jaune, D3 : diode rouge
Programme :
……..

Exercice N°26( Clavier)
On désire commander un afficheur à 7 segments à l’aide d’un microcontrôleur 16F84A via un clavier à 12
touches (Figure ci-dessous). Le principe de fonctionnement est le suivant :
- L’appui sur une touche de 0 à 9 affiche sa valeur sur l’afficheur 7 segments.
- L’appui sur la touche (*) affiche la lettre « c » code d’entrée du décodeur « 10 »..
- L’appui sur la touche (#) affiche la lettre « c » renversé code d’entrée du décodeur « 11 »
Écrire le programme en mikroC qui répond à ce cahier des charges
……..

Exercice N°27( Convertisseur analogique numérique)
Soit le montage suivant :
On veut réaliser un comparateur entre les valeurs de deux
tensions analogiques V0 et V1 appliquées respectivement
V0
sur chacune des pins RA0 et RA1 via de deux potentiomètres.
Écrire un programme en mikroC qui répond au cahier
des charges suivant :
• Si la tension V0>V1 alors afficher la lettre S.
V1
• Si la tension V0=V1 alors afficher la lettre E.
• Si la tension V0<V1 alors afficher la lettre I.
L’affichage des résultats se fera sur un afficheur 7 segments
à cathodes commune comme le montre la figure ci-dessus.
Programme :
……..
Exercice N°28( Convertisseur analogique numérique)

Soit le montage suivant :
• Si la tension V0<V1 On doit faire un comptage modulo20
• Si la tension V0>V1 ,On doit faire un décomptage modulo 20 .
• Si la tension V0=V1 alors afficher la lettre E sur les deux afficheurs.

Programme :
……..
Exercice N°29 ( Convertisseur analogique numérique)

Soit le montage ci-aprés :
• Si la tension V0>V1 alors afficher sur chaque afficheur 7 segments la lettre S
• Si la tension V0=V1, alors afficher sur chaque afficheur 7 segments la lettre E
• Si la tension V0<V1, alors afficher sur chaque afficheur 7 segments la lettre I
Le programme doit afficher aussi sur l’ LCD 16x4 :
Ligne1 : le message « comparateur »
Ligne2 : la valeur de la tension V0
Ligne3 : la valeur de la tension V1
Ligne 4 : la valeur de la tension maximale

Programme :
……..

Exercice N°30 (Modulation de largeur d’impulsion)
Pour faire varier la vitesse d’un moteur à courant continu, on propose le circuit de la figure ci-dessous :
Écrire un programme qui lit une valeur numérique sur le PORTB sous forme d’un nombre codé sur 8 bits, ce
nombre constituera le rapport cyclique d’un signal MLI de fréquence 1KHz qui va être généré par la sortie
RC1 pour commander un moteur à courant continu.
Programme :
……..
Exercice N°31 (Modulation de largeur d’impulsion)
Soit le schéma de la figure ci –après, ou quatre boutons BP1, BP2, BP3 et BP4 sont reliés aux quatre bits
de poids faible du PORTB du microcontrôleur avec les résistances de tirage vers le haut, ces boutons sont
utilisés pour commander le rapport cyclique du PWM de fréquence 5KHz qui est généré par les modules
CCP le fonctionnement est :
• Une impulsion sur le bouton BP1 augmente le rapport cyclique du PWM1
• Une impulsion sur le bouton BP2 diminue le rapport cyclique du PWM1
• Une impulsion sur le bouton BP3 augmente le rapport cyclique du PWM2
• Une impulsion sur le bouton BP4 diminue le rapport cyclique du PWM2

N.B Utiliser la fonction Button (&port,bit,temps d’appui en ms ,état logique actif)
Programme :
……..
Exercice N°32 (Timer TMR0 )

Selon le circuit de la figure ci-contre, écrire un programme en mikroC qui permet d’allumer une diode LED
branchée sur la broche RB0 pendant une seconde puis elle s’éteint chaque fois que 10 fronts montants
sont comptés
Programme :
……..

Exercice N°33 (Timer TMR0 )
On désire réaliser un compteur modulo100 en utilisant le timer TMR0 d’un PIC 16F84A .Le compteur est
incrémenté à chaque front descendant de RA4 .On adopte l’affichage multiplexé puisqu’on dispose d’un
seul décodeur BCD/7segments et de deux afficheurs à anodes communes.
Écrire un programme en mikroC qui répond à ce cahier des charges
Programme :
……..

Exercice N°34 ( interruption avec RB0 )
On désire réaliser un compteur binaire 8 bits et afficher le résultat sur 8 diodes LEDs. Pour réaliser ce
cahier des charges, on propose le circuit de la figure suivante.
Programme :
…….

Exercice N°35 (Interruption avec RB0 )
Modifier le programme précédent à fin d’afficher le résultat du comptage sur un afficheur LCD selon le
montage suivant :
Programme :
…….

Exercice N°36 (Interruption avec RBI )
Le but de cet exercice est de réaliser un décompteur dont le point de départ est géré par des interruptions
généré par le changement d’état sur RB4,RB5,et RB6.
• Si on appui sur RB6 alors le décompteur réalise le circuit suivant : F, E, D,….9, 8…..0.
• Si on appui sur RB5 alors le décompteur réalise le circuit suivant : A,….9, 8…..0.
• Si on appui sur RB4 alors le décompteur réalise le circuit suivant : 7,6…..0.
• Si non le décompteur réalise le cycle par défaut 5, 4,3…0.
Pour réaliser ce cahier des charges, on vous propose le montage ci-dessous, pour simplifier l’affichage des
résultats du décomptage, on utilise un afficheur 7 segments BCD sans décodeur, en effet, cet afficheur
affiche les valeurs de 0 à F (en hexadécimal) directement sans passer par la table de décodage des 7
segments
Programme :
…….

Exercice N°37 (Interruption avec RBI )
Utiliser l’interruption sur RBI pour changer la vitesse de clignotement d’une diode LED connecté à la broche
RA0 selon le schéma de la figure ci-dessous
Visualiser le registre INTCON au PORTC
Programme :
……………….

Exercice N°38 ( Mémoire )
Soit les schémas à contacts suivants :

S3
S2
S4
S1 KM2
KM1
1KM2
1KM1
M1 M2
2KM1 2KM2
Affectation des entrées Affectation des sorties
Entrées Entrées PIC Sorties Sorties PIC

S1 RA0 KM1 RB0
S2 RA1 KM2 RB1
S3 RA2
S4 RA3
On attribue à KM1 une variable de type bit (booléen) X et à KM2 une variable de type bit Y
1°) Donner l’équation de X X= ………………………..
2°) Donner l’équation de Y Y= ………………………..

3°) Traduire ces deux équations par un programme Mi kroC
Programme :
……………….

Exercice N°39 ( Jeux de lumière )
On veut réaliser un jeu de lumière avec 8 LEDs comme le montre le schéma ci-contre
On donne le programme suivant :
char i,j,k,l,m,n,o,p;
void main()
{
trisb=0;
portb=0;
for (;;)
{
for (i=0;i<5;i++)
{PORTB=255; delay_ms(100);PORTB=0;delay_ms(100);}
for (j=0;j<5;j++)
{
PORTB=128;
for (K=0;k<8;k++)
{delay_ms(50);PORTB=PORTB>>1;}
}
for (l=0;l<8;l++)
{
PORTB=1;
for (m=0;m<8;m++)
{delay_ms(50);PORTB=PORTB<<1;}
}
for (n=0;n<10;n++)
{
PORTB=24;delay_ms(50);PORTB=36;delay_ms(50);
}
}
}
Analyser le programme puis décrire brièvement le fonctionnement des LEDs

Exercice N°40 ( Commande d’un moteur à courant con tinu )
Soit à commander un moteur à courant continu en deux sens de marche en utilisant un microcontrôleur
16F84A et deux transistors NPN BC547 et deux relais 12V .On dispose de deux boutons poussoirs pour la
commande du moteur ,un bouton poussoir nommé BP_droite pour la commande du moteur en sens droite
,et un autre bouton poussoir nommé BP_gauche pour commander le moteur à gauche . Tant que un
bouton est actionné le moteur tourne dans le sens adéquat ,si on relâche le bouton le moteur s’arrête .Un
afficheur LCD 16x2 affiche les messages suivants :Si le moteur est à l’arrêt il affiche STOP ,si il tourne à
droite il affiche sens droite s’il tourne à gauche il affiche sens gauche.
Écrire un programme en mikroC qui répond au cahier de charges

………………. ……………….

Exercice N°41 ( Commande d’un moteur à courant cont inu )
On utilise le même cahier de charge de l’exercice précédent mais en modifiant un peu le fonctionnement
du moteur et l’affichage ,en effet on veut que lorsque le moteur tourne dans le sens droite un compteur est
incrémenté tous les 200ms de 0 à 99 ou il atteint la course maximale à droite alors le moteur s’arrête ,la
même chose pour le sens contraire si le moteur tourne à gauche se compteur est décrémenté jusqu'à la
valeur 0 ou il atteint la course maximale à gauche alors le moteur s’arrête .
Écrire un programme en mikroC qui répond au cahier de charges
Programme :
……………….
……………….

Correction des exercices
Exercice N°1 Exercice N°2
void main() void main()
{ {
TRISA.b0=0;PORTA.b0=0; // Configuration et initialisation // Configuration et initialisation
while (1) TRISA=0b11000;PORTA=0;
{ while (1)
RA0_bit=1;delay_ms(1000); {
RA0_bit=0;delay_ms(500); PORTA=7;delay_ms(1000);
} PORTA=0;delay_ms(1000);
} }
}
Exercice N°3
• 1ére façon :
• 2éme façon :
# define B1 RA0_bit # define B1 RA0_bit
void main() void main()

{
{
TRISA=0x1F;TRISB=0;PORTB=0;
TRISA=0x1F; TRISB=0; PORTB=0; while(1)
while(1) {
if (B1==0)
{
{
if (B1==0) // (!B1) PORTB=0XFF;delay_ms(1000);
{ PORTB=0X00;delay_ms(1000);
}
PORTB=0XFF;delay_ms(500);
if (B1==1)
PORTB=0X00;delay_ms(500); {
} PORTB=0X3; delay_ms(1000);
PORTB=0XC; delay_ms(2000);
if (B1==1) //(B1)
PORTB=0x30; delay_ms(3000);
{ PORTB=0xC0; delay_ms(4000);
PORTB=0X55;delay_ms(500); PORTB=0; delay_ms(1000);

}
PORTB=0XAA;delay_ms(500);
}
} }

Exercice N°4
# define B1 RA0_bit
# define B2 RA1_bit
char i;
void main()
{
TRISA=31;TRISB=0;PORTB=0; // Configuration et initialisation
while (1)
{
if (( B1==0)&&(B2==0))
{
PORTB=0X3;delay_ms(200);
PORTB=0XC;delay_ms(200);
PORTB=0XC0;delay_ms(200);
}
if (( B1==1)&&(B2==0))
{
PORTB=0b10000000;
for (i=0;i<8;i++)
{
delay_ms(100);
PORTB=PORTB>>1; // Décalage à droite du PORTB de 1bit
}
}
if (( B1==1)&&(B2==1))
{
PORTB=0b00000001;
for (i=0;i<8;i++)
{
delay_ms(100);
PORTB=PORTB<<1; // // Décalage à gauche du PORTB de 1bit
}
}
if (( B1==0)&&(B2==1))
{
}
}
}

Exercice N°5
1°) 2°) # define BP RA0_bit
# define BP RA0_bit void main()
void main() {
{ TRISA=31;TRISB=0;PORTB=0;
TRISA=31;TRISB=0;PORTB=0; while(1)
while(1) {
{ if (BP==1)PORTB=2;
if (BP==1)PORTB=3; else PORTB=1;
else PORTB=0; }
} }
}
Exercice N°6
Exercice N°7
# define BP1 RA0_bit
# define BP2 RA1_bit # define R RA0_bit
# define LED_BLEU RB0_bit
# define O RA1_bit
# define LED_VERTE RB1_bit
# define V RA2_bit
void main()
{ void main()
TRISA=31;TRISB=0;PORTB=0;
{
while(1)
TRISA=0;PORTA=0;
{
for(;;) // boucle infinie
if( BP1||BP2) // B1 ou B2
{
{
O=0;R=1;delay_ms(1000);
LED_BLEU=1; LED_VERTE=1; delay_ms(3000);
R=0;O=1;delay_ms(600);
LED_BLEU=0; LED_VERTE=1; delay_ms(2000);
O=0;V=1;delay_ms(1000);
}
O=1;V=0;delay_ms(600);
else
}
{
}
LED_BLEU=0; LED_VERTE=0;
}
}
}

Exercice N°8
1°) Voie 2 Voie1

PORTB=12 0 0 1 1 0 0
Duréé 32secondes
PORTB=26 0 1 1 0 1 0
Durée 4scondes
PORTB=33 1 0 0 0 0 1
Durée 32secondes
PORTB=19 0 1 0 0 1 1
Durée 4 secondes
2°) Programme
void main()
TRISB=0;PORTB=0;
while(1)
PORTB=12;
delay_ms(32000);
PORTB=26;
delay_ms(4000);
PORTB=33;
delay_ms(32000);
PORTB=19;
delay_ms(4000);

Exercice N°9
1°) Voie 2 secondaire Voie1 principale
Feux Piétons Feux Piétons
Vert2 Orangé2 Rouge2 V R Vert1 Orangé1 Rouge1 V R
RB5 RB4 RB3 RA3 RA2 RB2 RB1 RB0 RA1 RA0
PORTB=12
0 0 1 1 0 0
PORTA= 9 1 0 0 1
Duréé 32secondes
PORTB=26 0 1 1 0 1 0
PORTA=9 1 0 0 1
Durée 4secondes
PORTB=33 1 0 0 0 0 1
PORTA=6 0 1 1 0
Durée 32secondes
PORTB=19 0 1 0 0 1 1
PORTA=6 0 1 1 0
Durée 4 secondes
2°) Programme :
void main()
{
TRISB=0;PORTB=0;
TRISA=0;PORTA=0;
while(1)
{
PORTB=12;
PORTA=9;
delay_ms(32000);
PORTB=26;
PORTA=9;
delay_ms(4000);
PORTB=33;
PORTA=6;
delay_ms(32000);
PORTB=19;
PORTA=6;
delay_ms(4000);
}

Exercice N°10
void main()
{
trisa=31;
trisb=0;
PORTB=0;
for(;;) // boucle infinie
{
if (Button(&PORTA, 0, 100, 1)) // si RA0 est à l'état 1 pendant 100ms
PORTB.RB7=!PORTB.RB7; // inverser la broche RB7
}
}
Exercice N°10: (autre méthode sans utiliser la fonc tion button)
void main()
{
trisa=0b11111;
trisb=127;
porta=0;
portb=0;
for(;;)
{
if ((PORTA.b0)&(!portb.b7))
{PorTB.b7=1; delay_ms(300);} // Attente 0,3s pour un deuxième appuie
if ((PORTA.b0)&(portb.b7))
{PorTB.b7=0; delay_ms(300);} // Attente 0,3s pour un deuxième appuie
}
}
Exercice N°10: bis
void main() {
trisa=0b11111;
trisb=127;
porta=0;
portb=0;
for(;;)
{
if (((PORTA.b0)|(PORTA.b1)|(PORTA.b2))&(!portb.b7))
{PorTB.b7=1; delay_ms(300);}
if (((PORTA.b0)|(PORTA.b1)|(PORTA.b2))&(portb.b7))
{PorTB.b7=0; delay_ms(300);}
}
}

Exercice N°11:
void main()
{
trisa=0b11011;
trisb=255;
porta=0;
portb=0;
for(;;)
{
if ((PORTA.b0=1)&&(portb.b7=1))
{
PORTA.b2=1;
delay_ms(300000);
PorTA.b2=0 ;
}
if ((PORTA.b0)&&(portb.b6)) {PorTA.b2=1;delay_ms(180000);PorTA.b2=0 ;}
if ((PORTA.b0)&&(portb.b5)){PorTA.b2=1;delay_ms(60000);PorTA.b2=0 ;}
}
}
Exercice N°12:
sbit A at RA0_bit; {
sbit B at RA1_bit;
if (A|B|!C1&!B) S1=1 ; else S1=0;
sbit C1 at RA2_bit;
sbit S1 at RB0_bit; if ( A&!B|!C1&B|C1) S2=1; else S2=0;

sbit S2 at RB1_bit;
if ( !(A|B)|C1&!B) S3=1; else S3=0;
sbit S3 at RB2_bit;
sbit S4 at RB3_bit; if ( !(A^B)) S4=1; else S4=0;

sbit S5 at RB4_bit;
if ( B&!C1&A) S5=1; else S5=0;
void main()
{ }
TrisA=0x1F; // configuration du portA en entrée
}
TrisB=0b11100000; // configuration du portB
PORTB=0; // Initialisation du PORTB
while (1) // début de la boucle infinie

Exercice N°13:
char A,B,E,S1;
void ET_logique () // fonction Et void main()
{ {
S1= (A & B) ; ADCON1=0x17;

}
TRISB=0B11100000;TRISC=255;
void OU_logique () // fonction OU
{ TRISD=255;TRISE=7;
S1= (A | B) ; PORTB=0;
}
while (1)
void OU_exclusive () // fonction OU exclusive
{
{
A= (PORTC & 0X0F);
S1= (A ^ B) ;
B=(PORTD & 0X0F);
}
void addition () // fonction addition E= PORTE;
{ PORTB=S1;
S1= (A + B) ;
if (E==1) ET_logique(); // appel de la fonction
}
if (E==2) OU_logique(); // appel de la fonction
void soustraction () // fonction soustraction
{ if (E==3) OU_exclusive ();// appel de la fonction
S1= (A - B) ; if (E==4) addition (); // appel de la fonction
}
if (E==5) soustraction ();// appel de la fonction
void multiplication () // fonction multiplication
if (E==6) multiplication ();// appel de la fonction
{
S1= (A * B) ; if (E==7) division(); // appel de la fonction
} }
void division () // fonction dvision

}
{
S1= (A / B) ;
}

Exercice N°14: Exercice N° 15
char A,B; char tab [10]={ 63,6,91,79,102,109, 125,7,127,111};
# define V RE0_bit
char i;
void main()
void main()
{
ADCON1=0x17; {
TRISB=0B00000000;TRISC=255;
TRISB=0;
TRISD=255;TRISE=7;
PORTB=0;
PORTB=0;
while (1) while (1)
{
{
PORTB=0;
for (i=0;i<10;i++)
while(V=1)
{ {
A= (PORTC & 0X0F);
PORTB=tab[i];delay_ms(500);
B=(PORTD & 0X0F);
}
if (A==B) PORTB= 121;
if (A>B) PORTB= 109; }
if (A<B) PORTB= 48;
}
}
}
}
Exercice N° 16
char tab [10]={ 63,6,91,79,102,109, 125,7,127,111}; for (i=0 ;i<10;i++)
{
char i;
PORTB=tab[i];delay_ms(500);
void main()
}
{ }
if (PORTA.RA1==1)
TRISA=31;
{
TRISB=0;
for ( i=0 ;i<10;i++)
PORTB=0; {
PORTB=tab[9-i];delay_ms(500);
while (1)
}
{
}
if (PORTA.RA0==1) }
}
{

Exercice N° 17 Exercice N°18
char tab [10]={ 63,6,91,79,102,109, 125,7,127,111}; char tab [10]={ 63,6,91,79,102,109, 125,7,127,111};
char i;
char i;
void main()
{ void main()
TRISA=31; {
TRISB=0;
TRISA=31;
PORTB=0;
while (1) TRISB=0;
{ PORTB=63;
if (PORTA.RA0==1)
while (1)
{
for (i=0;i<10;i+=2) // i+=2 c'est a dire i=i+2 {
{ if (PORTA.RA3==1)
PORTB=tab[i]; delay_ms(500);
{
}
} delay_ms(300);
if (PORTA.RA1==1) i++;
{
PORTB=tab[i];
for (i=1;i<10;i+=2) // i+=2 c'est a dire i=i+2
{ if (i==10) {PORTB=63;i=0;}
PORTB=tab[i];delay_ms(500); }
}
}
}
} }
}
Exercice N°18 while (1)
En utilisant la fonction button {
char tab [10]={ 63,6,91,79,102,109, 125,7,127,111}; if (button (&PORTA,3,100,1))
char i; {
void main() i++;
{ PORTB=tab[i];
TRISA=31; if (i==10) {PORTB=63;i=0;}
TRISB=0; }
PORTB=63; }
}

Exercice N°19 while (1)
char tab [10]={ 63,6,91,79,102,109, 125,7,127,111};
{
char i,j;
for(i=0;i<10;i++)
void main()
{ {
TRISC=0;
for ( j=0;j<10;j++)
TRISB=0;
{
PORTB=0;
PORTC=0; Unite=Tab[j];
while (1)
Dizaine =Tab[i];
{
for (k=0;k<12;k++) // affichage multiplexé
for (i=0;i<10;i++)
{ {
for (j=0;j<10;j++)
Aucun_afficheur;
{
tempo_1;
PORTB=tab[j]; // unité
PORTC=tab[i]; // dizaine portb=Unite ;
delay_ms(500); // tempo
Afficheur_1;
}
tempo_2;
}
} Aucun_afficheur;
}
tempo_1;
Exercice N°20
portb= Dizaine ;
#define Aucun_afficheur PORTA=0b11
Afficheur_2;
#define Afficheur_1 PORTA=0b10
tempo_2;
Aucun_afficheur;
#define tempo_1 delay_ms(1)
tempo_1;
}
char tab[10]={63,6,91,79,102,109,124,7,127,103};
}
char Unite,Dizaine,i,j,k;
}
void main()
}
{
trisa=0; }
trisb=0;
porta=0;

portb=0;
Exercice N°21
#define Aucun_afficheur PORTA=0b00
char Unite,Dizaine,i,j,k,x;
void main()
{
trisa=0;
trisb=0;
porta=0;
portb=0;
while (1)
{
for(i=0;i<10;i++)
{
for ( j=0;j<10;j++)
{
Unite=j;
Dizaine =i;
for (k=0;k<12;k++) // affichage multiplexé
{
Aucun_afficheur;
tempo_1;
portb=Unite ;
Afficheur_1;
tempo_2;
Aucun_afficheur;
tempo_1;
portb= Dizaine ;
Afficheur_2;
tempo_2;
Aucun_afficheur;
tempo_1;
}
}
}
}

}
xercice N°22
1°) TRISA= 0X1F TRISB=0B 11110000

2°)
RA2 RA1 RA0 cycle RB3 RB2 RB1 RB0 PORTB=
0 0 1 1 1 0 0 1 9
Marche Avant 2 1 1 0 0 12
( AV) 3 0 1 1 0 6
PORTA=1
4 0 0 1 1 3
5 1 0 0 1 9
RA2 RA1 RA0
Arrêt 0 1 0 0 0 0 0 0
PORTA=2
RA2 RA1 RA0 1 0 0 1 1 3
1 0 0 2 0 1 1 0 6
Marche arrière
3 1 1 0 0 12
(AR) PORTA=4 4 1 0 0 1 9
5 0 0 1 1 3
3°) Programme :
while(PORTA==4)
#define tempo delay_ms(1000)
void main() {
{
PORTB=3;tempo;
TRISA=0X1F;
PORTB=6;tempo;
TRISB=0B11110000;
PORTB=12;tempo;
PORTB=0;
while (1) PORTB=9;tempo;
{
}
while(PORTA==1)
while(PORTA==2)
{
{
PORTB=9;tempo;
PORTB=0;
PORTB=12;tempo;
}
PORTB=6;tempo;
}
PORTB=3;tempo;
}
}

Exercice N°23
#define tempo1 delay_ms(1000)
void main()
{
TRISA=0X1F;
TRISB=0B11110000;
PORTB=0;
while (1)
{
while(PORTA==1) // sens avant mode de fonctionnement symétrique
{
PORTB=9;tempo1;
PORTB=12;tempo1;
PORTB=6;tempo1;
PORTB=3;tempo1;
}
while(PORTA==9) // sens avant mode de fonctionnement asymétrique
{
PORTB=9;tempo2;
PORTB=8;tempo2;
PORTB=12;tempo2;
PORTB=4;tempo2;
PORTB=6;tempo2;
PORTB=2;tempo2;
PORTB=3;tempo2;
PORTB=1;tempo2;
}
while(PORTA==4) // sens arrière mode de fonctionnement symétrique
{
PORTB=3;tempo1;
PORTB=6;tempo1;
PORTB=12;tempo1;
PORTB=9;tempo1;
}
while(PORTA==12) // sens arrière mode de fonctionnement asymétrique
{
PORTB=3;tempo2;
PORTB=2;tempo2;
PORTB=6;tempo2;
PORTB=4;tempo2;
PORTB=12;tempo2;
PORTB=8;tempo2;
PORTB=9;tempo2;
PORTB=1;tempo2;
}
while((PORTA==2)|(PORTA==10)) // Arret
{
PORTB=0;
}
}

}
Exercice N°24

char tab[]={9,8,12,4,6,2,3,1};
char i;
void main()
{
TRISA=0X1F;
TRISB=0B11110000;
PORTB=0;
while (1)
{
while(PORTA==1) // sens avant mode de fonctionnement symétrique
{
for (i=0;i<8;i+=2)
{
PORTB=tab[i];tempo1;
}
}
while(PORTA==9) // sens avant mode de fonctionnement asymétrique
{
for (i=0;i<8;i++)
{
PORTB=tab[i];tempo2;
}
}
while(PORTA==4) // sens arrière mode de fonctionnement symétrique
{
for (i=0;i<8;i+=2)
{
PORTB=tab[6-i];tempo1;
}
}
while(PORTA==12) // sens arrière mode de fonctionnement asymétrique
{
for (i=0;i<8;i++)
{
PORTB=tab[7-i];tempo2;
}
}
while((PORTA==2)|(PORTA==10)) // Arret
{
PORTB=0;
}

}
}
Exercice N°25
# define B1 RB0_bit
# define B2 RB1_bit
# define B3 RB2_bit
# define D1 RC0_bit
# define D2 RC1_bit
# define D3 RC2_bit
// LCD module connexion
sbit LCD_RS at RD2_bit;
sbit LCD_EN at RD3_bit;
sbit LCD_D4 at RD4_bit;
sbit LCD_RS_Direction at TRISD2_bit;
sbit LCD_EN_Direction at TRISD3_bit;
sbit LCD_D4_Direction at TRISD4_bit;
// Fin module connexion
void main()
{
TRISC=0b11111000;
TRISB=0b11111111;
PORTC=0;
Lcd_Init(); // Initialize LCD
Lcd_Cmd(_LCD_CLEAR); // effacer l'LCD
Lcd_Cmd(_LCD_CURSOR_OFF); // désactiver le curseur
while(1)
{
while (B1&!B2&!B3)
{
Lcd_Out(1,1,"BONJOUR");D1=!D1;delay_ms(500);
}
while (!B1& B2&!B3)
{
Lcd_Out(1,1,"BONSOIR");D2=!D2;delay_ms(500);
}
while (!B1&!B2&B3)
{
Lcd_Out(1,1,"SALAM");D3=!D3;delay_ms(500);
}
while ((!B1&!B2&!B3)|(B1&B2&B3)|(B1&B2&!B3)|(B1&B3&!B2)|(B2&B3&!B1))
{
Lcd_Cmd(_LCD_CLEAR); D1=0;D2=0;D3=0;

}
}
}
Exercice N°26
Exercice N°27
char keypadPORT at PORTB;// connexion du clavier
unsigned int valeur_V0, valeur_V1;
char kp;
void main()
void main()
{
{
TRISA=0b10000; TRISB=0;PORTB=0;
PORTA=0; ADCON1=0X80;
Keypad_Init();
ADC_Init();
while (1)
{ while(1)
kp=0; {
do
valeur_V0= ADC_Read(0);
{
kp=keypad_key_click(); valeur_V1= ADC_Read(1);
} if (valeur_V0 ==valeur_V1)PORTB= 121;

while (kp==0) ; // ne quitter pas ce boucle que lorsque
if (valeur_V0 <valeur_V1)PORTB= 6;
la condition devient fausse çad une touche actionnée
switch(kp) if (valeur_V0 >valeur_V1)PORTB= 109;
{ }
case 1: kp=1; break;
}
case 4: kp=10;break;
}
PORTA=Kp;
}
}

Exercice N°28
unsigned int valeur_V0,valeur_V1;
char i,j;
char tab[]={63,6,91,79,102,109,125,7, 127 ,111};
void main()
{
TRISB=0;PORTB=0;
TRISC=0;PORTC=0;
ADCON1=0X80;
ADC_Init();
while(1)
{
if (valeur_V0 ==valeur_V1)
{PORTB= 121;PORTC=121;}
if (valeur_V0 <valeur_V1)
{
for (i=0;i<2;i++)
{
for (j=0;j<10;j++)
{
PORTB=tab[1-i];PORTC=tab[9-j];delay_ms(500);
}
}
}
if (valeur_V0 >valeur_V1)
{
for (i=0;i<2;i++)
{
for (j=0;j<10;j++)
{
PORTB=tab[i];PORTC=tab[j];delay_ms(500);
}
}
}
}
}

Exercice N°29
unsigned int valeur_conversion_V0,valeur_conversion_V1 ; //2 octets car le résultat de conversion est sur 10 bits
float valeur_V0,valeur_V1;
char valeur_afichage_V0 [14];
char valeur_afichage_V1 [14];
// Connexions de l'LCD
sbit LCD_RS at RD0_bit;
sbit LCD_EN at RD1_bit;
sbit LCD_RS_Direction at TRISD0_bit;
sbit LCD_EN_Direction at TRISD1_bit;
void main()
{
TRISB=0;PORTB=0;
TRISC=0;PORTC=0;
ADCON1=0X80;
ADC_Init(); // initialisation du module CAN
lcd_init(); // initialisation de l'LCD
lcd_cmd(_LCD_CURSOR_OFF); // désactivation du curseur de l'LCD
lcd_out(1,4,"Comparateur"); // affichage Comparateur
lcd_out(2,1,"V0=");
lcd_out(3,1,"V1=");
lcd_out(4,1,"Vmax=");
while(1)
{
valeur_conversion_V0= ADC_Read(0); valeur_conversion_V1= ADC_Read(1);
valeur_V0= ((float)(valeur_conversion_V0)*5.0/1023.0);
valeur_V1= ((float)(valeur_conversion_V1)*5.0/1023.0);
floattostr(valeur_V0,valeur_afichage_V0);
floattostr(valeur_V1,valeur_afichage_V1);
lcd_out(2,5,valeur_afichage_V0 ); // affichage de la valeur V0
lcd_out(3,5,valeur_afichage_V1 ); // affichage de la valeur V1
if(valeur_V0 ==valeur_V1) {PORTB=121;PORTC=121;lcd_out(4,6,valeur_afichage_V1);}
if (valeur_V0 <valeur_V1) {PORTB= 6;PORTC=6; lcd_out(4,6,valeur_afichage_V1);}
if(valeur_V0 >valeur_V1) {PORTB=109;PORTC=109;lcd_out(4,6,valeur_afichage_V0);}
delay_ms(500); // pause entre deux lectures
}
}

Exercice N°30
void main()
{
TRISB=255; // Tout le PORTB est configuré comme entrée
TRISC.RC1=0; // configurer la broche RC1 en sortie
PORTC.RC1 = 0; // initialisé la broche RC1à 0
PWM2_Init(1000); // Initialiser le module PWM2 a 1KHz
PWM2_Start ();
while (1)
{
PWM2_Set_Duty(PORTB);
delay_ms(2000); // attendre pour une nouvelle lecture
}
}
Exercice N°31
char x,y;
void main()
X=0;Y=0;
TRISB=255; // configurer le PORTB en entrée
TRISC=0b11111001; // configurer le PORTC
PORTC = 0;
PWM1_Init(5000); PWM2_Init(5000); // Initialiser les modules PWM1 et PWM2 à 5KHz
PWM1_Start (); PWM2_Start ();
while (1)
if (button (&PORTB,0,50,0) && (X<=254)) X++ ;
if (button (&PORTB,1,50,0)&& (X>0)) X-- ;
if (button (&PORTB,2,50,0) && (Y<=254)) Y++ ;
if (button (&PORTB,3,50,0)&& (Y>0)) Y-- ;
PWM1_Set_Duty(X);PWM2_Set_Duty(Y);
}
}

Exercice N°32
#define LED RB0_bit
void main()
{
TRISB.RB0=0;
PORTB.RB0=0;
TRISA.RA4=1;
OPTION_REG=0b11101111; //TMR0 en mode compteur sur front montant sans pridiviseur
TMR0=0;
while (1)
{
if (TMR0==10)
{LED=1;delay_ms(1000);TMR0=0;}
else
LED=0;
}
}
Exercice N°33
char uni=0,diz=0;
void main()
{
TRISB=0b11110000;
PORTB=0;
TRISA=0b11100;
PORTA=0;
OPTION_REG=0b11111111; // TMR0 mode compteur sur front descendant sans pridiviseur
TMR0=0;
while (1)
{
if (TMR0==100) TMR0=0;
uni =(TMR0 %10) ; // uni = TMR0 modulo10
diz=(TMR0 /10); // diz = TMR0 div10
PORTA=0b00; // affichage multiplexé
delay_ms(1);
PORTB=uni;
PORTA=0b01;
delay_ms(10);
PORTA=0b00;
delay_ms(1);
PORTB=diz;
PORTA=0b10;
delay_ms(10);
}
}

Exercice N°34
void interrupt()
{
PORTC++ ;
INTCON=0X90;
}
void main()
{
TRISC=0;PORTC=0;
INTCON=0X90;
while (1)
{
} void interrupt()
} {
Exercice N°35
X++ ;
int x=0;
INTCON=0X90; // effacer le flag
char affichage [6];
}
// LCD module connexions
void main()
sbit LCD_RS at RC0_bit;
{
sbit LCD_EN at RC1_bit;
Lcd_Init(); // Initialise LCD
sbit LCD_D4 at RC2_bit;
Lcd_Cmd(_LCD_CLEAR); // effacer l'LCD
Lcd_Cmd(_LCD_CURSOR_OFF); // Curseur désactivé
Lcd_Out(1,1,"Nb de piece est:");
Lcd_Out(2,1,"N=");
sbit LCD_RS_Direction at TRISC0_bit;
INTCON=0X90; // autoriser l’interruption avec RB0
sbit LCD_EN_Direction at TRISC1_bit;
while (1)
sbit LCD_D4_Direction at TRISC2_bit;
{
inttostr(X,affichage);
Lcd_Out(2,3,affichage);
}
// fin du module connexion
}

char i,j;
#define LED RA0_bit
void interrupt()
int k ;
{
if (PORTB.RB4) void interrupt ()
{
{
for (i=15;i<255;i--)
{ PORTC=INTCON;
PORTA=i; delay_ms(200); if ( PORTB.RB4) K=1000;
}
if ( PORTB.RB5) K=500;
}
if (PORTB.RB5) if ( PORTB.RB6) K=200;
{ if ( PORTB.RB7) K=100;
for (i=10;i<255;i--)
INTCON.RBIF=0; // Effacer le Flag
{
PORTA=i; delay_ms(200); }
} void main()
}
{
if (PORTB.RB6)
{ ADCON1=0x17;
for (i=7;i<255;i--) TRISC=0;PORTC=0;
{
TRISA.RA0=0;
PORTA=i; delay_ms(200);
} LED=0;
} TRISB=255;
INTCON.RBIF=0; //effacer le flag pour sortir de l'interruption
K=2000;
}
void main() INTCON=0X88;
{ while (1)
INTCON=0b10001000;
{
TRISA=0;PORTA=0;
TRISB=0b11111111; PORTC=INTCON;
while (1) LED=!LED; Vdelay_ms(K);
{
}
for (j=5;j<255;j--)
{ }
PORTA=j; delay_ms(1000);
}
}
}

sbit LCD_RS at RB0_bit;

# define S1 RA0_bit
sbit LCD_EN at RB1_bit;
# define S2 RA1_bit sbit LCD_D4 at RB2_bit;
# define S3 RA2_bit
# define S4 RA3_bit
# define M1 RB0_bit
sbit LCD_RS_Direction at TRISB0_bit;
# define M2 RB1_bit sbit LCD_EN_Direction at TRISB1_bit;
bit X,Y; sbit LCD_D4_Direction at TRISB2_bit;

sbit LCD_D5_Direction at TRISB3_bit;
void main()
{ sbit LCD_D7_Direction at TRISB5_bit;
TRISA=31;TRISB=0b11111100; void main()

PORTB=0;X=0;Y=0; {
TRISA=0B11100;PORTA=0;// configuration et initialisation
while (1)
TRISB.B6=1;TRISB.B7=1;
{ Lcd_Init();
if (!S2 &(S1|X)) X=1 ; else X=0; Lcd_Cmd(_LCD_CLEAR);
Lcd_Cmd(_LCD_CURSOR_OFF);
if (S3 |(!S4&Y)) Y=1 ; else Y=0;
while (1)
if (X) M1=1 ;else M1=0; {
if (Y) M2=1 ;else M2=0; while (PORTB.RB6 ==0)
{
}
PORTA.RA0=1;PORTA.RA1=0;
} Lcd_Out(1,1,"sens droite");
}
while (PORTB.RB7 ==0)
{
Lcd_Out(1,1,"sens gauche");
}
PORTA=0;
Lcd_Out(1,1,"STOP ");
}
}

Exercice N°41
sbit LCD_RS at RB0_bit; while ((PORTB.RB7 ==0)&&!((b==48)&&(a==48)))
sbit LCD_EN at RB1_bit; {

sbit LCD_D6 at RB4_bit; Lcd_Out(1,1,"sens gauche");
sbit LCD_D7 at RB5_bit; a-- ; delay_ms(200);

sbit LCD_RS_Direction at TRISB0_bit;
if ((a== 47) && (b!=48))
sbit LCD_EN_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB2_bit; {
sbit LCD_D5_Direction at TRISB3_bit; a=57;b--;

}
char a=48,b=48; if ((a== 47) && (b=48))
void main() {
{
a=48;b=48;
TRISA=0B11100;PORTA=0;
TRISB.B6=1;TRISB.B7=1; }
Lcd_Init(); Lcd_Chr(1,15,a);
Lcd_Cmd(_LCD_CLEAR);
Lcd_Chr(1,14,b);
Lcd_Cmd(_LCD_CURSOR_OFF);
while (1) }
{ PORTA=0;
while ((PORTB.RB6 ==0)&&!((b==57)&&(a==57)))
Lcd_Out(1,1,"STOP ");
{
Lcd_Out(1,1,"sens droite"); }
a++ ; delay_ms(200);
}
if (a==58)
{
a=48;b++ ;
}
if ((a== 57) && (b==57))
{
a=57;b=57;
}
Lcd_Chr(1,15,a);
Lcd_Chr(1,14,b);
}

Document Formation Mikroc Finale

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Document Formation Mikroc Finale

Transféré par

Droits d'auteur :

Formats disponibles

RÉPUBLIQUE TUNISIENNE

FORMATION DES ENSEIGNANTS DE GÉNIE ÉLECTRIQUE

Programmation en MikroC PRO

Application pour les microcontrôleurs

Préparée et animée par : Hichem BORCHANI

Encadrée par l’inspecteur : Abdelhakim MANOUBI

CREFOC SFAX AS : 2021 – 2022

Le présent rapport est un résumé de plusieurs articles concernant la

programmation en langage mikroC. Il présente différents exemples d’activités

et d’exercices corrigés traitant en particulier l’exploitation des afficheurs LCD

et des claviers 4x4, la conversion analogique numérique, la génération de

signaux MLI, les interruptions par RB0 et RB4 à RB7, l’exploitation du

TIMER0 … Ce document est donc un outil pour se familiariser avec la

programmation en langage mikroC. Ainsi, il peut être utilisé comme support

pour préparer le cours de microcontrôleur destiné aux élèves de la 3ème et

4ème années Sciences Techniques.

Je tiens à remercier Monsieur Mourad HAMMAMI et Madame Hiyem FRIKHA

pour leurs soutiens, leurs remarques visées et leur contribution à l’élaboration

CREFOC SFAX Formation 2021-2022 en GE page : 2

II- LANGAGE ET COMPILATEUR mikroC POUR PIC

1. Compilateur mikroC PRO pour PIC

CREFOC SFAX Formation 2021-2022 en GE page : 3

Pas 2 : Cliquer sur Next

CREFOC SFAX Formation 2021-2022 en GE page : 4

Pas 5 : Cliquer sur Next

Pas 6 : Cliquer sur Install (Noter bien l’endroit d’installation)

Ou "C:\Users\Public\Documents\Mikroelektronika\mikroC PRO for PIC\"

CREFOC SFAX Formation 2021-2022 en GE page : 5

CREFOC SFAX Formation 2021-2022 en GE page : 6

Précompilation Compilation Assemblage Edition de lien

Fichier source .C Fichier .asm Fichier .obj Fichier .hex

Organisation générale d’un compilateur C

CREFOC SFAX Formation 2021-2022 en GE page : 7

Le développement d’un projet est

5. Création d’un nouveau projet

CREFOC SFAX Formation 2021-2022 en GE page : 8

6.1 Structure d'un programme en mikroC

Les types de variables utilisées en MikroC:

Type Taille en octet Longueur en bit Rang

Afin de connaitre la taille en octet d’une variable, on utilise la fonction sizeof() :

CREFOC SFAX Formation 2021-2022 en GE page : 9

Mais voici quelques identificateurs incorrects :

N.B : Les variables sont rangées dans la RAM

Syntaxe de la déclaration dune constante : const Nom_constante =valeur

CREFOC SFAX Formation 2021-2022 en GE page : 10

On donne ci-dessous un exemple simple d'un programme en mikroC. Ce programme assure le

CREFOC SFAX Formation 2021-2022 en GE page : 11

% Pour le binaire n’est pas accepté par le compilateur

CREFOC SFAX Formation 2021-2022 en GE page : 12

• Utilisation de la variable sbit : 0n nomme la variable LED_1 de type sbit

CREFOC SFAX Formation 2021-2022 en GE page : 13

Assignation du nom LED_1 à PORTB.B0

CREFOC SFAX Formation 2021-2022 en GE page : 14

CREFOC SFAX Formation 2021-2022 en GE page : 15

Instruction sélective if :( Branchements conditionnels)

L’ instruction conditionnelle if permet d’exécuter des instructions de manière sélective en fonction du

Sum = Sum + Cnt ;

CREFOC SFAX Formation 2021-2022 en GE page : 16

Opérateur Nom Notation Priorité Ordre

Opérateur Nom Notation Priorité Ordre

Activité4 : On désire commander une LED D1 en utilisant

CREFOC SFAX Formation 2021-2022 en GE page : 17

Ecrire un programme en mikroC qui

N.B :la variable C n’est pas acceptée par le compilateur