03 - Programmation en MikroC [PDF]

Zitiervorschau

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

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUE

UNIVERSITE M’HAMED BOGARA DE BOUMERDES FACULTE DES SCIENCES - DEPARTEMENT PHYSIQUE

Spécialité : INFOTRONIQUE & IMAGERIE ET APPAREILLAGE BIOMEDICAL

V. TOURTCHINE

Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC

/******************************* COMMUNICATION SERIE RS232 ========================= Cet exemple illustre l'utilisation de fonction Software_UART de la bibliothèque du compilateur mikroC PRO. Microcontrôl.: 16F887 Oscillat.: HS,10.0000 Mhz Fichier: COMMUNIC_RS232.c ******************************** / char error, byte_read; void main() { ANSEL = 0; ANSELH = 0; TRISC = 0x00; /*Configurer PORTB en sortie */ PORTC = 0; Initialiser Soft_UART en 9600 bods Soft_UART_Init(&PORTC, 7, 6, 9600, 1); if (error > 0)

Manuscrit élaboré selon le programme officiellement agrée et confirme par le Conseil Scientifique de la Faculté des Sciences

BOUMERDES - 2012 -0-

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

I. LANGAGE ET COMPILATEUR mikroC POUR PIC Le langage mikroC pour PIC a trouvé une large application pour le développement de systèmes embarqués sur la base de microcontrôleur. Il assure une combinaison de l'environnement de programmation avancée IDE (Integrated Development Environment) , et d’un vaste ensemble de bibliothèques pour le matériel, de la documentation complète et d’un grand nombre des exemples. Le compilateur mikroC pour PIC bénéficie d'une prise en main très intuitive et d'une ergonomie sans faille. Ses très nombreux outils intégrés (mode simulateur, terminal de communication Ethernet, terminal de communication USB, gestionnaire pour afficheurs 7 segments, analyseur statistique, correcteur d'erreur, explorateur de code, mode Débug ICD...) associé à sa capacité à pouvoir gérer la plupart des périphériques rencontrés dans l'industrie (Bus I2C™, 1Wire™, SPI™, RS485, Bus CAN™, USB, gestion de cartes compact Flash et SD™/MMC™, génération de signaux PWM, afficheurs LCD alphanumériques et graphiques, afficheurs LEDs à 7 segments, etc...) en font un outil de développement incontournable pour les systèmes embarqués, sans aucun compromis entre la performance et la facilité de débogage.

1.1 Compilateur mikroC PRO pour PIC La nouvelle version appelée mikroC PRO dispose de très nombreuses améliorations du compilateur mikroC : nouvelles variables utilisables, nouvelle interface IDE, amélioration des performances du linker et de l'optimisateur, cycle de compilation plus rapide, code machine généré plus compact (jusqu'à 40 % suivant les cas), nouveaux PIC supportés, environnement de développement encore plus ergonomique, nouveaux exemples d'applications, etc...

1. Dans la suite nous utiliserons le compilateur mikroC PRO v.1.65 2. La simulation des applications de programmation nous réalisons à l’aide du logiciel PROTEUS v.7.6 SP

1.2 Installation du compilateur mikroC PRO v. 1.65 Pas 1 : Cliquer sur l’icône mikroC_PRO_1.65.exe (Si la fenêtre du Contrôle de compte d’utilisateur s’ouvre, cliquer sur oui), et attendre que les données de l’installation se décompressent.

-1-

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Pas 2 : Cliquer sur Next

Pas 3 : Cocher la case : I accept the terms in the License Agreement et cliquer sur Next

-2-

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

Pas 5 : Cliquer sur Next

-3-

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Pas 6 : Cliquer sur Install (Noter bien l’endroit d’installation)

Pas 7 : Cliquer sur OUI pour l’association du format de fichier .c avec le logiciel mikroC PRO

-4-

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Pas 8 : Cliquer sur Finish

Pas 9 : Aller dans le répertoire M_License et copier les deux fichiers qui s’y trouvent.

Pas 10 : Coller pour remplacer les deux fichiers copiés auparavant dans le répertoire où mikroC PRO a été installé. Pas 11 : Cliquer deux fois sur le fichier mikroC_PRO_PIC.key pour enregistrer ses informations sur le registre de votre ordinateur. Pas 12 : Lancer le programme MikroC PRO en cliquant deux fois sur mikroCPIC1618.exe

1.3 IDE mikroC PRO Lancer le compilateur mikroC PRO en cliquant sur l’icône

mikroC PRO for PIC.lnk

C’est sur la figure 1.1 que vous obtenez lorsque vous démarrez l’ IDE mikroC PRO pour la première fois. Une description détaillé de toutes les options disponibles dans ce compilateur prendre trop de temps, de sorte que nous allions sauter cette étape. Au lieu de cela, nous allons décrire salement le processus d’écriture d’un programme en langage mikroC, un simulateur de contrôle. Pour plus d’informations reportez-vous à l’aide [F1]. -5-

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

Menu

Toolbar

Projet Manager

Code Explorer

Code Editor

Project Settings (paramètres principaux du microcontrôleur)

Error Window

Fig. 1.1 L’environnement IDE du compilateur microC PRO

Editeur de code (voire la figure 1.1 : Code Editeur) L’éditeur de code est le même que toute éditeur de texte standard pour l’environnement de Windows, y compris Copie, Coller , Annuler les actions etc… Il possède en plus des ressources comme suit :    

Coloration syntaxique réglable Assistant de code Assistant de paramètre Mise en forme automatique

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

-6-

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

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

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

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

-7-

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

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

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

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

d) Gestion des LCD graphiques Le "MikroC PRO" intègre un petit utilitaire qui vous permettra de convertir des fichiers BMP en données pouvant être affichées sur plusieurs types de LCD graphiques.

-8-

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

1.4 Création d’un nouveau projet Le mikroC PRO pour PIC organise des applications dans des projets, composé d'un seul fichier de projet (extension. mcppi) et un ou plusieurs fichiers sources (extension). Les fichiers source peut être compilé que si elles font partie d'un projet. Le fichier projet contient les informations suivantes : -

Nom du projet et une description facultative Composant cible Option du composant Fréquence d’horloge du composant La liste des fichiers source du projet avec les chemins Fichiers d'image Fichiers binaires (* mcl.) D'autres fichiers

La meilleure façon de créer un projet c’est à l'aide de l'Assistant Nouveau projet (menu Project> New ProjeCt ) ou en cliquant sur l'icône Nouveau projet du projet.

-9-

à partir de la barre d'outils

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

Nouvelles étapes de l'Assistant de projet Commencez à créer votre nouveau projet, en cliquant sur le bouton Next :

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

- 10 -

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

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

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

- 11 -

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.

Ici vous devez saisir votre code-source

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).

Fig. 1.4 Avertissement des érreures

Après la compilation réussie, le compilateur mikroC PRO pour PIC génère des fichiers de sortie dans le dossier du projet (dossier qui contient le fichier projet. mcppi). Les fichiers de sortie sont résumés dans le tableau ci-dessous: Format Intel HEX Binary

Description Code hexadécimal dans le format Intel. Fichier est utilisé pour programmer PIC Fichier compilé pour la bibliothèque mikroC. Les distributions binaires sont des routines qui susceptibles - 14 -

Type de fichier .hex .mcl

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

List File

Assembler File

d’être inscrits dans d'autres projets. .lst L’mage globale de l’allocation de mémoire du PIC pour : adresses d’instructions, les registres et les étiquettes du programme. Le fichier en assembleur avec des noms symboliques, .asm obtenus à partir de liste des fichiers.

1.5 Fichiers Sources Création d’un nouveau fichier source Pour créer un nouveau fichier source, procédez comme suit : Sélectionne New depuis le menu File ou pressez Ctrl+N ou cliquez sur l’icône New Fill depuis la barre d’outils File. Une nouvelle fenêtre s’ouvrira dans laquelle vous pourrez saisir votre code source. Sélectionnez alors Save depuis le menu File ou pressez Ctrl+S ou cliquez sur l’icône Save File depuis la barre d’outils File et nommez ce dernier comme vous le voulez.

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

Sauvegarder un fichier Assurez-vous que la fenêtre contenant le fichier que vous voulez sauvegarder est active. Sélectionnez ensuite Save depuis le menu File ou pressez Ctrl+S ou cliquez sur l’icône Save Fail de la barre d’outils File.

Sauvegarder un fichier sous un nom différent Assurez-vous que la fenêtre contenant le fichier que vous voulez sauvegarder est active. Sélectionnez ensuite Save As depuis le menu File. Une boîte - 15s’affichera de dialogue ‘Save [nom du fichier] .c as’ alors. Dans cette boîte, sélectionnez l’emplacement dans lequel vous voulez sauvegarder le fichier.

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

II. INTRODUCTION AU LANGAGE DE PROGRAMMATION MICROC 2.1 Structure d'un programme en mikroC La structure la plus simple d'un programme en mikroC, c’est le programme représenté dans le code-source 2.1, qui nous permettra de faire clignoter une LED connectée au PORTB (par exemple bit 0 du PORTB) du microcontrôleur PIC avec une période de 2 secondes (1 seconde allumée et une seconde éteinte). 2.1.1 Règles générale d’écriture en microC  Les instructions propres au langage microC doivent être écrites en minuscule (void main (void)).  Les instructions particulières aux microcontrôleurs doivent être écrites en majuscule (TRISB).  Les retours à la ligne et les espaces servent uniquement à aérer le code  Toutes instructions ou actions se terminent par un point virgule « ; ». Code-source 2.1 /**************************************************************************** LED clignotante ============== Ce programme fait clignoter d’une LED connectée au PORTB (broche RB0) avec un des intervalles d'une seconde. Microcontrôleur : 16F84A Oscillateur : HS, 4.0000 Mhz

- 16 -

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 }

Examinons le fichier LED.c du code-source

2.1.2 Commentaires Les commentaires sont utilisés pour préciser le fonctionnement du programme et pour une annotation du programme. Les lignes de commentaires sont ignorées et non compilé par le compilateur. En mikroC les commentaires de programmes peuvent être de deux types: de longs commentaires, s’étendant sur plusieurs lignes, et de courts commentaires, occupant une seule ligne. Un commentaire au début d'un programme peut décrire brièvement le fonctionnement du programme et de fournir le nom de l'auteur, le nom du fichier programme, la date à laquelle le programme a été écrit, et une liste des numéros de version, ainsi que les modifications dans chaque version. Comme montre le Code-source 2.1 les longs commentaires commencent par le caractère « /* » et se termine par le caractère « */ ». De même, de courts commentaires commencent par le caractère « // » et il n’a pas besoin d'un caractère de terminaison.

2.1.2 Début et fin d'un programme En langage microC, un programme commence avec les mots-clés: void

main()

Après cela, une accolade ouvrante est utilisée pour indiquer le début du corps de programme. Le programme se termine par une accolade fermante. Ainsi, comme indiqué dans le Code-source 2.1, le programme a la structure suivante : void main() { // Votre code ici } - 17 -

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

2.1.3 Fin d’une instruction Le point virgule « générée. j = 5; j = 5

; » indique la fin d’une instruction,

sinon une erreur du compilateur sera

// correcte // erreur

2.1.4 Espaces blancs Les espaces blancs sont des espaces, des flans, les tabulations et les caractères de nouvelle ligne. Le compilateur microC ne tient pas compte tous les espaces blancs. Ainsi, les trois séquences suivantes sont identiques : int i; char j; ou int i; char j; ou int i; char j; De même, les séquences suivantes sont identiques : i=j+2 ; ou i=j +2 ;

2.2 Eléments de programmation en mikroC 2.2.1 Les variables. Définition et déclaration de variables Une variable est une portion réservée d’une mémoire à laquelle on a donné un nom. On peut stocker ou lire les informations de ces variables. Toute variable utilisée dans un programme doit auparavant être définie. La définition d’une variable consiste à la nommer et lui donnée un type et éventuellement lui donner une valeur initiale (initialiser). C’est cette définition qui réserve (alloue) la place mémoire nécessaire en fonction du type. Lorsque le programme que l’on réalise est décomposé en plusieurs modules, une même variable, utilisée dans plusieurs modules, doit être déclarée dans chacun de ces modules. Par contre, on ne définira cette variable que dans un seul de ces modules. C’est au moment de l’édition des liens que l’on mettra en correspondance les variables apparaissant dans plusieurs modulez (variable partagée, mot-clé extern). La position de la déclaration ou de la définition d’une variable détermine sa portée c’est-à-dire sa durée de vie et sa visibilité.  Les variables globales sont déclarées en dehors de toute fonction. - 18 -

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. Voici quelques identificateurs valides: temperature_V1 Pressure no_hit dat2string SUM3 _vtext ... mais voici quelques identificateurs incorrectes: 7temp % Supérieur int

// ne peut pas commencer par un chiffre // ne peut pas contenir de caractères spéciaux // ne peut pas répéter un mot-clé

j23.07.04 (période)

// ne peut pas contenir de caractères spéciaux

Certains noms sont réservés pour le compilateur lui-même et ne peut pas être utilisés comme noms de variables dans un programme. Le tableau 2.1 donne une liste alphabétique de ces noms réservés.

asm

Tableau 2.1 Noms réservés en mikroC enum signed

auto

extern

sizeof

break

float

static

case

for

struct

char

goto

const

if

typedef

continue

int

union

default

long

unsigned

do

register

void

double

return

volatile

else

short

while

- 19 -

switch

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. Tableau 2.2: Types de variables en mikroC Type

unsigned

char

unsigned short int

Taille (bits)

Plage

8

0 à 255

8

0 à 255

unsigned int

16

0 à 65535

unsigned long int

32

0 à 4294967295

signed char

8

-128 à 127

signed short int

8

-128 à 127

signed int

16

-32768 à 32767

signed long int

32

- 2147483648 à 2147483647

float

32

± 1.17549435082E-38 à

±6.80564774407E38

double

32

± 1.17549435082E-38 à

± 6.80564774407E38

long double

32

± 1.17549435082E-38 à

± 6.80564774407E38

(unsigned) char or unsigned short (int) Les variables appelées (unsigned) char ou unsigned short (int), sont des variables non signées de 8 bits avec une plage de 0 à 255. Dans l'exemple suivant deux variables de 8 bits nommées total et sum sont créés, et sum est affectée la valeur décimale 150: unsigned char total, sum; sum = 150; ou char totale, sum; sum = 150; Les variables peuvent affecter des valeurs au cours de leur déclaration. Ainsi, les déclarations ci-dessus peuvent aussi être écrites comme suit: char total, sum = 150; - 20 -

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

signed char or (signed) short (int) Les variables appelées signed char, ou (signed) short (int) sont des variables signées de 8 bits avec une gamme de -128 à +127. Dans l'exemple suivant, une variable signée de 8 bits nommée counter est créé avec une valeur de – 50 : signed char counter =- 50; soit short counter = -50; soit short int counter = -50;

(signed) int Les variables appelés (signed) int sont des variables signées de 16 bits avec une gamme ayant de - 32768 à +32767. Dans l'exemple suivant d'un entier signé nommé Big est : int Big; unsigned (int) Les variables appelés unsigned (int) sont des variables non signés de 16 bits avec une gamme de 0 à 65535. Dans l'exemple suivant une variable de 16 bits nommée count est affectée la valeur décimale de 12000 : unsigned int count = 12000;

(signed) long (int) Les variables appelés (signed) long (int) sont des variables signées de 32 bits avec une gamme de - 2147483648 à +2147483647. Un exemple est suivant : signed long LargeNumber;

unsigned long (int) Les variables appelés unsigned long (int) sont des variables non signées de 32 bits ayant une gamme de 0 à 4294967295. Un exemple est suivant: unsigned long VeryLargeNumber;

float or double or long double Les variables appelées float ou double ou long double, sont des variables à virgule flottante mis en œuvre en utilisant le mikroC de format 32 bits. Nombres à virgule flottante comprise entre 1.17549435082E-38 à + 6.80564774407E38. Dans l'exemple suivant, une variable flottante nommée area est affectée la valeur 12.235: - 21 -

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

float area ; area = 12.235; Pour éviter toute confusion lors de l'élaboration du programme, il est recommandé de préciser le signe de la variable (signé ou non signé) ainsi que le type de variable. Par exemple, utiliser unsigned char au lieu de char seulement, et unsigned int au lieu de unsigned seulement.

2.2.2 Constantes Constantes représentent des valeurs fixes (numérique ou caractère) dans des programmes qui ne peuvent pas être changées. En mikroC, constantes peuvent être entiers, flottants, caractères, les chaînes, ou des types énumérés. Integer Constants Les constantes entières (Integer Constants) peuvent être en décimal, hexadécimal, octal ou binaire. Le type de données d'une constante est tiré par le compilateur à partir de sa valeur. Mais suffixes peut être utilisé pour changer le type d'une constante. Dans le tableau 2.2, nous avons vu que les constantes décimales (signed long int) peuvent avoir des valeurs de – 2147483648 à + 4294967295. Par exemple, nombre constant 210 est stocké comme un entier non signé ( unsigned char) ou (unsigned short int). De même, nombre constant - 200 est stocké comme un entier signé (signed int). Le suffixe u ou U force la constante d'être non signé (unsigned) et le suffixe l ou L force la constante d'être longue (long). Utilisation de U (ou u) et L (ou l) oblige la constante d'être unsigned long. Les constantes sont déclarées en utilisant le mot-clé const et sont stockées dans le flash de mémoire du microcontrôleur PIC. Par exemple, MAX est déclaré comme la constante 100 : const MAX =100; Les constantes hexadécimales commencent par les caractères 0x ou 0X et peuvent contenir des données numériques de 0 à 9 et les caractères hexadécimaux de A à F. Dans l'exemple suivant, TOTAL est la constante de la valeur hexadécimale FF: const TOTAL = 0xFF;

Les constantes octales ont un zéro au début du nombre et peuvent contenir des données numériques de 0 à 7. Dans l'exemple suivant, une constante CNT est affectée une valeur octale 17 : const CNT = 017;

- 22 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Les constantes binaires commencent par 0b ou 0B et ne peuvent contenir que 0 ou 1. Par exemple une constante nommée Min est déclarée comme ayant la valeur binaire 11110000: const Min = 0b11110000 Floating Point Constants Les constantes à virgule flottante (Floating Point Constants) se compose de:  Entier décimal  Point décimal  Partie décimale fractionnaire  e ou E et l'ordre du signe MikroC limite les valeurs de constantes à virgule flottante par la gamme : ±1.17549435082 * 10-38 ... ±6.80564774407 * 1038. Dans l'exemple suivant, une constante nommée TEMP est déclarée comme ayant la valeur fractionnelle 37.50 : const TEMP = 37.50 ou const TEMP = 3.750E1 Character Constants Une constante de caractère (Character Constants) est un caractère renfermé dans des guillemets simples. Par exemple, une constante nommée First_Alpha est déclarée comme ayant la valeur du caractère ‘‘A’’ : const First_Alpha = ‘A’; String Constants Les constantes de chaîne (String Constants ) sont des séquences fixes de caractères stockées dans la mémoire flash du microcontrôleur. La chaîne doit commencer et se terminer par un guillemet « " ». Un exemple d’une constante de type chaîne est la suivante : "Il s'agit d'un exemple de chaîne constante" Une constante chaîne peut être étendue à travers une frontière en ligne en utilisant une barre oblique inverse « "\" » :

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

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

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

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

Tableau 2.3: Quelques séquences d'échappement Valeur de la Séquence séquence d'échappement Hex Caractère \ a

0X07

BEL (cloche)

\ b

0X08

BS (backspace)

\ t

0X09

HT (tabulation horizontale)

\ n

0XLF

0A (saut de ligne)

\ v

0X0B

VT (tabulation verticale)

\ f

0X0C

FF (saut de page)

\ r

0X0D

CR (retour chariot)

\ xH

- 24 -

Chaîne de chiffres Hex

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

2.2.4 Variables statiques Les variables statiques (Static variables ) sont des variables locales utilisées dans les fonctions lorsque la dernière valeur d'une variable entre les appels successifs de la fonction doit être préservée. Comme le montre l'exemple suivant, les variables statiques sont déclarées en utilisant le mot clé static : statique unsigned int count ;

2.2.5 Variables externes Utilisation du mot (extern) devant un nom de variable déclare cette variable comme externe. Il indique au compilateur que la variable est déclarée ailleurs dans un code-source distincte

module. Dans l'exemple suivant, les variables sum1 et SUM2 sont déclarés comme externes entiers non signés : extern int sum1, SUM2 ;

2.2.6 Variables volatiles Les variables volatiles (Volatile Variables ) sont importantes dans d'interruption des programmes et de routines d’entrées-sorties. Utilisation de mot-clé volatile indique que la valeur de la variable peut changer au cours de la durée de vie du programme indépendant de l'écoulement normal du programme. Dans l'exemple suivant, la variable Led est déclarée comme un volatile non signé : volatile unsigned char Led;

2.2.7 Variables énumérées Les variables énumérées sont utilisées pour rendre un programme plus lisible. Dans une variable énumérée, une liste de références est spécifiée et la valeur du premier élément est fixé à 0, l'autre élément est mis à 1, et ainsi de suite. Dans l'exemple suivant, la Semaine de type est déclaré comme un liste énumérée et LUN = 0, MAR = 1, WEN = 2, et ainsi de suite : enum Semaine {LUN, MAR, MER, JEU, VEN, SAM, DIM}; Il est possible d'impliquer les valeurs des éléments dans une liste énumérée. Dans le exemple suivant, noir = 2, bleu = 3, rouge = 4, et ainsi de suite. enum couleurs {noir = 2, bleu, rouge, blanc, gris}; De même, dans l'exemple suivant, noir = 2, bleu = 3, rouge = 8, et gris = 9: enum couleurs {black = 2, bleu, rouge = 8, gris}; Les variables de type de recensement peuvent être déclarées par les spécifiant après la liste - 25 -

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: My_Week = MER

// assigne 2 à My_Week

ou My_Week = 2

// le même que ci-dessus

Après avoir défini Semaine comme un type énuméré, nous pouvons déclarer des variables This_Week et Next_Week de type Semaine : enum Semaine This_Week, Next_Week;

2.2.8 Tableaux Les tableaux (Arrays) sont utilisés pour stocker des éléments liés dans le même bloc de mémoire et en vertu d'un nom spécifié. Un tableau est déclaré en spécifiant son type, le nom, et le nombre d’éléments à stocker. Par exemple: unsigned int Total [5] ; Ce tableau de type unsigned int est nommé Total et dispose de cinq éléments. Le premier élément d'un tableau est indexé à 0. Ainsi, dans cet exemple, Total[0] se réfère au premier élément du tableau et Total[4] se réfère au dernier élément. Le tableau Total est stocké dans un mémoire ayant cinq emplacements consécutifs comme suit: Total[0] Total[1] Total[2] Total[3] Total[4] Les données peuvent être stockées dans le tableau en spécifiant le nom du tableau et de l'indice. Par exemple, pour stocker 25 dans le deuxième élément du tableau, nous devons écrire: Total[1] = 25; De même, le contenu d'un tableau peut être lu en spécifiant le nom du tableau et de son index. Par exemple, pour copier l'élément de tableau d’index 2 à une variable appelée Temp , nous devons écrire: Temp = Total[2]; Le contenu d'un tableau peut être initialisé lors de la déclaration du tableau en attribuant d'une séquence de valeurs séparées par des virgules dans le tableau. Voici un exemple d’un tableau ayant 12 éléments des mois[0] = 31, mois[1] = 28, et ainsi de suite: - 26 -

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

unsigned char mois[12] = {31,28,31,30,31,30,31,31,30,31,30,31}; www.newnespress. Le même tableau peut également être déclaré sans spécifier sa taille: unsigned char mois[ ] = {31,28,31,30,31,30,31,31,30,31,30,31}; Des tableaux de caractères peuvent être déclarés de manière similaire. Dans l'exemple suivant, un tableau de caractères nommés Hex_Letters est déclarée avec 6 éléments: unsigned char Hex_Letters[ ] ={‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’}; Les chaînes sont des tableaux de caractères avec un terminateur null. Les chaînes peuvent être déclarées soit par enfermant la chaîne entre guillemets, ou en spécifiant chaque caractère du tableau au sein de apostrophes et puis en terminant la chaîne avec un caractère nul. La chaîne de deux déclarations dans l'exemple suivant est identique : unsigned char Mystring[ ] = “COMP”;

et unsigned char Mystring[ ] = {‘C’, ‘O’, ‘M’, ‘P’, ‘\0’}; Dans le langage de programmation microC, nous pouvons aussi déclarer des tableaux aux dimensions multiples. Tableaux unidimensionnels sont généralement appelés vecteurs, et des tableaux bidimensionnels sont appelés matrices. Un réseau bidimensionnel est déclaré en spécifiant le type de données de la matrice, le nom de tableau, et la taille de chaque dimension. Dans l'exemple suivant, un tableau à deux dimensions nommé P contiens trois lignes et quatre colonnes. Au total, le tableau a douze éléments. Le premier élément de la matrice est P[0][0], et le dernier élément est P[2][3]. La structure de ce tableau est montrée ci-dessous:

P[0][0] P[0][1]

P[0][2]

P[0][3]

P[1][0] P[1][1]

P[1][2]

P[1][3]

P[2][0] P[2][1]

P[2][2]

P[2][3]

- 27 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Éléments d'un tableau multidimensionnel peut être spécifié lors de la déclaration du tableau. Dans l'exemple suivant, réseau bidimensionnel Q a deux rangées et deux colonnes, ses éléments diagonaux sont mis à 1, et de ses éléments non diagonaux sont remis à 0: unsigned char Q[2][2] = { {1,0}, {0,1} };

2.2.9 Pointeurs Les pointeurs (Pointers) sont une partie importante du langage microC, car ils occupent les adresses mémoire des autres variables. Les pointeurs sont déclarées de la même manière que d'autres variables, mais avec le caractère « * » en face du nom de variable. Dans l'exemple suivant, un pointeur de caractère non signé du nom pnt est déclaré: unsigned char *pnt; Quand un nouveau pointeur est créé, son contenu est d'abord indéterminé et il ne tient pas l'adresse d'une variable. Nous pouvons attribuer l'adresse d'une variable à un pointeur à l'aide le « & » : pnt = &Count;

Maintenant pnt affecte l'adresse de variable Count. La variable Count peut être affectée à une valeur en utilisant le caractère « * » en avant de son pointeur. Par exemple, le Count peut être attribuée à 10 à l'aide de son pointeur : * pnt = 10;

// Count = 10

c’est la même chose que Count = 10; // Count = 10 ou, la valeur du Count peut être copié à la variable Cnt en utilisant son pointeur : Cnt = *pnt;

// Cnt = Count

Pointeurs de tableaux Dans le langage microC, le nom d'un tableau est aussi un pointeur de tableau. Ainsi, pour le tableau : unsigned int Total[10]; Le nom Total est également un pointeur de ce tableau, et il contient l'adresse du premier ellément de la matrice. Ainsi, les deux énoncés suivants sont égaux: Total[2] = 0; et *(Total + 2) = 0; En outre, l'énoncé suivant est vrai: &Total[j] = Total + j ; - 28 -

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 :  Comparaison de deux pointeurs  Addition ou la soustraction d'un pointeur et un entier  La soustraction de deux pointeurs  Assigner un pointeur vers un autre  En comparant un pointeur avec zéro Par exemple, supposons que le pointeur P est affecté afin de contenir l'adresse du tableau d’élément Z[2]: P = &Z[2];

Nous pouvons maintenant effacer les éléments 2 et 3 du tableau Z, comme dans les deux exemples qui suivent. Les deux exemples sont identiques, sauf que dans le premier exemple pointeur P contient l'adresse de Z[3] à la fin des états, et il contient l'adresse de Z[2] à la fin de deuxième série de déclarations: *P = 0;

// Z[2] = 0

P = P + 1; *P = 0;

// maintenant P pointe l’élément 3 de Z // Z[3] = 0

ou *P = 0;

// Z[2] = 0

*(P +1) = 0;

// Z[3] = 0

Un pointeur peut être affecté à un autre pointeur. Dans l'exemple suivant, les variables Cnt et Tot sont l’ensable de 10 éléments créés à l'aide de deux pointeurs différents:

unsigned int *i, *j;

// déclare 2 pointeurs

unsigned int Cnt, Tot;

// déclare deux variables

i

// i pointe vers Cnt

= &Cnt;

*i = 10;

// Cnt = 10

j = i;

// copy pointeur i vers pointeur j

Tot = *j;

// Tot = 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: struct Personne Moi, Toi; Les variables de type Personne peuvent également être créées lors de la déclaration de la structure comme suit : struct Personne { unsigned char unsigned char unsigned char unsigned char }Moi, Toi

name[20]; prénom [20]; nationalité [20]; âge;

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. Considéront l'exemple ci-dessus : sizeof (MienCylindre) retours 8, étant donné que chaque variable de type float occupe 4 octets en mémoire.

Les champs de bits peuvent être définis en utilisant les structures. Avec les champs de bits, nous pouvons attribuer des identificateurs pour les bits d’une variable. Par exemple, pour identifier les bits 0, 1, 2, 3 d'une variable pour LowNibble et d'identifier les 4 bits restants pour HighNibble nous pouvons écrire : struct { LowNibble: 4; HighNibble: 4; } MienVariable;

On peut alors accéder aux quartets bits de la variable MienVariable : MienVariable.LowNibble = 12; MienVariable.HighNibble = 8;

En microC, nous pouvons utiliser les déclarations typedef pour créer de nouveaux types d’une variable. Par exemple, une nouvelle structure type de données nommé Reg peut être créé comme suit :

- 31 -

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: Reg MyReg, REG1, REG2; Le contenu d’une structure peut être copié dans une autre structure, à condition que des structures soient déterminées à partir du même modèle. Dans l'exemple qui suit , P2 est copié sur P1: struct Personne { unsigned char nom [20]; unsigned char prenom [20]; unsigned int âge; unsigned int hauteur; unsigned poids; }

struct Personne P1, P2; ........................ ........................

P2 = P1;

2.2.11 Unions Les unions sont utilisées pour les variables de recouvrement. Une union est similaire à une structure et il est même défini d'une manière similaire. Les deux sont basés sur des modèles, et les membres de tous les deux sont accessible à l'aide des opérateurs « . » ou « -> ». Une chausse diffère d'une structure en ce que tous variables dans une union occupent la même zone mémoire, ils partagent le même stockage. Un exemple de déclaration de l'union est la suivante : union flags { unsigned char x; unsigned int y; }P;

Dans cet exemple, les variables x et y occupent la même zone de mémoire, et la taille de ce l'union est de 2 octets de long, ce qui est de la taille de la plus grande partie de l'union. Quand la variable y est chargé avec une valeur de 2 octets, la variable x aura la même valeur que faible octet de y. Dans l'exemple suivant, y est 0xAEFA, et x est chargé avec 0xFA:

chargé

P.y = 0xAEFA ; - 32 -

avec

16-bit

valeur

hexadécimale

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. Cette union peut aussi être déclarée comme suit : union flags { unsigned char x; unsigned int y; } union flags P;

2.2.12 Opérateurs et expressions en mikroC Les opérateurs sont appliqués aux variables et d'autres objets dans les expressions pour assurer certaines conditions ou des calculs. Une expression est un objet syntaxique obtenu en assemblant des constantes, des variables et des opérateurs. Exemple : x + 12

Dans le langage microC, il y a d’autres opérateurs que les opérateurs arithmétiques qu’on a l’habitude de manipuler. Il y en a en fait plus de 40 opérateurs. Opérateurs et priorités Vous avez l’habitude de manipuler des expressions arithmétiques : 2+3*4*5-2, 2-3-4 On sait que ces expressions sons équivalentes à (2+(3*(4*5)))-2, (2-3)-4. Introduire les parenthèses permet de définir sans ambiguité l’expression que l’on manipule. Pour éviter l’usage des parenthèses qui alourdissent la lecture, il existe des règles pour lever toute ambigüité : Exemple : 2+3*4 La sous expression 3*4 est évaluée en premier et le résultat obtenu est ajouté à la valeur 2 (forme avec parenthèse : 2+(3+4)). On dit que l’opérateur « * » possède une priorité supérieur à la priorité de l’opérateur « + ». 2-3-4 - 33 -

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. Ces priorités et ordre d’évaluation ne permettent évidement pas de se dispenser complètement des parenthèses : (2+3)*4 à comparer à 2+3*4 Caractéristiques de l’opérateur (…) : Opérateur

Nom

Notation

Priorité

Ordre

()

parenthèses

(…)

15

gauche-droite

Opérateur d’affectation L’opérateur la plus importante dans un langage de programmation est celle qui consiste à donner une valeur à une variable. Cette opération est désignée par le symbole « = ». 

Comme l’affectation range une valeur dans une variable (une zone mémoire), il est impératif que le membre gauche d’une affectation représente une zone (left value). Une constante n’est pas une left value car il ne désigne pas l’adresse d’une zone mémoire. Elle ne peut donc pas figurer en membre gauche d’une affectation. Le membre droit d’une affectation peut désigner soit une constante soit une zone mémoire soit une expression. Opérateur

Nom

Notation

Priorité

Ordre

=

affectation

x=y

2

droite- gauche

Notation

Priorité

Ordre

Les opérateurs arithmétiques Opérateur

Nom

+

addition

x+y

12

gauche-droite

-

soustraction

x-y

12

gauche-droite

*

multiplication

x*y

13

gauche-droite

/

division

x/y

13

gauche-droite

- 34 -

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

modulo

x%y

13

gauche-droite

Les opérateurs +, -, * , fonctionnent comme en arithmétique. Par contre, l’opérateur / (division) se comporte de manière différente selon que les opérandes sont des entier ou des nombres flottants :

 Nombres flottants : le résultat est un nombre flottant obtenu en divisant les deux nombres.  Nombres entiers : le résultat est un nombre entier obtenu en calculant la division entier ou division euclidienne. L’opérateur % n’est défini que pour les entiers et le résultat est le reste de la division entière des opérandes. Rappel sur la division entière : On appelle quotient et reste de la division entière de a et de b, les nombres entiers q et vérifiant : a = q*b +r ; 0 < r < B Exemple 1 : Si a = 20 et b = 3 alors q = 6 et r = 2 (on a vérifié : 20 = 6*3 + 2) Exemple 2 : int a, b, c ; float x, y, z ; a a x x x x

= = = = = =

b/c; x/y; y/z; 2/3; 2.0/3.0; (float)((float)a)/y;

//division entière //reste entier //division réelle //division entière //division réelle //division réelle

L’opérateur unaire « – » a une priorité supérieure aux opérateurs binaires arithmétiques :

Opérateur

Nom

Notation

Priorité

Ordre

-(unaire)

négation

-x

13

droite- gauche

Les opérateurs de comparaison

Opérateur

Nom

Notation

==

teste d’égalité

!=

teste de non égalité

- 35 -

Priorité

Ordre

x == y

9

gauche-droite

x!=y

9

gauche-droite

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC = y

10

gauche-droite


y

10

gauche-droite

Théoriquement, le résultat d’une comparaison est une valeur booléenne (vrai ou faux). En microC, le résultat d’une comparaison est 1 (!= 0) ou 0 selon que cette comparaison est vraie ou fausse. Il n’existe pas de type booléen en microC : la valeur entière 0 sera considérée comme équivalente à la valeur faux et toute valeur différente de 0 équivalente à la valeur vrai.

Les opérateurs logiques Une variable booléenne est une variable pouvant prendre la valeur vrai ou faux. La valeur d’une expression booléenne est, comme le résultat des comparaisons, une valeur entière.

Opérateur

Nom

Notation

Priorité

Ordre

&&

ET

x && y

5

gauche-droite

II

OU

x II y

4

gauche-droite

! (unaire)

NON

!x

14

droite- gauche

Notation

Priorité

Ordre

Les opérateurs de manipulation de bits Opérateur

Nom

&

ET bit à bit

x&y

8

gauche-droite

I

OU bit à bit

xIy

6

gauche-droite

^

OU exclusif bit à bit

x^y

7

gauche-droite

x

14

droite-gauche

>> x

11

droite-gauche

 (unaire) >>

NON bit à bit décalage à droite - 36 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC 0) { PORTC = error; // Initialisation d’erreur while(1); // Stop programme } while(1) { // Boucle sans fin // Lire octet, puis tester drapeau 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

Fig.4.9. Schéma de simulation de l’exemple 10

Exemple 11. Mesure de la température à l'aide du capteur DS1822. L'utilisation de protocole de '1-Wire‘ 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:   

Ow_Reset est utilisé pour réinitialiser du capteur; Ow_Read est utilisé pour recevoir des données provenant du capteur, et Ow_Write est utilisé pour envoyer des commandes au capteur.

Le fichier TEMPERATURE_One_Wire est représenté dans le code source 4.12 et le schéma de simulation est donné par la figure 4.10 Avant de compiler le fichier TEMPERATURE_One_Wire.c, il est nécessaire de cocher les fonctions One_Wire et Lcd dans le gestionnaire de bibliothèque du compilateur mikroC PRO.

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; sbit sbit sbit sbit sbit sbit

LCD_RS_Direction LCD_EN_Direction LCD_D4_Direction LCD_D5_Direction LCD_D6_Direction LCD_D7_Direction

at at at at at at

TRISB0_bit; TRISB1_bit; TRISB4_bit; TRISB5_bit; TRISB6_bit; TRISB7_bit;

// Fin de configuration /* Configurer TEMP_RESOLUTION à la résolution correspondante du capteur utilisé DS1822: 12 (réglage par défaut peut être : 9,10,11 ou 12)*/ const unsigned short TEMP_RESOLUTION = 12; char *text = "000.0000"; unsigned temp ; void Display_Temperature(unsigned int temp2write ) { const unsigned short RES_SHIFT = TEMP_RESOLUTION - 8; char temp_whole;

- 104 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC unsigned int temp_fraction; Lcd_Chr(2,4,'+'); if (temp2write & 0x8000)

/* Vérification si la température est négative?*/

{ Lcd_Chr(2,4,'-'); temp2write = ~temp2write + 1;

// Correction de signe si oui // Complémenter à deux

} // Extraire de la partie entière (temp_whole) de température temp_whole = temp2write >> RES_SHIFT; text[0] = '0'; // Conversion temp_whole en caractères 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 /* Extraire de la partie fractionnaire (temp_fraction) de tempe'ratureand et convertion en unsigned int*/ temp_fraction = temp2write