MIKROC POUR

PIC
Sommaire
I. Introduction
II. Applications à base de microcontrôleurs
III. Cahier des charges fonctionnel
IV. Algorithme
V. MikroC pour PIC
VI. Eléments de la programmation en mikroC
VII. Operateurs et expressions en mikroC
VIII. Boucles et instructions de répétition
IX. Structures de contrôle
********************************************************************

I. Introduction
En décembre 2005, MikroElektronika a développé le premier compilateur C pour les microcontrôleurs du type PIC appelé « mikroC pour PIC ».
D’autres compilateurs destinés aux autres types de microcontrôleurs ont suivi.
II. Applications à base de microcontrôleurs
La figure 1 représente les sept étapes nécessaires pour la mise en œuvre d’une application à base de microcontrôleurs du type PIC.
 Fig. 1

**********************************************************************************************

III. Cahier des charges fonctionnel

Un cahier des charges fonctionnel (CDCF) est un document rédigé par un client. Dans ce document sont formulés explicitement les :
ü spécifications d’un produit à réaliser ou d’un service attendu ;
ü détails du produit ou du service attendu ;
ü contraintes auxquelles le produit à fournir ou le service attendu sont soumis ;
ü délais de livraisons ;
ü responsabilités à assumer en cas de non-conformité du produit ou de service aux exigences sus-indiquées.

IV. Algorithme
IV.1. Aperçu historique
Au 15e siècle, un mathématicien persan « Al-Khwârizmî » (figure 2) se lit en arabe ‫ الخوارزمي‬, a inventé "‫ "الخوارزميات‬les algorithmes formulés sans
aucune équation ni symbole.
Ces algorithmes, dits algorithmes textuels, sont génériques et susceptibles d’être traduits en des programmes dans n’importe quel système
d’exploitation. Ils sont, actuellement, considérés les plus efficaces pour l’apprentissage de la programmation.
 Fig. 2

**********************************************************************************************

V. MikroC pour PIC

V.1. Définition
Le mikroC pour PIC est un éditeur compilateur de programmes dédié aux microcontrôleurs du type PIC. La programmation en mikroC utilise une
syntaxe spécifique. Le mikroC, en plus qu’il est un environnement de développement intégré (IDE), dispose d’une aide très riche et d’outils
intégrés permettant la gestion d’une vaste diversité de périphériques.

V.2. Programme en mikroC pour PIC

V.2.1. Composantes d’un programme
Un programme écrit en langage mikroC est composé de deux parties (figure 3) :
ü 1ière partie réservée à la déclaration des variables d’entrée et de sortie, etc. ;
ü 2ème partie réservée à la suite séquentielle des instructions à exécuter par ce programme.

Fig. 3

V.2.2. Début et fin d'un programme

En mikroC, le contenu des expressions du programme :
ü commence par le mot-clé "void main()" énonçant le programme principal en commençant par une accolade ouvrante "{" ;
ü suivi par des expressions à exécuter entre une accolade ouvrante et une accolade fermante ("{" et "}") ;
ü se termine par "}" énonçant la fin du programme principal.
V.2.3. Règles spécifiques
ü Tout traitement se termine par un point-virgule ;
ü Un bloc d’instructions débute par « { » et se termine par « } » ;
ü Une ligne de commentaires débute par «//»;
ü Un commentaire de plusieurs lignes débute par « /* » et se termine par « */ ».
 **********************************************************************************************

VI. Eléments de la programmation en mikroC

VI.1. Données en langage mikroC
En mikroC, quatre types de données numériques de base sont utilisées :
ü Bit, signifiant que le type d’une variable est un état logique ;
ü Char, signifiant que le type d’une variable est un caractère (octet ou texte) ;
ü Int, signifiant que le type d’une variable est un entier défini sur un nombre fini de bits ;
ü "Float", signifiant que le type d’une variable est un nombre à virgule flottante.
En ajoutant un préfixe à certains types de données, la plage de leurs valeurs change ainsi que le nombre d'octets de mémoire nécessaires (figure 4).

Fig. 4

VI.2. Déclaration des constantes

Une constante est un nombre ou un caractère ayant une valeur fixe. Ainsi définie, elle est stockée dans la mémoire programme. Elle est
déclarée sous cette forme :
const Type NomConstante = Valeur ;
Le tableau (figure 5) donne les formats et des exemples de constantes.

Fig. 5

VI.3. Les variables

VI.3.1. Identification d’une variable
On distingue deux types de variables :
ü les variables locales déclarées dans une fonction et ne sont pas visibles ailleurs ;
ü les variables globales déclarées avant le mot clé de début du programme « void main() ».
Une variable est définie par un nom et un type, y compris un branchement pour certaines d’entre-elles. Elle doit être initialisée selon son type. Elle est
nommée par des termes composés de lettres minuscules ou majuscules et des chiffres en cas de besoin. Seuls les noms des variables réservées au
mikroC sont interdits à l’utilisation, telles que : void ; while ; if ; for ; else ; do ; case ; break ; switch ; const ; default ; int ; register ; char ; etc.

VI.3.2. Déclaration d’une variable

Une variable est déclarée par un nom, un type et une valeur initiale :
Type Nom = Valeur_Initiale ;
Exemples
ü Une variable nommée « compteur » de type entier non signé de valeur initiale = 4.
unsigned int compteur = 4 ;

ü Une variable nommée « Text1 » de type chaîne de caractères contenant le mot utilisé dans un programme.
char txt1[16] = "microcontroleur";

ü Une variable de type octet affectée à un port.

char MotA at portB;

VI.3.2. Registres TRIS et Ports

L’attribution d’un état logique à un bit défini d’un registre ou à une broche d’un PORT est énoncée par l’instruction suivante :
Nom.Position = Etat;

Exemples
ü Configuration en entrée d’une broche telle que RB2 du port B :
ü TRISB.RB2 = 1;
ü TRISB.F2 = 1;
ü TRISB.B2 = 1;
ü TRISB2_bit = 1.
ü Initialisation à un état logique d’une broche d’un port telle que l’initialisation à "0" de la broche RA4 du PortA.
ü PortA.RA4 = 0;
ü PortA.F4 = 0;
ü PortA.B4 = 0;
ü RA4_bit = 0;

ü Déclaration d’une variable d’entrée telle que « Dcy » connecté à la broche RA0.
ü sbit Dcy at PortA.B0;
ü Déclaration des variables d’étapes d’un grafcet du type bit.
ü bit X0, X1, X2 , X3 ;
ü Initialisation de toutes les broches d’un port à l’état "0 logique" tel que le PortC
ü PortC = 0b00000000;
ü Configuration en entrée de toutes les broches d’un port tel que le PortC.
ü TrisC = 0b11111111 ;

**********************************************************************************************

VII.Opérateurs et expressions en mikroC

Un opérateur signifie une opération de calcul à réaliser. Une expression est composée, au moins, de deux variables et d’un opérateur.
En mikroC les opérateurs utilisés sont :
ü un opérateur d’égalisation ;
ü des opérateurs logiques ;
ü un opérateur de bits (bit à bit) ;
ü des opérateurs d’arithmétiques binaires ;
ü des opérateurs d’affectation ;
ü des opérateurs de comparaison ;
ü des opérateurs d’incrémentation et de décrémentation.
VII.1. Opérateur d’égalisation
L’opérateur « = » affecte une valeur à une variable.
VII.2. Opérateurs logiques
Ces opérateurs sont utilisés pour définir une opération de calcul entre deux variables de type bit (figure 6).

Fig. 6

VII.3. Opérateurs de calcul bit à bit

Ces opérateurs sont destinés à exécuter la même opération de calcul entre les bits de même rang de deux variables (figure 7).
 Fig. 7

VII.4. Opérateurs d’arithmétiques binaires

Ces opérateurs sont destinés à effectuer des opérations de calcul d’arithmétique entre deux variables telles que l’addition binaire , la soustraction
binaire etc. (figure 8).

Fig. 8

VII.5. Affectation
Ces opérateurs sont destinés à être utilisés dans des opérations de calcul sur une seule variable (figure 9).

Fig. 9

VII.6. Comparaison
Les opérateurs (figure 10) sont destinés à la comparaison entre deux variables ou une variable et un seuil défini.
 Fig. 10

VII.7. Incrémentation et décrémentation

Ces opérateurs sont utilisés pour l’ajout ou la soustraction d’une unité du contenu d’une variable (figure 11).

Fig. 11

**********************************************************************************************

VIII. Boucles et instructions de répétition

Une instruction de répétition, encore appelée d’itération, d’une boucle dans un programme permet d'effectuer, infiniment ou à un nombre fini de fois, la
répétition séquentielle des expressions de cette boucle. Les instructions de répétitions sont :
ü la boucle "while" assurant une répétition séquentielle et infinie d’une ou de plusieurs actions tant qu’une condition vraie ;
ü la boucle "For" assurant une répétition séquentielle d’une ou de plusieurs actions jusqu’à l’atteinte d’un nombre fini de fois ;
ü la boucle "do" assurant l’exécution séquentielle d’une ou de plusieurs actions jusqu’à ce qu’une condition définie soit vraie ;
ü la boucle "goto, continue et break" assurant uniquement l’exécution séquentielle des actions dans une boucle sélectionnée parmi plusieurs
autres selon les instructions mentionnées dans un programme.

IX. Structures de contrôle

Les structures de contrôle sont destinées à résoudre des problèmes comportant au moins deux traitements. L'exécution d'un traitement entraîne
automatiquement la non-exécution des autres traitements. Ces structures sont :
ü structure de sélection "if else" et ses possibilités d’utilisation ;
ü structure de sélection "switch".
IX.1. Structure « if else »
IX.1.1. Définition
La structure « if else » assure l’exécution d’un traitement si une condition définie est vraie. Sinon ce traitement n’est pas exécuté.
IX.1.2. Application
La figure 12 illustre un mode de commande de la diode LED (L1). Celle-ci est dépendante des états du bouton-poussoir (S1) :
ü si S1= 1, alors L1=1 ;
ü sinon, L1=0.
 Fig. 12

IX.1.3. Structure syntaxique

Le tableau (figure 13) présente une structure algorithmique et la syntaxe utilisée en mikroC.

Fig. 13

NB : traitement signifie une ou plusieurs instructions

IX.1.4. Structure « if else » dans une boucle while

Cette structure (if else), placée dans une boucle, se prête à une répétition infinie.
La figure 14 montre une structure « if else » dans une boucle « tant que ».

Fig. 14

IX.1.5. Exemple d’application de la structure « if else »

La figure 16 illustre une situation d’application de la structure « if else » dans un schéma de circuit d’une carte électronique à base de microcontrôleur
du type PIC16F84A programmé en mikroC.
 Fig. 15

L’algorithme textuel explique le fonctionnement de cette carte électronique. Le programme est la traduction de cet algorithme (figure 16).

· ← : affecter une valeur à une variable ; → : relier une variable à une broche.
Fig. 16

IX.1.6. Structure « if else if …»

IX.1.6.1. Définition
L'instruction « if else if … » assure l’exécution d’un traitement si un nombre fini de conditions imbriquées est vrai. Sinon ce traitement n’est pas
exécuté.
IX.1.6.2. Exemple
La figure 18 illustre un mode de commande de la diode LED (L1). Celle-ci est dépendante des états des boutons-poussoirs (S1 et S2) :
ü si (S1)= 1 , alors L1=0 ;
ü sinon si (S1)=0 ;
§ Si (S2=1), alors L1=1 ;
§ Sinon L1=0 ;
ü sinon L1 = 0.
 Fig. 17

IX.1.6.3. Application de l’instruction « if else if.. »

La figure 18 Illustre une situation d’application de la structure « if else if… » dans un programme en mikroC.

Fig. 18

IX.2. Structure switch

IX.2.1. Définition
L'instruction « switch » assure la commutation entre un nombre fini de combinaisons de variables d’entrée et en exécuter les actions correspondantes.
En cas de défaut, exécuter d’autres actions données.
IX.2.2. Application
La figure 19 illustre un mode de commande de deux diodes LEDs (L1 et L2). Celles-ci sont dépendantes des états respectifs des boutons poussoirs
(S1 et S2) :
ü dans le cas où S1= 1 et S2= 0, uniquement L1=1 ;
ü dans le cas où S1= 0 et S2= 1, les diodes LEDs L1=1 et L2 = 1 ;
ü en absence de ces deux cas, les diodes LEDs sont éteintes.
 Fig. 19

IX.2.3. La structure syntaxique

Cette structure syntaxique (figure 20) est donnée dans :
ü un langage algorithmique textuel ;
ü un langage de programmation en mikroC.

Fig. 20

IX.3. Structure « do while »

IX.3.1. Définition
La boucle "do while" assure l’exécution séquentielle d’une ou de plusieurs actions jusqu’à ce qu’un nouvel ordre soit vrai (Figure 21).
 Fig. 21

IX.3.2. Application
La figure 22 illustre un schéma de circuit d’une carte électronique à base de PIC 16F84A destinée à la commande d’une diode LED (L1) par un
bouton-poussoir (S1) selon les instructions suivantes :
La Diode LED L1 est éteinte tant que le bouton poussoir S1 n’est pas actionné.

Fig. 22

IX.3.3. La structure syntaxique

Cette structure syntaxique (figure 23) est donnée dans :
ü un langage algorithmique textuel ;
ü un langage de programmation en mikroC.
 Fig. 23

IX.4. Structure « while do »

IX.4.1. Définition
La boucle "while do " assure l’exécution séquentielle répétitive d’une ou de plusieurs actions tant qu’une condition est toujours vraie (Figure 24). Dès
que la condition est fausse, l’action 2 est exécutée.

Fig. 24

IX.4.2. Application
La figure 25 illustre un schéma de circuit d’une carte électronique à base de PIC 16F84A destinée à la commande d’une diode LED (L1) par un
bouton-poussoir (S1) selon les instructions suivantes :
Tant que (S1=0) La Diode LED L1 est éteinte jusqu’à ce que ce bouton-poussoir change d’état.
 Fig. 25

IX.4.3. La structure syntaxique

Cette structure syntaxique (figure 26) est donnée dans :
ü un langage algorithmique textuel ;
ü un langage de programmation en mikroC.

Fig. 26

IX.5. Structure répétitive « goto »

IX.5.1. Définition
Cette structure permet de sélectionner et exécuter les expressions d’une boucle parmi plusieurs. La sélection est assurée par une condition.
IX.5.2. Application
La figure 27 illustre un exemple composé de deux boucles à exécuter :
ü la fonction OU si un sélecteur SL = 1 ;
ü la fonction logique ET si ce sélecteur SL =0.
 Fig. 27

IX.5.3. Structure syntaxique

Fig. 28

**********************************************************************************************