ProgrammationenmikroC PDF

V.TOURTCHINE. Programmation en mikroC.
Application pour les microcontrôleurs de la

famille PIC
REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA
RECHERCHE SCIENTIFIQUE
UNIVERSITE M’HAMED BOGARA DE BOUMERDES

FACULTE DES SCIENCES - DEPARTEMENT PHYSIQUE
Spécialité : INFOTRONIQUE
&
IMAGERIE ET APPAREILLAGE BIOMEDICAL
V. TOURTCHINE
Programmation en mikroC. Application pour les
microcontrôleurs de la famille PIC
/*******************************
COMMUNICATION SERIE RS232
=========================
Cet exemple illustre
l'utilisation de fonction
Software_UART de la bibliothèque
du compilateur mikroC PRO.
Microcontrôl.: 16F887
Oscillat.: HS,10.0000 Mhz
Fichier: COMMUNIC_RS232.c
********************************
/
char error, byte_read;
void main()
{
ANSEL = 0;
ANSELH = 0;
TRISC = 0x00; /*Configurer
PORTB en sortie */
PORTC = 0;
Initialiser Soft_UART en 9600
bods Soft_UART_Init(&PORTC,
7, 6, 9600, 1);
if (error > 0)
Manuscrit élaboré selon le programme officiellement agrée et confirme par le Conseil

Scientifique de la Faculté des Sciences
BOUMERDES - 2012
-0-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
I. 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 des
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.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...
1. Dans la suite nous utiliserons le compilateur mikroC PRO v.1.65
2. La simulation des applications de programmation nous réalisons à l’aide du

logiciel PROTEUS v.7.6 SP
1.2 Installation du compilateur mikroC PRO v. 1.65
Pas 1 : Cliquer sur l’icône mikroC_PRO_1.65.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.
-1-
famille PIC
Pas 2 : Cliquer sur Next
Pas 3 : Cocher la case : I accept the terms in the License Agreement et cliquer sur Next
-2-
famille PIC
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
-3-
famille PIC
Pas 6 : Cliquer sur Install (Noter bien l’endroit d’installation)
Pas 7 : Cliquer sur OUI pour l’association du format de fichier .c avec le logiciel mikroC PRO
-4-
famille PIC
Pas 8 : Cliquer sur Finish
Pas 9 : Aller dans le répertoire M_License et copier les deux fichiers qui s’y trouvent.
Pas 10 : Coller pour remplacer les deux fichiers copiés auparavant dans le répertoire où
mikroC PRO a été installé.
Pas 11 : Cliquer deux fois sur le fichier mikroC_PRO_PIC.key pour enregistrer ses
informations sur le registre de votre ordinateur.
Pas 12 : Lancer le programme MikroC PRO en cliquant deux fois sur mikroCPIC1618.exe
1.3 IDE mikroC PRO

Lancer le compilateur mikroC PRO en cliquant sur l’icône
mikroC PRO for PIC.lnk
C’est sur la figure 1.1 que vous obtenez lorsque vous démarrez l’ IDE mikroC PRO pour la
première fois.
Une description détaillé de toutes les options disponibles dans ce compilateur prendre trop de
temps, de sorte que nous allions sauter cette étape. Au lieu de cela, nous allons décrire
salement le processus d’écriture d’un programme en langage mikroC, un simulateur de
contrôle. Pour plus d’informations reportez-vous à l’aide [F1].
-5-
famille PIC
Menu Toolbar Projet Manager
Code Explorer
Code Editor
Project Settings
(paramètres
principaux du
microcontrôleur)
Error Window
Fig. 1.1 L’environnement IDE du compilateur microC PRO
Editeur de code (voire la figure 1.1 : Code Editeur)

L’éditeur de code est le même que toute éditeur de texte standard pour l’environnement de
Windows, y compris Copie, Coller , Annuler les actions etc… Il possède en plus des ressources
comme suit :
 Coloration syntaxique réglable

 Assistant de code
 Assistant de paramètre
 Mise en forme automatique
Dans la boîte de dialogue Obtions (figure 1.2) vous pouvez configurer la coloration syntaxique,
l'aide pour le code et paramètres, la correction automatique etc. Pour accéder à ce dialogue
cliquez sur Tools > Options du menu déroulant ou sur l'icône
Assistant de code
Si vous imprimez les premières lettres du mot et puis appuyez sur Ctrl + Espace, tous les
identificateurs autorisés correspondant aux caractères imprimés seront offerts dans une fenêtre
(voir la figure 1.3). Maintenant, nous pouvons continuer à réduire le choix de taper ou d'utiliser
la sourie pour sélectionner l'option appropriée dans la proposée et appuyez sur Entrée.
-6-
famille PIC
Fig.1.2. Boîte de dialogue « Options »
Fig.1.3. Assistant de code
Mise en forme automatique

Afin d'obtenir une lisibilité maximale, il est possible de générer automatiquement la mise en
forme de certaines instructions. Par exemple, tapez l'instruction IF, puis CRTL + J. A ce stade,
l'éditeur ajoute tout seul les instructions. A vous ensuite de compléter le programme.
Affichage syntaxique coloré

Toujours dans le but d'obtenir une lisibilité maximale de votre programme, il vous est possible
de configurer entièrement les couleurs de chaque partie du listing (figure 1.2). Par exemple les
commentaires en "vert", les instructions en "noir", les valeurs numériques en "bleu clair", etc.
Outils intégrés
Le compilateur "MikroC PRO" pour PIC intègre différents petits outils très pratiques qui vous
simplifieront l’écriture des programmes de vos applications.
-7-
famille PIC
a) Mini terminal USART

Le "MikroC PRO" intègre un petit terminal
de communication USART RS-232
(Universal Synchronous Asynchronous
Receiver) pour lequel vous pourrez
configurer le débit, les commandes RTS
et DTR....
b) Mini gestionnaire 7 segments

Le "MikroC PRO" intègre un petit utilitaire
qui vous permettra de sélectionner la
valeur décimale ou hexadécimale à fournir
pour piloter un afficheur 7 segments.
c) Table de conversion ASCII

Le "MikroC PRO" intègre un petit
utilitaire qui vous permettra d'afficher
une table de conversion ASCII (très utile
lorsque vous travaillez avec des
afficheurs LCD).
d) Gestion des LCD graphiques

Le "MikroC PRO" intègre un petit utilitaire
qui vous permettra de convertir des fichiers
BMP en données pouvant être affichées
sur plusieurs types de LCD graphiques.
-8-
famille PIC
1.4 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).
Les fichiers source peut être compilé que si elles font partie d'un projet.
Le fichier projet contient les informations suivantes :
- Nom du projet et une description facultative

- Composant cible
- Option du composant
- Fréquence d’horloge du composant
- La liste des fichiers source du projet avec les chemins
- Fichiers d'image
- Fichiers binaires (* mcl.)
- D'autres fichiers
La meilleure façon de créer un projet c’est à l'aide de l'Assistant Nouveau projet (menu
Project> New ProjeCt ) ou en cliquant sur l'icône Nouveau projet à partir de la barre d'outils
du projet.
-9-
famille PIC
Nouvelles étapes de l'Assistant de projet
Commencez à créer votre nouveau projet, en cliquant sur le bouton Next :
Premier pas - Sélectionnez le périphérique dans le périphérique dans la liste déroulante.
- 10 -
famille PIC
Deuxième pas - Saisir la valeur de fréquence de l'oscillateur.
Troisième pas - Spécifiez l'emplacement où votre projet sera enregistré.
- 11 -
famille PIC
Quatrième pas - Ajout pour le projet un fichier s’il sont disponibles en ce moment.
vous pouvez toujours ajouter des fichiers de projet plus tard
en utilisant Project Manager.
- 12 -
famille PIC
Cinquième étape - Cliquez sur Finish pour créer votre nouveau projet.
A ce stade, une nouvelle fenêtre vide (fig. 1.4) s’affiche afin que vous pussiez y saisir votre
programme.
Ici vous devez saisir votre code-source
1.5 Compilation
- 13 -
famille PIC
Lorsque vous avez créé le projet et écrit le code source, il est temps de le compiler.
Sélectionnez Project Build à partir du menu déroulant ou cliquez sur l'icône Build dans
la barre d'outils du projet.
Si plus d'un projet est ouvert, vous pouvez compiler tous ouverts projets en sélectionnant Project
Build All dans le menu déroulant, ou cliquez sur l’icône de la barre d'outils du projet.
Barre de progression s'affiche pour vous informer sur l'état de la compilation. Si il y a des
quelques erreurs, vous en serez informé dans la fenêtre d'erreur (fig. 1.4).
Fig. 1.4 Avertissement des érreures
Après la compilation 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

Intel HEX Code hexadécimal dans le format Intel. Fichier est utilisé .hex
pour programmer PIC
Binary Fichier compilé pour la bibliothèque mikroC. Les .mcl
distributions binaires sont des routines qui susceptibles
- 14 -
famille PIC
d’être inscrits dans d'autres projets.

List File L’mage globale de l’allocation de mémoire du PIC pour : .lst
adresses d’instructions, les registres et les étiquettes du
programme.
Assembler Le fichier en assembleur avec des noms symboliques, .asm
File obtenus à partir de liste des fichiers.
1.5 Fichiers Sources
Création d’un nouveau fichier source
Pour créer un nouveau fichier source, procédez comme suit :

Sélectionne New depuis le menu File ou pressez Ctrl+N ou cliquez
sur l’icône New Fill depuis la barre d’outils File.
Une nouvelle fenêtre s’ouvrira dans laquelle vous pourrez saisir
votre code source. Sélectionnez alors Save depuis le menu File ou
pressez Ctrl+S ou cliquez sur l’icône Save File depuis la barre
d’outils File et nommez ce dernier comme vous le voulez.
Ouvrir un fichier existant

Sélectionnez Open depuis le menu File ou pressez Ctrl+Q ou
cliquez sur l’icône Open File depuis la barre d’outils File. Dans la
boite de dialogue Ouvrir, sélectionnez alors l’emplacement du
fichier que vous désirez ouvrir et cliquez sur le bouton Ouvrir.
Le fichier sélectionné s’affiche dans sa propre fenetre. Si le

fichier sélectionné est déjà ouvert, sa fenetre d’édition (Editor)
deviendra alors active.
Sauvegarder un fichier
Assurez-vous que la fenêtre contenant le fichier que vous
voulez sauvegarder est active.
Sélectionnez ensuite Save depuis le menu File ou pressez

Ctrl+S ou cliquez sur l’icône Save Fail de la barre d’outils File.
Sauvegarder un fichier sous un nom différent

Assurez-vous que la fenêtre contenant le fichier que vous
voulez sauvegarder est active.
Sélectionnez ensuite Save As depuis le menu File. Une boîte

- 15s’affichera
de dialogue ‘Save [nom du fichier] .c as’ - alors.
Dans cette boîte, sélectionnez l’emplacement dans lequel
vous voulez sauvegarder le fichier.
famille PIC
II. INTRODUCTION AU LANGAGE DE PROGRAMMATION MICROC

2.1 Structure d'un programme en mikroC
La structure la plus simple d'un programme en mikroC, c’est le programme représenté dans le
code-source 2.1, qui nous permettra de faire clignoter 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).
2.1.1 Règles générale d’écriture en microC
 Les instructions propres au langage microC doivent être écrites en minuscule

(void main (void)).
 Les instructions particulières aux microcontrôleurs doivent être écrites en majuscule
(TRISB).
 Les retours à la ligne et les espaces servent uniquement à aérer le code
 Toutes instructions ou actions se terminent par un point virgule « ; ».
Code-source 2.1
/****************************************************************************
LED clignotante
==============
Ce programme fait clignoter d’une LED connectée au PORTB (broche RB0) avec
un des intervalles d'une seconde.
Microcontrôleur : 16F84A
Oscillateur : HS, 4.0000 Mhz
- 16 -
famille PIC
Fichier : LED.c
Date : Juillet 2012
****************************************************************************/
void main()
{
for(;;) // Boucle sans fin
{
TRISB = 0; // Configuration du PORTB en sortie
PORTB.0 = 0; // RB0 = 0
Delay_Ms(1000); // Pause d’une seconde
PORTB.F0 = 1; // RB0 = 1
Delay_Ms(1000); // Pause d’une seconde
} // Fin de la boucle
}
Examinons le fichier LED.c du code-source
2.1.2 Commentaires
Les commentaires sont utilisés pour préciser le fonctionnement du programme et pour une
annotation du programme. Les lignes de commentaires sont ignorées et non compilé par le
compilateur.
En mikroC les commentaires de programmes peuvent être de deux types: de longs

commentaires, s’étendant sur plusieurs lignes, et de courts commentaires, occupant une
seule ligne.
Un commentaire au début d'un programme peut décrire brièvement le fonctionnement du

programme et de fournir le nom de l'auteur, le nom du fichier programme, la date à laquelle le
programme a été écrit, et une liste des numéros de version, ainsi que les modifications dans
chaque version.
Comme montre le Code-source 2.1 les longs commentaires commencent par le caractère
« /* » et se termine par le caractère « */ ».
De même, de courts commentaires commencent par le caractère « // » et il n’a pas
besoin d'un caractère de terminaison.
2.1.2 Début et fin d'un programme
En langage microC, un programme commence avec les mots-clés:
void main()
Après cela, une accolade ouvrante est utilisée pour indiquer le début du corps de programme.
Le programme se termine par une accolade fermante.
Ainsi, comme indiqué dans le Code-source 2.1, le programme a la structure suivante :
void main()
{
// Votre code ici
}
- 17 -
famille PIC
2.1.3 Fin d’une instruction

Le point virgule « ; » indique la fin d’une instruction, sinon une erreur du compilateur sera
générée.
j = 5; // correcte
j = 5 // erreur
2.1.4 Espaces blancs
Les espaces blancs sont des espaces, des flans, les tabulations et les caractères de nouvelle
ligne. Le compilateur microC ne tient pas compte tous les espaces blancs. Ainsi, les trois
séquences suivantes sont identiques :
int i; char j;
ou
int i;
char j;
ou
int i;
char j;
De même, les séquences suivantes sont identiques :
i=j+2 ;
ou
i=j
+2 ;
2.2 Eléments de programmation en mikroC
2.2.1 Les variables. Définition et déclaration de variables
Une variable est une portion réservée d’une mémoire à laquelle on a donné un nom. On peut
stocker ou lire les informations de ces variables.
Toute variable utilisée dans un programme doit auparavant être définie.
La définition d’une variable consiste à la nommer et lui donnée un type et éventuellement lui
donner une valeur initiale (initialiser). C’est cette définition qui réserve (alloue) la place mémoire
nécessaire en fonction du type.
Lorsque le programme que l’on réalise est décomposé en plusieurs modules, une même
variable, utilisée dans plusieurs modules, doit être déclarée dans chacun de ces modules. Par
contre, on ne définira cette variable que dans un seul de ces modules. C’est au moment de
l’édition des liens que l’on mettra en correspondance les variables apparaissant dans plusieurs
modulez (variable partagée, mot-clé extern).
La position de la déclaration ou de la définition d’une variable détermine sa portée c’est-à-dire
sa durée de vie et sa visibilité.
 Les variables globales sont déclarées en dehors de toute fonction.
- 18 -
famille PIC
 Les variables locales sont déclarées à l’intérieur des fonctions et ne sont pas visible à
l’extérieur de la fonction dans laquelle celle-ci est définie.
Les noms des variables ne peuvent contenir que des lettres de a à z et à partir de A à Z, le trait
de soulignement "_" et les chiffres de 0 à 9.
Les noms des variables dans mikroC n'est pas sensible à la casse, de sorte que Sum, som et
soM représente le même identifiant.
Voici quelques identificateurs valides:
temperature_V1
Pressure
no_hit
dat2string
SUM3
_vtext
... mais voici quelques identificateurs incorrectes:
7temp // ne peut pas commencer par un chiffre

% Supérieur // ne peut pas contenir de caractères spéciaux
int // ne peut pas répéter un mot-clé
j23.07.04 // ne peut pas contenir de caractères spéciaux

(période)
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. Le tableau 2.1 donne une liste alphabétique de ces
noms réservés.
Tableau 2.1 Noms réservés en mikroC

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
- 19 -
famille PIC
Le langage mikroC prend en charge les types de variables indiquées dans le tableau 2.2.
Tableau 2.2: Types de variables en mikroC

Taille
(bits)
Type Plage
unsigned char 8 0 à 255
unsigned short int 8 0 à 255
unsigned int 16 0 à 65535
unsigned long int 32 0 à 4294967295
signed char 8 -128 à 127
signed short int 8 -128 à 127
signed int 16 -32768 à 32767
signed long int 32 - 2147483648 à 2147483647
float 32 ± 1.17549435082E-38 à ±6.80564774407E38
double 32 ± 1.17549435082E-38 à ± 6.80564774407E38
long double 32 ± 1.17549435082E-38 à ± 6.80564774407E38
(unsigned) char or unsigned short (int)
Les variables appelées (unsigned) char ou unsigned short (int), sont des variables non
signées de 8 bits avec une plage de 0 à 255. Dans l'exemple suivant deux variables de 8
bits nommées total et sum sont créés, et sum est affectée la valeur décimale 150:
unsigned char total, sum;
sum = 150;
ou
char totale, sum;

sum = 150;
Les variables peuvent affecter des valeurs au cours de leur déclaration. Ainsi, les
déclarations ci-dessus peuvent aussi être écrites comme suit:
char total, sum = 150;
- 20 -
famille PIC
signed char or (signed) short (int)
Les variables appelées signed char, ou (signed) short (int) sont des variables signées de
8 bits avec une gamme de -128 à +127. Dans l'exemple suivant, une variable signée de 8
bits nommée counter est créé avec une valeur de – 50 :
signed char counter =- 50;

soit
short counter = -50;
soit
short int counter = -50;
(signed) int
Les variables appelés (signed) int sont des variables signées de 16 bits avec une gamme
ayant de - 32768 à +32767. Dans l'exemple suivant d'un entier signé nommé Big est :
int Big;
unsigned (int)
Les variables appelés unsigned (int) sont des variables non signés de 16 bits avec une
gamme de 0 à 65535. Dans l'exemple suivant une variable de 16 bits nommée count est
affectée la valeur décimale de 12000 :
unsigned int count = 12000;
(signed) long (int)
Les variables appelés (signed) long (int) sont des variables signées de 32 bits avec une
gamme de - 2147483648 à +2147483647. Un exemple est suivant :
signed long LargeNumber;
unsigned long (int)
Les variables appelés unsigned long (int) sont des variables non signées de 32 bits ayant
une gamme de 0 à 4294967295. Un exemple est suivant:
unsigned long VeryLargeNumber;
float or double or long double
Les variables appelées float ou double ou long double, sont des variables à virgule
flottante mis en œuvre en utilisant le mikroC de format 32 bits.
Nombres à virgule flottante comprise entre - 1.17549435082E-38 à
+ 6.80564774407E38. Dans l'exemple suivant, une variable flottante nommée area est
affectée la valeur 12.235:
- 21 -
famille PIC
float area ;
area = 12.235;
Pour éviter toute confusion lors de l'élaboration du programme, il est recommandé de

préciser le signe de la variable (signé ou non signé) ainsi que le type de variable. Par
exemple, utiliser unsigned char au lieu de char seulement, et unsigned int au lieu
de unsigned seulement.
2.2.2 Constantes
Constantes représentent des valeurs fixes (numérique ou caractère) dans des programmes qui
ne peuvent pas être changées.
En mikroC, constantes peuvent être entiers, flottants, caractères, les chaînes, ou des types
énumérés.
Integer Constants
Les constantes entières (Integer Constants) peuvent être en décimal, hexadécimal, octal
ou binaire. Le type de données d'une constante est tiré par le compilateur à partir de sa
valeur. Mais suffixes peut être utilisé pour changer le type d'une constante.
Dans le tableau 2.2, nous avons vu que les constantes décimales (signed long int)
peuvent avoir des valeurs de – 2147483648 à + 4294967295. Par exemple, nombre
constant 210 est stocké comme un entier non signé ( unsigned char) ou (unsigned short
int). De même, nombre constant - 200 est stocké comme un entier signé (signed int).
Le suffixe u ou U force la constante d'être non signé (unsigned) et le suffixe l ou L force

la constante d'être longue (long). Utilisation de U (ou u) et L (ou l) oblige la constante
d'être
unsigned long.
Les constantes sont déclarées en utilisant le mot-clé const et sont stockées dans le flash
de mémoire du microcontrôleur PIC. Par exemple, MAX est déclaré comme la constante
100 :
const MAX =100;
Les constantes hexadécimales commencent par les caractères 0x ou 0X et peuvent

contenir des données numériques de 0 à 9 et les caractères hexadécimaux de A à F.
Dans l'exemple suivant, TOTAL est la constante de la valeur hexadécimale FF:
const TOTAL = 0xFF;
Les constantes octales ont un zéro au début du nombre et peuvent contenir des données
numériques de 0 à 7. Dans l'exemple suivant, une constante CNT est affectée une valeur
octale 17 :
const CNT = 017;
- 22 -
famille PIC
Les constantes binaires commencent par 0b ou 0B et ne peuvent contenir que 0 ou 1.

Par exemple une constante nommée Min est déclarée comme ayant la valeur binaire
11110000:
const Min = 0b11110000
Floating Point Constants
Les constantes à virgule flottante (Floating Point Constants) se compose de:
 Entier décimal
 Point décimal
 Partie décimale fractionnaire
 e ou E et l'ordre du signe
MikroC limite les valeurs de constantes à virgule flottante par la gamme :
±1.17549435082 * 10-38 ... ±6.80564774407 * 1038.
Dans l'exemple suivant, une constante nommée TEMP est déclarée comme ayant la
valeur fractionnelle 37.50 :
const TEMP = 37.50

ou
const TEMP = 3.750E1
Character Constants
Une constante de caractère (Character Constants) est un caractère renfermé dans des
guillemets simples. Par exemple, une constante nommée First_Alpha est déclarée
comme ayant la valeur du caractère ‘‘A’’ :
const First_Alpha = ‘A’;
String Constants
Les constantes de chaîne (String Constants ) sont des séquences fixes de caractères
stockées dans la mémoire flash du microcontrôleur. La chaîne doit commencer et se
terminer par un guillemet « " ». Un exemple d’une constante de type chaîne est la
suivante :
"Il s'agit d'un exemple de chaîne constante"
Une constante chaîne peut être étendue à travers une frontière en ligne en utilisant une
barre oblique inverse « "\" » :
"C'est la première partie de la chaîne \

et c'est la poursuite de la chaîne "
Cette déclaration de la constante chaîne est la même que :
"C'est la première partie de la chaîne et c'est la poursuite

de la chaîne "
- 23 -
famille PIC
Enumerated Constants
Les constantes énumérées (Enumerated Constants) sont de type entier et sont utilisées
pour faire un programme plus facile à suivre. Dans l'exemple suivant, une constante
nommée couleur stocke les noms de couleurs. Le premier élément de couleur a la
valeur 0:
enum couleur {noir, marron, rouge, orange, jaune, vert, bleu,

gris,
white};
2.2.3 Séquences d'échappement
Les séquences d'échappement (Escape Sequences) sont utilisées pour représenter les
caractères ASCII non imprimables. Tableau 2.3 montre quelques séquences d'échappement
couramment utilisés et de leur représentation en langage microC.
Par exemple, la combinaison de caractères « \n » représente le caractère de nouvelle ligne.
Un caractère ASCII peut également être représenté en précisant son code hexadécimal, après
une barre oblique inverse.
Par exemple, le caractère de nouvelle ligne peut également être représenté comme « \x0A ».
Tableau 2.3: Quelques séquences d'échappement

Valeur de
la
Séquence séquence
d'échappement Hex
Caractère
\ a 0X07 BEL (cloche)
\ b 0X08 BS (backspace)
\ t 0X09 HT (tabulation horizontale)
\ n 0XLF 0A (saut de ligne)
\ v 0X0B VT (tabulation verticale)
\ f 0X0C FF (saut de page)
\ r 0X0D CR (retour chariot)
\ xH Chaîne de chiffres Hex
- 24 -
famille PIC
2.2.4 Variables statiques
Les variables statiques (Static variables ) sont des variables locales utilisées dans les fonctions
lorsque la dernière valeur d'une variable entre les appels successifs de la fonction doit être
préservée. Comme le montre l'exemple suivant, les variables statiques sont déclarées en
utilisant le mot clé static :
statique unsigned int count ;
2.2.5 Variables externes
Utilisation du mot (extern) devant un nom de variable déclare cette variable comme externe. Il
indique au compilateur que la variable est déclarée ailleurs dans un code-source distincte
module. Dans l'exemple suivant, les variables sum1 et SUM2 sont déclarés comme externes
entiers non signés :
extern int sum1, SUM2 ;
2.2.6 Variables volatiles
Les variables volatiles (Volatile Variables ) sont importantes dans d'interruption des
programmes et de routines d’entrées-sorties. Utilisation de mot-clé volatile indique que la valeur
de la variable peut changer au cours de la durée de vie du programme indépendant de
l'écoulement normal du programme. Dans l'exemple suivant, la variable Led est déclarée
comme un volatile non signé :
volatile unsigned char Led;
2.2.7 Variables énumérées
Les variables énumérées sont utilisées pour rendre un programme plus lisible. Dans une
variable énumérée, une liste de références est spécifiée et la valeur du premier élément est fixé
à 0, l'autre élément est mis à 1, et ainsi de suite. Dans l'exemple suivant, la Semaine de type
est déclaré comme un liste énumérée et LUN = 0, MAR = 1, WEN = 2, et ainsi de suite :
enum Semaine {LUN, MAR, MER, JEU, VEN, SAM, DIM};
Il est possible d'impliquer les valeurs des éléments dans une liste énumérée. Dans le
exemple suivant, noir = 2, bleu = 3, rouge = 4, et ainsi de suite.
enum couleurs {noir = 2, bleu, rouge, blanc, gris};
De même, dans l'exemple suivant, noir = 2, bleu = 3, rouge = 8, et gris = 9:
enum couleurs {black = 2, bleu, rouge = 8, gris};
Les variables de type de recensement peuvent être déclarées par les spécifiant après la liste
- 25 -
famille PIC
des articles. Par exemple, pour déclarer la variable My_Week de la Semaine de type énuméré,
utilisez la déclaration suivante:
enum Semaine {LUN, MAR, MER, JEU, VEN, SAM, DIM} My_Week;
Maintenant, nous pouvons utiliser My_Week comme une variable dans un programme:
My_Week = MER // assigne 2 à My_Week
ou
My_Week = 2 // le même que ci-dessus
Après avoir défini Semaine comme un type énuméré, nous pouvons déclarer des variables
This_Week et Next_Week de type Semaine :
enum Semaine This_Week, Next_Week;
2.2.8 Tableaux
Les tableaux (Arrays) sont utilisés pour stocker des éléments liés dans le même bloc de
mémoire et en vertu d'un nom spécifié. Un tableau est déclaré en spécifiant son type, le nom, et
le nombre d’éléments à stocker. Par exemple:
unsigned int Total [5] ;
Ce tableau de type unsigned int est nommé Total et dispose de cinq éléments. 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. Le tableau Total est stocké
dans un mémoire ayant cinq emplacements consécutifs comme suit:
Total[0]
Total[1]
Total[2]
Total[3]
Total[4]
Les données peuvent être stockées dans le tableau en spécifiant le nom du tableau et de
l'indice. Par exemple, pour stocker 25 dans le deuxième élément du tableau, nous devons
écrire:
Total[1] = 25;
De même, le contenu d'un tableau peut être lu en spécifiant le nom du tableau et de son
index. Par exemple, pour copier l'élément de tableau d’index 2 à une variable appelée Temp ,
nous devons écrire:
Temp = Total[2];
Le contenu d'un tableau peut être initialisé lors de la déclaration du tableau en

attribuant d'une séquence de valeurs séparées par des virgules dans le tableau. Voici un
exemple d’un tableau ayant 12 éléments des mois[0] = 31, mois[1] = 28, et
ainsi de suite:
- 26 -
famille PIC
unsigned char mois[12] = {31,28,31,30,31,30,31,31,30,31,30,31};

www.newnespress.
Le même tableau peut également être déclaré sans spécifier sa taille:
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. Dans l'exemple suivant,
un tableau de caractères nommés Hex_Letters est déclarée avec 6 éléments:
unsigned char Hex_Letters[ ] ={‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’};
Les chaînes sont des tableaux de caractères avec un terminateur null. 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 de 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”;
et
unsigned char Mystring[ ] = {‘C’, ‘O’, ‘M’, ‘P’, ‘\0’};
Dans le langage de programmation microC, nous pouvons aussi déclarer des tableaux aux
dimensions multiples. Tableaux unidimensionnels sont généralement appelés vecteurs, et des
tableaux bidimensionnels sont appelés matrices. Un réseau bidimensionnel est déclaré en
spécifiant le type de données de la matrice, le nom de tableau, et la taille de chaque dimension.
Dans l'exemple suivant, un tableau à deux dimensions nommé P contiens trois lignes et quatre
colonnes. Au total, le tableau a douze éléments. Le premier élément de la matrice est
P[0][0], et le dernier élément est P[2][3].
La structure de ce tableau est montrée ci-dessous:
P[0][0] P[0][1] P[0][2] P[0][3]
P[1][0] P[1][1] P[1][2] P[1][3]
P[2][0] P[2][1] P[2][2] P[2][3]
- 27 -
famille PIC
Éléments d'un tableau multidimensionnel peut être spécifié lors de la déclaration du

tableau. Dans l'exemple suivant, réseau bidimensionnel Q a deux rangées et deux
colonnes, ses éléments diagonaux sont mis à 1, et de ses éléments non diagonaux sont
remis à 0:
unsigned char Q[2][2] = { {1,0}, {0,1} };
2.2.9 Pointeurs
Les pointeurs (Pointers) sont une partie importante du langage microC, car ils occupent les
adresses mémoire des autres variables. Les pointeurs sont déclarées de la même manière que
d'autres variables, mais avec le caractère « * » en face du nom de variable.
Dans l'exemple suivant, un pointeur de caractère non signé du nom pnt est déclaré:
unsigned char *pnt;
Quand un nouveau pointeur est créé, son contenu est d'abord indéterminé et il ne tient pas
l'adresse d'une variable. Nous pouvons attribuer l'adresse d'une variable à un pointeur à l'aide
le « & » :
pnt = &Count;
Maintenant pnt affecte l'adresse de variable Count. La variable Count peut être affectée à
une valeur en utilisant le caractère « * » en avant de son pointeur. Par exemple, le Count peut
être attribuée à 10 à l'aide de son pointeur :
* pnt = 10; // Count = 10
c’est la même chose que
Count = 10; // Count = 10

ou, la valeur du Count peut être copié à la variable Cnt en utilisant son pointeur :
Cnt = *pnt; // Cnt = Count
Pointeurs de tableaux
Dans le langage microC, le nom d'un tableau est aussi un pointeur de tableau. Ainsi, pour le
tableau :
unsigned int Total[10];
Le nom Total est également un pointeur de ce tableau, et il contient l'adresse du premier

ellément de la matrice. Ainsi, les deux énoncés suivants sont égaux:
Total[2] = 0;
et
*(Total + 2) = 0;
En outre, l'énoncé suivant est vrai:
&Total[j] = Total + j ;
- 28 -
famille PIC
En langage microC, nous pouvons effectuer des opérations arithmétiques pour pointeurs qui
peuvent impliquer :
 Comparaison de deux pointeurs

 Addition ou la soustraction d'un pointeur et un entier
 La soustraction de deux pointeurs
 Assigner un pointeur vers un autre
 En comparant un pointeur avec zéro
Par exemple, supposons que le pointeur P est affecté afin de contenir l'adresse du tableau
d’élément Z[2]:
P = &Z[2];
Nous pouvons maintenant effacer les éléments 2 et 3 du tableau Z, comme dans les deux
exemples qui suivent. Les deux exemples sont identiques, sauf que dans le premier
exemple pointeur P contient l'adresse de Z[3] à la fin des états, et il contient l'adresse de Z[2]
à la fin de deuxième série de déclarations:
*P = 0; // Z[2] = 0
P = P + 1; // maintenant P pointe l’élément 3 de Z

*P = 0; // Z[3] = 0
ou
*P = 0; // Z[2] = 0
*(P +1) = 0; // Z[3] = 0
Un pointeur peut être affecté à un autre pointeur. Dans l'exemple suivant, les variables Cnt et
Tot sont l’ensable de 10 éléments créés à l'aide de deux pointeurs différents:
unsigned int *i, *j; // déclare 2 pointeurs
unsigned int Cnt, Tot; // déclare deux variables
i = &Cnt; // i pointe vers Cnt
*i = 10; // Cnt = 10
j = i; // copy pointeur i vers pointeur j
Tot = *j; // Tot = 10
2.2.10 Structures
- 29 -
famille PIC
Une structure peut être utilisée pour recueillir des éléments connexes, qui sont ensuite traités
comme un seul objet. Contrairement à un tableau, une structure peut contenir un mélange de
types de données. Par exemple, un structure permet de stocker les données personnelles
(nom, prénom, âge, date de naissance, etc) d'un étudiant.
Une structure est créée en utilisant le mot-clé struct, suivie d'une structure de nom et d’une
liste des déclarations de membre. Éventuellement, des variables de même type que la structure
peuvent déclarer à l'extrémité de la structure.
L'exemple suivant déclare une structure nommée Personne :
struct Personne
{
unsigned char name[20];
unsigned char prénom[20];
unsigned char nationalité[20];
unsigned char âge;
}
Nous pouvons déclarer des variables du même type que la structure en donnant le nom de la
structure et le nom de la variable.
Par exemple, deux variables Moi et Toi de type Personne vous pouvez créer par
la déclaration:
struct Personne Moi, Toi;
Les variables de type Personne peuvent également être créées lors de la déclaration de la
structure comme suit :
struct Personne
{
unsigned char name[20];
unsigned char prénom [20];
unsigned char nationalité [20];
unsigned char âge;
}Moi, Toi
Nous pouvons attribuer des valeurs aux élements d'une structure en spécifiant le nom de la
structure, suivi d'un point « . » et le nom de l'élément. Dans l'exemple suivant, l'âge
des variables de structure Moi est mis à 25, et M variable est affecté à la valeur de l'âge dans
variable de structure Vous:
Moi.age = 25;
M = Vous.age;
Eléments de la structure peut être initialisé lors de la déclaration de la structure. Dans l'exemple
suivant, le rayon et la hauteur de la structure sont initialisés Cylindre à 1.2 et
2.5 respectivement :
- 30 -
famille PIC
struct Cylindre
{
valeur de rayon;
valeur d’hauteur;
} MienCylindre {1.2, 2.5};
Les valeurs peuvent également être attribuées pour les éléments d'une structure à l’ade des
pointeurs en définissant les variable el les types des pointeurs. Par exemple, si LeCylindre
est défini comme un pointeur vers la structure Cylindre, alors nous pouvons écrire :
struct Cylindre
{
valeur de rayon;
flotter d’auteur;
}*LeCylinder;
LeCylinder -> rayon = 1.2;
LeCylinder -> hauteur = 2.5;
La taille d'une structure est le nombre d'octets contenus dans la structure. Nous pouvons utiliser
l'opérateur sizeof pour obtenir la taille d'une structure.
Considéront l'exemple ci-dessus :
sizeof (MienCylindre)
retours 8, étant donné que chaque variable de type float occupe 4 octets en mémoire.
Les champs de bits peuvent être définis en utilisant les structures. Avec les champs de bits,
nous pouvons attribuer des identificateurs pour les bits d’une variable. Par exemple, pour
identifier les bits 0, 1, 2, 3 d'une variable pour LowNibble et d'identifier les 4 bits restants pour
HighNibble nous pouvons écrire :
struct
{
LowNibble: 4;
HighNibble: 4;
} MienVariable;
On peut alors accéder aux quartets bits de la variable MienVariable :
MienVariable.LowNibble = 12;
MienVariable.HighNibble = 8;
En microC, nous pouvons utiliser les déclarations typedef pour créer de nouveaux types
d’une variable. Par exemple, une nouvelle structure type de données nommé Reg peut être
créé comme suit :
- 31 -
famille PIC
typedef struct
{
unsigned char nom[20];
unsigned char prenom[20];
unsigned âge;
}Reg;
Les variables de type Reg peuvent ensuite être créés de la même manière que les autres types
de variables. Dans l'exemple suivant, les variables MyReg, Reg1, et Reg2 sont créés à partir
de type de données Reg:
Reg MyReg, REG1, REG2;
Le contenu d’une structure peut être copié dans une autre structure, à condition que
des structures soient déterminées à partir du même modèle. Dans l'exemple qui suit , P2 est
copié sur P1:
struct Personne
{
unsigned char nom [20];
unsigned char prenom [20];
unsigned int âge;
unsigned int hauteur;
unsigned poids;
}
struct Personne P1, P2;

........................
........................
P2 = P1;
2.2.11 Unions
Les unions sont utilisées pour les variables de recouvrement. Une union est similaire à une
structure et il est même défini d'une manière similaire. Les deux sont basés sur des modèles, et
les membres de tous les deux sont accessible à l'aide des opérateurs « . » ou « -> ». Une
chausse diffère d'une structure en ce que tous variables dans une union occupent la même
zone mémoire, ils partagent le même stockage. Un exemple de déclaration de l'union est la
suivante :
union flags
{
unsigned char x;
unsigned int y;
}P;
Dans cet exemple, les variables x et y occupent la même zone de mémoire, et la taille de ce
l'union est de 2 octets de long, ce qui est de la taille de la plus grande partie de l'union. Quand
la variable y est chargé avec une valeur de 2 octets, la variable x aura la même valeur que
faible octet de y.
Dans l'exemple suivant, y est chargé avec 16-bit valeur hexadécimale

0xAEFA, et x est chargé avec 0xFA:
P.y = 0xAEFA ;
- 32 -
famille PIC
La taille d'une union est la taille (nombre d'octets) de son élément est le plus important. Ainsi,
la déclaration:
sizeof (P)
renvoie 2.
Cette union peut aussi être déclarée comme suit :
union flags
{
unsigned char x;
unsigned int y;
}
union flags P;
2.2.12 Opérateurs et expressions en mikroC
Les opérateurs sont appliqués aux variables et d'autres objets dans les expressions pour
assurer certaines conditions ou des calculs.
Une expression est un objet syntaxique obtenu en assemblant des constantes, des variables et
des opérateurs.
Exemple :
x + 12
Dans le langage microC, il y a d’autres opérateurs que les opérateurs arithmétiques qu’on a
l’habitude de manipuler. Il y en a en fait plus de 40 opérateurs.
Opérateurs et priorités
Vous avez l’habitude de manipuler des expressions arithmétiques :
2+3*4*5-2, 2-3-4
On sait que ces expressions sons équivalentes à (2+(3*(4*5)))-2, (2-3)-4.
Introduire les parenthèses permet de définir sans ambiguité l’expression que l’on manipule.
Pour éviter l’usage des parenthèses qui alourdissent la lecture, il existe des règles pour lever
toute ambigüité :
Exemple :
2+3*4
La sous expression 3*4 est évaluée en premier et le résultat obtenu est ajouté à la valeur 2
(forme avec parenthèse : 2+(3+4)).
On dit que l’opérateur « * » possède une priorité supérieur à la priorité de l’opérateur « + ».
2-3-4
- 33 -
famille PIC
La sous expression 2-3 est évaluée en premier et au résultat obtenu, on soustrait la valeur 4
(forme avec parenthèse : (2-3)-4).
On dit que l’ordre d’évaluation de l’opérateur – est de gauche à droite.
La donnée d’une priorité et d’un ordre d’évaluation permet de fixer des règles communes
d’évaluation des expressions.
Ces priorités et ordre d’évaluation ne permettent évidement pas de se dispenser

complètement des parenthèses :
(2+3)*4 à comparer à 2+3*4
Caractéristiques de l’opérateur (…) :
Opérateur Nom Notation Priorité Ordre
() parenthèses (…) 15 gauche-droite
Opérateur d’affectation
L’opérateur la plus importante dans un langage de programmation est celle qui consiste à
donner une valeur à une variable.
Cette opération est désignée par le symbole « = ».
 Comme l’affectation range une valeur dans une variable (une zone mémoire), il est
impératif que le membre gauche d’une affectation représente une zone (left value).
Une constante n’est pas une left value car il ne désigne pas l’adresse d’une zone
mémoire. Elle ne peut donc pas figurer en membre gauche d’une affectation.
Le membre droit d’une affectation peut désigner soit une constante soit une zone
mémoire soit une expression.
= affectation x=y 2 droite- gauche
Les opérateurs arithmétiques
+ addition x+y 12 gauche-droite
- soustraction x-y 12 gauche-droite
* multiplication x*y 13 gauche-droite
/ division x/y 13 gauche-droite
- 34 -
famille PIC
% modulo x%y 13 gauche-droite
Les opérateurs +, -, * , fonctionnent comme en arithmétique.
Par contre, l’opérateur / (division) se comporte de manière différente selon que les opérandes
sont des entier 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 entier
ou division euclidienne. L’opérateur % n’est défini que pour les entiers et le résultat est le reste
de la division entière des opérandes.
Rappel sur la division entière : On appelle quotient et reste de la division entière de a et de b,

les nombres entiers q et vérifiant :
a = q*b +r ; 0 < r < B
Exemple 1 :
Si a = 20 et b = 3 alors q = 6 et r = 2 (on a vérifié : 20 = 6*3 + 2)
Exemple 2 :
int a, b, c ;
float x, y, z ;
a = b/c; //division entière

a = x/y; //reste entier
x = y/z; //division réelle
x = 2/3; //division entière
x = 2.0/3.0; //division réelle
x = (float)((float)a)/y; //division réelle
L’opérateur unaire « – » a une priorité supérieure aux opérateurs binaires arithmétiques :
-(unaire) négation -x 13 droite- gauche
Les opérateurs de comparaison
== teste d’égalité x == y 9 gauche-droite
!= teste de non égalité x!=y 9 gauche-droite
- 35 -
famille PIC
<= teste inférieur ou égal x <= y 10 gauche-droite
>= teste supérieur ou égal x >= y 10 gauche-droite
< teste inférieur strict x<y 10 gauche-droite
> teste supérieur strict x>y 10 gauche-droite
Théoriquement, le résultat d’une comparaison est une valeur booléenne (vrai ou faux). En
microC, le résultat d’une comparaison est 1 (!= 0) ou 0 selon que cette comparaison est vraie
ou fausse.
Il n’existe pas de type booléen en microC : la valeur entière 0 sera considérée comme
équivalente à la valeur faux et toute valeur différente de 0 équivalente à la valeur vrai.
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
II OU x II y 4 gauche-droite
! (unaire) NON !x 14 droite- gauche
Les opérateurs de manipulation de bits
& ET bit à bit x&y 8 gauche-droite
I OU bit à bit xIy 6 gauche-droite
^ OU exclusif bit à bit x^y 7 gauche-droite
 (unaire) NON bit à bit x 14 droite-gauche
>> décalage à droite >> x 11 droite-gauche
- 36 -
famille PIC
<< décalage à gauche << x 11 droite-gauche
Les autres opérateurs binaires d’affectation
Les opérateurs suivants ne sont que des raccourcis de notation (pas d’optimisation du
code généré) :
Opérateur Equivalent Notation Priorité Ordre
+= x=x+y x += y 2 droite-gauche
-= x=x-y x -= y 2 droite-gauche
*= x=x*y x *= y 2 droite-gauche
/= x=x/y x /= y 2 droite-gauche
%= x=x%y x %= y 2 droite-gauche
= x=xy x = y 2 droite-gauche
<<= x = x << y x <<= y 2 droite-gauche
&= x=x&y x &= y 2 droite-gauche
I= x=xIy x I= y 2 droite-gauche
^= x=x^y x ^= y 2 droite-gauche
Autres opérateurs unaires d’affectation
++ x=x+1 x++ ou ++x 14 droite-gauche
-- x=x-1 x-- ou --x 14 droite-gauche

y =
x++ ;
c’est le raccourci pour y = x ; x = x+1 ;
y = ++x ; c’est le raccourci pour x = x + 1 ; y = x ;
Autres opérateurs
 Opérateur conditionnel
? opérateur e ? x : y 3 droite-gauche
conditionnel
- 37 -
famille PIC
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 : 2 ;
affecte la variable a à la valeur 1 si v vaut 2, sinon la variable a à la valeur 2.
 Opérateur séquentiel
, opérateur e1 , e2 1 droite-gauche
séquentiel
Cet
opérateur permet de regrouper plusieurs expressions en une seule : l’évaluation de l’expression
e1, e2 consiste en l’évaluation successive (dans l’ordre) des expressions e1 puis de e2.
 Opérateur de dimension
Cet opérateur donne l’occupation mémoire (en octets) d’une variable ou d’un type de donné.
sizeof opérateur de sizeof (e) 14 droite-gauche

dimension
Exemple :
La valeur de l’expression sizeof(c) est 1 si c est une variable de type char.

L’expression sizeof(char)donne également la valeur 1.
 Opérateur de parenthèse
L’opérateur de parenthèse ( ) permet de définir l’ordre d’évaluation d’une expression.

C’est également ce même opérateur qui est utilisé pour encapsuler les parenthèses des
fonctions.
Même lorsqu’une fonction n’a pas d’arguments, ces parenthèses sont obligatoires.
() opérateur d’adressage () 15 gauche-droite
 Opérateur de sélection
Ces opérateurs « . » et « -> » servent à sélectionner des champs de données structurées.

- 38 -
famille PIC
. opérateur de sélection x,info 15 gauche-droite
-> opérateur de sélection x->info 15 gauche-droite
[] opérateur de sélection x[3] 15 gauche-droite
Opérateurs du préprocesseur
Toute ligne de code-source commence par « # » est considérée comme un opérateur de

préprocesseur (ou l’opérateur de prétraitement ou encore la ligne de commande).
Les opérateurs du préprocesseur sont généralement placés au début du code-source, mais ils
ont le droit d'être n'importe où dans le programme.
Le préprocesseur permet à un programmeur de :
 Compiler un programme de sorte que les parties du code ne sont pas compilés
 Remplacer les symboles avec d'autres symboles ou des valeurs
 Insérer des fichiers texte dans un programme
La syntaxe plus commune d'un opérateur du préprocesseur est :
#include <math.h>
MikroC compilateur prend en charge les commandes de préprocesseur suivantes:
#define #undef
#if #elif #endif
#ifdef #ifndef
#error
#ligne
Commande du préprocesseur #define
La commande préprocesseur #define fournit une macro où chaque apparition de son nom
dans le programme est remplacé par la valeur de ce nom.
Par exemple, pour remplacer toutes les apparitions de MAX avec une valeur de 100, nous
pouvons écrire:
#define MAX 100
Notez que la commande préprocesseur #define n’occupe pas l’espace en mémoire.
Nous pouvons passer des paramètres à une définition de macro en précisant les paramètres
entre les parenthèses après le nom de la macro. Par exemple :
#define ADD (a, b) (a + b)

- 39 -
famille PIC
Lorsque cette macro est utilisée dans un programme, (a, b) sera remplacé par (a + b)
comme indiqué ci-dessous :
p = ADD (x, y) sera transformé en p = (x + y)
De même, nous pouvons définir une macro pour calculer le carré de deux nombres :
#define CARRE (a) (a * a)
Nous pouvons maintenant utiliser cette macro dans un programme :
p = CARRE (x) sera transformé en p = (x * x)
Commande du préprocesseur #include
La commande #include est utilisé pour inclure un fichier source dans un programme.
Habituellement les fichiers avec l'extension ". H" sont utilisés avec #include. Il y a deux
formats pour l'utilisation de #include:
#include <fichier>
et
#include "fichier"
Dans la première option le fichier est recherché d'abord dans le répertoire d'installation mikroC,
puis dans les chemins de recherche des utilisateurs.
En seconde option le fichier spécifié est recherché dans le dossier de projet mikroC , puis dans
le dossier d'installation mikroC, puis dans les chemins de recherche des utilisateurs.
Il est également possible de spécifier un chemin de répertoire complet :
#include "C: \ temp \ last.h"
Le dossier dans ce cas n’est recherché que dans le chemin du répertoire spécifié.
Commande du préprocesseur #if, #elif, #else, #endif
Les commandes préprocesseur #if, #elif, #else et #endif sont utilisée pour les
compilations conditionnelles, où certaines parties du code-source peut être compilée si
certaines conditions sont remplies.
Dans l'exemple suivant, si M a une valeur différente de zéro la section de code où les variables
A et B sont mis à zéro est établi, sinon la section de code où A et B sont tous les deux à 1 est
compilé.
Notez que le #if doit se terminer par #endif:
#if M
A = 0;
B = 0;
#else
A = 1;
B = 1;
#endif
- 40 -
famille PIC
Nous pouvons également utiliser la condition #elif, qui teste une nouvelle condition si la
condition précédente était fausse :
#if M
A = 0;
B = 0;
#elif N
A = 1;
B = 1;
#else
A = 2;
B = 2;
#endif
Dans l'exemple ci-dessus, si M a une valeur différente de zéro, A = 0 ; B = 0. Sinon, si N

est une valeur non nulle, A = 1; B = 1. Enfin, si à la fois M et N sont égaux à zéro, alors A
= 2 ; B = 2.
Notez qu’une seule section de code est compilé entre #if et #endif et qu'une section
de code peut contenir n'importe quel nombre d’instructions.
2.2.13 Structure de contrôle de programme
Les instructions sont normalement exécutées séquentiellement à partir du début à la fin d’un
programme. Nous pouvons utiliser des instructions de contrôle pour modifier ce flux séquentiel
normal dans un programme C. Les instructions de contrôle suivantes sont disponibles dans les
programmes en mikroC:
De sélection if et switch
D'itération ou bouclage for
Modifications inconditionnels d’exécution
Instructions de sélection if et switch
 Instruction if
Cette 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
ou
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.
- 41 -
famille PIC
Le mot-clé else est optionnel et peut être omis.

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 déclarations dans bouclés
entre parenthèses. Par exemple:
if (x> MAX)
{
P++;
Cnt = P;
Sum = Sum = Cnt;
}
else
P--;
Dans cet exemple, si x est supérieur à MAX, donc les trois instructions bouclés
entre les parenthèses sont exécutés, sinon la déclaration P-- est exécuté.
Un autre exemple en utilisant l'instruction if est la suivante:
if (x> 0 && x <10)

{
Total + = Sum;
Sum++;
}
else
{
Total = 0;
Sum = 0;
}
 Instruction switch
L'instruction switch (commutateur) est utilisé pour assurer le commutation entre des
déférentes déclarations si un certain nombre des conditions son vraie ou faut.
La syntaxe de commutation :
switch (condition)
{
case condition1:
Instructions;
break;
case condition2:
Instructions;
break;
. . . . . . . . . . . . . . . . . . . . .
- 42 -
famille PIC
. . . . . . . . . . . . . . . . . . . . .
case condition:
Instructions;
break;
default:
Instructions;
}
L’instruction switch fonction comme suit : d'abord la condition est évaluée. La

condition est ensuite comparée à condition1 et si une correspondance est trouvée, les
déclarations contenues dans ce bloc sont évalués. Puis s’effectuer le saut de contrôle en dehors
de l'instruction switch lorsque le mot break est rencontré.
Si la condition ne se trouve pas, la condition est comparée à condition2

et si une correspondance est trouvée, les déclarations de ce bloc sont évaluées et le saut de
contrôle dehors d’états de commutation s’effectuer, et ainsi de suite.
Lavaleur par défault est facultative, si la condition ne correspond à aucune des conditions
spécifiées.
Dans l'exemple suivant, la valeur de la variable est évalué Cnt. Si Cnt = 1, A est mis à
1. Si Cnt = 10, B est mis à 1, et si Cnt = 100, C est mis à 1. Si Cnt n'est pas égal à 1,
10,ou100, donc D est fixé à 1:
switch (Cnt)
{
case 1:
A=1;
break;
case 10:
B=10 ;
break ;
case 100:
C=100;
break;
default:
D =1;
}
Puisque les espaces blancs sont ignorés en langage C, nous pouvons également écrire le code
précédent comme suit:
switch (Cnt)
{
case 1: A = 1; break;
case 10: B = 1; break;
case 100: C = 1; break;
défault: D = 1;
}
- 43 -
famille PIC
Instructions d'itération for, while, do, goto, continue et break
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é un certain nombre de fois. Dans mikroC l'itération peut être
effectuée de quatre façons. Nous se penchera sur chacun des exemples :
 Utilisation de for
 Utilisation de while
 Utilisation de do
 Utilisation de goto, continue et break
Instruction for
La syntaxe d'une instruction for est :
for (expression initiale; expression de condition; expression

incrément)
{
Instructions;
}
L'expression initiale définit la variable au départ de la boucle, et cette variable est

comparée à l'expression de condition avant l'entrée dans la boucle. Déclarations à l'intérieur de
la boucle sont exécutées de façon répétée, et après chaque itération la valeur d’expression est
incrémentée. L'itération se poursuit jusqu'à moment où l'expression de condition devient fausse.
Une boucle sans fin est formée si l'expression condition est toujours vraie.
L'exemple suivant montre comment une boucle peut être mise en place pour exécuter 10 fois.
Dans cet exemple, la variable i commence par 0 et elle est augmentée de 1 à la fin de chaque
itération. La boucle se termine quand i = 10, puisque dans ce cas, la condition i <10 devient
fausse. À la sortie de la boucle, la valeur de i est de 10:
for(i = 0; i < 10; i ++)

{
Instructions;
}
Cette boucle pourrait également être lancée par une expression initiale avec une valeur
différente de zéro. Ici, i commence par 1 et la boucle se termine quand i = 11. La sortie de la
boucle se produira lorsque la valeur dei sera de 11 :
for (i = 1; i <= 10; i++)

{
Instructions;
}
Les paramètres d'une boucle for sont tous optionnels et peuvent être omises. Si la condition
expression est laissée de côté, il est supposé pour être vrai. Dans l'exemple suivant, une boucle
sans fin est formée par l'expression de condition qui est toujours vraie et la valeur de i
commence avec 0 et est incrémenté après chaque itération :
// Boucle sans fin avec incrémentation i

for (i = 0;; i++)
{
Instructions;
}
- 44 -
famille PIC
Dans l'exemple suivant d'une boucle sans fin où tous les paramètres sont omis :
// Exemple de boucle sans fin

for (;;)
{
Instructions;
}
Dans la boucle sans fin suivante, i commence par 1 et n'est pas incrémenté à l'intérieur de la
boucle :
// Boucle sans fin avec i = 1

for (i = 1;;)
{
Instructions;
}
S’il n'y a qu'une seule instruction à l'intérieur de la boucle for, les accolades peuvent être
omises comme c’est montré dans l'exemple suivant :
for (k = 0; k <10; k++) Total = Total + Sum;
Les boucles imbriquées peuvent également être utilisés. 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;
}
}
Dans l'exemple suivant, la somme de tous les éléments d'un matrice M [3 x 4] est calculée
et stockées dans une variable appelée Sum :
// Ajouter tous les éléments d'une matrice 3x4

Sum = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
Sum = Sum + M[i][j];
}
}
Comme il n'y a qu'une seule instruction à exécuter, l'exemple précédent pourrait également être
s'écrit :
// Ajouter tous les éléments d'une matrice 3x4

Sum = 0;
for (i = 0; i < 3; i++)
- 45 -
famille PIC
{
for (j = 0; j < 4; j++) Sum = Sum + M[i][j];
}
Instruction while
La syntaxe d'une instruction while est la suivante :
while (condition)
{
Instructions;
}
Ici, les instructions sont exécutées jusqu'à ce que la condition devienne fausse, ou les
instructions sont exécutées de façon répétée aussi longtemps que la condition est vraie. Si la
condition est fausse à l'entrée de la boucle, la boucle ne sera pas exécuté et le programme sera
continuer de l'extrémité de la boucle while. Il est important que la condition est changé
intérieur de la boucle, sinon une boucle sans fin sera formé.
Le code suivant montre comment mettre en place une boucle d'exécuter 10 fois :
// Une boucle qui s'exécute 10 fois

k = 0;
while (k <10)
{
Instructions;
k++;
}
Au début du code, la variable k est égal à 0. Comme k est inférieur à 10, la boucle while
commence. L'intérieur de la boucle, la valeur de k est incrémenté d’un après chaque itération.
La boucle se répète tant que k < 10 et se termine lorsque k = 10. À la fin la valeur de k est
10. Notez qu’une boucle sans fin sera formé si k n'est pas incrémenté à l'intérieur de la boucle:
// Une boucle sans fin

k = 0;
while (k <10)
{
Instructions;
}
Une boucle sans fin peut également être formée par réglage de la condition qui doit être
toujours vrai :
// Une boucle sans fin

while (k = k)
{
Instructions;
}
Voici un exemple de calcul de la somme des nombres de 1 à 10 et le stockage du

résultat d'une somme variable appelée sum :
- 46 -
famille PIC
// Calculer la somme des nombres de 1 à 10

unsigned int k, sum;
k = 1;
sum = 0;
while (k <= 10)
{
sum = sum + k;
k++;
}
Il est possible d'avoir une déclaration while sans corps. Une telle déclaration est utile, pour par
exemple, si nous attendons un port d'entrée pour changer sa valeur. Voici un exemple où le
programme va attendre aussi longtemps que le bit 0 de PORTB (PORTB.0) est au niveau
logique 0. Le programme se poursuivra jusqu’au changement à la valeur logique 1 sur les
broches du port.
while (PORTB.F0 == 0); // Attendre jusqu'à ce que PORTB.0 devient un

ou
while (PORTB.F0);
Instruction do
Une déclaration do est similaire à une déclaration while sauf ce que la boucle
exécute jusqu'à ce que la condition devient fausse, ou, la boucle s'exécute tant que la
la condition est vraie. La condition est testée à la fin de la boucle. La syntaxe d'une déclaration
do est la suivante :
do
{
Instructions;
} while (condition);
La première itération est toujours effectuée si la condition est vraie ou fausse. Il s'agit de la
principale différence entre une déclaration while et une déclaration do.
Le code suivant montre comment mettre en place une boucle d'exécuter 10 fois en utilisant la
déclaration do
/*Exécute 10 fois */
k = 0;
do
{
Instructions;
k++;
} while (k <10);
La boucle commence avec k = 0, et la valeur de k est incrémenté intérieur de la boucle après

chaque itération. À la fin de boucle k est testé, et si k n'est pas inférieur à 10, la boucle termine.
Dans cet exemple k = 0 au début de la boucle, à la fin de la boucle la valeur de k est 10.
Une boucle sans fin sera formée si la condition n'est pas modifiée à l'intérieur de la boucle,
comme est illustré dans l'exemple ci-dessous. Ici k est toujours inférieur à 10 :
- 47 -
famille PIC
/*Une boucle sans fin*/

k = 0 ;
do
{
Instructions;
} while (k < 10);
Une boucle sans fin peut également être créée si la condition est réglée pour être vrai tout le
temps:
/* Une boucle sans fin */

do
{
Instructions;
}while (k = k);
Instruction goto, continue et break
Une instruction goto peut être utilisée pour modifier le flux normal de contrôle dans un
programme. Elle provoque le programme à sauter à une étiquette spécifiée. Une étiquette peut
être n'importe quel jeu de caractères alphanumériques commençant par une lettre et se
terminant par le caractère « : ».
Bien que l’instruction goto soit non recommandée, elle peut être utilisée conjointement avec
une instruction if pour créer un programme en itérations. L'exemple suivant montre comment
mettre en place une boucle pour l’exécuter 10 fois en utilisant goto et if :
/ * Exécute 10 fois * /
k = 0;
Boucle:
Instructions;
k++;
if (k < 10) goto Boucle;
La boucle commence par l’étiquette Boucle et la variable k = 0. Les instructions sont

exécutées à l'intérieur de la boucle et k est incrémenté de 1. La valeur de k est alors comparé à
10 et le programme retourne à l’étiquette Boucle si k <10. Ainsi, la boucle est exécutée 10

fois jusqu'à ce que la condition à la fin devienne fausse. À la fin de la boucle la valeur de k est
10.
Les instructions continue et break peuvent être utilisés à l'intérieur d’itérations pour modifier
le flux de commande. Une instruction continue est généralement utilisée avec une instruction
if et provoque le saut de la boucle d’itération.
Voici un exemple qui calcule la somme des nombres de 1 à 10, sauf le nombre 5:
- 48 -
famille PIC
/* Calculer la somme des nombres 1,2,3,4,6,7,8,9,10 */

Sum = 0;
i = 1;
for (i = 1; i <= 10; i++)
{
if (i == 5) continue; // Passer numéro 5
Sum = Sum + i;
}
De même, une instruction break peut être utilisé pour mettre fin à une boucle à l'intérieur de la
boucle.
Dans l'exemple suivant, la somme des nombres de 1 à 5 est calculée, même si les paramètres
de la boucle sont mis à parcourir 10 fois:
/ * Calculer la somme des nombres 1,2,3,4,5 * /

Sum = 0;
i = 1;
for (i = 1; i <= 10; i++)
{
if (i > 5) break; // Stop boucle si i > 5
}
2.2.14 Utilisation mikroC avec des instructions en langage d’assembleur
Il devient parfois nécessaire d’utiliser la langue assembleur pour microcontrôleurs PIC et des
instructions en langage mikroC.
Des instructions en langage assembleur peuvent être incluses dans un programme en utilisant
mot-clé asm (ou _asm, ou __ asm).
La syntaxe est la suivante:
asm
{
Instructions
}
Commentaires du langage d’assembleur (une ligne commençant par un point-virgule) ne sont

pas autorisés, mais les deux types de commentaires en microC peuvent être utilisés dans les
routines en langage d'assembleur :
asm
{
// Ce code introduit un temporisation
MOVLW 6 // Charge W avec 6

. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
Les variables en microC peuvent être utilisées dans les routines en langage d'assembleur,
mais elles doivent être déclarées et initialisées avant son utilisation.
Par exemple, une variable Temp peut être initialisée et ensuite chargée dans le registre W :
- 49 -
famille PIC
III. FONCTIONS ET BIBLIOTHEQUES DANS MIKROC

3.1 Fonctions dans mikroC
Les fonctions sont généralement définies comme des sous-programmes qui renvoient une
valeur fondée sur un certain nombre de paramètres d'entrée.
Chaque programme doit avoir une seule fonction externe marquant le point d'entrée dans le
programme principale.
Les fonctions sont déclarés comme des prototypes en standard ou fourni par l'utilisateur, ou par
des fichiers du programme.
Chaque programme écrit en langage mikroC se compose de nombre plus ou moins de
fonctions. L'idée principale est de diviser un programme en plusieurs parties qui utilisent ces
fonctions afin de résoudre le problème réel plus facile. En outre, les fonctions nous permettent
d'utiliser les compétences et les connaissances d'autres programmeurs. Par exemple, s’il est
nécessaire d'envoyer une chaîne de caractères à un écran LCD, il est beaucoup plus facile
d'utiliser une partie déjà écrite du programme que de recommencer.
Les fonctions consistent des commandes précisant ce qui doit être fait sur des variables. Elles
peuvent être comparées à des sous-routines. En règle générale, il est beaucoup mieux d'avoir
un programme composé d'un grand nombre de fonctions simples que de quelques fonctions
importantes.
3.1.1 Déclaration d’une fonction
Chaque fonction doit être déclarée de manière à être correctement interprété au cours du
processus de compilation. 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 d'une définition de fonction est montrée ci-dessous :
type_de_résultat nom_fonction(parameter1, parameter2, .....)

{
.............
corps de la fonction
.............
}
Dans l’exemple qui suit, la fonction, nommée Mult, reçoit deux arguments entiers, a et b, et
renvoie leur produit. Notez que l'utilisation des parenthèses dans une instruction de retour est
facultative :
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 :
- 54 -
famille PIC
z = Mult (x, y);
où la variable z est le type de données int. Notez que les arguments déclarés dans la
définition de la fonction et les arguments passés lorsque la fonction est appelée sont
indépendants les uns des autres, même si elles ont le même nom. Dans l'exemple précédent,
lorsque la fonction est appelée, variable x est copié à a et variable y et est copiée à b sur
entrée en fonction Mult.
Certaines fonctions ne renvoient pas de données. Le type de données de ces fonctions doit être
déclarées comme nul. Par exemple
void LED(unsigned char D)

{
PORTB = D;
}
Fonctions void peut être appelée sans aucune instruction d'affectation, mais les parenthèses
sont nécessaire pour indiquer au compilateur que un appel de fonction est faite:
LED ();
En outre, certaines fonctions ne possèdent pas d'arguments. Dans l'exemple suivant, la

fonction, nommée Compl, complète PORTC du microcontrôleur. Il ne renvoie pas de données
et n'a pas d'arguments:
void Compl()
{
PORTC = PORTC;
}
Cette fonction peut être appelée en tant que :
Compl ();
Les fonctions sont normalement définies avant le début du programme principal.
Certaines définitions de fonction et de leur utilisation dans les programmes principaux sont
illustrées dans les exemples suivants:
Exercice 3.1
Écrire une fonction appelée Cercle_Surface pour calculer la surface d'un cercle dont le
rayon sera utilisé comme un argument. Utilisez cette fonction dans un programme principal pour
calculer la surface d'un cercle dont le rayon est de 2,5 cm. Sauvegarder la valeur de cette
surface dans une variable appelée Cercle.
Solution 3.1
Le type de données de la fonction est déclaré comme float. La surface d'un cercle est
calculée par la formule :
- 55 -
famille PIC
3.1.3 Définition de fonction
La fonction se compose de sa déclaration et de son corps de la fonction. Le corps de fonction

est un bloc, représentant de définitions locales et des déclarations entre les accolades {}.
Toutes les variables déclarées au sein de corps sont locales. La fonction elle-même peut être
définie uniquement dans le cadre du fichier. Cela signifie que les déclarations ne peuvent pas
être imbriquées. Pour revenir au résultat de la fonction, utilisez l'instruction de return.
Déclaration à retour d’une fonction de type void ne peut pas avoir un paramètre, vous pouvez
omettre l’instruction return si elle est la dernière instruction du corps de la fonction. Voici une
définition de fonction échantillon :
// retourne Max avec le plus grand l'un de ses 2 arguments
int Max (int x, int y)

{
return (x >= y)? x: y;
}
Voici un exemple de fonction qui dépend des effets secondaires plutôt que de la valeur de
retour :
/* Fonction qui convertit coordonnées Descartes (x, y)

en coordonnées polaires (r, fi): */
#include <math.h>
voide polaire (double x, double y, double *r, double *fi)
{
*r = sqrt (x * x + y y *);
*fi = (x == 0 && y == 0)? 0: atan2 (y, x);
return; // cette ligne peut être omise
}
3.1.3 Appels de fonctions
Une fonction est appelée avec des arguments réels placés dans la même séquence que leur
correspondant paramètres formels. Utilisez un opérateur d'appel de fonction () :
fonction_nom (expression_1, expression_2, ..., expression_n)
Chaque expression dans l'appel de fonction est un argument réel. Nombre et types des
arguments réels doivent correspondre à ceux des paramètres de fonctions formelles.
Arguments réels peuvent être de n'importe quelle complexité. Sur l’appel de fonction, tous les
paramètres formels sont créés en tant qu'objets locaux initialisé par des valeurs d'arguments
réels. De retour d'une fonction, l’objet temporaire est créé à la place de l'appel, et il est initialisé
par l'expression de la déclaration de retour.
Cela signifie que l'appel de fonction comme un opérande de l'expression complexe est traitée
en résultat de fonction.
- 62 -
famille PIC
Si la fonction est sans résultat (type void) ou vous n'avez pas besoin du résultat, vous pouvez
écrire l'appel de fonction comme une expression autonome.
En C, les paramètres scalaires sont toujours passés à la fonction par valeur. Une fonction peut
modifier les valeurs de ses paramètres formels, mais cela n'a aucun effet sur le réel argument
dans la routine d'appel. Vous pouvez passer objet scalaire par le discours de déclarer un
paramètre formel d'être un pointeur. Ensuite, utilisez l'opérateur « * » pour accéder à l'objet
pointu.
3.1.4 Conversion argument
Quand un prototype de la fonction n'a pas été préalablement déclaré, mikroC convertit
arguments intégraux à un appel de fonction de l'élargissement intégrante (l'expansion)
Quand un prototype de fonction est en portée, mikroC convertit l'argument donné par le type de
paramètre déclaré comme par affectation.
Si un prototype est présent, le nombre d'arguments doivent correspondre. Les types doivent
être compatibles uniquement dans la mesure où une cession peut également les convertir.
Vous pouvez toujours utiliser une conversion explicite pour convertir un argument pour un type
qui est acceptable à un prototype de fonction.
Remarque :
Si le prototype de fonction ne correspond pas à la définition de la fonction réelle,
mikroC permet le détecter si et seulement si cette définition se trouve dans la même unité de
compilation comme le prototype.
Le compilateur est aussi capable de forcer les arguments du type approprié. Supposons que
vous ayez le code qui suit :
int limit = 32;

char ch = 'A';
long res;
extern long fonc(long par1, long par2); // prototype
main ()
{
//...
res = fonc(limit, ch); // fonction call (appeler)
}
Comme il a le prototype de fonction pour func, ce programme convertit limit et ch

à long, en utilisant la règle standard, avant qu'il ne les place sur la pile pour l'appel la fonction
fonc.
Sans le prototype de fonction, limit et ch aurait été placé dans la pile comme un entier et un
caractère, respectivement. Dans ce cas, la contenu de pile ne serait pas correspondre à la taille
ou le contenu de fonc, conduisant à un problème. L’utilisation des prototypes de fonctions
facilite grandement dans la révélation des erreurs.
- 63 -
famille PIC
3.2 Fonctions intégrées

Le compilateur mikroC fournit un ensemble de fonctions intégrées qui peuvent être appelées à
partir du programme. Ces fonctions sont énumérées dans le tableau 3.1, avec une brève
description de chacune.
La plupart de ces fonctions peuvent être utilisées dans un programme sans avoir à inclure des
fichiers d'en-tête.
Tableau 3.1: Fonctions intégrées

Fonction Description
Lo Renvoie le plus faible nombre d'octets (bits 0 à 7)
Hi Renvoie le plus faible nombre d'octets (bits 8 à 15)
Higher Renvoie le plus élevée d'octet d'un nombre (bits 16 à 23)
Highest Retourne le plus grand d'octets d'un nombre (bits 24 à 31)
Delay_us Crée le retard dans les unités de microseconde
Delay_ms Crée le retard constante dans les unités de millisecondes
Vdelay_ms Crée le retard en millisecondes en utilisant des variables de programme
Delay_Cyc Crée le retard basé sur l'horloge de microcontrôleur
Clock_Khz Régler l’horloge de microcontrôleur en KHz
Clock_Mhz Régler l’horloge de microcontrôleur en MHz
Les exceptions sont des fonctions Lo, Hi, Higher, et Highest, qui exigent le fichier d’en-tête
built_in.h. De plus détails sur l'utilisation de ces fonctions sont disponibles dans le manuel
de mikroC.
Delay_us et delay_ms fonctions sont fréquemment utilisés dans les programmes où les
retards sont requis (par exemple, se met à clignoter une LED).
L'exemple suivant illustre l'utilisation de la fonction Delay_ms :
Exercice 3.6
Une LED est connectée au PORTB (broche RB0) d'un microcontrôleur PIC16F84A
à travers d’une résistance de limitation, comme indiqué dans la figure 3.1.
Ecrire un programme qui fera clignoter le LED ON et OFF en permanence dans l’intervalle
d'une seconde.
- 64 -
famille PIC
3.3.2 Bibliothèque pour LCD
La programmation en assembleur d'un écran LCD en mode parallèle ou en série est

généralement une tâche complexe et nécessite d’une bonne compréhension du fonctionnement
interne de l'écran LCD. La langue mikroC fournit des fonctions pour les deux modes de
programmation basée sur le texte déjà préparé, ce qui simplifie l'utilisation d'écrans LCD.
Le contrôleur LCD HD44780
Le HD44780 est l'un des contrôleurs de cristaux liquides les plus appréciés, étant utilisé dans
l'industrie et dans les applications commerciales.
Le module est monochrome et vient dans différentes formes et tailles. Des modules avec 8, 16,
20, 24, 32 et 40 caractères sont disponibles.
Selon le modèle, l'écran LCD est fabriqué avec 14 ou 16 pattes pour l'interface.
Le tableau 3.3 présente la configuration des pattes et les fonctions des pattes d’un LCD à 14
pattes.
La patte VSS est à 0V ou du sol. La patte VDD doit être connecté à la borne positive
d’alimentation. Bien que les fabricants spécifient une alimentation 5V DC, les modules
travaillent habituellement aussi avec une alimentation un peu bas que 3V ou aussi haut que 6V.
La patte 3 VEE est désigné pour réglage du contraste de l'affichage et doit être reliée à une
alimentation en courant continu. Un potentiomètre est généralement connecté à l'alimentation
avec son curseur raccordé à la patte VEE et l'autre patte du potentiomètre relié à la masse. De
cette façon la tension à la patte VEE, et où le contraste de l'affichage, peut être réglée à
volonté.
La patte 4 est le registre de sélection (RS) et lorsque cette patte à 0 V, les données sont
transférés à l'affichage à cristaux liquides. Lorsque RS est à +5 V, les données de caractères
peuvent être transférés à partir du module LCD.
La patte 5 est le registre de sélection de lecture / écriture (R / W). Cette patte est reliée avec la
masse (état logique bas) afin d'écrire des données de caractères au module LCD. Lorsque
cette broche est à +5 V (états logique haut) donc les informations sortants du module LCD
peuvent être lues.
La patte 6 est la validation (EN), qui est utilisé pour initier le transfert de commandes ou de
données entre le module et le microcontrôleur. Lors de l'écriture à l'écran, les données sont
transférés uniquement sur le front descendant (haut-bas) sur cette patte. Lors de la lecture de
l’affichage, les données deviennent accessibles après le front montant (bas-haut) de la patte de
validation, et ces données demeurent tant que la patte de validation est au niveau logique haut.
Les broches 7 à 14 sont les huit lignes de bus de données (D0 à D7). Les données peuvent
être transférées entre le microcontrôleur et le module LCD à l'aide soit d'un seul octet de 8 bits
soit de deux 4-bits. Dans ce dernier cas, seuls les quatre lignes de données supérieures (D4 à
D7) sont utilisées. Le 4-bits mode a l'avantage de nécessiter moins de lignes d'E / S pour
communiquer avec l'écran LCD.
- 69 -
famille PIC
Tableau 3.3 : Les pattes du module LCD HD44780
Broche Appellation Fonction

N°
1 VSS Ground
2 VDD +ve supply
3 VEE Contrast
4 RS Register select
5 R/W Read/write
6 EN Enable
7 D0 Data bit 0
8 D1 Data bit 1
9 D2 Data bit 2
10 D3 Data bit 3
11 D4 Data bit 4
12 D5 Data bit 5
13 D6 Data bit 6
14 D7 Data bit 7
Le mikroC LCD bibliothèque fournit un grand nombre de fonctions pour contrôler du texte LCD
avec 4-bits et les interfaces de données 8-bit, et pour les graphiques LCD. La plus courante
sont les 4-bit interface en mode texte sur écran LCD. Ce qui suit sont les fonctions disponibles
pour LCD 4-bit interface en mode texte LCD :
 Lcd_Config
 Lcd_Init
 Lcd_Out
 Lcd_Out_Cp
 Lcd_Chr
 Lcd_Chr_Cp
 Lcd_Cmd
 Lcd_Config
La fonction Lcd_Config est utilisée pour configurer l'interface LCD. La connexion par défaut
entre le LCD et le microcontrôleur est la suivante :
LCD Patte du port de microcontrôleurs
- 70 -
famille PIC
RS → 2
FR → 3
D4 → 4
D5 → 5
D6 → 6
D7 → 7
La patte R / W de l'écran n'est pas utilisé et doit être reliée à la masse.
Cette fonction devrait être utilisée pour modifier la connexion par défaut. Il devrait être appelé
avec les paramètres dans l'ordre suivant :
nom de port, RS patte, EN patte, R/W patte, D7 patte, D6 patte, D5

patte, D4 patte
Le nom du port doit être spécifié en passant son adresse. Par exemple, si RS patte est
connectée à RB0, EN patte à RB1, D7 patte à RB2, D6 patte à RB3, D5 patte à RB4, et D4
patte à RB5, alors la fonction doit être appelée comme suit :
Lcd_Init
La fonction Lcd_Init est appelée pour configurer l'interface entre le microcontrôleur et l'écran
LCD lorsque les connexions sont faites par défaut que vient d'être illustré. Le nom du port doit
être spécifié en passant son adresse. Par exemple, en supposant que LCD est reliée à PORTB
et les connexions par défaut précédentes sont utilisées, la fonction doit être appelée en tant que
:
Lcd_Init();
 Lcd_Out
La fonction Lcd_Out affiche du texte à la ligne indiquée et la position des colonnes

de l'écran LCD. La fonction doit être appelée avec des paramètres dans l'ordre suivant :
ligne, colonne, texte
Par exemple, pour afficher du texte "Ordinateur" à la ligne 1 et la colonne 2 de l'écran LCD
nous devrions appeler la fonction comme suit :
Lcd_Out (1, 2, "Ordinateur");
 Lcd_Out_Cp
La fonction Lcd_Out_Cp affiche le texte à la position actuelle du curseur.

Par exemple, pour afficher le texte "Ordinateur" à la position actuelle du curseur, la fonction
devrait être appelé en tant que :
Lcd_Out_Cp ("Ordinateur");
Lcd_Chr
La fonction Lcd_Chr affiche un caractère à la ligne indiquée et la colonne la position du

curseur. La fonction doit être appelée avec les paramètres dans le l'ordre suivant :
- 71 -
famille PIC
ligne, colonne, caractère
Par exemple, pour afficher caractère "K" à la ligne 2 et la colonne 4 de l'écran LCD nous
devrions appeler la fonction de :
Lcd_Chr(2, 4, ‘K’);
 Lcd_Chr_Cp
La fonction Lcd_Chr_Cp affiche un caractère à la position actuelle du courser. Par exemple,

pour afficher le caractère "M" à la position actuelle du curseur, la fonction doit être appelée en
tant que :
Lcd_Chr_Cp ('M');
 Lcd_Cmd
La fonction Lcd_Cmd est utilisée pour envoyer une commande à l'écran LCD. Avec ce
commande, nous pouvons déplacer le curseur vers n'importe quelle ligne, désactiver l'écran
LCD, faire clignote le curseur, décaler l'affichage, etc. Une liste des plus couramment utilisés
commandes LCD est donnée dans Tableau 3.4.
Par exemple, pour effacer l'écran LCD nous devrions appeler la fonction comme suit :
Lcd_Cmd (Lcd_Clear);
Tableau 3.4: Commandes LCD

Commande LCD Description
LCD_CLEAR Effacer l'affichage
LCD_RETURN_HOME Retourner vers la position du curseur
LCD_FIRST_ROW Déplacer le curseur vers la première ligne
LCD_SECOND_ROW Déplacer le curseur vers la deuxième ligne
LCD_THIRD_ROW Déplacer le curseur vers la troisième ligne
LCD_FOURTH_ROW Déplacer le curseur vers la quatrième ligne
LCD_BLINK_CURSOR_ON Clignotement du curseur
LCD_MOVE_CURSOR_LEFT Déplacer le curseur à gauche
LCD_MOVE_CURSOR_RIGHT Déplacer le curseur à droite
LCD_SHIFT_LEFT Décaler l'affichage à gauche
LCD_SHIFT_RIGHT Décaler l'affichage à droite
Un exercice ci-dessous illustre l'initialisation et l'utilisation de l'écran LCD.
- 72 -
famille PIC
utilisé pour le bus RS232 de la communication série entre deux appareils électroniques.
Dans la communication de série, seulement deux câbles (plus un câble de terre) sont
nécessaires pour transférer des données dans les deux sens. Les données
sont envoyés en format série bit par bit. Normalement, le dispositif de réception est au
repos.
Pour l’émission la patte TX est au niveau logique 1, également connu sous le nom
MARK. Transmission des données commence lorsque le niveau logique sur cette patte
passe de 1 à 0, également connu sous le nom ESPACE. Le premier bit envoyé est le bit
de départ à la logique 0. La suite de ce bit, 7 ou 8 bits de données sont envoyés, suivie
par un bit de parité en option. Le dernier bit envoyé s’appelle bit d'arrêt est au niveau
logique 1. Les données en série est généralement envoyé sous forme de 10 bits : un bit
de départ, 8 bits de données, et un bit d'arrêt, et aucun bits de parité.
La figure 3.3 montre comment le caractère «A» peut être envoyée en utilisant la communication
série. Caractère "A" a la configuration binaire ASCII est 01000001.
IDLE 1 1 STOP
0 0 0 0 0 0 0
START
Fig. 3.3 Envoi un caractère "A" par la communication série
Comme montre cette figure, le premier bit de départ est envoyé, cela est suivi par 8 bits de
données 01000001, et enfin le bit d'arrêt est envoyé. Le rythme binaire est très important dans
la communication de série, et la transmission (TX) et réception (Rx) dispositifs doivent avoir la
même rythme de bits. Le rythme binaire est mesuré par la vitesse de transmission, qui spécifie
le nombre de bits transmis ou reçus par seconde.
Les vitesses typiques de transmission sont : 4800, 9600, 19200, 38400, et ainsi de suite. Par
exemple, lorsque exploitation à 9600 bauds avec une taille d'image de 10 bits, 960 caractères
sont transmis ou reçus par seconde. La synchronisation entre les bits est alors d'environ
104ms.
En RS232, basée sur la communication en série, les deux périphériques sont connectés les uns
aux autres (voir figure 3.4) en utilisant soit un connecteur à 9 voies ou d'un connecteur à 25
voies. Normalement, seul le Broches TX, RX et GND sont nécessaires pour la communication.
Les pattes nécessaires pour deux types de connecteurs sont données dans le tableau 3.5.
Fig. 3.4 Les connecteurs RS232
Les niveaux de tension spécifiés par le protocole RS232 sont ± 12V. Un signal logique HIGH
(haut) est à - 12V et un signal logique LOW (bas) est à + 12V. Les microcontrôleurs PIC,
fonctionnent normalement à des niveaux de tension : 0 et 5 V. Donc les signaux pour RS232
doivent être convertie pour l'entrée d'un microcontrôleur. De même, la sortie du microcontrôleur
- 75 -
famille PIC
doit être convertie en ± 12V avant l'envoi au dispositif de réception RS232. La conversion de
tension est généralement réalisée avec des circuits de conversion, comme le MAX232,
fabriqué par Maxim Inc.
La communication série peut être mis en œuvre dans un matériel utilisant une patte spécifique
d'un microcontrôleur, ou les signaux nécessaires peuvent être générés par le logiciel pour toute
patte nécessaire d’un microcontrôleur. Mise en œuvre matérielle nécessite soit une carte
intérieure de circuit UART (ou USART) ou d'une carte UART extérieure connectée au
microcontrôleur.
Le mikroC PRO pour PIC fournit des routines pour la mise en œuvre du logiciel de
communication UART. Ces routines sont indépendantes du matériel et peut être utilisé avec
n'importe quel microcontrôleur.
Le compilateur mikroC PRO prend en charge les fonctions du logiciel UART suivantes:
 Soft_UART_Init
 Soft_UART_Read
 Soft_UART_Write
 Soft_UART_Break
 Soft_UART_Init
La fonction UART1_Init spécifie les paramètres de communication série et le fait

dans l'ordre suivant :
port, rx patte, tx patte, vitesse de transmission, mode
Ici :
port est le port utilisé comme UART logiciel (par exemple, PORTB) ;
rx est le receveur d’un nombre de transmission ;
tx est l’émméteur de transmission ;
vitesse de transmission est le taux de transmission choisi, où la valeur maximale

dépend de la fréquence d'horloge du microcontrôleur ;
mode spécifie si les données devraient être inversés ou non lors de la sortie. Un 0
indiquent qu’ils ne devraient pas être inversés, et un 1 indique qu'ils devraient être
inversés. Quand un RS232 est utilisé donc dans ce cas le mode doit être réglé à 1.
Soft_Uart_Init doit être la première fonction appelée avant que le logiciel soit
établié.
L'exemple suivant configure l'UART à utiliser PORTC comme un port série, avec RC6 pour la
patte TX et RC7 pour la patte RX. La vitesse de transmission est fixé à 9600 avec le mode non
inversés:
- 76 -
famille PIC
Soft_Uart_Init (PORTB, 0, 1, 9600, 0);
 Soft_Uart_Read
La fonction Soft_Uart_Read reçoit un octet à partir d'une patte du port série spécifié. La
renvoie une condition d'erreur et les données sont lues à partir du port série. La fonction
ne pas attendre que les données soient disponibles sur le port, et donc le paramètre d'erreur
doit être testé si un octet est prévu. L'erreur est normalement de 1 et devient 0 quand un octet
est lu à partir du port.
L'exemple suivant illustre la lecture d'un octet à partir du port configuré en série
en appelant la fonction Soft_Uart_Init. L'octet reçu est stocké dans une variable Temp:
do
Temp = Soft_Uart_Read(&Rx_Error);
while (Rx_Error);
 Soft_Uart_Write
La fonction Soft_Uart_Write transmet un octet à une patte de port configuré en série. Les
données à envoyer doivent être spécifiés comme un paramètre dans l'appel de la fonction.
Par exemple, pour envoyer un caractère "A" à la patte de port série :
char MyData = ‘A’;

Soft_Uart_Write(MyData);
L'exercice suivant illustre l'utilisation des fonctions du logiciel UART.
Exercice 3.9
Le port série d'un ordinateur (par exemple, COM1) est relié à un microcontrôleur PIC16F887, et
logiciel d'émulation de terminal (par exemple, HyperTerminal) est exploité sur le PC pour utiliser
un port série. Pattes RC6 et RC7 du microcontrôleur sont les broches TX et RX respectivement.
Le débit en bauds est de 9600.
Ecrire un programme pour lire les données du terminal, puis les renvoyer vers le terminal. Par
Un circuit intégré de conversion MAX232 est utilisé pour convertir les signaux du
microcontrôleur à des niveaux RS232.
La figure 3.5 montre le schéma du circuit de cet exercice.
Solution 3.9
Le circuit MAX232 reçoit le signal TX de la patte RC6 du microcontrôleur et le convertit en

niveaux RS232. Les données séries reçues du circuit MAX232 sont converties en niveaux de
tension du microcontrôleur, puis envoyé à la patte RC7. Noter que le fonctionnement correct du
circuit MAX232 nécessite quatre condensateurs à être connecté au circuit.
- 77 -
famille PIC
Tableau 3.5 Fonctions de la bibliothèque Ctype

isalnum Retourne 1 si le caractère spécifié est alphanumérique (a - z, A - Z, 0 - 9)
isalpha Retourne 1 si le caractère spécifié est alphabétique ( a - z, A - Z)
isntrl Retourne 1 si le caractère spécifié est un caractère de contrôle (décimale 0- 31

et 127)
isdigit Retourne 1 si le caractère spécifié est un chiffre (0 - 9)
islower Retourne 1 si le caractère spécifié est en minuscules
isprint Retourne 1 si le caractère spécifié est imprimable (décimal 32 - 126)
isupper Retourne 1 si le caractère spécifié est en majuscule
toupper Convertir un caractère en majuscules
tolower Convertir un caractère en minuscule
 Bibliothèque Stdlib
La bibliothèque stdlib contient des fonctions de bibliothèque standard. Tableau 3.7 dresse la
liste des fonctions les plus utilisées dans cette bibliothèque.
Tableau 3.6 Fonctions de la bibliothèque Math

acos Retours en radians de l'arc cosinus de son paramètre

asin Retours en radians de l'arc sinus de son paramètre
atan Retours en radians de l'arc tangent de son paramètre
atan2 Retours en radians de l'arc tangent de son paramètre où les signes des
paramètres sont utilisés pour déterminer le quadrant du résultat
cos Retourne le cosinus de son paramètre en radians
cosh Renvoie le cosinus hyperbolique de son paramètre
exp Renvoie la valeur exponentielle de son paramètre
fabs Retourne la valeur absolue de son paramètre
log Retourne le logarithme naturel de son paramètre
Log10 Retourne le logarithme en base 10 de son paramètre
pow Retourne la puissance d'un nombre
sin Retourne le sinus de son paramètre en radians
sinh Retourne le sinus hyperbolique de son paramètre
sqrt Retourne la racine carrée de ses paramètre
tan Retourne la tangente de son paramètre en radians
tanh Retourne la tangente hyperbolique de son paramètre en radians
Tableau 3.7 Fonctions de la bibliothèque Stdlib
- 80 -

ProgrammationenmikroC PDF

Transféré par

Informations du document

Titre original

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

ProgrammationenmikroC PDF

Transféré par

Droits d'auteur :

Formats disponibles

V.TOURTCHINE. Programmation en mikroC.

Application pour les microcontrôleurs de la

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE

UNIVERSITE M’HAMED BOGARA DE BOUMERDES

Manuscrit élaboré selon le programme officiellement agrée et confirme par le Conseil

I. LANGAGE ET COMPILATEUR mikroC POUR PIC

1.1 Compilateur mikroC PRO pour PIC

La nouvelle version appelée mikroC PRO dispose de très nombreuses améliorations du

1. Dans la suite nous utiliserons le compilateur mikroC PRO v.1.65

2. La simulation des applications de programmation nous réalisons à l’aide du

1.2 Installation du compilateur mikroC PRO v. 1.65

Pas 1 : Cliquer sur l’icône mikroC_PRO_1.65.exe (Si la fenêtre du Contrôle de compte

Pas 2 : Cliquer sur Next

Pas 5 : Cliquer sur Next

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

Pas 8 : Cliquer sur Finish

1.3 IDE mikroC PRO

mikroC PRO for PIC.lnk

Menu Toolbar Projet Manager

Fig. 1.1 L’environnement IDE du compilateur microC PRO

Editeur de code (voire la figure 1.1 : Code Editeur)

 Coloration syntaxique réglable

cliquez sur Tools > Options du menu déroulant ou sur l'icône

Fig.1.2. Boîte de dialogue « Options »

Fig.1.3. Assistant de code

Mise en forme automatique

Affichage syntaxique coloré

a) Mini terminal USART

b) Mini gestionnaire 7 segments

c) Table de conversion ASCII

d) Gestion des LCD graphiques

1.4 Création d’un nouveau projet

- Nom du projet et une description facultative

Nouvelles étapes de l'Assistant de projet

Commencez à créer votre nouveau projet, en cliquant sur le bouton Next :

Premier pas - Sélectionnez le périphérique dans le périphérique dans la liste déroulante.

Deuxième pas - Saisir la valeur de fréquence de l'oscillateur.

Troisième pas - Spécifiez l'emplacement où votre projet sera enregistré.

Ici vous devez saisir votre code-source

Fig. 1.4 Avertissement des érreures

Format Description Type de fichier

d’être inscrits dans d'autres projets.

1.5 Fichiers Sources

Création d’un nouveau fichier source

Pour créer un nouveau fichier source, procédez comme suit :

Ouvrir un fichier existant

Le fichier sélectionné s’affiche dans sa propre fenetre. Si le

Sélectionnez ensuite Save depuis le menu File ou pressez

Sauvegarder un fichier sous un nom différent

Sélectionnez ensuite Save As depuis le menu File. Une boîte

II. INTRODUCTION AU LANGAGE DE PROGRAMMATION MICROC

2.1.1 Règles générale d’écriture en microC

 Les instructions propres au langage microC doivent être écrites en minuscule

 Toutes instructions ou actions se terminent par un point virgule « ; ».

Examinons le fichier LED.c du code-source

En mikroC les commentaires de programmes peuvent être de deux types: de longs

Un commentaire au début d'un programme peut décrire brièvement le fonctionnement du

2.1.2 Début et fin d'un programme

En langage microC, un programme commence avec les mots-clés:

Ainsi, comme indiqué dans le Code-source 2.1, le programme a la structure suivante :

2.1.3 Fin d’une instruction

2.1.4 Espaces blancs

2.2 Eléments de programmation en mikroC