Académique Documents
Professionnel Documents
Culture Documents
03 Programmation en MikroC
03 Programmation en MikroC
03 Programmation en MikroC
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)
BOUMERDES - 2012
-0-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Pas 3 : Cocher la case : I accept the terms in the License Agreement et cliquer sur Next
-2-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Pas 4 : Avant de cliquer sur Next, il est recommandé de laisser la case Install For All Users
coché. Cliquer sur Next
-3-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Pas 7 : Cliquer sur OUI pour l’association du format de fichier .c avec le logiciel mikroC PRO
-4-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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
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-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code Explorer
Code Editor
Project Settings
(paramètres
principaux du
microcontrôleur)
Error Window
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
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-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
-8-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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 :
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-
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
- 10 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
- 11 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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.
1.5 Compilation
- 13 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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).
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:
- 14 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Sauvegarder un fichier
Assurez-vous que la fenêtre contenant le fichier que vous
voulez sauvegarder est active.
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).
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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
}
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.
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.
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.
void main()
{
// Votre code ici
}
- 17 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
j = 5; // correcte
j = 5 // erreur
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 ;
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é.
- 18 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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.
temperature_V1
Pressure
no_hit
dat2string
SUM3
_vtext
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.
const if typedef
do register void
- 19 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Le langage mikroC prend en charge les types de variables indiquées dans le tableau 2.2.
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:
sum = 150;
ou
Les variables peuvent affecter des valeurs au cours de leur déclaration. Ainsi, les
déclarations ci-dessus peuvent aussi être écrites comme suit:
- 20 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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) 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 :
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 :
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:
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
float area ;
area = 12.235;
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).
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 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 :
- 22 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Entier décimal
Point décimal
Partie décimale fractionnaire
e ou E et l'ordre du signe
Dans l'exemple suivant, une constante nommée TEMP est déclarée comme ayant la
valeur fractionnelle 37.50 :
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’’ :
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 :
Une constante chaîne peut être étendue à travers une frontière en ligne en utilisant une
barre oblique inverse « "\" » :
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:
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.
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 ».
\ b 0X08 BS (backspace)
- 24 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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 :
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 :
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é :
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 :
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.
Les variables de type de recensement peuvent être déclarées par les spécifiant après la liste
- 25 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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:
ou
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 :
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:
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];
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:
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 :
et
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:
- 27 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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é:
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 :
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];
Total[2] = 0;
et
*(Total + 2) = 0;
&Total[j] = Total + j ;
- 28 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
En langage microC, nous pouvons effectuer des opérations arithmétiques pour pointeurs qui
peuvent impliquer :
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
ou
*P = 0; // Z[2] = 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:
*i = 10; // Cnt = 10
2.2.10 Structures
- 29 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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:
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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.
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;
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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:
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;
}
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.
P.y = 0xAEFA ;
- 32 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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.
union flags
{
unsigned char x;
unsigned int y;
}
union flags P;
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
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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.
Opérateur d’affectation
L’opérateur la plus importante dans un langage de programmation est celle qui consiste à
donner une valeur à une variable.
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.
- 34 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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.
Exemple 1 :
Exemple 2 :
int a, b, c ;
float x, y, z ;
- 35 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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.
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.
II OU x II y 4 gauche-droite
- 36 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Les opérateurs suivants ne sont que des raccourcis de notation (pas d’optimisation du
code généré) :
+= 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
I= x=xIy x I= y 2 droite-gauche
^= x=x^y x ^= y 2 droite-gauche
Autres opérateurs
Opérateur conditionnel
? opérateur e ? x : y 3 droite-gauche
conditionnel
- 37 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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 ;
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é.
Exemple :
Opérateur de parenthèse
Opérateur de sélection
Opérateurs du préprocesseur
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
#include <math.h>
#define #undef
#if #elif #endif
#ifdef #ifndef
#error
#ligne
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:
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 :
Lorsque cette macro est utilisée dans un programme, (a, b) sera remplacé par (a + b)
comme indiqué ci-dessous :
De même, nous pouvons définir une macro pour calculer le carré de deux nombres :
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 :
Le dossier dans ce cas n’est recherché que dans le chemin du répertoire spécifié.
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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
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
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
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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é.
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
. . . . . . . . . . . . . . . . . . . . .
case condition:
Instructions;
break;
default:
Instructions;
}
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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 :
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:
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 :
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 :
- 44 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Dans l'exemple suivant d'une boucle sans fin où tous les paramètres sont omis :
Dans la boucle sans fin suivante, i commence par 1 et n'est pas incrémenté à l'intérieur de la
boucle :
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 :
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 :
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 :
Comme il n'y a qu'une seule instruction à exécuter, l'exemple précédent pourrait également être
s'écrit :
{
for (j = 0; j < 4; j++) Sum = Sum + M[i][j];
}
Instruction while
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 :
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 peut également être formée par réglage de la condition qui doit être
toujours vrai :
- 46 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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.
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);
- 47 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Une boucle sans fin peut également être créée si la condition est réglée pour être vrai tout le
temps:
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;
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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:
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).
asm
{
Instructions
}
asm
{
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
2.3 Exercices
Exercice 2.1
Ecrire un programme pour mettre tous les 8 pattes du PORTB au niveau 1.
Solution 2.1
PORTB est configuré comme un port de sortie (à l’aide du registre TRISB), et ensuite
tous les 8 bits du port sont mis au niveau logique 1 (en chargeant le registre PORTB
par le nombre hexadécimal 0xFF) :
void main ()
{
TRISB = 0; // Configurer PORTB en sortie
PORTB = 0xFF; // Mettre toutes les bits du port à 1
}
Exercice 2.2
Écrire un programme pour mettre les pattes impaires (1, 3, 5 et 7) du PORTB au
niveau 1.
Solution 2.2
Repères impaires de port peuvent être mis au niveau logique 1 en envoyant la
configuration binaire 10101010 au registre PORTB. Cette configuration binaire est le
nombre hexadécimal 0xAA et le programme nécessaire est :
void main ()
{
TRISB = 0; // Configurer PORTB en sortie
PORTB = 0xAA; // Activer les pattes impairs numérotés
}
Exercice 2.3
Ecrire un programme pour compter en binaire sans fin et envoie ces données à
PORTB :
- 50 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
00000000
00000001
00000010
00000011
............
............
11111110
11111111
00000000
............
Solution 2.3
Une boucle sans fin peut être utilisée, et à l'intérieur de cette boucle la valeur d'une
variable peut être incrémentée, puis envoyée à PORTB:
void main ()
{
unsigned char Cnt = 0;
for (;;) // Boucle sans fin
{
PORTB = Cnt; // Envoyer Cnt à PORTB
Cnt++; // Incrémentation Cnt
}
}
Exercice 2.4
Écrire un programme pour mettre tous les bits de PORTB au niveau logique 1, puis à
la logique 0, et répéter ce procédé dix fois.
Solution 2.4
L’instruction for peut être utilisée pour créer une boucle à répéter les opérations
requises dix fois
void main ()
{
unsigned char j;
for (j = 0; j < 10; j++) // Répéter 10 fois
{
PORTB = 0xFF; // Mettre les bits de PORTB à 1
PORTB = 0; // Mettre les bits de PORTB à 0
}
}
- 51 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Exercice 2.5
Le rayon et la hauteur d'un cylindre sont de 2,5 cm et 10 cm respectivement. Ecrire un
programme pour calculer le volume de ce cylindre.
Solution 2.5
Le programme est :
void main ()
{
float Rayon = 2.5, Hauteur = 10;
float Volume;
Volume = PI * Rayon * Rayon * Hauteur;
}
Exercice 2.6
Ecrire un programme pour trouver le plus grand élément d'un tableau d'entiers ayant
dix éléments.
Solution 2.6
Au début, la variable m est affectée sur le premier élément de la matrice. Une boucle
est alors formée et le plus grand élément de la matrice se trouve :
void main ()
{
unsigned char j ;
int m, A [10];
m = A [0]; // Premier élément du tableau
for (j = 1; j < 10; j++)
{
if (A [j]> m) m = A [j];
}
}
Exercice 2.7
Ecrire un programme en utilisant une boucle while pour effacer tous les dix éléments
entiers dans un tableau M.
Solution 2.7
Dans le programme qui suit, NUM est définie comme 10 et une variable j est utilisée
comme le compteur de boucle:
- 52 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
#define NUM 10
void main ()
{
int M[NUM];
unsigned char j = 0;
while (j < NUM)
{
M[j] = 0;
j++;
}
}
Exercice 2.8
Ecrire un programme pour convertir la température de °C à °F à partir de 0 °C, avec le
pas de 1 °C jusqu'à 100 °C, et stocker les résultats dans un tableau appelé F.
Solution 2.8
°F = (°C- 32.0)/1.08
Une boucle for est utilisée pour calculer la température en °F et la ranger dans tableau F :
void main ()
{
float F[100];
unsigned char C;
for (C = 0; C <= 100; C++)
{
F[C] =(C – 32.0) / 1.8;
}
}
- 53 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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
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 :
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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
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 ();
void Compl()
{
PORTC = PORTC;
}
Compl ();
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Surface = πr2
où r est le rayon du cercle. La surface est calculée et stockée dans une variable locale
appelée s, qui est ensuite retournée par la fonction :
Le code-source 3.1 montre comment la fonction Cercle_Surface peut être utilisée dans un
programme principal pour calculer la surface d'un cercle dont le rayon est de 2,5 cm. La
fonction est définie avant le programme principal. La fonction est appelée à l'intérieur du
programme principal pour calculer la surface et la stocker dans la variable Cercle.
Code-source 3.1
/****************************************************************************
SURFACE D'UN CERCLE
====================
Ce programme appelle la fonction Cercle_Surface pour calculer la surface d'un
cercle.
Microcontrôleur : PIC 18F452
Oscillateur : HS, 08.0000 Mhz
Fichier: SURFACE_CERCLE.c
Date: Juillet 2012
****************************************************************************/
//Calcule la surface d'un cercle en fonction de rayon
void main ()
{
float r, Cercle;
r = 2.5;
Cercle = Cercle_Surface(r);
}
- 56 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Exercice3.2
Écrire une fonction appelée Surface et une fonction appelée Volume pour calculer la surface
et le volume d'un cylindre, respectivement. Puis écrire un programme principal pour calculer la
surface et le volume du cylindre dont le rayon est 2,0cm et la hauteur est 5,0cm. Stocker la
valeur de cette surface dans la variable Cylindre_Surface et la valeur de volume dans la
variable Cylindre_Volume.
Solution 3.2
Exercice 3.3
Solution 3.3
La valeur ASCII du caractère en majuscule du premier caractère ('A') est égale à 0x41. De
même, la valeur l'ASCII du premier caractère en minuscule ('a') est égale à 0x61. Un caractère
minuscule peut être converti en son équivalent majuscule en soustrayant 0x20 du caractère en
minuscule.
Les fonctions nécessaires sont montrées dans le code-source 3.3.
Exercice 3.4
Utilisez la fonction que vous avez créé dans l'exemple 3.3 dans un programme principal pour
convertir la lettre «r» en majuscules.
- 57 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Solution 3.4
Code-source 3.2
/**************************************************************************
SURFACE ET VOLME D’UN CYLINDRE
==============================
Ce programme calcule la surface et le volume d'un cylindre dont le rayon est
2,0cm et la hauteur est 5,0cm.
Microcontrôleur : PIC 18F452
Oscillateur : HS, 08.0000 Mhz
Fichier: VOLUM_CYLINDRE.c
Date: Juillet 2012
***************************************************************************/
//Fonction pour calculer la surface d'un cylindre
void main ()
{
float r = 2.0, h = 5.0;
float Cylindre_Surface, Cylindre_Volume;
Cylindre_Surface = Surface(r,h);
Cylindre_Volume = Volume(r,h);
}
- 58 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 3.3
/***********************************************************************
MINUSCULE–MAJUSCULE
===================
Ce programme convertit le caractère en minuscule de la variable Lc dans le
caractère en majuscule et le sauvegarde dans la variable Uc.
Microcontrôleur : PIC 16F84A
Oscillateur : HS, 8.0000 Mhz
Fichier: MINUSC_MAJUSC.c
Date: Juillet 2012
*************************************************************************/
void main ()
{
unsigned char Lc, Uc;
Lc = ‘r’;
Uc = Minuscule_Majuscule (Lc);
}
Si une fonction n'est pas définie avant qu'il ne soit appelé, le compilateur génère une erreur.
Une façon de contourner ce problème est de créer un prototype de fonction. Une fonction
prototype est construite facilement en faisant une copie de la tête de la fonction.
Les paramètres ne sont pas obligatoires, mais le type de données et des paramètres doivent
être définis.
Dans un exemple, qui suit, le prototype de fonction appelée Area est déclarée et la fonction
s'attend d’avoir un paramètre de type en virgule flottante :
Prototype de fonction doit être déclaré au début d'un programme. Les définitions et les appels
de fonction peuvent alors être faits à n'importe quel point dans le programme.
- 59 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 3.4
/****************************************************************************
MINUSCULES EN MAJUSCULES
============================
Ce programme convertit le caractère en minuscule de la variable Lc en
majuscule et le sauvegarde dans la variable Uc.
Microcontrôleur : 16F84A
Oscillateur : HS, 8.0000 Mhz
Fichier: MINUSC_MAJUSCUL.c
Date: Juillet 2012
****************************************************************************/
// Fonction pour convertir un caractère de minuscule en majuscule
void main ()
{
unsigned char Lc, Uc;
Lc = ‘r’;
Uc = Minuscule_Majuscule(Lc);
}
Exercice 3.5
Répéter l'exemple 3.4, mais déclarer que Minuscule_Majuscule est un prototype de fonction.
Solution 3.5
- 60 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 3.5
/****************************************************************************
MINUSCULES EN MAJUSCULES
============================
Ce programme convertit le caractère en minuscule de la variable Lc en
majuscule et le sauvegarde dans la variable Uc.
Microcontroller: 16F84A
Oscillateur : HS, 8.0000 Mhz
Fichier: MIN_MAJ_2.c
Date: Juillet 2012
***************************************************************************/
unsigned char Minuscule_Majuscule(unsigned char);
void main ()
{
unsigned char Lc, Uc;
Lc = ‘r’;
Uc = Minuscule_Majuscule (Lc);
}
Dans cet exemple, le prototype de fonction déclare les deux arguments long,
les variables x et c sont convertis en long avant d'être utilisé à l'intérieur de la fonction
MaFonc.
- 61 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Voici un exemple de fonction qui dépend des effets secondaires plutôt que de la valeur de
retour :
#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
}
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 () :
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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.
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 :
main ()
{
//...
res = fonc(limit, ch); // fonction call (appeler)
}
- 63 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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).
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Solution 3.6
Une LED peut être connectée à un microcontrôleur en deux modes : source de courant et
absorption de courant.
En mode d'absorption de courant (voir figure 3.1a) une patte de la LED est connectée à + 5 V à
travers une résistance R de limitation de courant et l'autre patte est reliée à la patte de port de
sortie du microcontrôleur. La LED sera allumée lorsque le port de sortie du microcontrôleur est
au niveau logique 0 (à savoir, environ +0 V).
En mode de source de courant (voir figure 3.1b) une patte de la LED est reliée au port de sortie
du microcontrôleur et l'autre patte est reliée à la masse à travers une résistance R de limitation
de courant. La LED sera allumé lorsque le port de sortie du microcontrôleur est au niveau
logique 1 (à savoir, environ +5 V). La même valeur de résistance R peut être utilisée en mode
de source de courant.
a) b)
Le programme requis est donné dans le code-source 3.6 (fichier LED CLIGNOT.C). Le port
PORTB est configuré en sortie en utilisant la déclaration TRISB = 0. Une boucle sans fin est
alors formée avec la déclaration for, et à l'intérieur de cette boucle la LED est allumée ou
éteinte avec un délai d’une second.
Un autre programme à clignoter une LED donné par le code-source 3.7 (fichier LED
CLIGNOT2.C) est plus facile à suivre en utilisant la commande de préprocesseur #define.
- 65 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Le tableau 3.2 donne une liste des fonctions de la bibliothèque mikroC, organisée en ordre
fonctionnel.
Certaines des fonctions de la bibliothèque fréquemment utilisées sont les suivantes :
EEPROM bibliothèque
LCD bibliothèque
Logiciel UART bibliothèque
Matériel USART bibliothèque
Sound bibliothèque
ANSI C bibliothèque
Divers bibliothèques
Code-source 3.6
/****************************************************************************
LED CLIGNOTANTE
================
Ce programme fait clignoter d’une LED connectée au port RB0 d'un
microcontrôleur PIC avec l’intervalle d’une seconde. La fonction intégré
Delay_ms est utilisé pour créer un délai de 1 seconde entre les
clignotements.
Microcontrôleur: 16F84A
Oscillateur: HS, 4.0000 Mhz
Fichier: LED_CLIGNOTE.c
Date: Juillet 2012
****************************************************************************/
void main ()
{
TRISB = 0; // Configurer PORTB en sortie
for (;;) // Boucle sans fin
{
PORTB = 1; // Activer LED
Delay_ms (1000); // Retard 1 seconde
PORTB = 0; // Désactiver LED
Delay_ms (1000); // Retard 1 seconde
}
}
Code-source 3.7
/***************************************************************************
LED CLIGNOTANTE_2
===================
Ce programme fait clignoter d’une LED connectée au port RB0 d'un
microcontrôleur PIC avec l’intervalle d’une seconde. En utilisant les
commandes de préprocesseur #define le programme est devenu plus facile à
suivre.
Microcontrôleur: 16F84A
Oscillateur: HS, 4.0000 Mhz
Fichier: LED_CLIGNOTE2.c
Date: Juillet 2012
**************************************************************************/
#define LED PORTB.0
#define ON 1
#define OFF 0
#define One_Second_Delay Delay_ms(1000)
- 66 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
void main()
{
TRISB = 0; // PORTB est configuré en sortie
for(; ;) // Boucle sans fin
{
LED = ON; // LED est allumée (ON)
One_Second_Delay; // Retard 1 seconde
LED = OFF; // LED est désactivée (OFF)
One_Second_Delay; // Retard 1 seconde
}
}
La bibliothèque EEPROM inclut des fonctions pour lire les données non volatiles d’EEPROM du
PIC, ou pour écrire des données sur cette mémoire. Deux fonctions sont prévues :
Eeprom_Read
Eeprom_Write
La fonction Eeprom_Read lit un octet à partir d'une adresse spécifiée de la mémoire EEPROM.
L’adresse est de type entier, et donc la fonction prend en charge les microcontrôleurs PIC avec
- 67 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
plus de 256 octets. Un retard de 20 ms doit être utilisé entre lectures successives de l’EEPROM
pour garantir le retour des données correctes.
Dans l'exemple suivant, l'octet d'adresse 0x1F de la mémoire EEPROM est lu et stocké dans
variable Temp:
Exercice 3.7
Ecrivez un programme pour lire le contenu de l'EEPROM de l'adresse 0 à 0x2F puis envoyez
ces données pour PORTB d'un microcontrôleur PIC.
Solution 3.7
Le programme requis est donné dans le code-source 3.8 (fichier LECTURE DE L’EEPROM).
Une boucle for est utilisée pour lire les données de l’EEPROM et puis de l'envoyer au PORTB
du microcontrôleur. Notez que quelques 20ms retardé sont utilisés entre chaque lecture
successive.
Code-source 3.8
/****************************************************************************
LECTURE DE L’EEPROM
====================
Ce programme lit les données à partir d'adresses de 0 à 0x2F de l'EEPROM et
puis envoie ces données pour PORTB du microcontrôleur.
Microcontrôleur: 16F84A
Oscillateur: HS, 4.0000 Mhz
Fichier: EEPROM.c
Date: Juillet 2012
****************************************************************************/
void main()
{
unsigned int j;
unsigned char Temp;
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
1 VSS Ground
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 :
- 70 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
RS → 2
FR → 3
D4 → 4
D5 → 5
D6 → 6
D7 → 7
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 :
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
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_Cp
Lcd_Out_Cp ("Ordinateur");
Lcd_Chr
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
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);
- 72 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Exercice 3.8
Un contrôleur de texte LCD est relié à un microcontrôleur PIC16F84A dans le mode par défaut
comme illustre la figure 3.2.
Solution 3.8
Au début le PORTB est configuré en sortie par la déclaration TRISB = 0. L'écran LCD est
alors initialisé, l'affichage est effacé, et le texte «Mon Ordinateur "est affiché sur l'écran LCD.
Code-source 3.9
/****************************************************************************
REDACTION D'UN TEXTE A L’ECRAN LCD
==================================
Un contrôleur de texte LCD est relié à un microcontrôleur PIC dans le mode
(4,5,3,2,1,0). Ce programme affiche les textes "AFFICHAGE" sur la 1 ère ligne
et ”display_LCD_4bit” sur la 2ème ligne d'écran LCD.
Microcontrôleur: 16F887
Oscillateur: HS, 10.0000 Mhz
Compilateur: microC PRO v.1.56
Fichier: LCD.c
Date: Juillet 2012
***************************************************************************/
// Connections de LCD
// Fin de connections
- 73 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
void main()
{
TRISB = 0;
PORTB = 0xFF;
TRISB = 0xff;
/* Configurer E/S du portB comme numériques*/
ANSELH = 0;
ANSEL = 0;
Lcd_Init(); // Initialiser LCD
Lcd_Cmd(_LCD_CLEAR); // Effacer un texte sur l’ecrant LCD
Lcd_Cmd(_LCD_CURSOR_OFF); // Curseur est en off
Lcd_Out(1,2,"-- AFFICHAGE -- "); // Ecrire le texte sur la 1ère ligne
Lcd_Out(2,1,"display_LCD_4bit"); // Ecrire le texte sur la 2ème ligne
}
Fig. 3.2 Connexion du PIC avec LCD (pour la simulation dans le PROTEUS)
- 74 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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
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.
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
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
Ici :
port est le port utilisé comme UART logiciel (par exemple, PORTB) ;
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 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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.
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
- 77 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Le programme requis est indiqué dans le code-source 3.10 (fichier SERIAL.C). Au début du
programme, la fonction Soft_Uart_Init est appelée pour configurer le port série.
Puis une boucle sans fin est formée en utilisant l’instruction while(1). La fonction
Soft_Uart_Read est appelé à lire un caractère à partir du terminal. Après la lecture d'un
caractère, il est renvoyé à la patte en appelant la fonction Soft_Uart_Write.
Fig. 3.5 Schéma du circuit d’exercice 3.9 (pour la simulation dans le PROTEUS)
Les bibliothèques standards ANSI C se compose des bibliothèques suivantes (plus de détails
sur ces bibliothèques sont disponibles dans le manuel de l'utilisateur mikroC):
Ctype bibliothèque
Math bibliothèque
Stdlib bibliothèque
String bibliothèque
Bibliothèque Ctype
Les fonctions de la bibliothèque Ctype sont principalement utilisées pour la conversion des
essais ou des données. Tableau 3.5 dresse la liste des fonctions les plus couramment utilisés
dans cette bibliothèque.
Bibliothèque Math
Les fonctions de la bibliothèque Math sont utilisées pour les opérations mathématiques en
- 78 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
virgule flottante. Le tableau 3.6 dresse la liste des fonctions les plus couramment utilisés dans
cette bibliothèque.
Code-source 3.10
/***************************************************************
LECTURE ET ÉCRITURE DE PORT SERIE
==================================
Dans ce programme les pattes RC6 et RC7 du PORTC sont configurés comme
série TX et RX, respectivement. La vitesse de transmission est fixée à
9600. Un caractère est reçu à partir du terminal, et ensuite il est renvoyé
vers le terminal.
Microcontrôleur: 16F887
Oscillateur: HS, 10.0000 Mhz
Ficher: SERIAL_PORT.c
Date: Juillet, 2012
******************************************************************/
char error, byte_read; // Variables locales
void main()
{
ANSEL = 0; // Configurer des pins AN en E/S numériques
ANSELH = 0;
if (error > 0)
{
PORTC = error; // Signaler error d’Initialisation
while(1); // Stop programme
}
Delay_ms(100);
byte_read = Soft_UART_Read(&error);
Soft_UART_Write(byte_read);
}
}
- 79 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
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.
- 80 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Fonction Description
rand Retourne un nombre aléatoire compris entre 0 et 32767; la fonction stand doit
être appelée à obtenir une séquence différente de nombres
srand Génère une fonction rand donc une nouvelle séquence de nombres est générée
Exemple 3.10
Ecrire un programme pour calculer le sinus des angles de 0° à 90° avec le pas de 1° et stocker
le résultat dans un tableau appelé Trig_Sine.
Solution 3.10
Le programme requis est indiqué dans le code-source 3.11 (fichier SINE.C). Une boucle est
créé en utilisant l’instruction for, et à l'intérieur de cette boucle le sinus d'angles sont calculées
et stockées dans le tableau Trig_Sine. Notez que les angles doivent être convertis en radians
avant d'être utilisé dans les fonctions sin.
Code-source 3.11
/**************************************************************************
SINUS DES ANGLES DE 0° A 90°
=============================
Ce programme calcule le sinus d'angles de 0° à 90°. Les résultats sont
stockés dans un tableau appelé Trig_Sine.
Microcontrôleur: 16F887
Oscillateur: HS, 10.0000 Mhz
Compilateur: microC PRO v.1.56
Ficher: SINE.C
Date: Juillet, 2012
**************************************************************************/
void main()
{
unsigned char j;
double PI = 3.14159, rads;
for(j = 0; j <= 90; j++)
{
rads = j*PI /180.0;
angle = sin(rad);
Trig_Sine[j] = angle; - 81 -
}
}
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Bibliothèque String
La bibliothèque des fonctions string est utilisée pour effectuer la manipulation de chaînes de
caractères et de la mémoire opérations. Tableau 3.8 dresse la liste des fonctions les plus
couramment utilisés dans cette bibliothèque.
Exemple 3.11
Ecrire un programme pour illustrer comment les deux chaînes "MON PUISSANT» et
«COMPUTER» peuvent être joints dans une nouvelle chaîne en utilisant les fonctions de la
bibliothèque string.
Solution 3.11
Code-source 3.12
/**************************************************************************
ASSEMBLAGE DE DEUX LIGNES DE CARACTERES
=================================
Ce programme montre comment deux chaînes peuvent être jointes pour obtenir
une nouvelle chaîne de caractères.
La fonction strcat est utilisé pour joindre les deux chaînes pointées par
p1 et p2 dans une nouvelle chaîne stockée dans le tableau de caractères
New_String.
Microcontrôleur: 16F887
Oscillateur: HS, 10.0000 Mhz
Fichier: JOIN.C
Date:Juillet, 2012
************************************************************************/
void main()
{
const char *p1 = “ MON PUISSANT “; // Première ligne
const char *p2 = “COMPUTEUR”; // Deuxième ligne
char New_String[80];
strcat(strcat(New_String, p1), p2); // Joindre les deux lignes
} - 82 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Les divers bibliothèques se compose des bibliothèques suivantes (plus de détails sur ces
bibliothèques sont disponibles dans le manuel de l'utilisateur mikroC):
Bibliothèque de conversions
Bibliothèque de fonctions trigonométriques
Bibliothèque de fonctions de sortie sprint
Bibliothèque de Setjmp
Bibliothèque pour travailler avec le temps
Le tableau 3.9 dresse la liste des fonctions les plus couramment utilisés dans la bibliothèque de
conversions.
Tableau 3.9
Fonction Description
- 83 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Dans ce projet les huit LEDs sont connectées à PORTC d'un microcontrôleur.
Lorsqu'une tension est appliquée au microcontrôleur (ou est réinitialisé), les LEDs s'allument en
alternance. Il y a le délai d’une seconde de sorte qu’une LED peut être vu tourner sur ON et
OFF.
Le schéma de principe du projet est illustré à la figure 4.1.
- 84 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 4.1
/****************************************************************************
Chenille à LEDs
===============
Les huit LEDs sont connectées à PORTC du microcontrôleur 18f452. Lorsqu'une
tension est appliquée au microcontrôleur (ou est réinitialisé), les LEDs
s'allument en alternance.
Microcontrôleur: 18F452
Oscillateur : HS, 4.0000 Mhz
Fichier: LED1.c
Date: Juillet 2012
***************************************************************************/
void main()
{
unsigned char J = 1;
TRISC = 0; // PORTC est configure en sortie
for(;;) // Boucle sans fin
{
PORTC = J; // Envoyer J au PORTC
Delay_ms(100); // Pause 100 ms
J = J << 1; // Décalage à gauche J
if(J == 0) J = 1; // Si la dernière LED, allumer la 1ère LED
}
}
On propose de faire clignoter LEDs branchées au port B d’un microcontrôleur (fig. 4.2) de deux
façons différentes :
1. Dès que le microcontrôleur est activé, tous les LEDs clignotent avec une période d’une
seconde (voire la figure ci-dessous). Et ça doit répéter 10 fois.
2. Après cela, les LEDs doivent clignoter chaque 500 ms infiniment comme indiqué dans la
figure ci-dessous.
Le fichier nommé LED2.C qui réalise ce projet est représenté dans le code-source 4.2
- 85 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 4.2
/****************************************************************************
LEDs clignotantes différemment
===============================
Les huit LEDs sont connectées à PORTB du microcontrôleur 16f887. Lorsqu'une
tension est appliquée au microcontrôleur (ou est réinitialisé), les LEDs
s'allument en alternance en deux façon différente.
Microcontrôleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: LED2.c
Date: Juillet 2012
***************************************************************************/
void main()
{
ANSEL = 0;
ANSELH = 0;
PORTB = 0xFF;
TRISB= 0;
Delay_ms(500);
PORTB = 0;
Delay_ms(500);
}
}
PORTB=0b01010101;
while(1)
{
PORTB= ~PORTB;
Delay_ms(500);
}
}
Exemple 3. RELAI
Dans ce projet la minuterie, sur la base de registre TMR0, est utilisée comme un compteur.
L'entrée de comptage est reliée à un bouton-poussoir Input (fig. 4.3) de sorte que toute
pression sur Input provoque TMR0 à compter une impulsion. Lorsque le nombre d'impulsions
correspond au nombre stocké dans le registre nommé TEST, la valeur logique 1 (5V) apparaît
sur le pin3 de PORTD. Cette tension active un relais électromécanique, et ce bit est appelé
«RELAI» dans le programme (voire le fichier RELAI.C de code-source 4.3).
Dans le registre de TEST est stocké un nombre de 5 pour cet exemple. Bien sûr, il peut être
n'importe quel nombre défini comme une constante. Par ailleurs, le microcontrôleur peut activer
un autre appareil au lieu de relais, tandis que le capteur peut être utilisé à la place du bouton-
poussoir. Cet exemple illustre l'une des applications les plus courantes du microcontrôleur dans
l'industrie; quand quelque chose est effectué autant de fois que nécessaire, puis quelque chose
d'autre doit être activé ou désactivé ....
- 87 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 4.3
/****************************************************************************
RELAI
=======
Dans ce projet la minuterie, sur la base de registre TMR0, est utilisée comme
un compteur. L'entrée de comptage est reliée à un bouton-poussoir Input de
sorte que toute pression sur Input provoque TMR0 à compter une impulsion.
Lorsque le nombre d'impulsions correspond au nombre stocké dans le registre
nommé TEST, la valeur logique 1 (5V) apparaît sur le pin3 de PORTD. Cette
tension active un relais électromécanique RELAI.
Microcontrôleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: RELAI.c
Date: Juillet 2012
***********************************************************************************/
void main()
{
char TEST = 5; // Constante TEST = 5
enum sortie {RELAI = 3}; // Constante RELAI = 3
ANSEL = 0; // Les E/S sont configurées en numériques
ANSELH = 0;
PORTA = 0; // Initialisation du porte A
TRISA = 0xFF; // Porte A est configuré en entré
PORTD = 0; // Initialisation du PORTD
TRISD = 0b11110111; // Broche 3 du PORTD3 est configuré en sortie
Une selle constante énumérée RELAI est utilisée dans cet exemple. Il est attribué un valeur
lorsqu’elle est déclarée :
Si plusieurs broches du PORTD sont reliées à des RELAIS, l’expression ci-dessus pourrait être
écrite comme suit :
Toutes les constantes, après celle avec les valeurs affectées (RELAI = 3 et ECLARAGE = 6),
sont des valeurs automatiquement incrémenté de 1 par rapport à la valeur précédente. Dans ce
cas, la constante CHAUFFAGE et celle POMPE seront affectés les valeurs 4 et 7 respectivement
(CHAUFFAGE = 4 et POMPE = 7).
- 88 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Dans l'exemple précédent, le microcontrôleur ne fait rien entre des impulsions de comptage en
utilisant des boucles sans fin. Ces déchets du temps est un luxe inadmissible et par conséquent
une autre méthode doit être appliquée.
Considérons le schéma à microcontrôleur 16F887 de la figure 4.1 qui sera toujours le même
pour réaliser les nouvelles fonctions.
Le fichier INTERRUP_TMR0.C du code-source 4.4 montre l’utilisation du registre TMRO avec
prédiviseur pour générer une interruption. Une fois que le registre TMR0 est ’’ trop-plein’’ le
routin d’interruption incrémente automatiquement la variable cnt par 1. Lorsque sa valeur
atteint 400, le PORTB est incrémenté de 1. L'ensemble de la procédure est ‘’masqué’’, qui
permet au microcontrôleur de faire autre chose.
Code-source 4.4
/***************************************************************************
TMR0
=======
Une fois que le registre TMR0 est ’’ trop-plein’’ le routin d’interruption
incrémente automatiquement la variable cnt par 1. Lorsque sa valeur atteint
400, le PORTB est incrémenté de 1. L'ensemble de la procédure est ’’masqué’’,
qui permet au microcontrôleur de faire autre chose.
Microcontrôleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: INTERRUP_TMR0.c
Date: Juillet 2012
***************************************************************************/
unsigned cnt; // Définir la variable cnt
void interrupt()
{
cnt++; /* Interruption cause l’incrémentation par 1
de la variable cnt*/
- 89 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
On voie que l’Interruption se produit sur chaque débordement du registre TMR0. Le nombre
d’interruption à 400, dans cet exemple, provoque l’incrémentation du PORTB comme indique la
figure ci-dessous.
Code-source 4.5
/****************************************************************************
TMR1
=======
Une fois que le registre TMR1 est ’’ trop-plein’’ la routine d’interruption
incrémente automatiquement par 1 la variable cnt. Lorsque sa valeur atteint
76, les bits du PORTB sont inversés.
Microcontrôleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: INTERRUP_TMR1.c
Date: Juillet 2012
****************************************************************************/
unsigned short cnt; // Définir la variable cnt
void interrupt()
{
cnt++ ; /* Interruption cause l’incrémentation par 1 de la
variable cnt*/
PIR1.TMR1IF = 0; // Remise à 0 bit TMR1IF
TMR1H = 0x80;
TMR1L = 0x00; // Valeurs initiales du TMR1H and TMR1L
}
void main()
{
ANSEL = 0; // Broches E/S sont configuré en numériques
ANSELH = 0;
PORTB = 0xF0; // Initialisation de PORTB
TRISB = 0; // PORTB est configuré en sortie
T1CON = 1; // Remise à 1 du TMR1
PIR1.TMR1IF = 0; // Remise à 0 du TMR1IF
TMR1H = 0x80; // Initialisation du TMR1
TMR1L = 0x00;
PIE1.TMR1IE = 1; /* Activer l’interruption en cas de débordement du
TMR1*/
cnt = 0; // Remis à 0 la variable cnt
INTCON = 0xC0; // Activer interruption (bits GIE et PEIE)
do
{ // Boucle sans fin
- 90 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
if (cnt == 76)
{
PORTB = ~PORTB; /* Bits du PORTB sont inversés après 76
d’interruptions*/
Cet exemple illustre l'utilisation de module CCP1 en mode PWM. Pour rendre les choses plus
intéressantes, la durée d’impulsions à la sortie P1A/CCP1 (PORTC, 2) peut être changée avec
les touches symboliquement marqués comme "BRILLANT" et "NOIR", tandis que la durée est
considérée comme la combinaison binaire sur le port B (fig.4.4).
Remarque d’auteur : La diode D1 dans le schéma de simulation dans le PROTEUS (fig. 4.4)
signale que le module CCP1 est activé. Dans le montage réel son état corresponde à l’état de
la diode D2 pendant la simulation.
Afin de rendre cet exemple fonctionne correctement, il est nécessaire de cocher les
bibliothèques suivantes dans le gestionnaire de bibliothèque avant de compiler:
PWM
Bouton
- 91 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 4.6
/****************************************************************************
Module CCP1 comme générateur du signal PWM
==========================================
Cet exemple illustre l'utilisation de module CCP1 en mode PWM. La
durée d’impulsions à la sortie P1A/CCP1 (PORTC, 2) peut être changée
avec les touches symboliquement marqués comme "BRILLANT" et "NOIR",
tandis que la durée est considérée comme la combinaison binaire sur le
PORTB.
Microcontrôleur: 16F887
Oscillateur : HS, 8.0000 Mhz
Fichier: SIGNAL_PWM.c
Date: Juillet 2012
****************************************************************************/
unsigned short current_duty, old_duty; /* Définition des variables
current_duty and old_duty*/
void initMain()
{
ANSEL = 0; // Toutes les E/S sont numériques
ANSELH = 0;
PORTA = 0x00; // Initialisation du PORTA
TRISA = 0xFF; // PORTA est configuré en entrée
PORTB = 0; // Initialisation du PORTB
TRISB = 0; // PORTB est configuré en sortie
PORTC = 0; // Initialisation du PORTC
TRISC = 0xFF; // PORTC est configuré en entré
- 92 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Dans ce projet un signal analogique variable est appliqué à la broche AN2 de microcontrôleur
16F887, tandis que le résultat de conversion de 10 bits est localisée sur les ports B et D (8 LSB
sur le PORTD et 2 MSB sur le PORTB). GND est utilisé comme référence de tension négative
Vref-.
Le convertisseur A / D génère toujours un résultat binaire de 10 bits, ce qui signifie qu'il détecte
au total de 1024 niveaux de tension et donc il est capable de détecter de légères modifications
de la tension.
Le fichier CONVERT_A/D.C est donné dans le code–source 4.7 et le schéma de simulation du
projet est représenté sur la figure 4.5.
- 93 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 4.7
/****************************************************************************
CONVERTISSEUR A/D
===================
Un signal analogique variable est appliqué à la broche AN2 du microcontrôleur
16F887, tandis que le résultat de conversion de 10 bits est localisée dans
les PORTB et PORTD (8 LSB dans le PORTD et 2 MSB dans le PORTB). GND est
utilisé comme référence de tension négative Vref-.
Microcontrôleur: 16F887
Oscillateur : HS, 8.0000 Mhz
Fichier: CONVERT_A/D.c
Date: Juillet 2012
****************************************************************************/
unsigned int temp_res;
void main()
{
ADCON1 = 0x80; // Configurer Vref
ANSEL = 0x0C; /* Configurer la broche AN2 du PORTA en
analogique */
TRISA = 0xFF; // PORTA est configuré en entrée
ANSELH = 0; /* Configurer les autres broches du
PORTA en numérique */
do
{
temp_res = ADC_Read(2); /* Résultat de la conversion A / D est
copié dans temp_res */
Dans cet exemple le registre du PORTB est incrémenté en permanence. Au moment de l'appui
sur le bouton appelé MEMO_EEPROM, un nombre binaire du PORTB sera sauvegardé dans
la mémoire EEPROM. Ce nombre doit être directement lu de l’EEPROM et ensuite affiché sur
PORTD sous forme binaire.
Le fichier EEPROM.c est donné dans le code-source 4.8.
- 94 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 4.8
/****************************************************************************
Mémoire EEPROM
===================
Le registre du PORTB est incrémenté en permanence. Au moment de l'appui sur
le bouton appelé MEMO_EEPROM, un nombre binaire du PORTB sera sauvegardé
dans la mémoire EEPROM. Ce nombre doit être directement lu de l’EEPROM et
ensuite affiché sur PORTD sous forme binaire.
Microcontrôleur: 16F887
Oscillateur : HS, 8.0000 Mhz
Fichier: EEPROM.c
Date: Juillet 2012
****************************************************************************/
void main()
{
ANSEL = 0; //Toutes les E/S sont configurés en numériques
ANSELH = 0;
PORTB = 0; // Initialisation du PORTB
TRISB = 0; // PORTB est configuré en sortie
PORTD = 0; // Initialisation du PORTD
- 95 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Dans ce projet de deux afficheurs 7 segments à LEDs (cathode commune) sont connectées à
PORTC d'un microcontrôleur.
La cathode de chiffre 1 (chiffre de gauche) est connecté au PORTB (broche RB0)
et la cathode de chiffre 2 (chiffre de droite) est connecté au PORTB (broche RB1) du
microcontrôleur.
- 96 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Microcontrôleur: 18F452
Oscillateur : HS, 4.0000 Mhz
Fichier: AFFICH_MULTIPLEXE.c
Date: Juillet 2012
****************************************************************************/
#define DIGIT1 PORTB.F0
- 97 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
- 98 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Delay_ms(1000);
for(;;) // Boucle sans fin
{
Cnt++; // Incrémentation de Cnt
if(Cnt == 100) Cnt = 0; // Comptage de 0 è 99
Delay_ms(1000); // Attendre 1 seconde
}
}
- 99 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 4.10
/****************************************************************************
MULTIMETRE AVEC L’AFFICHEUR LCD
================================
Ce projet illustre l'utilisation d'un écran LCD alphanumérique.
Un message écrit en deux lignes apparaît sur l'afficheur LCD :
Multimètre
- Mesure de -
Deux secondes plus tard, le message dans la seconde ligne est modifié et
affiche tension présenté sur l'entrée (broche RA2) de convertisseur A / D :
Multimetre
Tension:
Microcontrôleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: MULTIMETRE_LCD.c
Date: Juillet 2012
****************************************************************************/
// Connections du module LCD
while (1)
{
adc_rd = ADC_Read(2); // Conversion A / D. Pin RA2 est une entrée.
Lcd_Out(2,1,text); // Ecrire résultat dans la deuxième ligne
tlong = (long)adc_rd * 5000;// Convertir le résultat en millivolts
tlong = tlong / 1023; // 0 .. 1023 -> 0-5000mV
ch = tlong / 1000; /* Extrait volts (en milliers de millivolts)
à partir du résultat */
Lcd_Chr(2,9,48+ch); // Ecrire le résultat en format ASCII
Lcd_Chr_CP('.');
ch = (tlong / 100) % 10; // Extrait des centaines de millivolts
Lcd_Chr_CP(48+ch); // Ecrire le résultat en format ASCII
ch = (tlong / 10) % 10; // Extrait des dizaines de millivolts
Lcd_Chr_CP(48+ch); // Ecrire le résultat en format ASCII
ch = tlong % 10; // Extrait chiffres pour millivolts
Lcd_Chr_CP(48+ch); // Ecrire le résultat en format ASCII
Lcd_Chr_CP('V');
Delay_ms(1);
}
}
- 101 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Une des façons de simuler le fonctionnement de cette instalation consiste en l’utilisation d'un
programme représenté dans le fichier COMMUNIC_RS232.c du code-source 4.11. Cet
exemple illustre l'utilisation de la fonction Software_UART de bibliothèque du compilateur
mikroC PRO.
Dans le schéma de simulation donné par la figure 4.9, la visualisation de chaque octet envoyé
et reçu via la communication série est affichée à l'aide d'un programme standard de PROTEUS
appelé VIRTUAL TERMINAL.
Code-source 4.11
/****************************************************************************
COMMUNICATION SERIE RS232
==========================
Cet exemple illustre l'utilisation de fonction Software_UART de la
bibliothèque du compilateur mikroC PRO.
Microcontrôleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: COMMUNIC_RS232.c
Date: Juillet 2012
****************************************************************************/
char error, byte_read; // Variables auxiliaires
void main()
{
ANSEL = 0; // Configuration E/S en numérique
ANSELH = 0;
TRISC = 0x00; /* Configurer PORTB en sortie
(signalisation d’erreur)*/
PORTC = 0; // Pas d’erreur
byte_read = Soft_UART_Read(&error);
if (error) // Si l'erreur a été détectée
PORTC= error; // signale error sur le PORTB
else
Soft_ UART_Write (byte_read) ; /* Si l’errur n’a pas été détectée,
l’octet lu en retour */
}
}
- 102 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Mesure de la température est l'une des tâches les plus courantes effectuées par le
microcontrôleur. Un capteur DS1822 est utilisé pour la mesure. Il est capable de mesurer la
température dans la plage de -55 ° C à +125 ° C avec la précision 0,5 ° C. Pour le but de
transférer des données vers le microcontrôleur, un type particulier de communication série
appelé 1-Wire (1-fil) est utilisée (voire la figure ci-dessous).
- 103 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
En raison d'une utilisation simple de ces capteurs, les commandes utilisées pour exécuter et
contrôler sont stockées sous la forme de fonctions dans la bibliothèque One_Wire du
compilateur mikroC PRO. Il y a trois fonctions au total:
Code-source 4.12
/****************************************************************************
Mesure de la température à l'aide du capteur DS1822.
L'utilisation de protocole de '1-Wire‘
====================================================
Un capteur DS1822 est utilisé pour la mesure. Il est capable de mesurer la
température dans la plage de -55 ° C à +125 ° C avec la précision 0,5 ° C.
Pour le but de transférer des données vers le microcontrôleur, un type
particulier de communication série appelé 1-Wire (1-fil) est utilisée
Microcontrôleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: TEMPERATURE_One_Wire.c
Date: Juillet 2012
****************************************************************************/
// Configuration des connections d'afficheur LCD avec PIC
sbit LCD_RS at RB0_bit;
sbit LCD_EN at RB1_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
// Fin de configuration
- 104 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Lcd_Chr(2,4,'+');
if (temp_whole/100)
text[0] = temp_whole/100 + 48; // Extrait d'un chiffre des centaines
else
text[0] = '0';
text[1] = (temp_whole/10)%10 + 48; // Extrait d'un chiffre des dizaines
text[2] = temp_whole%10 + 48; // Extrait d'un chiffre des unités
Lcd_Out(2,5, text);
}
void main()
{
ANSEL = 0; // Configurer E/S en numérique
ANSELH = 0;
Lcd_Init(); // Initialiser LCD
Lcd_Cmd(_LCD_CLEAR); // Effacer l'affichage sur LCD
Lcd_Cmd(_LCD_CURSOR_OFF); // Mettre invisible le curseur
Lcd_Out(1, 1, " Temperature: ");
- 105 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Ow_Reset(&PORTA, 5);
Ow_Write(&PORTA, 5, 0xCC); // Envoi de commandes SKIP_ROM
Ow_Write(&PORTA, 5, 0xBE); // Envoi de commandes READ_SCRATCHPAD
Delay_ms(400);
Display_Temperature(temp);
Delay_ms(500);
} while (1);
}
- 106 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Les signaux audio sont souvent utilisés quand il est nécessaire d'attirer votre l’attention que
certains des boutons-poussoirs sont enfoncé, vous avertir que les valeurs minimales ou
maximales sont atteintes, etc. Il peut être juste un «bip» du signal ainsi que plus ou moins
longue mélodie. Cet exemple montre comment à l'aide des fonctions appartenant à la
bibliothèque Sound du compilateur mikroC PRO réaliser un générateur de sons (voire le code-
source 4.13). Le schéma de simulation pour cet exemple est représenté sur la figure 4.11.
Code_source 4.13
/****************************************************************************
Générateur de sons
===================
A l'aide des fonctions appartenant à la bibliothèque Sound du compilateur
mikroC PRO il est facile de réaliser un générateur de sons
Microcontrôleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: GENERAT_SONS.c
Date: Juillet 2012
****************************************************************************/
void Tone1()
{
Sound_Play(659, 250); // Son de fréquence = 659Hz, durée = 250ms
}
void Tone2()
{
Sound_Play(698, 250); // Son de fréquence = 698Hz, durée = 250ms
}
void Tone3()
{
Sound_Play(784, 250); // Son de fréquence = 784Hz, durée = 250ms
}
void ToneA()
{
Sound_Play( 880, 100);
}
void ToneC()
{
Sound_Play(1046, 100);
}
- 107 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
void ToneE()
{
Sound_Play(1318, 100);
}
void Melody2()
{
unsigned short i;
for (i = 9; i > 0; i--)
{
ToneA(); ToneC(); ToneE();
}
}
void main()
{
ANSEL = 0; // Configurer PORTB en numérique
ANSELH = 0; // Configurer PORTE en numérique
C1ON_bit;
C2ON_bit;
Sound_Init(&PORTB, 0);
Sound_Play(1200, 600); // Son à 880Hz pendant 1 seconde
while (1)
{
if (Button(&PORTB,7,1,1)) // RB7 – son Tone1
Tone1();
while (RB7_bit) ; // Attendre que le bouton d'être relâché
- 108 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Un écran LCD graphique (GLCD) fournit une méthode avancée pour afficher des messages
visuels. Bien que l'écran LCD de caractères ne puisse afficher que des caractères
alphanumériques, le GLCD peut afficher des messages sous la forme de dessins et de bitmaps.
L'écran GLCD le plus couramment utilisé est à 128x64 pixels que signifie la résolution de
l'écran.
Sur la figure 4.12, le GLCD affiche une image de camion qui est stocké dans le fichier
truck_bmp.c.
- 109 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 4.14
/****************************************************************************
Utilisation d’afficheur LCD graphique
========================================
GLCD peut afficher des messages sous la forme de dessins et de bitmaps.
L'écran GLCD le plus couramment utilisé est à 128x64 pixels que signifie la
résolution de l'écran. Ici on a représenté poussières images : d’un camion,
des lignes, des cercles, des caractères.
Microcontrôleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: IMAGE_GLCD.c
Date: Juillet 2012
****************************************************************************/
// Declarations
const code char truck_bmp[1024];
// Connections d’afficheur Glcd
char GLCD_DataPort at PORTD;
- 110 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
// Fin de connections
void delay2S()
{ // 2 secondes de temporisation
Delay_ms(2000);
}
void main()
{
unsigned short ii;
char *someText;
#define COMPLETE_EXAMPLE
ANSEL = 0; // Configurer E/S en numérique
ANSELH = 0;
C1ON_bit = 0; // Désactiver les comparateurs
C2ON_bit = 0;
Glcd_Init(); // Initialiser GLCD
Glcd_Fill(0x00); // Effacer l’écran de GLCD
while(1)
{
#ifdef COMPLETE_EXAMPLE
Glcd_Image(truck_bmp); // Afficher l'image d’une camion
delay2S(); delay2S();
#endif
Glcd_Fill(0x00); // Effacer l’écran de GLCD
Glcd_Box(62,40,124,56,1); // Tracer une boîte
Glcd_Rectangle(5,5,84,35,1); // Tracer un rectangle
Glcd_Line(0, 0, 127, 63, 1); // Tracer une line
delay2S();
for(ii = 5; ii < 60; ii+=5 ) /* Tracer les lignes horizontales
et verticales
{
Delay_ms(250);
Glcd_V_Line(2, 54, ii, 1);
Glcd_H_Line(2, 120, ii, 1);
}
delay2S();
Glcd_Fill(0x00); // Effacer l’écran de GLCD
#ifdef COMPLETE_EXAMPLE
#ifdef COMPLETE_EXAMPLE
Glcd_Fill(0xFF); // Remplir GLCD
Glcd_Set_Font(Character8x7, 8, 7, 32); // Changer des caractères
- 111 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
// ------------------------------------------------------
// GLCD Picture name: truck.bmp
// GLCD Model: KS0108 128x64
// ------------------------------------------------------
- 112 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
255,255,255,255,255,255,255,127,127,127,127,127,127,127,127,255,
255,255,127,127,125,120,120120,120,120,248,120,120,120,120,120,
120,248,248,232,143, 0, 0, 0, 0, 0, 0, 0, 0,128,240,248,
120,188,220, 92,252, 28, 28, 60, 92, 92, 60,120,248,248, 96,192,
143,168,216,136, 49, 68, 72, 50,160, 96, 0, 0, 0, 0, 0, 0,
0, 0, 0,128,192,248,248,248,248,252,254,254,254,254,254,254,
254,254,254,254,254,255,255,255,255,255,246,239,208,246,174,173,
169,128,209,208,224,247,249,255,255,252,220,240,127,255,223,255,
255,255,255,255,255,254,254,255,255,255,255,255,255,255,254,255,
255,255,255,255,255,255,254,254,254,254,254,254,254,254,254,254,
254,254,254,254,255,255,255,255,255,255,254,255,190,255,255,253,
240,239,221,223,254,168,136,170,196,208,228,230,248,127,126,156,
223,226,242,242,242,242,242,177, 32, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 1, 1, 1, 3, 3, 3, 7, 7, 7, 7, 7, 15,
15, 15, 7, 15, 15, 15, 7, 7, 15, 14, 15, 13, 15, 47, 43, 43,
43, 43, 43, 47,111,239,255,253,253,255,254,255,255,255,255,255,
191,191,239,239,239,191,255,191,255,255,255,255,255,255,255,255,
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
255,255,255,255,127,127,127,127,255,255,191,191,191,191,255,254,
255,253,255,255,255,251,255,255,255,127,125, 63, 31, 31, 31, 31,
31, 31, 63, 15, 15, 7, 7, 3, 3, 3, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
1, 1, 1, 1, 3, 3, 3, 11, 11, 11, 11, 7, 3, 14, 6, 6,
6, 2, 18, 19, 19, 3, 23, 21, 21, 17, 1, 19, 19, 3, 6, 6,
14, 15, 15, 7, 15, 15, 15, 11, 2, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
Avant de compiler le fichier IMAGE_GLCD.c il est nécessaire de cocher les fonctions Glcd dans
le gestionnaire de bibliothèque du compilateur mikroC PRO.
Pour inclure le fichier truck_bmp.c dans le projet, il faut procéder les étapes de 1 à 8 dans le
compilateur mikroC PRO comme c’est montré ci-dessous.
1
2 3
- 113 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
33
4 5 6 7
8
GLCD Picture name: truck.bmp
Le projet est une calculatrice simple qui peut effectuer des opérations arithmétiques entières.
Les touches sont organisées comme suit :
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
Les touches sont étiquetées comme suit :
1 2 3 4
5 6 7 8
9 0 ; Entrer
+ - * /
Les opérations et résultats de calcule doivent être affichés sur l’écran de LCD.
Le fichier pour cet exemple appelé CALCUL_LCD.c est présenté dans le code-source 4.15.
- 114 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 4.15
/****************************************************************************
Calculatrice avec CLAVIER et LCD
================================
Le projet est une calculatrice simple qui peut effectuer des opérations
arithmétiques entières.
Les touches sont organisées comme suit :
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
Les touches sont étiquetées comme suit :
1 2 3 4
5 6 7 8
9 0 ; Entrer
+ - * /
Les opérations et résultats de calcule sont affichés sur l’écran de LCD
Microcontrôleur: 18F452
Oscillateur : HS, 10.0000 Mhz
Fichier: CALCUL_LCD.c
Date: Septembre 2012
********************************************************************/
#define MASK 0xF0
#define Enter 11
#define Plus 12
#define Minus 13
#define Multiply 14
#define Divide 15
//
// Cette fonction obtient une touche du clavier
//
- 116 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1,1,"Res="); // Afficher Res=
switch(MyKey) // Effectuer l'opération
{
case Plus:
Calc = Op1 + Op2; // Si Plus
break;
case Minus:
Calc = Op1 - Op2; // Si Minus
break;
case Multiply:
Calc = Op1 * Op2; // Si Multiply
break;
case Divide:
Calc = Op1 / Op2; // Si Divide
break;
}
LongToStr(Calc, op); // Convertir en chaine dans op
//
// Supprimer les espaces à gauche
//
j=0;
for(i=0;i<=11;i++)
{
if(op[i] != ' ') // Si un blanc
{
lcd[j]=op[i];
j++;
}
}
Lcd_Out_CP(lcd); // Afficher le résultat
Delay_ms(5000); // Temporisation de 5 secondes
Lcd_Cmd(_LCD_CLEAR);
}
}
- 117 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Dans cet exemple, le PC est connecté au microcontrôleur via un câble RS232. Le projet c’est
une simple calculatrice où les données sont envoyées au microcontrôleur en utilisant le clavier
de l'ordinateur et ensuite ils sont affichés sur monitor de PC.
L’exemple de calcul :
CALCULATRICE PROGRAMME
Entrer Premier Nombre : 12
Entrer Deuxième nombre : 2
Entrer Opération : +
Résultat : 14
- 118 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
Code-source 4.16
/***************************************************************************
CALCULATRICE AVEC L’INTERFACE RS232
===================================
Le projet est une simple calculatrice. L'utilisateur saisit les données à l'aide
du clavier du PC. Les résultats sont affichés sur l'écran du PC.
Les opérations suivantes peuvent être effectuées:
+,-,*,/.
Dans ce programme, la communication série est traitée par le logiciel
Soft_UART et le port série est configuré pour fonctionner avec 9600 Baud.
Broches du port RC6 et RC7 sont utilisés pour série TX et RX respectivement.
Microcontrôleur: 18F452
Oscillateur : HS, 10.0000 Mhz
Fichier: CALCUL_RS232.c
Date: Septembre 2012
***************************************************************************/
#define Enter 13
#define Plus '+'
#define Minus '.'
#define Multiply '.'
#define Divide '/'
void Newline()
{
Soft_UART_Write(0x0D); // Envoyer retour chariot
Soft_UART_Write(0x0A); // Envoyer saut de ligne
}
void main()
{
unsigned char MyKey, i,j,error,kbd[5],op[12];
unsigned long Calc, Op1, Op2,Key;
unsigned char msg1[] = " CALCULATRICE PROGRAMME";
unsigned char msg2[] = " Entrer Premier Nombre : ";
unsigned char msg3[] = " Entrer Deuxieme Nombre : ";
unsigned char msg4[] = " Enter Operation : ";
unsigned char msg5[] = " Resultat = ";
- 119 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
// Program loop
for(;;) // Boucle sans fin
{
MyKey = 0;
Op1 = 0;
Op2 = 0;
Newline(); // Envoyer saut de ligne
Newline(); // Envoyer saut de ligne
Text_To_Usart(msg1); // Envoyer TEXT
Newline(); // Envoyer saut de ligne
Newline(); // Envoyer saut de ligne
// Pour premier nombre
Text_To_Usart(msg2); // Envoyer message 2
do // Obtenir le premier numéro
{
do // Si un nombre est tapé
MyKey = Soft_UART_Read(&error); // Envoyer ce nombre
while (error);
if(MyKey == Enter)break; // Si le clavier ENTER est pressé
Soft_UART_Write(MyKey); // Sauter à nouvelle ligne
Key = MyKey - '0';
Op1 = 10*Op1 + Key; // Premier nombre de Op1
} while(1);
Newline();
// Pour deuxième nombre
Text_To_Usart(msg3); // Envoyer message 3
do // Obtenir le deuxième nombre
{
do
MyKey = Soft_UART_Read(&error); // Envoyer le deuxième nombre
while(error);
if(MyKey == Enter) break; // Si le clavier ENTER est pressé
Soft_UART_Write(MyKey); // Sauter à nouvelle ligne
Key = MyKey - '0';
Op2 = 10*Op2 + Key; // Deuxième nombre de Op2
} while(1);
Newline();
// Pour opération
Text_To_Usart(msg4);
do
{
do
MyKey = Soft_UART_Read(&error);
while(error);
if(MyKey == Enter)break;
Soft_UART_Write(MyKey);
Key = MyKey;
} while(1);
Newline();
switch(Key) // Calcule
{
case Plus:
Calc = Op1 + Op2; // Si Addition
break;
case Minus:
Calc = Op1 - Op2; // Si Soustraction
break;
case Multiply:
- 120 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
- 121 -
V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la
famille PIC
- 122 -