03- Programmation en MikroC

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-


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-


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-


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-


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-


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-


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


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 -


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 -


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 -


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


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.


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 -


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


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 -


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 -


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 -


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


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 -


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 -


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 -


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


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 <=

teste inférieur ou égal

x <= y

10

gauche-droite

>=

teste supérieur ou égal

x >= y

10

gauche-droite

<

teste inférieur strict

x
10

gauche-droite

>

teste supérieur strict

x>y

10

gauche-droite

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

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

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

décalage à gauche

<< x

11

droite-gauche

Les autres opérateurs binaires d’affectation Les opérateurs suivants ne sont que des raccourcis de notation (pas d’optimisation du code généré) : Opérateur

Equivalent

Notation

Priorité

Ordre

+=

x=x+y

x

+= y

2

droite-gauche

-=

x=x-y

x

-= y

2

droite-gauche

*=

x=x*y

x

*= y

2

droite-gauche

/=

x=x/y

x

/= y

2

droite-gauche

x=x%y

x %= y

2

droite-gauche

x=xy

x

= y

2

droite-gauche

<<=

x = x << y

x <<= y

2

droite-gauche

&=

x=x&y

x &= y

2

droite-gauche

I=

x=xIy

x

I= y

2

droite-gauche

^=

x=x^y

x ^= y

2

droite-gauche

%= =

Autres opérateurs unaires d’affectation

Opérateur

Equivalent

Notation

Priorité

Ordre

++

x=x+1

x++ ou ++x

14

droite-gauche

--

x=x-1

x-- ou --x

14

droite-gauche y = x++ ;

c’est le raccourci pour y = x ; x = x+1 ; y = ++x ; c’est le raccourci pour x = x + 1 ; y = x ; Autres opérateurs 

Opérateur conditionnel Opérateur

Equivalent

Notation

Priorité

Ordre

?

opérateur conditionnel

e ? x : y

3

droite-gauche

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

affecte la variable a à la valeur 1 si v vaut 2, sinon la variable a à la valeur 2. 

Opérateur séquentiel Opérateur

Equivalent

Notation

Priorité

Ordre

,

opérateur séquentiel

e1 , e2

1

droite-gauche

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é. Opérateur

Equivalent

Notation

Priorité

Ordre

sizeof

opérateur de dimension

sizeof (e)

14

droite-gauche

Exemple : La valeur de l’expression sizeof(c) est 1 si c est une variable de type char. L’expression sizeof(char)donne également la valeur 1. 

Opérateur de parenthèse

L’opérateur de parenthèse ( ) permet de définir l’ordre d’évaluation d’une expression. C’est également ce même opérateur qui est utilisé pour encapsuler les parenthèses des fonctions. Même lorsqu’une fonction n’a pas d’arguments, ces parenthèses sont obligatoires.



Opérateur

Equivalent

Notation

Priorité

Ordre

()

opérateur d’adressage

()

15

gauche-droite

Opérateur de sélection

Ces opérateurs « . » et « -> » servent à sélectionner des champs de données structurées. - 38 -


Opérateur

Equivalent

Notation

Priorité

Ordre

.

opérateur de sélection

x,info

15

gauche-droite

->


x->info

15

gauche-droite

[]


x[3]

15

gauche-droite

Opérateurs du préprocesseur Toute ligne de code-source commence par « # » est considérée comme un opérateur de préprocesseur (ou l’opérateur de prétraitement ou encore la ligne de commande). Les opérateurs du préprocesseur sont généralement placés au début du code-source, mais ils ont le droit d'être n'importe où dans le programme. Le préprocesseur permet à un programmeur de :   

Compiler un programme de sorte que les parties du code ne sont pas compilés Remplacer les symboles avec d'autres symboles ou des valeurs Insérer des fichiers texte dans un programme

La syntaxe plus commune d'un opérateur du préprocesseur est : #include

MikroC compilateur prend en charge les commandes de préprocesseur suivantes: #define #if #ifdef #error #ligne

#undef #elif #ifndef

#endif

Commande du préprocesseur #define La commande préprocesseur #define fournit une macro où chaque apparition de son nom dans le programme est remplacé par la valeur de ce nom. Par exemple, pour remplacer toutes les apparitions de MAX avec une valeur de 100, nous pouvons écrire: #define MAX 100 Notez que la commande préprocesseur #define n’occupe pas l’espace en mémoire. Nous pouvons passer des paramètres à une définition de macro en précisant les paramètres entre les parenthèses après le nom de la macro. Par exemple : #define ADD (a, b) (a + b) - 39 -


Lorsque cette macro est utilisée dans un programme, (a, b) sera remplacé par (a + b) comme indiqué ci-dessous : p = ADD (x, y) sera transformé en p = (x + y) De même, nous pouvons définir une macro pour calculer le carré de deux nombres : #define CARRE (a) (a * a) Nous pouvons maintenant utiliser cette macro dans un programme : p = CARRE (x) sera transformé en p = (x * x) Commande du préprocesseur #include La commande #include est utilisé pour inclure un fichier source dans un programme. Habituellement les fichiers avec l'extension ". H" sont utilisés avec #include. Il y a deux formats pour l'utilisation de #include: #include et #include "fichier" Dans la première option le fichier est recherché d'abord dans le répertoire d'installation mikroC, puis dans les chemins de recherche des utilisateurs. En seconde option le fichier spécifié est recherché dans le dossier de projet mikroC , puis dans le dossier d'installation mikroC, puis dans les chemins de recherche des utilisateurs. Il est également possible de spécifier un chemin de répertoire complet : #include "C: \ temp \ last.h" Le dossier dans ce cas n’est recherché que dans le chemin du répertoire spécifié.

Commande du préprocesseur #if, #elif, #else, #endif Les commandes préprocesseur #if, #elif, #else et #endif sont utilisée pour les compilations conditionnelles, où certaines parties du code-source peut être compilée si certaines conditions sont remplies. Dans l'exemple suivant, si M a une valeur différente de zéro la section de code où les variables A et B sont mis à zéro est établi, sinon la section de code où A et B sont tous les deux à 1 est compilé. Notez que le #if doit se terminer par #endif:

#if M A = 0; B = 0; #else A = 1; B = 1; #endif - 40 -


Nous pouvons également utiliser la condition #elif, qui teste une nouvelle condition si la condition précédente était fausse : #if M A = 0; B = 0; #elif N A = 1; B = 1; #else A = 2; B = 2; #endif Dans l'exemple ci-dessus, si M a une valeur différente de zéro, A = 0 ; B = 0. Sinon, si N est une valeur non nulle, A = 1; B = 1. Enfin, si à la fois M et N sont égaux à zéro, alors A = 2 ; B = 2. Notez qu’une seule section de code est compilé entre #if et #endif et qu'une section de code peut contenir n'importe quel nombre d’instructions.

2.2.13 Structure de contrôle de programme Les instructions sont normalement exécutées séquentiellement à partir du début à la fin d’un programme. Nous pouvons utiliser des instructions de contrôle pour modifier ce flux séquentiel normal dans un programme C. Les instructions de contrôle suivantes sont disponibles dans les programmes en mikroC: De sélection if et switch D'itération ou bouclage for Modifications inconditionnels d’exécution Instructions de sélection if et switch  Instruction if Cette instruction conditionnelle if permet d’exécuter des instructions de manière sélective en fonction du résultat d’un test. La déclaration du format général de l'instruction if est la suivante : if (expression) instruction1 else instruction2 ou if(expression) instruction1; else instruction2; Si l’expression est vraie (valeur non nulle), l’instruction1 s’exécute sinon, dans le deuxième cas, c’est l’istruction2 qui s’exécute. - 41 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Le mot-clé else est optionnel et peut être omis. Dans l'exemple suivant, si la valeur de x est supérieure à MAX alors la variable P est incrémentée de 1, sinon elle est décrémenté de 1: if (x > MAX) P++; else P--; Nous pouvons avoir plus d'une instruction en joignant les déclarations dans bouclés entre parenthèses. Par exemple: if (x> MAX) { P++; Cnt = P; Sum = Sum = Cnt; } else P--; Dans cet exemple, si x est supérieur à MAX, donc les trois instructions bouclés entre les parenthèses sont exécutés, sinon la déclaration P-- est exécuté. Un autre exemple en utilisant l'instruction if est la suivante:

if (x> 0 && x <10) { Total + = Sum; Sum++; } else { Total = 0; Sum = 0; }



Instruction switch

L'instruction switch (commutateur) est utilisé pour assurer le commutation entre des déférentes déclarations si un certain nombre des conditions son vraie ou faut. La syntaxe de commutation : switch (condition) { case condition1: Instructions; break; case condition2: Instructions; break; . . . . . . . . . . . . . . . . . . . . .

- 42 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC . . . . . . . . . . . . . . . . . . . . . case condition: Instructions; break; default: Instructions; }

L’instruction switch fonction comme suit : d'abord la condition est évaluée. La condition est ensuite comparée à condition1 et si une correspondance est trouvée, les déclarations contenues dans ce bloc sont évalués. Puis s’effectuer le saut de contrôle en dehors de l'instruction switch lorsque le mot break est rencontré. Si la condition ne se trouve pas, la condition est comparée à condition2 et si une correspondance est trouvée, les déclarations de ce bloc sont évaluées et le saut de contrôle dehors d’états de commutation s’effectuer, et ainsi de suite. Lavaleur par défault est facultative, si la condition ne correspond à aucune des conditions spécifiées. Dans l'exemple suivant, la valeur de la variable est évalué Cnt. Si Cnt = 1, A est mis à 1. Si Cnt = 10, B est mis à 1, et si Cnt = 100, C est mis à 1. Si Cnt n'est pas égal à 1, 10,ou100, donc D est fixé à 1:

switch (Cnt) { case 1: A=1; break; case 10: B=10 ; break ; case 100: C=100; break; default: D =1; }

Puisque les espaces blancs sont ignorés en langage C, nous pouvons également écrire le code précédent comme suit: switch (Cnt) { case 1: A case 10: B case 100: C défault: D }

= = = =

1; 1; 1; 1;

break; break; break;

- 43 -


Instructions d'itération for, while, do, goto, continue et break Les instructions d'itération nous permettent d'effectuer des boucles dans un programme, où une partie d'un code doit être répété un certain nombre de fois. Dans mikroC l'itération peut être effectuée de quatre façons. Nous se penchera sur chacun des exemples :    

Utilisation de for Utilisation de while Utilisation de do Utilisation de goto, continue et break

Instruction for La syntaxe d'une instruction for est : for (expression initiale; expression de condition; expression incrément) { Instructions;

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

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

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

- 44 -


Dans l'exemple suivant d'une boucle sans fin où tous les paramètres sont omis : // Exemple de boucle sans fin for (;;) { Instructions; }

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

S’il n'y a qu'une seule instruction à l'intérieur de la boucle for, les accolades peuvent être omises comme c’est montré dans l'exemple suivant : for (k = 0; k <10; k++) Total = Total + Sum; Les boucles imbriquées peuvent également être utilisés. Dans une boucle for imbriquée, la boucle intérieure est exécutée pour chaque itération de la boucle externe. Dans l'exemple suivant la boucle interne est exécutée 5 fois et la boucle extérieure est exécutée 10 fois. Le nombre d’itérations totales est de cinquante : // Exemple de deux boucles imbriquées for (i = 0; i < 10; i++) { for (j = 0; j < 5; j++) { Instructions; } }

Dans l'exemple suivant, la somme de tous les éléments d'un matrice M [3 x 4] est calculée et stockées dans une variable appelée Sum : // Ajouter tous Sum = 0; for (i = 0; i < { for (j = 0; j { Sum = Sum + } }

les éléments d'une matrice 3x4 3; i++) < 4; j++) M[i][j];

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

- 45 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC { for (j = 0; j < 4; j++) Sum = Sum + M[i][j]; }

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

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

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

Voici un exemple de calcul de la somme des nombres de 1 à 10 et le stockage du résultat d'une somme variable appelée sum :

- 46 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC // Calculer la somme des nombres de 1 à 10 unsigned int k, sum; k = 1; sum = 0; while (k <= 10) { sum = sum + k; k++; }

Il est possible d'avoir une déclaration while sans corps. Une telle déclaration est utile, pour par exemple, si nous attendons un port d'entrée pour changer sa valeur. Voici un exemple où le programme va attendre aussi longtemps que le bit 0 de PORTB (PORTB.0) est au niveau logique 0. Le programme se poursuivra jusqu’au changement à la valeur logique 1 sur les broches du port. while (PORTB.F0 == 0); // Attendre jusqu'à ce que PORTB.0 devient un ou while (PORTB.F0); Instruction do Une déclaration do est similaire à une déclaration while sauf ce que la boucle exécute jusqu'à ce que la condition devient fausse, ou, la boucle s'exécute tant que la la condition est vraie. La condition est testée à la fin de la boucle. La syntaxe d'une déclaration do est la suivante : do { Instructions; } while (condition); La première itération est toujours effectuée si la condition est vraie ou fausse. Il s'agit de la principale différence entre une déclaration while et une déclaration do. Le code suivant montre comment mettre en place une boucle d'exécuter 10 fois en utilisant la déclaration do /*Exécute 10 fois */ k = 0; do { Instructions; k++; } while (k <10);

La boucle commence avec k = 0, et la valeur de k est incrémenté intérieur de la boucle après chaque itération. À la fin de boucle k est testé, et si k n'est pas inférieur à 10, la boucle termine. Dans cet exemple k = 0 au début de la boucle, à la fin de la boucle la valeur de k est 10. Une boucle sans fin sera formée si la condition n'est pas modifiée à l'intérieur de la boucle, comme est illustré dans l'exemple ci-dessous. Ici k est toujours inférieur à 10 :

- 47 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC /*Une boucle sans fin*/ k = 0 ; do { Instructions; } while (k < 10);

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

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

La boucle commence par l’étiquette Boucle et la variable k = 0. Les instructions sont exécutées à l'intérieur de la boucle et k est incrémenté de 1. La valeur de k est alors comparé à 10 et le programme retourne à l’étiquette Boucle si k <10. Ainsi, la boucle est exécutée 10 fois jusqu'à ce que la condition à la fin devienne fausse. À la fin de la boucle la valeur de k est 10. Les instructions continue et break peuvent être utilisés à l'intérieur d’itérations pour modifier le flux de commande. Une instruction continue est généralement utilisée avec une instruction if et provoque le saut de la boucle d’itération. Voici un exemple qui calcule la somme des nombres de 1 à 10, sauf le nombre 5:

- 48 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC /* Calculer la somme des nombres 1,2,3,4,6,7,8,9,10 */ Sum = 0; i = 1; for (i = 1; i <= 10; i++) { if (i == 5) continue; // Passer numéro 5 Sum = Sum + i; }

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

2.2.14 Utilisation mikroC avec des instructions en langage d’assembleur Il devient parfois nécessaire d’utiliser la langue assembleur pour microcontrôleurs PIC et des instructions en langage mikroC. Des instructions en langage assembleur peuvent être incluses dans un programme en utilisant mot-clé asm (ou _asm, ou __ asm). La syntaxe est la suivante: asm { Instructions } Commentaires du langage d’assembleur (une ligne commençant par un point-virgule) ne sont pas autorisés, mais les deux types de commentaires en microC peuvent être utilisés dans les routines en langage d'assembleur : asm { // Ce code introduit un temporisation MOVLW 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

// Charge W avec 6

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

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC unsigned char Temp = 10; asm { MOVLW Temp // W = Temp =10 . . . . . . . . . . . . . . . . . . }

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; PORTB = 0xFF; }

// Configurer PORTB en sortie // 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; PORTB = 0xAA; }

// Configurer PORTB en sortie // 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 -


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 (;;) { PORTB = Cnt; Cnt++; } }

// Boucle sans fin // Envoyer Cnt à PORTB // 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++) { PORTB = 0xFF; PORTB = 0; } }

// Répéter 10 fois // Mettre les bits de PORTB à 1 // Mettre les bits de PORTB à 0

- 51 -


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]; for (j = 1; j < 10; j++) { if (A [j]> m) m = A [j]; } }

// Premier élément du tableau

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

La température équivalente en °F, est calculée selon la formule: °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 -


III. FONCTIONS ET BIBLIOTHEQUES DANS MIKROC 3.1 Fonctions dans mikroC Les fonctions sont généralement définies comme des sous-programmes qui renvoient une valeur fondée sur un certain nombre de paramètres d'entrée. Chaque programme doit avoir une seule fonction externe marquant le point d'entrée dans le programme principale. Les fonctions sont déclarés comme des prototypes en standard ou fourni par l'utilisateur, ou par des fichiers du programme. Chaque programme écrit en langage mikroC se compose de nombre plus ou moins de fonctions. L'idée principale est de diviser un programme en plusieurs parties qui utilisent ces fonctions afin de résoudre le problème réel plus facile. En outre, les fonctions nous permettent d'utiliser les compétences et les connaissances d'autres programmeurs. Par exemple, s’il est nécessaire d'envoyer une chaîne de caractères à un écran LCD, il est beaucoup plus facile d'utiliser une partie déjà écrite du programme que de recommencer. Les fonctions consistent des commandes précisant ce qui doit être fait sur des variables. Elles peuvent être comparées à des sous-routines. En règle générale, il est beaucoup mieux d'avoir un programme composé d'un grand nombre de fonctions simples que de quelques fonctions importantes.

3.1.1 Déclaration d’une fonction Chaque fonction doit être déclarée de manière à être correctement interprété au cours du processus de compilation. Déclaration contient les éléments suivants:     

Nom de la fonction Liste des paramètres Déclaration des paramètres Corps de la fonction Type de résultat de la fonction

La syntaxe générale d'une définition de fonction est montrée ci-dessous : type_de_résultat nom_fonction(parameter1, parameter2, .....) { ............. corps de la fonction ............. }

Dans l’exemple qui suit, la fonction, nommée Mult, reçoit deux arguments entiers, a et b, et renvoie leur produit. Notez que l'utilisation des parenthèses dans une instruction de retour est facultative : int Mult(int a, int b) { return (a*b); }

Quand une fonction est appelée, elle s'attend généralement à donner le nombre d'arguments exprimés en liste d'arguments de la fonction. Par exemple, la fonction précédente peut être appelée : - 54 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC z = Mult (x, y); où la variable z est le type de données int. Notez que les arguments déclarés dans la définition de la fonction et les arguments passés lorsque la fonction est appelée sont indépendants les uns des autres, même si elles ont le même nom. Dans l'exemple précédent, lorsque la fonction est appelée, variable x est copié à a et variable y et est copiée à b sur entrée en fonction Mult. Certaines fonctions ne renvoient pas de données. Le type de données de ces fonctions doit être déclarées comme nul. Par exemple void LED(unsigned char D) { PORTB = D; }

Fonctions void peut être appelée sans aucune instruction d'affectation, mais les parenthèses sont nécessaire pour indiquer au compilateur que un appel de fonction est faite: LED (); En outre, certaines fonctions ne possèdent pas d'arguments. Dans l'exemple suivant, la fonction, nommée Compl, complète PORTC du microcontrôleur. Il ne renvoie pas de données et n'a pas d'arguments: void Compl() { PORTC = PORTC; }

Cette fonction peut être appelée en tant que : Compl (); Les fonctions sont normalement définies avant le début du programme principal. Certaines définitions de fonction et de leur utilisation dans les programmes principaux sont illustrées dans les exemples suivants: Exercice 3.1 Écrire une fonction appelée Cercle_Surface pour calculer la surface d'un cercle dont le rayon sera utilisé comme un argument. Utilisez cette fonction dans un programme principal pour calculer la surface d'un cercle dont le rayon est de 2,5 cm. Sauvegarder la valeur de cette surface dans une variable appelée Cercle.

Solution 3.1 Le type de données de la fonction est déclaré comme float. La surface d'un cercle est calculée par la formule : - 55 -

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 appelée s, qui est ensuite retournée par la fonction :

locale

float Cercle_Surface(float rayon) { float s; s = PI*rayon*rayon; return s ; }

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 float Cercle_Surface (float rayon) { float s; s = PI*rayon*rayon; return s; } /* Début du programme principal. Calcul de la surface d'un cercle où le rayon = 2,5 */ void main () { float r, Cercle; r = 2.5; Cercle = Cercle_Surface(r); }

- 56 -


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 La surface d'un cylindre est calculée par la formule: Surface = 2πrh où r et h sont le rayon et la hauteur du cylindre, respectivement. Le volume d'un cylindre est calculé par la formule: Volume = πr2h Le code-source 3.2 montre les fonctions qui calculent la surface et le volume d'un cylindre et le programme principal qui calcule la surface et le volume d'un cylindre dont le rayon = 2,0cm et 5,0cm de hauteur.

Exercice 3.3 Écrire une fonction appelée Minuscule_Majuscule pour convertir un caractère de minuscule en majuscule.

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 -


Solution 3.4 Le programme requis est indiqué dans le code-source 3.4. La fonction Minuscule_Majuscule est appelée pour convertir le caractère en minuscule de la variable Lc en majuscules et de stocker dans la variable Uc.

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 float Surface(float rayon, float hauteur) { float s; s = 2.0*PI*rayon*hauteur; return s; } // Fonction pour calculer le volume d'un cylindre float Volume(float rayon, float hauteur) { float s ; s = PI*rayon*rayon*hauteur; return s; } // Début du programme principale 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 *************************************************************************/ /* Fonction pour convertir un caractère en minuscule dans un caractère en majuscule*/ unsigned char Minuscule_Majuscule (unsigned char c) { if(c > ='a' && c <= 'z') return(c - 0x20); else return c; } // Début du programme principal void main () { unsigned char Lc, Uc; Lc = ‘r’; Uc = Minuscule_Majuscule (Lc); }

3.1.2 Prototypes de fonctions 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 : float Area(float rayon); Ce prototype de fonction pourrait également être déclaré comme suit : float Area (float); 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 unsigned { if (c> return else return }

char Minuscule_Majuscule(unsigned char c) = 'a' && c <= 'z') (c - 0x20); c;

// Début du programme principal 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 Le code-source 3.5 présente le programme où la fonction Minuscule_Majuscule est déclarée comme un prototype de fonction au début du programme. Dans cet exemple, la fonction réelle est écrite après le programme principal. Un avantage important de l'utilisation des prototypes de fonction, c'est que si le prototype de fonction ne correspond pas à la définition de la fonction réelle, mikroC va détecter et modifier les types de données dans l'appel de fonction pour faire correspondre les types de données déclarés dans le prototype de fonction.

- 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); // Début du programme principal void main () { unsigned char Lc, Uc; Lc = ‘r’; Uc = Minuscule_Majuscule (Lc); } // Fonction pour convertir un caractère de minuscule en majuscule unsigned { if (c> return else return }

char Minuscule_Majuscule (unsigned char c) = 'a' && c <= 'z') (c - 0x20); c;

Supposons que nous ayons le code suivant : unsigned char c = ‘A’; unsigned int x = 100; long Tmp; long MaFonc(long a, long b); void main () { . . .. . .. . .. . .. . . . . .. . .. . .. . .. . . Tmp = MaFonc(c, x); . . .. . .. . .. . .. . . . . .. . .. . .. . .. . . }

// prototype de fonction

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 -


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

Voici un exemple de fonction qui dépend des effets secondaires plutôt que de la valeur de retour : /* Fonction qui convertit coordonnées Descartes (x, y) en coordonnées polaires (r, fi): */ #include voide polaire (double x, double y, double *r, double *fi) { *r = sqrt (x * x + y y *); *fi = (x == 0 && y == 0)? 0: atan2 (y, x); return; // cette ligne peut être omise }

3.1.3 Appels de fonctions Une fonction est appelée avec des arguments réels placés dans la même séquence que leur correspondant paramètres formels. Utilisez un opérateur d'appel de fonction () : fonction_nom (expression_1, expression_2, ..., expression_n) Chaque expression dans l'appel de fonction est un argument réel. Nombre et types des arguments réels doivent correspondre à ceux des paramètres de fonctions formelles. Arguments réels peuvent être de n'importe quelle complexité. Sur l’appel de fonction, tous les paramètres formels sont créés en tant qu'objets locaux initialisé par des valeurs d'arguments réels. De retour d'une fonction, l’objet temporaire est créé à la place de l'appel, et il est initialisé par l'expression de la déclaration de retour. Cela signifie que l'appel de fonction comme un opérande de l'expression complexe est traitée en résultat de fonction. - 62 -

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.

3.1.4 Conversion argument Quand un prototype de la fonction n'a pas été préalablement déclaré, mikroC convertit arguments intégraux à un appel de fonction de l'élargissement intégrante (l'expansion) Quand un prototype de fonction est en portée, mikroC convertit l'argument donné par le type de paramètre déclaré comme par affectation. Si un prototype est présent, le nombre d'arguments doivent correspondre. Les types doivent être compatibles uniquement dans la mesure où une cession peut également les convertir. Vous pouvez toujours utiliser une conversion explicite pour convertir un argument pour un type qui est acceptable à un prototype de fonction. Remarque : Si le prototype de fonction ne correspond pas à la définition de la fonction réelle, mikroC permet le détecter si et seulement si cette définition se trouve dans la même unité de compilation comme le prototype. Le compilateur est aussi capable de forcer les arguments du type approprié. Supposons que vous ayez le code qui suit : int limit = 32; char ch = 'A'; long res; extern long fonc(long par1, long par2);

// prototype

main () { //... // fonction call (appeler)

res = fonc(limit, ch); }

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

- 63 -


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

Fonction Lo

Renvoie le plus faible nombre d'octets (bits 0 à 7)

Hi

Renvoie le plus faible nombre d'octets (bits 8 à 15)

Higher

Renvoie le plus élevée d'octet d'un nombre (bits 16 à 23)

Highest

Retourne le plus grand d'octets d'un nombre (bits 24 à 31)

Delay_us

Crée le retard dans les unités de microseconde

Delay_ms

Crée le retard constante dans les unités de millisecondes

Vdelay_ms

Crée le retard en millisecondes en utilisant des variables de programme

Delay_Cyc

Crée le retard basé sur l'horloge de microcontrôleur

Clock_Khz

Régler l’horloge de microcontrôleur en KHz

Clock_Mhz

Régler l’horloge de microcontrôleur en MHz

Les exceptions sont des fonctions Lo, Hi, Higher, et Highest, qui exigent le fichier d’en-tête built_in.h. De plus détails sur l'utilisation de ces fonctions sont disponibles dans le manuel de mikroC. Delay_us et delay_ms fonctions sont fréquemment utilisés dans les programmes où les retards sont requis (par exemple, se met à clignoter une LED). L'exemple suivant illustre l'utilisation de la fonction Delay_ms :

Exercice 3.6 Une LED est connectée au PORTB (broche RB0) d'un microcontrôleur PIC16F84A à travers d’une résistance de limitation, comme indiqué dans la figure 3.1. Ecrire un programme qui fera clignoter le LED ON et OFF en permanence dans l’intervalle d'une seconde.

- 64 -


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) Fig.3.1 LED connectée au port RB0 d'un microcontrôleur PIC

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.

3.3 Fonctions de la bibliothèque mikroC Un vaste ensemble de fonctions de la bibliothèque est disponible avec le compilateur mikroC. Ces fonctions de la bibliothèque peuvent être appelées à partir de n'importe quel programme, et ils sont inclus dans le programme. Le manuel d'utilisation mikroC donne une description détaillée de chaque fonction de la bibliothèque, avec des exemples. Dans cette partie, les fonctions de la bibliothèque disponibles sont identifiées, et les fonctions de la bibliothèque importante et couramment utilisés sont décrites dans détail, avec des exemples. - 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; for(; ;) { LED = ON; One_Second_Delay; LED = OFF; One_Second_Delay; } }

// PORTB est configuré en sortie // Boucle sans fin // // // //

LED est Retard LED est Retard

allumée (ON) 1 seconde désactivée (OFF) 1 seconde

Tableau 3.2: Bibliothèque mikroC Bibliothèque ADC CAN CANSPI Compact Flash EEPROM EthernetPIC18FxxJ60 Flash Memory Graphics LCD T6963C Graphics LCD I2C Keypad LCD Manchester Code Multi Media One Wire PS/2 PWM RS-485 Sound SPI UART SPI Graphics LCD

Description Utilisé pour conversion analogique/numérique Utilisé pour le fonctionnement avec le module CAN Utilisé pour le fonctionnement avec le module extern CAN Utilisé pour les operations avec les cartes mémoire Compact Fash Utilisé pour les operations avec la mémoire EEPROM Utilisé pour les operations avec le module Ethernet Utilisé pour le fonctionnement avec mémoire integé Flash Utilisé pour le fonctionnement avec module LCD graphique avec une résolution de 128x64 Utilisé pour la communication avec module LCD graphiques T6963 Utilisé pour la simulation du protocole I2C Utilisé pour les operations avec le clavier Utilisé pour le fonctionnement avec LCD standard Utilisé pour les communication à l’aide du code de Manchester Utilisé pour les operation avec les cartes multimedia flasch MMC Utilisé pour le bus 1-Wire Utilisé pour les operations avec le clavier PS/2 standard Utilisé pour les operations avec le module de PWM Utilisé pour les operations avec les modules à la communication série RS-485 Utilisé pour le fonctionnement du module sonore Utilisé pour les operations avec le module SPI Utilisé poue les operations avec le module de UART Utilisé pour la communication avec SPI graphique LCD

3.3.1 Bibliothèque EEPROM 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: Temp = Eeprom_Read (0x1F); La fonction Eeprom_Write écrit un octet à 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 plus de 256 octets. Un retard de 20 ms doit être utilisé entre écritures successives dans la mémoire EEPROM pour garantir le transfert correct de données dans la mémoire EEPROM. Dans l'exemple suivant, le nombre 0x05 est écrit à l'adresse 0x2F de l'EEPROM : Eeprom_Write (0x2F, 0x05);

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; TRISB = 0; for(j=0; j <= 0x2F; j++) { Temp = Eeprom_Read(j); PORTB = Temp; Delay_ms(20); }

// PORTB est configuré en sortie

}

- 68 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC 3.3.2 Bibliothèque pour LCD La programmation en assembleur d'un écran LCD en mode parallèle ou en série est généralement une tâche complexe et nécessite d’une bonne compréhension du fonctionnement interne de l'écran LCD. La langue mikroC fournit des fonctions pour les deux modes de programmation basée sur le texte déjà préparé, ce qui simplifie l'utilisation d'écrans LCD.

Le contrôleur LCD HD44780 Le HD44780 est l'un des contrôleurs de cristaux liquides les plus appréciés, étant utilisé dans l'industrie et dans les applications commerciales. Le module est monochrome et vient dans différentes formes et tailles. Des modules avec 8, 16, 20, 24, 32 et 40 caractères sont disponibles. Selon le modèle, l'écran LCD est fabriqué avec 14 ou 16 pattes pour l'interface. Le tableau 3.3 présente la configuration des pattes et les fonctions des pattes d’un LCD à 14 pattes. La patte VSS est à 0V ou du sol. La patte VDD doit être connecté à la borne positive d’alimentation. Bien que les fabricants spécifient une alimentation 5V DC, les modules travaillent habituellement aussi avec une alimentation un peu bas que 3V ou aussi haut que 6V. La patte 3 VEE est désigné pour réglage du contraste de l'affichage et doit être reliée à une alimentation en courant continu. Un potentiomètre est généralement connecté à l'alimentation avec son curseur raccordé à la patte VEE et l'autre patte du potentiomètre relié à la masse. De cette façon la tension à la patte VEE, et où le contraste de l'affichage, peut être réglée à volonté. La patte 4 est le registre de sélection (RS) et lorsque cette patte à 0 V, les données sont transférés à l'affichage à cristaux liquides. Lorsque RS est à +5 V, les données de caractères peuvent être transférés à partir du module LCD. La patte 5 est le registre de sélection de lecture / écriture (R / W). Cette patte est reliée avec la masse (état logique bas) afin d'écrire des données de caractères au module LCD. Lorsque cette broche est à +5 V (états logique haut) donc les informations sortants du module LCD peuvent être lues. La patte 6 est la validation (EN), qui est utilisé pour initier le transfert de commandes ou de données entre le module et le microcontrôleur. Lors de l'écriture à l'écran, les données sont transférés uniquement sur le front descendant (haut-bas) sur cette patte. Lors de la lecture de l’affichage, les données deviennent accessibles après le front montant (bas-haut) de la patte de validation, et ces données demeurent tant que la patte de validation est au niveau logique haut.

Les broches 7 à 14 sont les huit lignes de bus de données (D0 à D7). Les données peuvent être transférées entre le microcontrôleur et le module LCD à l'aide soit d'un seul octet de 8 bits soit de deux 4-bits. Dans ce dernier cas, seuls les quatre lignes de données supérieures (D4 à D7) sont utilisées. Le 4-bits mode a l'avantage de nécessiter moins de lignes d'E / S pour communiquer avec l'écran LCD. - 69 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Tableau 3.3 : Les pattes du module LCD HD44780 Broche N°

Appellation

Fonction

1

VSS

Ground

2

VDD

+ve supply

3

VEE

Contrast

4

RS

Register select

5

R/W

Read/write

6

EN

Enable

7

D0

Data bit 0

8

D1

Data bit 1

9

D2

Data bit 2

10

D3

Data bit 3

11

D4

Data bit 4

12

D5

Data bit 5

13

D6

Data bit 6

14

D7

Data bit 7

Le mikroC LCD bibliothèque fournit un grand nombre de fonctions pour contrôler du texte LCD avec 4-bits et les interfaces de données 8-bit, et pour les graphiques LCD. La plus courante sont les 4-bit interface en mode texte sur écran LCD. Ce qui suit sont les fonctions disponibles pour LCD 4-bit interface en mode texte LCD :       

Lcd_Config Lcd_Init Lcd_Out Lcd_Out_Cp Lcd_Chr Lcd_Chr_Cp Lcd_Cmd

 Lcd_Config La fonction Lcd_Config est utilisée pour configurer l'interface LCD. La connexion par défaut entre le LCD et le microcontrôleur est la suivante : LCD

Patte du port de microcontrôleurs - 70 -


RS FR D4 D5 D6 D7

→ → → → → →

2 3 4 5 6 7

La patte R / W de l'écran n'est pas utilisé et doit être reliée à la masse. Cette fonction devrait être utilisée pour modifier la connexion par défaut. Il devrait être appelé avec les paramètres dans l'ordre suivant : nom de port, RS patte, EN patte, R/W patte, D7 patte, D6 patte, D5 patte, D4 patte Le nom du port doit être spécifié en passant son adresse. Par exemple, si RS patte est connectée à RB0, EN patte à RB1, D7 patte à RB2, D6 patte à RB3, D5 patte à RB4, et D4 patte à RB5, alors la fonction doit être appelée comme suit : Lcd_Init La fonction Lcd_Init est appelée pour configurer l'interface entre le microcontrôleur et l'écran LCD lorsque les connexions sont faites par défaut que vient d'être illustré. Le nom du port doit être spécifié en passant son adresse. Par exemple, en supposant que LCD est reliée à PORTB et les connexions par défaut précédentes sont utilisées, la fonction doit être appelée en tant que : Lcd_Init();  Lcd_Out La fonction Lcd_Out affiche du texte à la ligne indiquée et la position des colonnes de l'écran LCD. La fonction doit être appelée avec des paramètres dans l'ordre suivant : ligne, colonne, texte Par exemple, pour afficher du texte "Ordinateur" à la ligne 1 et la colonne 2 de l'écran LCD nous devrions appeler la fonction comme suit : Lcd_Out (1, 2, "Ordinateur");

 Lcd_Out_Cp La fonction Lcd_Out_Cp affiche le texte à la position actuelle du curseur. Par exemple, pour afficher le texte "Ordinateur" à la position actuelle du curseur, la fonction devrait être appelé en tant que : Lcd_Out_Cp ("Ordinateur"); Lcd_Chr La fonction Lcd_Chr affiche un caractère à la ligne indiquée et la colonne la position du curseur. La fonction doit être appelée avec les paramètres dans le l'ordre suivant : - 71 -


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

Commande LCD LCD_CLEAR

Effacer l'affichage

LCD_RETURN_HOME

Retourner vers la position du curseur

LCD_FIRST_ROW

Déplacer le curseur vers la première ligne

LCD_SECOND_ROW

Déplacer le curseur vers la deuxième ligne

LCD_THIRD_ROW

Déplacer le curseur vers la troisième ligne

LCD_FOURTH_ROW

Déplacer le curseur vers la quatrième ligne

LCD_BLINK_CURSOR_ON

Clignotement du curseur

LCD_MOVE_CURSOR_LEFT

Déplacer le curseur à gauche

LCD_MOVE_CURSOR_RIGHT

Déplacer le curseur à droite

LCD_SHIFT_LEFT

Décaler l'affichage à gauche

LCD_SHIFT_RIGHT

Décaler l'affichage à droite

Un exercice ci-dessous illustre l'initialisation et l'utilisation de l'écran LCD. - 72 -


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. Ecrire un programme pour envoyer le texte Mon Ordinateur à la ligne 1, à la colonne 4 de l’écran LCD.

Solution 3.8 Le programme est donné dans le code-source 3.9 (fichier : LCD.C). 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 sbit sbit sbit sbit sbit sbit

LCD_RS LCD_EN LCD_D4 LCD_D5 LCD_D6 LCD_D7

at at at at at at

sbit sbit sbit sbit sbit sbit

LCD_RS_Direction LCD_EN_Direction LCD_D4_Direction LCD_D5_Direction LCD_D6_Direction LCD_D7_Direction

RB4_bit; RB5_bit; RB0_bit; RB1_bit; RB2_bit; RB3_bit; at at at at at at

TRISB4_bit; TRISB5_bit; TRISB0_bit; TRISB1_bit; TRISB2_bit; TRISB3_bit;

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

3.3.3 Bibliothèque pour UART (réalisation Software) L’émetteur-récepteur asynchrone universel (UART) - 74 -

est un logiciel de bibliothèque


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

IDLE

0

STOP

1

0

0

0

0

0

0

START

Fig. 3.3 Envoi un caractère "A" par la communication série Comme montre cette figure, le premier bit de départ est envoyé, cela est suivi par 8 bits de données 01000001, et enfin le bit d'arrêt est envoyé. Le rythme binaire est très important dans la communication de série, et la transmission (TX) et réception (Rx) dispositifs doivent avoir la même rythme de bits. Le rythme binaire est mesuré par la vitesse de transmission, qui spécifie le nombre de bits transmis ou reçus par seconde. Les vitesses typiques de transmission sont : 4800, 9600, 19200, 38400, et ainsi de suite. Par exemple, lorsque exploitation à 9600 bauds avec une taille d'image de 10 bits, 960 caractères sont transmis ou reçus par seconde. La synchronisation entre les bits est alors d'environ 104ms. En RS232, basée sur la communication en série, les deux périphériques sont connectés les uns aux autres (voir figure 3.4) en utilisant soit un connecteur à 9 voies ou d'un connecteur à 25 voies. Normalement, seul le Broches TX, RX et GND sont nécessaires pour la communication. Les pattes nécessaires pour deux types de connecteurs sont données dans le tableau 3.5.

Fig. 3.4 Les connecteurs RS232 Les niveaux de tension spécifiés par le protocole RS232 sont ± 12V. Un signal logique HIGH (haut) est à - 12V et un signal logique LOW (bas) est à + 12V. Les microcontrôleurs PIC, fonctionnent normalement à des niveaux de tension : 0 et 5 V. Donc les signaux pour RS232 doivent être convertie pour l'entrée d'un microcontrôleur. De même, la sortie du microcontrôleur - 75 -

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 La fonction UART1_Init spécifie les paramètres de communication série et le fait dans l'ordre suivant : port, rx patte, tx patte, vitesse de transmission, mode Ici : port est le port utilisé comme UART logiciel (par exemple, PORTB) ; rx est le receveur d’un nombre de transmission ; tx est l’émméteur de transmission ; vitesse de transmission est le taux de transmission choisi, où la valeur maximale dépend de la fréquence d'horloge du microcontrôleur ; mode spécifie si les données devraient être inversés ou non lors de la sortie. Un 0 indiquent qu’ils ne devraient pas être inversés, et un 1 indique qu'ils devraient être inversés. Quand un RS232 est utilisé donc dans ce cas le mode doit être réglé à 1. Soft_Uart_Init doit être la première fonction appelée avant que le logiciel soit établié. L'exemple suivant configure l'UART à utiliser PORTC comme un port série, avec RC6 pour la patte TX et RC7 pour la patte RX. La vitesse de transmission est fixé à 9600 avec le mode non inversés: - 76 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Soft_Uart_Init (PORTB, 0, 1, 9600, 0); 

Soft_Uart_Read

La fonction Soft_Uart_Read reçoit un octet à partir d'une patte du port série spécifié. La renvoie une condition d'erreur et les données sont lues à partir du port série. La fonction ne pas attendre que les données soient disponibles sur le port, et donc le paramètre d'erreur doit être testé si un octet est prévu. L'erreur est normalement de 1 et devient 0 quand un octet est lu à partir du port. L'exemple suivant illustre la lecture d'un octet à partir du port configuré en série en appelant la fonction Soft_Uart_Init. L'octet reçu est stocké dans une variable Temp: do Temp = Soft_Uart_Read(&Rx_Error); while (Rx_Error);  Soft_Uart_Write La fonction Soft_Uart_Write transmet un octet à une patte de port configuré en série. Les données à envoyer doivent être spécifiés comme un paramètre dans l'appel de la fonction. Par exemple, pour envoyer un caractère "A" à la patte de port série : char MyData = ‘A’; Soft_Uart_Write(MyData); L'exercice suivant illustre l'utilisation des fonctions du logiciel UART.

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

Solution 3.9 Le circuit MAX232 reçoit le signal TX de la patte RC6 du microcontrôleur et le convertit en niveaux RS232. Les données séries reçues du circuit MAX232 sont converties en niveaux de tension du microcontrôleur, puis envoyé à la patte RC7. Noter que le fonctionnement correct du circuit MAX232 nécessite quatre condensateurs à être connecté au circuit. - 77 -

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)

3.3.4 Bibliothèques standards ANSI C 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 Math Stdlib String

bibliothèque bibliothèque bibliothèque 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; ANSELH = 0; TRISC = 0x00; PORTC = 0;

// Configurer des pins AN en E/S numériques

// Configurer PORTC en sortie // No error

/* Initialiser Soft UART pour la vitesse de 9600 byts*/ error = Soft_UART_Init(&PORTC, 7, 6, 9600, 1); if (error > 0) { PORTC = error; while(1); } Delay_ms(100); while(1) {

// Signaler error d’Initialisation // Stop programme

// Boucle sans fin

/* Lire octet, puis tester un drapeau d'erreur */ byte_read = Soft_UART_Read(&error); if (error)

// Si l'erreur a été détectée

PORTC= error; else

// Envouer Le signale d’error sur le PORTC

/* Si l'erreur n'a pas été détectée, l'octet lu est en retoure */ Soft_UART_Write(byte_read); } }

- 79 -


Tableau 3.5 Fonctions de la bibliothèque Ctype Description

Fonction isalnum

Retourne 1 si le caractère spécifié est alphanumérique (a - z, A - Z, 0 - 9)

isalpha

Retourne 1 si le caractère spécifié est alphabétique ( a - z, A - Z)

isntrl

Retourne 1 si le caractère spécifié est un caractère de contrôle (décimale 0- 31 et 127)

isdigit

Retourne 1 si le caractère spécifié est un chiffre (0 - 9)

islower

Retourne 1 si le caractère spécifié est en minuscules

isprint

Retourne 1 si le caractère spécifié est imprimable (décimal 32 - 126)

isupper

Retourne 1 si le caractère spécifié est en majuscule

toupper

Convertir un caractère en majuscules

tolower

Convertir un caractère en minuscule



Bibliothèque Stdlib

La bibliothèque stdlib contient des fonctions de bibliothèque standard. Tableau 3.7 dresse la liste des fonctions les plus utilisées dans cette bibliothèque.

Fonction acos asin atan atan2 cos cosh exp fabs log Log10 pow sin sinh sqrt tan tanh

Tableau 3.6 Fonctions de la bibliothèque Math Description Retours en radians de l'arc cosinus de son paramètre Retours en radians de l'arc sinus de son paramètre Retours en radians de l'arc tangent de son paramètre Retours en radians de l'arc tangent de son paramètre où les signes des paramètres sont utilisés pour déterminer le quadrant du résultat Retourne le cosinus de son paramètre en radians Renvoie le cosinus hyperbolique de son paramètre Renvoie la valeur exponentielle de son paramètre Retourne la valeur absolue de son paramètre Retourne le logarithme naturel de son paramètre Retourne le logarithme en base 10 de son paramètre Retourne la puissance d'un nombre Retourne le sinus de son paramètre en radians Retourne le sinus hyperbolique de son paramètre Retourne la racine carrée de ses paramètre Retourne la tangente de son paramètre en radians Retourne la tangente hyperbolique de son paramètre en radians Tableau 3.7 Fonctions de la bibliothèque Stdlib - 80 -

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

Description

abs

Retourne la valeur absolue

atof

Convertit des caractères ASCII en nombre à virgule flottante

atoi

Convertit des caractères ASCII en nombre entier

atol

Convertit des caractères ASCII en entier long

max

Retourne le plus grand des deux nombres entiers

min

Retourne le plus petit de deux nombres entiers

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

xtoi

Convertir chaîne d'entrée constitué de chiffres hexadécimaux en entier

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); - 81 Trig_Sine[j] = angle; } }

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. Tableau 3.8 Fonctions de la bibliothèque String Description

Fonction strcat,strncat

Ajouter deux chaînes

strchr, strpbrk

Rechercher le premier caractère dans une chaîne

strcmp, strncmp

Comparer deux chaînes de caractères

strcpy, strncpy

Copier une chaîne de caractères dans une autre

strlen

Retourne la longueur d'une chaîne

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 Le programme requis est indiqué dans le code-source 3.12 (fichier JOIN.C). La mikroC bibliothèque String de la fonction strcat est utilisée pour joindre les deux chaînes pointées par p1 et p2 dans une nouvelle chaîne stockée dans un tableau de caractères appelée New_String. 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 3.3.5 Divers bibliothèques 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

ByteToStr

Convertir un octet en chaîne

ShortToStr

Convertir en une chaîne courte

WordToStr

Convertir un mot non signé en chaîne

IntToStr

Convertir un nombre entier en chaîne

LongToStr

Convertir en une longue chaîne

FloatToStr

Convertir un float en chaîne

Bcd2Dec

Convertir un nombre BCD en décimal

Dec2Bcd

Convertir un nombre décimal en BCD

- 83 -


IV. EXEMPLES DE PROGRAMMATION EN mikroC POUR LES MICROCONTROLEURS DE LA FAMILLE PIC

Exemple 1. Chenille à LEDs 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.

Fig.4.1. Schéma de simulation pour l’exemple 1 Le fichier désigné comme LED1.c et donné dans le code-source 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 } }

Exemple 2. Clignotement des LEDs à deux façons différentes 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 -


Fig.4.2. Schéma de simulation pour l’exemple 2

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; for(k=1; k<20; k++) { switch(PORTB) { case 0x00: PORTB = 0xFF; Delay_ms(500); break; case 0xFF: PORTB = 0x00;

- 86 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC 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 boutonpoussoir. 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; enum sortie {RELAI = 3}; ANSEL = 0; ANSELH = 0; PORTA = 0; TRISA = 0xFF; PORTD = 0; TRISD = 0b11110111; OPTION_REG.F5 = 1; OPTION_REG.F3 = 1; TMR0 = 0; do { if (TMR0 == TEST) (PORTD.RELAI = 1); } while (1);

// Constante TEST = 5 // Constante RELAI = 3 // Les E/S sont configurées en numériques // // // //

Initialisation du porte A Porte A est configuré en entré Initialisation du PORTD Broche 3 du PORTD3 est configuré en sortie

/* Conteur TMR0 reçoit des impulsions par la broche RA4 * / // Taux de prédiviseur est de 1:1 // Initialisation du compteur TMR0

/* Est-ce que le nombre d’impulsion TMRO est égale à constante TEST? */ /* Nombre est égale à TEST. La broche RD3 est en 1(RELAIS est activé) */ // Restez dans la boucle sans fin

}

Une selle constante énumérée RELAI est utilisée dans cet exemple. Il est attribué un valeur lorsqu’elle est déclarée : enum sortie {RELAI = 3};

Si plusieurs broches du PORTD sont reliées à des RELAIS, l’expression ci-dessus pourrait être écrite comme suit : enum sortie {RELAI=3, CHAFFAGE, ECLAIRAGE =6, POMPE} ;

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 -


Exemple 4. Registres TMR0 et TMR1 comme minuteries 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*/ TMR0 = 100; INTCON = 0x20; } void main() { OPTION_REG = 0x84; ANSEL = 0; ANSELH = 0; TRISB = 0; PORTB = 0x0; TMR0 = 100; INTCON = 0xA0; cnt = 0; do { if (cnt == 400) { PORTB = PORTB++; cnt = 0; } } while(1); }

// Valeur initiale du TMR0 // Bit T0IE est positionné à 1, bit T0IF est en 0

// Prédiviseur pour TMR0 // Toutes les broches E/S sont configuré en digitale // // // // //

PORTB est configuré en sortie Initialisation du PORTB TMR0 conte de 100 à 255 Interruption par TMR0 est autorisés Variable cnt est initialisée à 0

// Boucle sans fin // Incrémenter port B après 400 interruptions // Incrémenter PORTB par 1 // Initialiser 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.

Dans le code-source 4.5 (fichier INTERRUP_TMR1) on utilise l’interruption produit par le débordement de registre TMR1(TMR1H, TMR1L). Après 76 d’interruption se produit l’évolution sur le 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;

cnt = 0; } } while (1);

/* Bits du PORTB sont inversés après 76 d’interruptions*/ // Initialisation de la variable cnt

}

Exemple 5. Module CCP1 comme générateur du signal PWM 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. Le fonctionnement de ce module est sous le contrôle des fonctions appartenant à la bibliothèque spécialisée PWM. Trois d'entre eux sont utilisés ici : PWM1_init a le prototype : void Pwm1_Init( long freq) ; Paramètre Freq détermine la fréquence du signal PWM exprimée en Hz. Dans cet exemple, elle est égale à 5 kHz. PWM1_Start a le prototype : void Pwm1_Start( void ) ; PWM1_Set_Duty a le prototype: void Pwm1_Set_Duty( unsigned short duty_ratio); Duty_ratio paramètre définit la durée d'impulsion dans la séquence d'impulsions. 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 Le programme de ce projet est donné dans le code-source 4.6 (fichier : SIGNAL_PWM.C).

Avant de compiler le fichier, SIGNAL_PWM.c, il est nécessaire de cocher PWM dans le gestionnaire de bibliothèque du compilateur mikroC PRO.

- 91 -


Fig.4.4. Schéma de simulation de l’exemple 5. 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 -


CCP1CON =0b00111110;

/* Uniquement pour la simulation. Enlever cette instruction avant de programmer le microcontrôleur*/

PWM1_Init(5000);

// Initialisation du module PWM (5KHz)

} void main() { initMain(); current_duty = 155; old_duty = 0; PWM1_Start(); while (1) { if (Button(&PORTA, 0,1,0)) current_duty++ ; if (Button(&PORTA, 1,1,0)) current_duty-- ; if (old_duty != current_duty) { PWM1_Set_Duty(current_duty); old_duty = current_duty; PORTB = old_duty;

// Programme principal

/* Valeur initiale de variable current_duty*/ // RAZ de variable old_duty // Start du module PWM1 // Boucle sans fin /* Si le bouton connecté pressé*/ // incrémenter la valeur /* Si le bouton connecté pressé*/ // décrémenter la valeur

à RA0 est de current_duty à RA1 est de current_duty

/* Si les variables current_duty et old_duty ne sont pas égales*/ // Charger PWM à la nouvelle valeur /* Sauvegarder la nouvelle valeur et l'afficher sur le PORTB*/

} Delay_ms(150);

// Retardement de 150ms

} }

Exemple 6. Convertisseur A/D 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. Avant de compiler le fichier CONVERT_A/D.c, il est nécessaire de cocher ADC dans le gestionnaire de bibliothèque du compilateur mikroC PRO.

- 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; ANSEL = 0x0C; TRISA = 0xFF; ANSELH = 0;

TRISB

= 0x3F;

TRISD

= 0;

do { temp_res = ADC_Read(2);

PORTD = temp_res; PORTB = Une temp_res >> 2; } while(1);

// Configurer Vref /* Configurer la broche AN2 du PORTA en analogique */ // PORTA est configuré en entrée /* Configurer les autres broches du PORTA en numérique */ /* Broches de RB7, RB6 du PORTB sont en sortie */ // PORTD est configuré en sortie

/* Résultat de la conversion A / D est copié dans temp_res */ // Envoyer 8 bits LSB au PORTD /* 2 bits MSB sont déplacés vers les broches RB7, RB6 du PORTB */ // Boucle sans fin

}

Exemple 7. Mémoire EEPROM 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. Avant de compilation le fichier EEPROM.c , il est nécessaire de cocher EEPROM dans le gestionnaire de bibliothèque du compilateur mikroC PRO. Le schéma de simulation est représenté sur la figure 4.6. Afin de vérifier la simulation de circuit de la figure 4.5, il suffit d'appuyer sur la touche MEMO_EEPROM et éteindre la simulation. Après le redémarrage de la simulation, le programme affichera la valeur enregistrée sur le port D. Rappelez-vous qu’au moment de l'écriture, cette valeur a été affiché sur le port B. - 94 -


Fig. 4.5. Schéma de simulation pour l’exemple 6

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 TRISD = 0; TRISA = 0xFF; PORTD = EEPROM_Read(5); do { PORTB=PORTB++;

// PORTD est configuré en sortie // PORTA est configuré en entrée // Lecture d’EEPROM à l’adresse 5

// Incrémenter par 1 du registre de PORTB

- 95 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Delay_ms(100);

// Retardement de 100mS

if (PORTA.F2 == 0) { EEPROM_Write(5,PORTB); PORTD = EEPROM_Read(5); do; while (PORTA.F2 ==0); } } while(1);

// Le bouton MEMO_EEPROM est pressé ? /* Oui, sauvegarder des données dans EEPROM à l’adresse 5 */ // Lecture des données écrites dans EEPROM /* Rester dans ce boucle aussi longtemps que le bouton MEMO_EEPROM est pressé */

// Boucle sans fin

}

Fig. 4.6. Schéma de simulation de l’exemple 7

Exemple 8. Affichage multiplexé pour deux afficheurs 7 segments à LEDs 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 Le programme compte de 0 à 99 avec un retard d’une seconde entre chaque comptage. L'affichage est multiplexé et est assuré par une routine d'interruption toutes les 5 ms. Le schéma de simulation pour cet exemple est donné par la figure 4.7. Le programme du projet (fichier : AFFICH_MULTIPLEX.c) est représenté dans le code-source 4.9.

Fig.4.7. Schéma de simulation de l’exemple 8 Code-source 4.9 /**************************************************************************** AFFICHAGE MULTIPLEXE ===================== 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. Le programme compte de 0 à 99 avec un retard d’une second entre chaque comptage. L'affichage est multiplexé par une routine d'interruption toutes les 5 ms. 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 #define DIGIT2 PORTB.F1 unsigned char Cnt = 0; unsigned char Flag = 0; // /* Cette fonction retrouve la configuration de bits à envoyer au port pour afficher un numéro sur la LED 7 segments. Le numéro est passé dans la liste des arguments de la fonction */ // unsigned char Display(unsigned char no) { unsigned char Pattern; unsigned char SEGMENT[] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D, 0x7D,0x07,0x7F,0x6F}; Pattern = SEGMENT[no]; return (Pattern); } // /* Routine de service d'interruption timer TMR0 . Les sauts de programme à la à chaque 5ms.*/ void interrupt () { unsigned char Msd, Lsd; TMR0L = 100; // Charger TMR0 INTCON = 0x20; // Set du drapeau T0IF et effacé T0IE Flag = ~ Flag; // Inverser le drapeau Flag if(Flag == 0) // 1èr chiffre { DIGIT2 = 0; Msd = Cnt / 10; // Bit MSD if(Msd != 0) { PORTC = Display(Msd); // Envoyer au PORTC DIGIT1 = 1; // Activer le chiffre 1 } } else { // 2èm chiffre DIGIT1 = 0; // Désactiver le chiffre 1 Lsd = Cnt % 10; // Bit LSD PORTC = Display(Lsd); // Envoyer au PORTC DIGIT2 = 1; // Activer le chiffre 2 } } // /* Début du programme principal. Configurer PORTB et PORTC en sorties. Configurer l'interruption de TMR0 à toutes les 10ms */ void main() { TRISC = 0; // PORTC est en sortie TRISB = 0; // RB0, RB1 est en sortie DIGIT1 = 0; // Désactiver le chiffre 1 DIGIT2 = 0; // Désactiver le chiffre 2 // // Configure l’interruption du timer TMR0 // T0CON = 0xC4; // Prediviseur = 32 TMR0L = 100; // Charger TMR0 avec 100 INTCON = 0xA0; // Activer l’interruption du TMR0

- 98 -


Delay_ms(1000); for(;;) { Cnt++; if(Cnt == 100) Cnt = 0; Delay_ms(1000); } }

// Boucle sans fin // Incrémentation de Cnt // Comptage de 0 è 99 // Attendre 1 seconde

Exemple 9. Multimètre avec l’afficheur LCD Cet exemple illustre l'utilisation d'un écran LCD alphanumérique. Un message écrit en deux lignes apparaît sur l'afficheur : 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 (la broche RA2) de convertisseur A / D. Multimetre Tension: Dans le dispositif vrai, le courant ou une autre valeur mesurée peut être affichée à la place de la tension. Le schéma de simulation de cet exemple est donné par la figure 4.8. Le fichier MULTIMETRE_LCD.c est donné dans le code-source 4.10.

Fig.4.8. Schéma de simulation de l’exemple 9. - 99 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Avant de compiler le fichier MULTIMETRE_LCD.c, il est nécessaire de cocher Lcd dans le gestionnaire de bibliothèque du compilateur mikroC PRO.

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

LCD_RS at RB4_bit; LCD_EN at RB5_bit; LCD_D4 at RB0_bit; LCD_D5 at RB1_bit; LCD_D6 at RB2_bit; LCD_D7 at RB3_bit; LCD_RS_Direction at LCD_EN_Direction at LCD_D4_Direction at LCD_D5_Direction at LCD_D6_Direction at LCD_D7_Direction at


// Fin des connexions du module LCD unsigned char ch; unsigned int adc_rd; char *text; long tlong; void main() { INTCON = 0; ANSEL = 0x04; TRISA = 0x04; ANSELH = 0; Lcd_Init(); Lcd_Cmd(_LCD_CURSOR_OFF); Lcd_Cmd(_LCD_CLEAR); text = "Multimetre"; Lcd_Out(1,1,text); text = "- Mesure de - "; Lcd_Out(2,1,text);

// Déclarer les variables

/* Toutes les interruptions sont désactivées */ /* Broche RA2 est configurée comme une entrée analogique */ /* Reste de broches sont configurées comme numériques */ // Initialisation d’affichesur LCD // Commande LCD (curseur OFF) // Commande LCD (effacer l’écran LCD) // Définir le premier message /* Ecrire le premier message dans la première ligne // Définir le deuxième message // Ecrire le deuxième message dans la deuxième ligne

- 100 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC ADCON1 = 0x82; TRISA = 0xFF; Delay_ms(2000); text = "Tension:";

//

Une tension de référence

A/D est GRD

/* Toutes les broches du PORTA sont configurées en entrées */ // Définir le troisième message

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); } }

Exemple 10. Communication série RS232 Cet exemple illustre l'utilisation du module UART du microcontrôleur. La connexion à un PC est possible grâce à la norme RS232. Le programme fonctionne de la manière suivante. Chaque octet envoyé et reçu via la communication série est affiché sur l’écran d’ordinateur (voire la figure ci-dessous).

- 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. Avant de compiler le fichier COMMUNIC_RS232.c, il est nécessaire de cocher Software_UART dans le gestionnaire de bibliothèque du compilateur mikroC PRO.

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; ANSELH = 0; TRISC = 0x00; PORTC = 0;

// Configuration E/S en numérique /* Configurer PORTB en sortie (signalisation d’erreur)*/ // Pas d’erreur

// Initialiser Soft_UART en 9600 bods error = Soft_UART_Init(&PORTC, 7, 6, 9600, 1); if (error > 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 -


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


// 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 << (4-RES_SHIFT); temp_fraction &= 0x0F; temp_fraction *= 625; // Conversion temp_fraction en caractères text[4] = text[5] = text[6] = text[7] = // Affichage

temp_fraction/1000

+ 48; /* Extrait d'un milliers*/ (temp_fraction/100)%10 + 48; /* Extrait d'un centaines*/ (temp_fraction/10)%10 + 48; /* Extrait d'un dizaines*/ temp_fraction%10 + 48; /* Extrait d'un unités*/ de la température sur l'écran LCD

chiffre des chiffre des chiffre des chiffre des

Lcd_Out(2,5, text); } void main() { ANSEL = 0; ANSELH = 0; Lcd_Init(); Lcd_Cmd(_LCD_CLEAR); Lcd_Cmd(_LCD_CURSOR_OFF); Lcd_Out(1, 1, " Temperature: ");

// Configurer E/S en numérique // Initialiser LCD // Effacer l'affichage sur LCD // Mettre invisible le curseur

// Afficher le caractère, 'C' pour degrés Celsius Lcd_Chr(2,13,223);

/*si vous voyez la lettre grecque alpha essayez de taper 178 au lieu de 223*/

Lcd_Chr(2,14,'C');

- 105 -


//--- boucle principale-------do { //--- effectuer la lecture de température----Ow_Reset(&PORTA, 5); /* Signal de remise a` zéro sur le bus OneWire */ Ow_Write(&PORTA, 5, 0xCC); Ow_Write(&PORTA, 5, 0x44); Delay_us(120); Ow_Reset(&PORTA, 5); Ow_Write(&PORTA, 5, 0xCC); Ow_Write(&PORTA, 5, 0xBE); Delay_ms(400);

// Envoi de commandes SKIP_ROM // Envoi de commandes CONVERT_T

// Envoi de commandes SKIP_ROM // Envoi de commandes READ_SCRATCHPAD

temp = Ow_Read(&PORTA, 5); temp = (Ow_Read(&PORTA, 5) << 8)+ temp; //--- Affichage de la température sur l’écran Lcd ---Display_Temperature(temp); Delay_ms(500); } while (1); }

Fig.4.10. Schéma de simulation de l’exemple 11

- 106 -


Exemple 12. Générateur de sons 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 codesource 4.13). Le schéma de simulation pour cet exemple est représenté sur la figure 4.11. Avant de compiler le fichier GENERAT_SONS.c il est nécessaire de cocher les fonctions Boutton et Sound dans le gestionnaire de bibliothèque du compilateur mikroC PRO. 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); } void Tone3() { Sound_Play(784, 250); } void Melody() { Tone1(); Tone2(); Tone1(); Tone2(); Tone1(); Tone2(); Tone1(); Tone2(); Tone1(); Tone2(); Tone3(); Tone3(); }

// Son de fréquence = 698Hz, durée = 250ms

// Son de fréquence = 784Hz, durée = 250ms

// Son de mélodie "Maison jaune" Tone3(); Tone3(); Tone3(); Tone3(); Tone3(); Tone2();

Tone3(); Tone3(); Tone3(); Tone2(); Tone1();

void ToneA() { Sound_Play( 880, 100); } void ToneC() { Sound_Play(1046, 100); }

- 107 -


void ToneE() { Sound_Play(1318, 100); } void Melody2() { unsigned short i; for (i = 9; i > 0; i--) { ToneA(); ToneC(); ToneE(); } } void main() { ANSEL = 0; ANSELH = 0; C1ON_bit; C2ON_bit; TRISB

= 0xF8;

Sound_Init(&PORTB, 0); Sound_Play(1200, 600); while (1) { if (Button(&PORTB,7,1,1)) Tone1(); while (RB7_bit) ;

// Configurer PORTB en numérique // Configurer PORTE en numérique

/* Configurer les broches RB7...RB3 en entrée */

// Son à 880Hz pendant 1 seconde

// RB7 – son

Tone1

// Attendre que le bouton d'être relâché

if (Button(&PORTB,6,1,1)) Tone2(); while (RB6_bit) ;

// RB6 - son Tone2

if (Button(&PORTB,5,1,1)) Tone3(); while (RB5_bit) ;

// RB5 - son Tone3

if (Button(&PORTB,4,1,1)) Melody2(); while (RB4_bit) ;

// RB4 - son de Melody2

if (Button(&PORTB,3,1,1)) Melody(); while (RB3_bit) ;

// RB3 - son Melody

// Attendre que RB6 soit relâché




} }

- 108 -



Exemple 13. Utilisation d’afficheur LCD graphique 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. Le fichier IMAGE_GLCD.c est décrit dans le code-source 4.14.

- 109 -


Fig.4.12 Schéma de simulation pour l’exemple 13

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

GLCD_CS1 at RB0_bit; GLCD_CS2 at RB1_bit; GLCD_RS at RB2_bit; GLCD_RW at RB3_bit; GLCD_EN at RB4_bit; GLCD_RST at RB5_bit;

- 110 -


sbit sbit sbit sbit sbit sbit

GLCD_CS1_Direction at TRISB0_bit; GLCD_CS2_Direction at TRISB1_bit; GLCD_RS_Direction at TRISB2_bit; GLCD_RW_Direction at TRISB3_bit; GLCD_EN_Direction at TRISB4_bit; GLCD_RST_Direction at TRISB5_bit;

// Fin de connections void delay2S() { Delay_ms(2000); } void main() { unsigned short ii; char *someText; #define COMPLETE_EXAMPLE ANSEL = 0; ANSELH = 0; C1ON_bit = 0; C2ON_bit = 0; Glcd_Init(); Glcd_Fill(0x00); while(1) { #ifdef COMPLETE_EXAMPLE Glcd_Image(truck_bmp); delay2S(); delay2S(); #endif Glcd_Fill(0x00); Glcd_Box(62,40,124,56,1); Glcd_Rectangle(5,5,84,35,1); Glcd_Line(0, 0, 127, 63, 1); delay2S(); for(ii = 5; ii < 60; ii+=5 )

// 2 secondes de temporisation

// Configurer E/S en numérique // Désactiver

les comparateurs

// Initialiser GLCD // Effacer l’écran de GLCD

// Afficher l'image d’une camion

// // // //

Effacer l’écran de GLCD Tracer une boîte Tracer un rectangle Tracer une line

/* 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 // Choisir la police, consulter __ Lib_GLCDFonts.c Glcd_Set_Font(Character8x7, 8, 7, 32); #endif Glcd_Write_Text("mikroE", 1, 7, 2); // Afficher le texte for (ii = 1; ii <= 10; ii++) Glcd_Circle(63,32, 3*ii, 1); // Afficher le cercle delay2S(); Glcd_Box(12,20, 70,57, 2); // Afficher le boîte delay2S(); #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 someText = "8x7 Font"; Glcd_Write_Text(someText, 5, 0, 2); // Afficher le texte delay2S(); Glcd_Set_Font(System3x5, 3, 5, 32); // Changer les caractères someText = "3X5 CAPITALS ONLY"; Glcd_Write_Text(someText, 60, 2, 2); // Afficher le texte delay2S(); Glcd_Set_Font(font5x7, 5, 7, 32); // Changer les caractères someText = "5x7 Font"; Glcd_Write_Text(someText, 5, 4, 2); // Afficher le texte delay2S(); Glcd_Set_Font(FontSystem5x7_v2, 5, 7, 32); someText = "5x7 Font (v2)"; Glcd_Write_Text(someText, 5, 6, 2); delay2S(); #endif } } // // // //

-----------------------------------------------------GLCD Picture name: truck.bmp GLCD Model: KS0108 128x64 ------------------------------------------------------

unsigned char const truck_bmp[1024] = { 0, 0, 0, 0, 0,248, 8, 8, 8, 8, 8, 8, 12, 12, 12, 12, 12, 10, 10, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,137,137,137,137,137,137, 137,137,137,137,137,137,137, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 13,253, 13,195, 6,252, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240,240,240,240,240,224,224,240,240,240,240,240,224,192,192,224, 240,240,240,240,240,224,192, 0, 0, 0,255,255,255,255,255,195, 195,195,195,195,195,195, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,255,240, 79,224,255, 96, 96, 96, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64,128, 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,255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255,255,255,255,255, 0, 0, 0, 0,255,255,255,255,255, 0, 0, 0, 0,255,255,255,255,255, 0, 0, 0,255,255,255,255,255,129, 129,129,129,129,129,129,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,255, 1,248, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 16,224, 24, 36,196, 70,130,130,133,217,102,112, 160,192, 96, 96, 32, 32,160,160,224,224,192, 64, 64,128,128,192, 64,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63, 96, 96, 96,224, 96, 96, 96, 96, 96, 96, 99, 99, 99, 99, 99, 96, 96, 96, 96, 99, 99, 99, 99, 99, 96, 96, 96, 96, 99, 99, 99, 99, 99, 96, 96, 96, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 96, 96, 96, 96, 96, 96, 96, 64, 64, 64,224,224,255,246, 1, 14, 6, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,130, 67,114, 62, 35, 16, 16, 0, 7, 3, 3, 2, 4, 4, 4, 4, 4, 4, 4, 28, 16, 16, 16, 17, 17, 9, 9, 41, 112, 32, 67, 5,240,126,174,128, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,127,127,127,127,255,255,247,251,123,191, 95, 93,125,189, 189, 63, 93, 89,177,115,243,229,207, 27, 63,119,255,207,191,255,

- 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

- 113 -

2

3


33

4

5

6

7

8 GLCD Picture name: truck.bmp

Exemple 14 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 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 // unsigned char getkeypad() { unsigned char i, Key = 0; PORTB = 0x01; while((PORTB & MASK) == 0) { PORTB = (PORTB << 1); Key++; if(Key == 4) { PORTB = 0x01; Key = 0; } } Delay_ms(20); for(i = 0x10; i !=0; i <<=1) { if((PORTB & i) != 0)break; Key = Key + 4; } PORTB=0x0F; while((PORTB & MASK) != 0);

Delay_ms(20); return (Key);

// Commencer par la colonne 1 // Masquer si aucune touche ne pas pressée // Colonne suivante // Numéro de colonne

// Sauvegarder la colonne 1

// Mettre anti-rebond // Déterminer la touche enfoncée

/* Attendre jusqu'a ce que touche sera relâchée */ // Mettre anti-rebond // Retour le numéro de la touche

} // Connections de LCD

- 115 -

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

LCD_RS LCD_EN LCD_D4 LCD_D5 LCD_D6 LCD_D7

at at at at at at

RC2_bit; RC3_bit; RC4_bit; RC5_bit; RC6_bit; RC7_bit;

sbit LCD_RS_Direction sbit LCD_EN_Direction sbit LCD_D4_Direction sbit LCD_D5_Direction sbit LCD_D6_Direction sbit LCD_D7_Direction // Fin de connections

at at at at at at

TRISC2_bit; TRISC3_bit; TRISC4_bit; TRISC5_bit; TRISC6_bit; TRISC7_bit;

//Start du program principale // void main() { unsigned char MyKey, i,j,lcd[5],op[12]; unsigned long Calc, Op1, Op2; TRISC = 0; // PORTC est configure en sortie TRISB = 0xF0; // RB4-RB7 sont configures en entrée // // Configuration de LCD // Lcd_Init(); // LCD est connectŽe ˆ PORTC Lcd_Cmd(_LCD_CLEAR); Lcd_Out(1,1,"CALCULATRICE"); // Ecrire CALCULATRICE Delay_ms(2000); // Temporisation de 2 secondes Lcd_Cmd(_LCD_CLEAR); // Effacer l'écran LCD // // Boucle de programme // for(;;) // Boucle sans fin { MyKey = 0; Op1 = 0; Op2 = 0; Lcd_Out(1,1,"No1: "); // Afficher No1: while(1) // Composer la première chiffre { MyKey = getkeypad(); if(MyKey == Enter)break; // Presser ENTRER MyKey++; if(MyKey == 10)MyKey = 0; // Si la touche 0 est pressée Lcd_Chr_CP( MyKey + '0'); Op1 = 10*Op1 + MyKey; // Premier numéro de Op1 } Lcd_Out(2,1,"No2: "); // Afficher No2: while(1) // Composer la deuxième chiffre { MyKey = getkeypad(); if(MyKey == Enter)break; // Si ENTRER est pressée MyKey++; if(MyKey == 10)MyKey = 0;// Si la touche 0 est pressée Lcd_Chr_CP( MyKey +'0'); Op2 = 10*Op2 + MyKey; // Second numéro de Op2 } Lcd_Cmd(_LCD_CLEAR); // Effacer l'écran de LCD Lcd_Out(1,1,"Op: "); // Afficher Op:

- 116 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC MyKey = getkeypad(); Lcd_Cmd(_LCD_CLEAR); Lcd_Out(1,1,"Res="); switch(MyKey) { case Plus: Calc = Op1 + Op2; break; case Minus: Calc = Op1 - Op2; break; case Multiply: Calc = Op1 * Op2; break; case Divide: Calc = Op1 / Op2; break; } LongToStr(Calc, op);

// Obtenir le fonctionnement

// Afficher Res= // Effectuer l'opération

// Si Plus

// Si Minus

// Si Multiply

// Si Divide

// // // Supprimer les espaces à gauche // j=0; for(i=0;i<=11;i++) { if(op[i] != ' ') // { lcd[j]=op[i]; j++; } } Lcd_Out_CP(lcd); // Delay_ms(5000); // Lcd_Cmd(_LCD_CLEAR); } }

Convertir en chaine dans op

Si un blanc

Afficher le résultat Temporisation de 5 secondes

Avant de compiler le fichier CALCUL_LCD.c il est nécessaire de cocher les fonctions Conversions et Lcd dans le gestionnaire de bibliothèque du compilateur mikroC PRO.

- 117 -



Exemple 15 Calculatrice avec l’interface RS232 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

Le fichier de ce projet appelé CALCUL_RS232.c est donné dans le code-source 4.16.

Avant de compiler le fichier CALCUL_RS232.c il est nécessaire de cocher les fonctions Conversions et Software_UART dans le gestionnaire de bibliothèque du compilateur mikroC PRO.

- 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 '/' // Retour de chariot et saut

de ligne à USART

void Newline() { Soft_UART_Write(0x0D); Soft_UART_Write(0x0A); }

// Envoyer retour chariot // Envoyer saut de ligne

// Envoyer un texte à port série void Text_To_Usart(unsigned char *m) { unsigned char i; i = 0; while(m[i] != 0) { // Envoyer TEXT vers le port série Soft_UART_Write(m[i]); i++; } } // Start du programme principale void main() { unsigned char unsigned long unsigned char unsigned char unsigned char unsigned char unsigned char

MyKey, i,j,error,kbd[5],op[12]; Calc, Op1, Op2,Key; msg1[] = " CALCULATRICE PROGRAMME"; msg2[] = " Entrer Premier Nombre : "; msg3[] = " Entrer Deuxieme Nombre : "; msg4[] = " Enter Operation : "; msg5[] = " Resultat = ";

// Configurer port série Soft_UART_Init(PORTC,7,6,9600,0);

// TX=RC6, RX=RC7, Baud=9600

- 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); // Perform the operation Newline(); switch(Key) { case Plus: Calc = Op1 + Op2; break; case Minus: Calc = Op1 - Op2; break; case Multiply:

// Calcule

// Si Addition

// Si Soustraction

- 120 -

V.TOURTCHINE. Programmation en mikroC. Application pour les microcontrôleurs de la famille PIC Calc = Op1 * Op2; break; case Divide: Calc = Op1 / Op2; break;

// Si Multiplication

// Si

Diviser

} LongToStr(Calc, op); // Convertir en ligne // Remove leading blanks j=0; for(i=0;i<=11;i++) { if(op[i] != ' ') // Si un espace { kbd[j]=op[i]; j++; } } Text_To_Usart(msg5); for(i=0; i
Le schéma de simulation pour ce projet est représenté sur la figure 4.14

Fig. 4.14. Schéma de câblage pour la simulation de l’exemple 15

- 121 -


- 122 -

03- Programmation en MikroC

Recommend Documents