Académique Documents
Professionnel Documents
Culture Documents
Spcialit : INFOTRONIQUE
&
IMAGERIE ET APPAREILLAGE BIOMEDICAL
V. TOURTCHINE
/*******************************
COMMUNICATION SERIE RS232
=========================
Cet exemple illustre
l'utilisation de fonction
Software_UART de la bibliothque
du compilateur mikroC PRO.
Microcontrl.: 16F887
Oscillat.: HS,10.0000 Mhz
Fichier: COMMUNIC_RS232.c
********************************
/
char error, byte_read;
void main()
{
ANSEL = 0;
ANSELH = 0;
TRISC = 0x00; /*Configurer
PORTB
en sortie */
PORTC = 0;
Initialiser Soft_UART en 9600
bods Soft_UART_Init(&PORTC,
7, 6, 9600, 1);
if (error > 0)
BOUMERDES - 2012
-0-
-1-
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
-3-
Pas 7 : Cliquer sur OUI pour lassociation du format de fichier .c avec le logiciel mikroC PRO
-4-
Pas 9 : Aller dans le rpertoire M_License et copier les deux fichiers qui sy trouvent.
Pas 10 : Coller pour remplacer les deux fichiers copis auparavant dans le rpertoire 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
Cest sur la figure 1.1 que vous obtenez lorsque vous dmarrez l IDE mikroC PRO pour la
premire fois.
Une description dtaill 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 dcrire
salement le processus dcriture dun programme en langage mikroC, un simulateur de
contrle. Pour plus dinformations reportez-vous laide [F1].
-5-
Menu
Toolbar
Projet Manager
Code Explorer
Code Editor
Project Settings
(paramtres
principaux du
microcontrleur)
Error Window
Dans la bote de dialogue Obtions (figure 1.2) vous pouvez configurer la coloration syntaxique,
l'aide pour le code et paramtres, la correction automatique etc. Pour accder ce dialogue
cliquez sur Tools > Options du menu droulant ou sur l'icne
Assistant de code
Si vous imprimez les premires lettres du mot et puis appuyez sur Ctrl + Espace, tous les
identificateurs autoriss correspondant aux caractres imprims seront offerts dans une fentre
(voir la figure 1.3). Maintenant, nous pouvons continuer rduire le choix de taper ou d'utiliser
la sourie pour slectionner l'option approprie dans la propose et appuyez sur Entre.
-6-
-7-
-8-
La meilleure faon de crer un projet cest l'aide de l'Assistant Nouveau projet (menu
Project> New ProjeCt ) ou en cliquant sur l'icne Nouveau projet
du projet.
-9-
- 10 -
- 11 -
Quatrime pas - Ajout pour le projet un fichier sil sont disponibles en ce moment.
vous pouvez toujours ajouter des fichiers de projet plus tard
en utilisant Project Manager.
- 12 -
A ce stade, une nouvelle fentre vide (fig. 1.4) saffiche afin que vous pussiez y saisir votre
programme.
1.5 Compilation
- 13 -
Lorsque vous avez cr le projet et crit le code source, il est temps de le compiler.
Slectionnez Project
Build partir du menu droulant ou cliquez sur l'icne Build dans
la barre d'outils du projet.
Si plus d'un projet est ouvert, vous pouvez compiler tous ouverts projets en slectionnant Project
Build All dans le menu droulant, ou cliquez sur licne
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 fentre d'erreur (fig. 1.4).
Aprs la compilation russie, le compilateur mikroC PRO pour PIC gnre des fichiers de sortie
dans le dossier du projet (dossier qui contient le fichier projet. mcppi). Les fichiers de sortie sont
rsums dans le tableau ci-dessous:
Format
Intel HEX
Binary
Description
Code hexadcimal dans le format Intel. Fichier est utilis
pour programmer PIC
Fichier compil pour la bibliothque mikroC. Les
distributions binaires sont des routines qui susceptibles
- 14 -
Type de fichier
.hex
.mcl
List File
Assembler
File
Sauvegarder un fichier
Assurez-vous que la fentre contenant le fichier que vous
voulez sauvegarder est active.
Slectionnez ensuite Save depuis le menu File ou pressez
Ctrl+S ou cliquez sur licne Save Fail de la barre doutils File.
- 16 -
2.1.2 Commentaires
Les commentaires sont utiliss pour prciser le fonctionnement du programme et pour une
annotation du programme. Les lignes de commentaires sont ignores et non compil par le
compilateur.
En mikroC les commentaires de programmes peuvent tre de deux types: de longs
commentaires, stendant sur plusieurs lignes, et de courts commentaires, occupant une
seule ligne.
Un commentaire au dbut d'un programme peut dcrire brivement 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 numros de version, ainsi que les modifications dans
chaque version.
Comme montre le Code-source 2.1 les longs commentaires commencent par le caractre
/* et se termine par le caractre */ .
De mme, de courts commentaires commencent par le caractre // et il na pas
besoin d'un caractre de terminaison.
main()
Aprs cela, une accolade ouvrante est utilise pour indiquer le dbut 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 -
// correcte
// erreur
j23.07.04
(priode)
Certains noms sont rservs pour le compilateur lui-mme et ne peut pas tre utiliss comme
noms de variables dans un programme. Le tableau 2.1 donne une liste alphabtique de ces
noms rservs.
asm
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 indiques dans le tableau 2.2.
Tableau 2.2: Types de variables en mikroC
Type
unsigned
char
Taille
(bits)
Plage
0 255
0 255
unsigned int
16
0 65535
32
0 4294967295
signed char
-128 127
-128 127
signed int
16
-32768 32767
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
(signed) int
Les variables appels (signed) int sont des variables signes 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 appels unsigned (int) sont des variables non signs de 16 bits avec une
gamme de 0 65535. Dans l'exemple suivant une variable de 16 bits nomme count est
affecte la valeur dcimale de 12000 :
unsigned int count = 12000;
virgule
flottante
comprise
entre
1.17549435082E-38
+ 6.80564774407E38. Dans l'exemple suivant, une variable flottante nomme area est
affecte la valeur 12.235:
- 21 -
float area ;
area = 12.235;
Pour viter toute confusion lors de l'laboration du programme, il est recommand de
prciser 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 reprsentent des valeurs fixes (numrique ou caractre) dans des programmes qui
ne peuvent pas tre changes.
En mikroC, constantes peuvent tre entiers, flottants, caractres, les chanes, ou des types
numrs.
Integer Constants
Les constantes entires (Integer Constants) peuvent tre en dcimal, hexadcimal, octal
ou binaire. Le type de donnes 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 dcimales (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 mme, 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 dclares en utilisant le mot-cl const et sont stockes dans le flash
de mmoire du microcontrleur PIC. Par exemple, MAX est dclar comme la constante
100 :
const MAX =100;
Les constantes hexadcimales commencent par les caractres 0x ou 0X et peuvent
contenir des donnes numriques de 0 9 et les caractres hexadcimaux de A F.
Dans l'exemple suivant, TOTAL est la constante de la valeur hexadcimale FF:
const TOTAL = 0xFF;
Les constantes octales ont un zro au dbut du nombre et peuvent contenir des donnes
numriques de 0 7. Dans l'exemple suivant, une constante CNT est affecte une valeur
octale 17 :
const CNT = 017;
- 22 -
Enumerated Constants
Les constantes numres (Enumerated Constants) sont de type entier et sont utilises
pour faire un programme plus facile suivre. Dans l'exemple suivant, une constante
nomme couleur stocke les noms de couleurs. Le premier lment de couleur a la
valeur 0:
enum couleur {noir, marron, rouge, orange, jaune, vert, bleu,
gris,
white};
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 -
module. Dans l'exemple suivant, les variables sum1 et SUM2 sont dclars comme externes
entiers non signs :
extern int sum1, SUM2 ;
// assigne 2 My_Week
ou
My_Week = 2
Aprs avoir dfini Semaine comme un type numr, nous pouvons dclarer des variables
This_Week et Next_Week de type Semaine :
enum Semaine This_Week, Next_Week;
2.2.8 Tableaux
Les tableaux (Arrays) sont utiliss pour stocker des lments lis dans le mme bloc de
mmoire et en vertu d'un nom spcifi. Un tableau est dclar en spcifiant son type, le nom, et
le nombre dlments stocker. Par exemple:
unsigned int Total [5] ;
Ce tableau de type unsigned int est nomm Total et dispose de cinq lments. Le premier
lment d'un tableau est index 0. Ainsi, dans cet exemple, Total[0] se rfre au premier
lment du tableau et Total[4] se rfre au dernier lment. Le tableau Total est stock
dans un mmoire ayant cinq emplacements conscutifs comme suit:
Total[0]
Total[1]
Total[2]
Total[3]
Total[4]
Les donnes peuvent tre stockes dans le tableau en spcifiant le nom du tableau et de
l'indice. Par exemple, pour stocker 25 dans le deuxime lment du tableau, nous devons
crire:
Total[1] = 25;
De mme, le contenu d'un tableau peut tre lu en spcifiant le nom du tableau et de son
index. Par exemple, pour copier l'lment de tableau dindex 2 une variable appele Temp ,
nous devons crire:
Temp = Total[2];
Le contenu d'un tableau peut tre initialis lors de la dclaration du tableau en
attribuant d'une squence de valeurs spares par des virgules dans le tableau. Voici un
exemple dun tableau ayant 12 lments des mois[0] = 31, mois[1] = 28, et
ainsi de suite:
- 26 -
et
unsigned char Mystring[ ] = {C, O, M, P, \0};
Dans le langage de programmation microC, nous pouvons aussi dclarer des tableaux aux
dimensions multiples. Tableaux unidimensionnels sont gnralement appels vecteurs, et des
tableaux bidimensionnels sont appels matrices. Un rseau bidimensionnel est dclar en
spcifiant le type de donnes 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 lments. Le premier lment de la matrice est
P[0][0], et le dernier lment est P[2][3].
La structure de ce tableau est montre 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 -
2.2.9 Pointeurs
Les pointeurs (Pointers) sont une partie importante du langage microC, car ils occupent les
adresses mmoire des autres variables. Les pointeurs sont dclares de la mme manire que
d'autres variables, mais avec le caractre * en face du nom de variable.
Dans l'exemple suivant, un pointeur de caractre non sign du nom pnt est dclar:
unsigned char *pnt;
Quand un nouveau pointeur est cr, son contenu est d'abord indtermin 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 affecte
une valeur en utilisant le caractre * en avant de son pointeur. Par exemple, le Count peut
tre attribue 10 l'aide de son pointeur :
* pnt = 10;
// Count = 10
// 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
ellment de la matrice. Ainsi, les deux noncs 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 oprations arithmtiques pour pointeurs qui
peuvent impliquer :
Nous pouvons maintenant effacer les lments 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 deuxime srie de dclarations:
*P = 0;
// Z[2] = 0
P = P + 1;
*P = 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 lensable de 10 lments crs l'aide de deux pointeurs diffrents:
// dclare 2 pointeurs
= &Cnt;
*i = 10;
// Cnt = 10
j = i;
Tot = *j;
// Tot = 10
2.2.10 Structures
- 29 -
Une structure peut tre utilise pour recueillir des lments connexes, qui sont ensuite traits
comme un seul objet. Contrairement un tableau, une structure peut contenir un mlange de
types de donnes. Par exemple, un structure permet de stocker les donnes personnelles
(nom, prnom, ge, date de naissance, etc) d'un tudiant.
Une structure est cre en utilisant le mot-cl struct, suivie d'une structure de nom et dune
liste des dclarations de membre. ventuellement, des variables de mme type que la structure
peuvent dclarer l'extrmit de la structure.
L'exemple suivant dclare une structure nomme Personne :
struct Personne
{
unsigned char name[20];
unsigned char prnom[20];
unsigned char nationalit[20];
unsigned char ge;
}
Nous pouvons dclarer des variables du mme 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 crer par
la dclaration:
struct Personne Moi, Toi;
Les variables de type Personne peuvent galement tre cres lors de la dclaration de la
structure comme suit :
struct Personne
{
unsigned char
unsigned char
unsigned char
unsigned char
}Moi, Toi
name[20];
prnom [20];
nationalit [20];
ge;
Nous pouvons attribuer des valeurs aux lements d'une structure en spcifiant le nom de la
structure, suivi d'un point . et le nom de l'lment. 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;
Elments de la structure peut tre initialis lors de la dclaration de la structure. Dans l'exemple
suivant, le rayon et la hauteur de la structure sont initialiss Cylindre 1.2 et
2.5 respectivement :
- 30 -
Les valeurs peuvent galement tre attribues pour les lments d'une structure lade des
pointeurs en dfinissant les variable el les types des pointeurs. Par exemple, si LeCylindre
est dfini comme un pointeur vers la structure Cylindre, alors nous pouvons crire :
struct Cylindre
{
valeur de rayon;
flotter dauteur;
}*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'oprateur sizeof pour obtenir la taille d'une structure.
Considront l'exemple ci-dessus :
sizeof (MienCylindre)
retours 8, tant donn que chaque variable de type float occupe 4 octets en mmoire.
Les champs de bits peuvent tre dfinis en utilisant les structures. Avec les champs de bits,
nous pouvons attribuer des identificateurs pour les bits dune 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;
En microC, nous pouvons utiliser les dclarations typedef pour crer de nouveaux types
dune variable. Par exemple, une nouvelle structure type de donnes nomm Reg peut tre
cr comme suit :
- 31 -
Les variables de type Reg peuvent ensuite tre crs de la mme manire que les autres types
de variables. Dans l'exemple suivant, les variables MyReg, Reg1, et Reg2 sont crs partir
de type de donnes Reg:
Reg MyReg, REG1, REG2;
Le contenu dune structure peut tre copi dans une autre structure, condition que
des structures soient dtermines partir du mme modle. 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;
}
P2 = P1;
2.2.11 Unions
Les unions sont utilises pour les variables de recouvrement. Une union est similaire une
structure et il est mme dfini d'une manire similaire. Les deux sont bass sur des modles, et
les membres de tous les deux sont accessible l'aide des oprateurs . ou -> . Une
chausse diffre d'une structure en ce que tous variables dans une union occupent la mme
zone mmoire, ils partagent le mme stockage. Un exemple de dclaration 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 mme zone de mmoire, 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 mme 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
hexadcimale
La taille d'une union est la taille (nombre d'octets) de son lment est le plus important. Ainsi,
la dclaration:
sizeof (P)
renvoie 2.
Cette union peut aussi tre dclare comme suit :
union flags
{
unsigned char x;
unsigned int y;
}
union flags P;
Dans le langage microC, il y a dautres oprateurs que les oprateurs arithmtiques quon a
lhabitude de manipuler. Il y en a en fait plus de 40 oprateurs.
Oprateurs et priorits
Vous avez lhabitude de manipuler des expressions arithmtiques :
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 parenthses permet de dfinir sans ambiguit lexpression que lon manipule.
Pour viter lusage des parenthses qui alourdissent la lecture, il existe des rgles pour lever
toute ambigit :
Exemple :
2+3*4
La sous expression 3*4 est value en premier et le rsultat obtenu est ajout la valeur 2
(forme avec parenthse : 2+(3+4)).
On dit que loprateur * possde une priorit suprieur la priorit de loprateur + .
2-3-4
- 33 -
Nom
Notation
Priorit
Ordre
()
parenthses
()
15
gauche-droite
Oprateur daffectation
Loprateur la plus importante dans un langage de programmation est celle qui consiste
donner une valeur une variable.
Cette opration est dsigne par le symbole = .
Comme laffectation range une valeur dans une variable (une zone mmoire), il est
impratif que le membre gauche dune affectation reprsente une zone (left value).
Une constante nest pas une left value car il ne dsigne pas ladresse dune zone
mmoire. Elle ne peut donc pas figurer en membre gauche dune affectation.
Le membre droit dune affectation peut dsigner soit une constante soit une zone
mmoire soit une expression.
Oprateur
Nom
Notation
Priorit
Ordre
affectation
x=y
droite- gauche
Notation
Priorit
Ordre
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 -
modulo
x%y
13
gauche-droite
Nombres flottants : le rsultat est un nombre flottant obtenu en divisant les deux
nombres.
Nombres entiers : le rsultat est un nombre entier obtenu en calculant la division entier
ou division euclidienne. Loprateur % nest dfini que pour les entiers et le rsultat est le reste
de la division entire des oprandes.
Rappel sur la division entire : On appelle quotient et reste de la division entire de a et de b,
les nombres entiers q et vrifiant :
a = q*b +r ; 0 < r < B
Exemple 1 :
Si a = 20 et b = 3 alors q = 6 et r = 2 (on a vrifi : 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 entire
//reste entier
//division relle
//division entire
//division relle
//division relle
Oprateur
Nom
Notation
Priorit
Ordre
-(unaire)
ngation
-x
13
droite- gauche
Oprateur
Nom
Notation
==
teste dgalit
!=
- 35 -
Priorit
Ordre
x == y
gauche-droite
x!=y
gauche-droite
x <= y
10
gauche-droite
>=
x >= y
10
gauche-droite
<
x<y
10
gauche-droite
>
x>y
10
gauche-droite
Thoriquement, le rsultat dune comparaison est une valeur boolenne (vrai ou faux). En
microC, le rsultat dune comparaison est 1 (!= 0) ou 0 selon que cette comparaison est vraie
ou fausse.
Il nexiste pas de type boolen en microC : la valeur entire 0 sera considre comme
quivalente la valeur faux et toute valeur diffrente de 0 quivalente la valeur vrai.
Oprateur
Nom
Notation
Priorit
Ordre
&&
ET
x && y
gauche-droite
II
OU
x II y
gauche-droite
! (unaire)
NON
!x
14
droite- gauche
Notation
Priorit
Ordre
Nom
&
ET bit bit
x&y
gauche-droite
OU bit bit
xIy
gauche-droite
x^y
gauche-droite
14
droite-gauche
>> x
11
droite-gauche
(unaire)
>>
dcalage gauche
<< x
11
droite-gauche
Equivalent
Notation
Priorit
Ordre
+=
x=x+y
+= y
droite-gauche
-=
x=x-y
-= y
droite-gauche
*=
x=x*y
*= y
droite-gauche
/=
x=x/y
/= y
droite-gauche
x=x%y
x %= y
droite-gauche
x=xy
= y
droite-gauche
<<=
x = x << y
x <<= y
droite-gauche
&=
x=x&y
x &= y
droite-gauche
I=
x=xIy
I= y
droite-gauche
^=
x=x^y
x ^= y
droite-gauche
%=
=
Oprateur
Equivalent
Notation
Priorit
Ordre
++
x=x+1
x++ ou ++x
14
droite-gauche
--
x=x-1
x-- ou --x
14
droite-gauche
y =
x++ ;
Oprateur conditionnel
Oprateur
Equivalent
Notation
Priorit
Ordre
oprateur
conditionnel
e ? x : y
droite-gauche
- 37 -
Exemple :
a =
(v == 2) ? 1 : 2 ;
Oprateur squentiel
Oprateur
Equivalent
Notation
Priorit
Ordre
oprateur
squentiel
e1 , e2
droite-gauche
Cet
oprateur permet de regrouper plusieurs expressions en une seule : lvaluation de lexpression
e1, e2 consiste en lvaluation successive (dans lordre) des expressions e1 puis de e2.
Oprateur de dimension
Cet oprateur donne loccupation mmoire (en octets) dune variable ou dun type de donn.
Oprateur
Equivalent
Notation
Priorit
Ordre
sizeof
oprateur de
dimension
sizeof (e)
14
droite-gauche
Exemple :
La valeur de lexpression sizeof(c) est 1 si c est une variable de type char.
Lexpression sizeof(char)donne galement la valeur 1.
Oprateur de parenthse
Oprateur
Equivalent
Notation
Priorit
Ordre
()
oprateur dadressage
()
15
gauche-droite
Oprateur de slection
Oprateur
Equivalent
Notation
Priorit
Ordre
oprateur de slection
x,info
15
gauche-droite
->
oprateur de slection
x->info
15
gauche-droite
[]
oprateur de slection
x[3]
15
gauche-droite
Oprateurs du prprocesseur
Toute ligne de code-source commence par # est considre comme un oprateur de
prprocesseur (ou loprateur de prtraitement ou encore la ligne de commande).
Les oprateurs du prprocesseur sont gnralement placs au dbut du code-source, mais ils
ont le droit d'tre n'importe o dans le programme.
Le prprocesseur permet un programmeur de :
Compiler un programme de sorte que les parties du code ne sont pas compils
Remplacer les symboles avec d'autres symboles ou des valeurs
Insrer des fichiers texte dans un programme
#undef
#elif
#ifndef
#endif
Lorsque cette macro est utilise 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 mme, nous pouvons dfinir 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 prprocesseur #include
La commande #include est utilis pour inclure un fichier source dans un programme.
Habituellement les fichiers avec l'extension ". H" sont utiliss avec #include. Il y a deux
formats pour l'utilisation de #include:
#include <fichier>
et
#include "fichier"
Dans la premire option le fichier est recherch d'abord dans le rpertoire d'installation mikroC,
puis dans les chemins de recherche des utilisateurs.
En seconde option le fichier spcifi 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 spcifier un chemin de rpertoire complet :
#include "C: \ temp \ last.h"
Le dossier dans ce cas nest recherch que dans le chemin du rpertoire spcifi.
#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 prcdente 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 diffrente de zro, 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 zro, alors A
= 2 ; B = 2.
Notez quune seule section de code est compil entre #if et #endif et qu'une section
de code peut contenir n'importe quel nombre dinstructions.
Instruction if
Cette instruction conditionnelle if permet dexcuter des instructions de manire slective en
fonction du rsultat dun test. La dclaration du format gnral de l'instruction if est la
suivante :
if (expression)
instruction1
else
instruction2
ou
if(expression) instruction1; else instruction2;
Si lexpression est vraie (valeur non nulle), linstruction1 sexcute sinon, dans le deuxime cas,
cest listruction2 qui sexcute.
- 41 -
Instruction switch
L'instruction switch (commutateur) est utilis pour assurer le commutation entre des
dfrentes dclarations 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 -
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 ignors en langage C, nous pouvons galement crire le code
prcdent comme suit:
switch (Cnt)
{
case 1:
A
case 10:
B
case 100:
C
dfault:
D
}
=
=
=
=
1;
1;
1;
1;
break;
break;
break;
- 43 -
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
incrment)
{
Instructions;
}
L'expression initiale dfinit la variable au dpart de la boucle, et cette variable est
compare l'expression de condition avant l'entre dans la boucle. Dclarations l'intrieur de
la boucle sont excutes de faon rpte, et aprs chaque itration la valeur dexpression est
incrmente. L'itration se poursuit jusqu' moment o l'expression de condition devient fausse.
Une boucle sans fin est forme si l'expression condition est toujours vraie.
L'exemple suivant montre comment une boucle peut tre mise en place pour excuter 10 fois.
Dans cet exemple, la variable i commence par 0 et elle est augmente de 1 la fin de chaque
itration. 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 lance par une expression initiale avec une valeur
diffrente de zro. 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 paramtres d'une boucle for sont tous optionnels et peuvent tre omises. Si la condition
expression est laisse de ct, il est suppos pour tre vrai. Dans l'exemple suivant, une boucle
sans fin est forme par l'expression de condition qui est toujours vraie et la valeur de i
commence avec 0 et est incrment aprs chaque itration :
// Boucle sans fin avec incrmentation i
for (i = 0;; i++)
{
Instructions;
}
- 44 -
Dans l'exemple suivant d'une boucle sans fin o tous les paramtres sont omis :
// Exemple de boucle sans fin
for (;;)
{
Instructions;
}
Dans la boucle sans fin suivante, i commence par 1 et n'est pas incrment l'intrieur de la
boucle :
// Boucle sans fin avec i = 1
for (i = 1;;)
{
Instructions;
}
Sil n'y a qu'une seule instruction l'intrieur de la boucle for, les accolades peuvent tre
omises comme cest montr dans l'exemple suivant :
for (k = 0; k <10; k++) Total = Total + Sum;
Les boucles imbriques peuvent galement tre utiliss. Dans une boucle for imbrique, la
boucle intrieure est excute pour chaque itration de la boucle externe. Dans l'exemple
suivant la boucle interne est excute 5 fois et la boucle extrieure est excute 10 fois. Le
nombre ditrations totales est de cinquante :
// Exemple de deux boucles imbriques
for (i = 0; i < 10; i++)
{
for (j = 0; j < 5; j++)
{
Instructions;
}
}
Dans l'exemple suivant, la somme de tous les lments d'un matrice M [3 x 4] est calcule
et stockes dans une variable appele Sum :
// Ajouter tous
Sum = 0;
for (i = 0; i <
{
for (j = 0; j
{
Sum = Sum +
}
}
Comme il n'y a qu'une seule instruction excuter, l'exemple prcdent pourrait galement tre
s'crit :
// Ajouter tous les lments d'une matrice 3x4
Sum = 0;
for (i = 0; i < 3; i++)
- 45 -
Instruction while
La syntaxe d'une instruction while est la suivante :
while (condition)
{
Instructions;
}
Ici, les instructions sont excutes jusqu' ce que la condition devienne fausse, ou les
instructions sont excutes de faon rpte aussi longtemps que la condition est vraie. Si la
condition est fausse l'entre de la boucle, la boucle ne sera pas excut et le programme sera
continuer de l'extrmit de la boucle while. Il est important que la condition est chang
intrieur de la boucle, sinon une boucle sans fin sera form.
Le code suivant montre comment mettre en place une boucle d'excuter 10 fois :
// Une boucle qui s'excute 10 fois
k = 0;
while (k <10)
{
Instructions;
k++;
}
Au dbut du code, la variable k est gal 0. Comme k est infrieur 10, la boucle while
commence. L'intrieur de la boucle, la valeur de k est incrment dun aprs chaque itration.
La boucle se rpte tant que k < 10 et se termine lorsque k = 10. la fin la valeur de k est
10. Notez quune boucle sans fin sera form si k n'est pas incrment l'intrieur de la boucle:
// Une boucle sans fin
k = 0;
while (k <10)
{
Instructions;
}
Une boucle sans fin peut galement tre forme par rglage de la condition qui doit tre
toujours vrai :
// Une boucle sans fin
while (k = k)
{
Instructions;
}
- 46 -
Il est possible d'avoir une dclaration while sans corps. Une telle dclaration est utile, pour par
exemple, si nous attendons un port d'entre 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 jusquau 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 dclaration do est similaire une dclaration while sauf ce que la boucle
excute jusqu' ce que la condition devient fausse, ou, la boucle s'excute tant que la
la condition est vraie. La condition est teste la fin de la boucle. La syntaxe d'une dclaration
do est la suivante :
do
{
Instructions;
} while (condition);
La premire itration est toujours effectue si la condition est vraie ou fausse. Il s'agit de la
principale diffrence entre une dclaration while et une dclaration do.
Le code suivant montre comment mettre en place une boucle d'excuter 10 fois en utilisant la
dclaration do
/*Excute 10 fois */
k = 0;
do
{
Instructions;
k++;
} while (k <10);
- 47 -
Une boucle sans fin peut galement tre cre si la condition est rgle pour tre vrai tout le
temps:
/* Une boucle sans fin */
do
{
Instructions;
}while (k = k);
- 48 -
De mme, une instruction break peut tre utilis pour mettre fin une boucle l'intrieur de la
boucle.
Dans l'exemple suivant, la somme des nombres de 1 5 est calcule, mme si les paramtres
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
}
// Charge W avec 6
}
Les variables en microC peuvent tre utilises dans les routines en langage d'assembleur,
mais elles doivent tre dclares et initialises avant son utilisation.
Par exemple, une variable Temp peut tre initialise et ensuite charge dans le registre W :
- 49 -
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 ( laide 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 hexadcimal 0xFF) :
void main ()
{
TRISB = 0;
PORTB = 0xFF;
}
Exercice 2.2
crire un programme pour mettre les pattes impaires (1, 3, 5 et 7) du PORTB au
niveau 1.
Solution 2.2
Repres 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 hexadcimal 0xAA et le programme ncessaire est :
void main ()
{
TRISB = 0;
PORTB = 0xAA;
}
Exercice 2.3
Ecrire un programme pour compter en binaire sans fin et envoie ces donnes
PORTB :
- 50 -
00000000
00000001
00000010
00000011
............
............
11111110
11111111
00000000
............
Solution 2.3
Une boucle sans fin peut tre utilise, et l'intrieur de cette boucle la valeur d'une
variable peut tre incrmente, puis envoye PORTB:
void main ()
{
unsigned char Cnt = 0;
for (;;)
{
PORTB = Cnt;
Cnt++;
}
}
Exercice 2.4
crire un programme pour mettre tous les bits de PORTB au niveau logique 1, puis
la logique 0, et rpter ce procd dix fois.
Solution 2.4
Linstruction for peut tre utilise pour crer une boucle rpter les oprations
requises dix fois
void main ()
{
unsigned char j;
for (j = 0; j < 10; j++)
{
PORTB = 0xFF;
PORTB = 0;
}
}
// Rpter 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 lment d'un tableau d'entiers ayant
dix lments.
Solution 2.6
Au dbut, la variable m est affecte sur le premier lment de la matrice. Une boucle
est alors forme et le plus grand lment 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];
}
}
Exercice 2.7
Ecrire un programme en utilisant une boucle while pour effacer tous les dix lments
entiers dans un tableau M.
Solution 2.7
Dans le programme qui suit, NUM est dfinie comme 10 et une variable j est utilise
comme le compteur de boucle:
- 52 -
Exercice 2.8
Ecrire un programme pour convertir la temprature de C F partir de 0 C, avec le
pas de 1 C jusqu' 100 C, et stocker les rsultats dans un tableau appel F.
Solution 2.8
void main ()
{
float F[100];
unsigned char C;
for (C = 0; C <= 100; C++)
{
F[C] =(C 32.0) / 1.8;
}
}
- 53 -
Nom de la fonction
Liste des paramtres
Dclaration des paramtres
Corps de la fonction
Type de rsultat de la fonction
Dans lexemple qui suit, la fonction, nomme Mult, reoit deux arguments entiers, a et b, et
renvoie leur produit. Notez que l'utilisation des parenthses dans une instruction de retour est
facultative :
int Mult(int a, int b)
{
return (a*b);
}
Quand une fonction est appele, elle s'attend gnralement donner le nombre d'arguments
exprims en liste d'arguments de la fonction. Par exemple, la fonction prcdente peut tre
appele :
- 54 -
Fonctions void peut tre appele sans aucune instruction d'affectation, mais les parenthses
sont ncessaire pour indiquer au compilateur que un appel de fonction est faite:
LED ();
En outre, certaines fonctions ne possdent pas d'arguments. Dans l'exemple suivant, la
fonction, nomme Compl, complte PORTC du microcontrleur. Il ne renvoie pas de donnes
et n'a pas d'arguments:
void Compl()
{
PORTC = PORTC;
}
Solution 3.1
Le type de donnes de la fonction est dclar comme float. La surface d'un cercle est
calcule par la formule :
- 55 -
locale
Le code-source 3.1 montre comment la fonction Cercle_Surface peut tre utilise dans un
programme principal pour calculer la surface d'un cercle dont le rayon est de 2,5 cm. La
fonction est dfinie avant le programme principal. La fonction est appele l'intrieur 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.
Microcontrleur : 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;
}
/* Dbut 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 appele Surface et une fonction appele 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 calcule par la formule:
Surface = 2rh
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 appele Minuscule_Majuscule pour convertir un caractre de minuscule
en majuscule.
Solution 3.3
La valeur ASCII du caractre en majuscule du premier caractre ('A') est gale 0x41. De
mme, la valeur l'ASCII du premier caractre en minuscule ('a') est gale 0x61. Un caractre
minuscule peut tre converti en son quivalent majuscule en soustrayant 0x20 du caractre en
minuscule.
Les fonctions ncessaires sont montres 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 appele pour convertir le caractre en minuscule de la variable
Lc en majuscules et de stocker dans la variable Uc.
Code-source 3.2
/**************************************************************************
SURFACE ET VOLME DUN CYLINDRE
==============================
Ce programme calcule la surface et le volume d'un cylindre dont le rayon est
2,0cm et la hauteur est 5,0cm.
Microcontrleur : 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;
}
// Dbut 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 -
- 59 -
Exercice 3.5
Rpter l'exemple 3.4, mais dclarer que Minuscule_Majuscule est un prototype de fonction.
Solution 3.5
Le code-source 3.5 prsente le programme o la fonction Minuscule_Majuscule est dclare
comme un prototype de fonction au dbut du programme. Dans cet exemple, la fonction relle
est crite aprs 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 dfinition de la fonction relle, mikroC va dtecter et modifier
les types de donnes dans l'appel de fonction pour faire correspondre les types de donnes
dclars dans le prototype de fonction.
- 60 -
// prototype de fonction
Dans cet exemple, le prototype de fonction dclare les deux arguments long,
les variables x et c sont convertis en long avant d'tre utilis l'intrieur de la fonction
MaFonc.
- 61 -
Voici un exemple de fonction qui dpend des effets secondaires plutt que de la valeur de
retour :
/* Fonction qui convertit coordonnes Descartes (x, y)
en coordonnes polaires (r, fi): */
#include <math.h>
voide polaire (double x, double y, double *r, double *fi)
{
*r = sqrt (x * x + y y *);
*fi = (x == 0 && y == 0)? 0: atan2 (y, x);
return;
// cette ligne peut tre omise
}
// prototype
main ()
{
//...
// fonction call (appeler)
- 63 -
Fonction
Lo
Hi
Higher
Highest
Delay_us
Delay_ms
Vdelay_ms
Delay_Cyc
Clock_Khz
Clock_Mhz
Les exceptions sont des fonctions Lo, Hi, Higher, et Highest, qui exigent le fichier den-tte
built_in.h. De plus dtails sur l'utilisation de ces fonctions sont disponibles dans le manuel
de mikroC.
Delay_us et delay_ms fonctions sont frquemment utiliss 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 connecte au PORTB (broche RB0) d'un microcontrleur PIC16F84A
travers dune rsistance de limitation, comme indiqu dans la figure 3.1.
Ecrire un programme qui fera clignoter le LED ON et OFF en permanence dans lintervalle
d'une seconde.
- 64 -
Solution 3.6
Une LED peut tre connecte un microcontrleur 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 connecte + 5 V
travers une rsistance R de limitation de courant et l'autre patte est relie la patte de port de
sortie du microcontrleur. La LED sera allume lorsque le port de sortie du microcontrleur 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 relie au port de sortie
du microcontrleur et l'autre patte est relie la masse travers une rsistance R de limitation
de courant. La LED sera allum lorsque le port de sortie du microcontrleur est au niveau
logique 1 ( savoir, environ +5 V). La mme valeur de rsistance R peut tre utilise en mode
de source de courant.
a)
b)
Fig.3.1 LED connecte au port RB0 d'un microcontrleur 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 dclaration TRISB = 0. Une boucle sans fin est
alors forme avec la dclaration for, et l'intrieur de cette boucle la LED est allume ou
teinte avec un dlai dune 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 prprocesseur #define.
Code-source 3.7
/***************************************************************************
LED CLIGNOTANTE_2
===================
Ce programme fait clignoter dune LED connecte au port RB0 d'un
microcontrleur PIC avec lintervalle dune seconde. En utilisant les
commandes de prprocesseur #define le programme est devenu plus facile
suivre.
Microcontrleur: 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 -
LED est
Retard
LED est
Retard
allume (ON)
1 seconde
dsactive (OFF)
1 seconde
Description
Utilis pour conversion analogique/numrique
Utilis pour le fonctionnement avec le module CAN
Utilis pour le fonctionnement avec le module extern CAN
Utilis pour les operations avec les cartes mmoire Compact
Fash
Utilis pour les operations avec la mmoire EEPROM
Utilis pour les operations avec le module Ethernet
Utilis pour le fonctionnement avec mmoire integ Flash
Utilis pour le fonctionnement avec module LCD graphique avec
une rsolution 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 laide 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
srie 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
Eeprom_Read
Eeprom_Write
La fonction Eeprom_Read lit un octet partir d'une adresse spcifie de la mmoire EEPROM.
Ladresse est de type entier, et donc la fonction prend en charge les microcontrleurs PIC avec
- 67 -
Exercice 3.7
Ecrivez un programme pour lire le contenu de l'EEPROM de l'adresse 0 0x2F puis envoyez
ces donnes pour PORTB d'un microcontrleur PIC.
Solution 3.7
Le programme requis est donn dans le code-source 3.8 (fichier LECTURE DE LEEPROM).
Une boucle for est utilise pour lire les donnes de lEEPROM et puis de l'envoyer au PORTB
du microcontrleur. Notez que quelques 20ms retard sont utiliss entre chaque lecture
successive.
Code-source 3.8
/****************************************************************************
LECTURE DE LEEPROM
====================
Ce programme lit les donnes partir d'adresses de 0 0x2F de l'EEPROM et
puis envoie ces donnes pour PORTB du microcontrleur.
Microcontrleur: 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);
}
- 68 -
Les broches 7 14 sont les huit lignes de bus de donnes (D0 D7). Les donnes peuvent
tre transfres entre le microcontrleur 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 donnes suprieures (D4
D7) sont utilises. Le 4-bits mode a l'avantage de ncessiter moins de lignes d'E / S pour
communiquer avec l'cran LCD.
- 69 -
Appellation
Fonction
VSS
Ground
VDD
+ve supply
VEE
Contrast
RS
Register select
R/W
Read/write
EN
Enable
D0
Data bit 0
D1
Data bit 1
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 bibliothque fournit un grand nombre de fonctions pour contrler du texte LCD
avec 4-bits et les interfaces de donnes 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 utilise pour configurer l'interface LCD. La connexion par dfaut
entre le LCD et le microcontrleur est la suivante :
LCD
RS
FR
D4
D5
D6
D7
2
3
4
5
6
7
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 caractre la ligne indique et la colonne la position du
curseur. La fonction doit tre appele avec les paramtres dans le l'ordre suivant :
- 71 -
Commande LCD
LCD_CLEAR
Effacer l'affichage
LCD_RETURN_HOME
LCD_FIRST_ROW
LCD_SECOND_ROW
LCD_THIRD_ROW
LCD_FOURTH_ROW
LCD_BLINK_CURSOR_ON
Clignotement du curseur
LCD_MOVE_CURSOR_LEFT
LCD_MOVE_CURSOR_RIGHT
LCD_SHIFT_LEFT
LCD_SHIFT_RIGHT
Exercice 3.8
Un contrleur de texte LCD est reli un microcontrleur PIC16F84A dans le mode par dfaut
comme illustre la figure 3.2.
Ecrire un programme pour envoyer le texte Mon Ordinateur la ligne 1, la colonne 4 de
lcran LCD.
Solution 3.8
Le programme est donn dans le code-source 3.9 (fichier : LCD.C).
Au dbut le PORTB est configur en sortie par la dclaration 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 LECRAN LCD
==================================
Un contrleur de texte LCD est reli un microcontrleur 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 2me ligne d'cran LCD.
Microcontrleur: 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 -
Fig. 3.2 Connexion du PIC avec LCD (pour la simulation dans le PROTEUS)
utilis pour le bus RS232 de la communication srie entre deux appareils lectroniques.
Dans la communication de srie, seulement deux cbles (plus un cble de terre) sont
ncessaires pour transfrer des donnes dans les deux sens. Les donnes
sont envoys en format srie bit par bit. Normalement, le dispositif de rception est au
repos.
Pour lmission la patte TX est au niveau logique 1, galement connu sous le nom
MARK. Transmission des donnes 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 dpart la logique 0. La suite de ce bit, 7 ou 8 bits de donnes sont envoys, suivie
par un bit de parit en option. Le dernier bit envoy sappelle bit d'arrt est au niveau
logique 1. Les donnes en srie est gnralement envoy sous forme de 10 bits : un bit
de dpart, 8 bits de donnes, et un bit d'arrt, et aucun bits de parit.
La figure 3.3 montre comment le caractre A peut tre envoye en utilisant la communication
srie. Caractre "A" a la configuration binaire ASCII est 01000001.
1
IDLE
STOP
START
Le mikroC PRO pour PIC fournit des routines pour la mise en uvre du logiciel de
communication UART. Ces routines sont indpendantes du matriel et peut tre utilis avec
n'importe quel microcontrleur.
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 spcifie les paramtres de communication srie 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 dun nombre de transmission ;
tx est lmmteur de transmission ;
vitesse de transmission est le taux de transmission choisi, o la valeur maximale
dpend de la frquence d'horloge du microcontrleur ;
mode spcifie si les donnes devraient tre inverss ou non lors de la sortie. Un 0
indiquent quils ne devraient pas tre inverss, et un 1 indique qu'ils devraient tre
inverss. Quand un RS232 est utilis donc dans ce cas le mode doit tre rgl 1.
Soft_Uart_Init doit tre la premire fonction appele avant que le logiciel soit
tabli.
L'exemple suivant configure l'UART utiliser PORTC comme un port srie, avec RC6 pour la
patte TX et RC7 pour la patte RX. La vitesse de transmission est fix 9600 avec le mode non
inverss:
- 76 -
Soft_Uart_Read
La fonction Soft_Uart_Read reoit un octet partir d'une patte du port srie spcifi. La
renvoie une condition d'erreur et les donnes sont lues partir du port srie. La fonction
ne pas attendre que les donnes soient disponibles sur le port, et donc le paramtre d'erreur
doit tre test si un octet est prvu. 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 srie
en appelant la fonction Soft_Uart_Init. L'octet reu 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 srie. Les
donnes envoyer doivent tre spcifis comme un paramtre dans l'appel de la fonction.
Par exemple, pour envoyer un caractre "A" la patte de port srie :
char MyData = A;
Soft_Uart_Write(MyData);
L'exercice suivant illustre l'utilisation des fonctions du logiciel UART.
Exercice 3.9
Le port srie d'un ordinateur (par exemple, COM1) est reli un microcontrleur PIC16F887, et
logiciel d'mulation de terminal (par exemple, HyperTerminal) est exploit sur le PC pour utiliser
un port srie. Pattes RC6 et RC7 du microcontrleur sont les broches TX et RX respectivement.
Le dbit en bauds est de 9600.
Ecrire un programme pour lire les donnes du terminal, puis les renvoyer vers le terminal. Par
Un circuit intgr de conversion MAX232 est utilis pour
convertir les signaux du
microcontrleur des niveaux RS232.
La figure 3.5 montre le schma du circuit de cet exercice.
Solution 3.9
Le circuit MAX232 reoit le signal TX de la patte RC6 du microcontrleur et le convertit en
niveaux RS232. Les donnes sries reues du circuit MAX232 sont converties en niveaux de
tension du microcontrleur, puis envoy la patte RC7. Noter que le fonctionnement correct du
circuit
MAX232 ncessite quatre condensateurs tre connect au circuit.
- 77 -
Fig. 3.5 Schma du circuit dexercice 3.9 (pour la simulation dans le PROTEUS)
Ctype
Math
Stdlib
String
bibliothque
bibliothque
bibliothque
bibliothque
Bibliothque Ctype
Les fonctions de la bibliothque Ctype sont principalement utilises pour la conversion des
essais ou des donnes. Tableau 3.5 dresse la liste des fonctions les plus couramment utiliss
dans cette bibliothque.
Bibliothque Math
Les fonctions de la bibliothque Math sont utilises pour les oprations mathmatiques en
- 78 -
// Si l'erreur a t dtecte
PORTC= error;
else
- 79 -
Fonction
isalnum
isalpha
isntrl
isdigit
islower
isprint
isupper
toupper
tolower
Bibliothque Stdlib
La bibliothque stdlib contient des fonctions de bibliothque standard. Tableau 3.7 dresse la
liste des fonctions les plus utilises dans cette bibliothque.
Fonction
acos
asin
atan
atan2
cos
cosh
exp
fabs
log
Log10
pow
sin
sinh
sqrt
tan
tanh
Description
abs
atof
atoi
atol
max
min
rand
srand
Gnre une fonction rand donc une nouvelle squence de nombres est gnre
xtoi
Exemple 3.10
Ecrire un programme pour calculer le sinus des angles de 0 90 avec le pas de 1 et stocker
le rsultat 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 linstruction for, et l'intrieur de cette boucle le sinus d'angles sont calcules
et stockes 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 rsultats sont
stocks dans un tableau appel Trig_Sine.
Microcontrleur: 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;
}
}
Bibliothque String
La bibliothque des fonctions string est utilise pour effectuer la manipulation de chanes de
caractres et de la mmoire oprations. Tableau 3.8 dresse la liste des fonctions les plus
couramment utiliss dans cette bibliothque.
Tableau 3.8 Fonctions de la bibliothque String
Description
Fonction
strcat,strncat
strchr, strpbrk
strcmp, strncmp
strcpy, strncpy
strlen
Exemple 3.11
Ecrire un programme pour illustrer comment les deux chanes "MON PUISSANT et
COMPUTER peuvent tre joints dans une nouvelle chane en utilisant les fonctions de la
bibliothque string.
Solution 3.11
Le programme requis est indiqu dans le code-source 3.12 (fichier JOIN.C). La
mikroC bibliothque String de la fonction strcat est utilise pour joindre les deux chanes
pointes par p1 et p2 dans une nouvelle chane stocke dans un tableau de caractres appele
New_String.
Code-source 3.12
/**************************************************************************
ASSEMBLAGE DE DEUX LIGNES DE CARACTERES
=================================
Ce programme montre comment deux chanes peuvent tre jointes pour obtenir
une nouvelle chane de caractres.
La fonction strcat est utilis pour joindre les deux chanes pointes par
p1 et p2 dans une nouvelle chane stocke dans le tableau de caractres
New_String.
Microcontrleur: 16F887
Oscillateur: HS, 10.0000 Mhz
Fichier: JOIN.C
Date:Juillet, 2012
************************************************************************/
void main()
{
const char *p1 = MON PUISSANT ;
// Premire ligne
const char *p2 = COMPUTEUR;
// Deuxime ligne
char New_String[80];
strcat(strcat(New_String, p1), p2);
// Joindre les deux lignes
- 82 }
Description
ByteToStr
ShortToStr
WordToStr
IntToStr
LongToStr
FloatToStr
Bcd2Dec
Dec2Bcd
- 83 -
- 84 -
2. Aprs cela, les LEDs doivent clignoter chaque 500 ms infiniment comme indiqu dans la
figure ci-dessous.
Le fichier nomm LED2.C qui ralise ce projet est reprsent dans le code-source 4.2
- 85 -
Code-source 4.2
/****************************************************************************
LEDs clignotantes diffremment
===============================
Les huit LEDs sont connectes PORTB du microcontrleur 16f887. Lorsqu'une
tension est applique au microcontrleur (ou est rinitialis), les LEDs
s'allument en alternance en deux faon diffrente.
Microcontrleur: 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 -
Exemple 3. RELAI
Dans ce projet la minuterie, sur la base de registre TMR0, est utilise comme un compteur.
L'entre de comptage est relie 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) apparat
sur le pin3 de PORTD. Cette tension active un relais lectromcanique, 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 sr, il peut tre
n'importe quel nombre dfini comme une constante. Par ailleurs, le microcontrleur 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 microcontrleur dans
l'industrie; quand quelque chose est effectu autant de fois que ncessaire, puis quelque chose
d'autre doit tre activ ou dsactiv ....
- 87 -
***********************************************************************************/
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 configures en numriques
//
//
//
//
Initialisation du porte A
Porte A est configur en entr
Initialisation du PORTD
Broche 3 du PORTD3 est configur en sortie
Une selle constante numre RELAI est utilise dans cet exemple. Il est attribu un valeur
lorsquelle est dclare :
enum sortie {RELAI = 3};
Si plusieurs broches du PORTD sont relies des RELAIS, lexpression ci-dessus pourrait tre
crite comme suit :
enum sortie {RELAI=3, CHAFFAGE, ECLAIRAGE =6, POMPE} ;
Toutes les constantes, aprs celle avec les valeurs affectes (RELAI = 3 et ECLARAGE = 6),
sont des valeurs automatiquement incrment de 1 par rapport la valeur prcdente. Dans ce
cas, la constante CHAUFFAGE et celle POMPE seront affects les valeurs 4 et 7 respectivement
(CHAUFFAGE = 4 et POMPE = 7).
- 88 -
- 89 -
Code-source 4.5
/****************************************************************************
TMR1
=======
Une fois que le registre TMR1 est trop-plein la routine dinterruption
incrmente automatiquement par 1 la variable cnt. Lorsque sa valeur atteint
76, les bits du PORTB sont inverss.
Microcontrleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: INTERRUP_TMR1.c
Date: Juillet 2012
****************************************************************************/
unsigned short cnt;
// Dfinir la variable cnt
void interrupt()
{
cnt++ ;
/* Interruption cause lincrmentation 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 numriques
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 linterruption en cas de dbordement du
TMR1*/
cnt = 0;
// Remis 0 la variable cnt
INTCON = 0xC0;
// Activer interruption (bits GIE et PEIE)
do
{
// Boucle sans fin
- 90 -
cnt = 0;
}
} while (1);
- 91 -
- 92 -
CCP1CON =0b00111110;
PWM1_Init(5000);
}
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
RA0 est
de current_duty
RA1 est
de current_duty
}
Delay_ms(150);
// Retardement de 150ms
}
}
- 93 -
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 entre
/* Configurer les autres broches du
PORTA en numrique */
/* Broches de RB7, RB6 du PORTB sont en
sortie */
// PORTD est configur en sortie
Code-source 4.8
/****************************************************************************
Mmoire EEPROM
===================
Le registre du PORTB est incrment en permanence. Au moment de l'appui
sur
le bouton appel MEMO_EEPROM, un nombre binaire
du PORTB sera sauvegard
dans la mmoire EEPROM. Ce nombre doit tre directement lu de lEEPROM et
ensuite affich sur PORTD sous forme binaire.
Microcontrleur: 16F887
Oscillateur : HS, 8.0000 Mhz
Fichier: EEPROM.c
Date: Juillet 2012
****************************************************************************/
void main()
{
ANSEL = 0;
//Toutes les E/S sont configurs en numriques
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++;
- 95 -
// Retardement de 100mS
if (PORTA.F2 == 0)
{
EEPROM_Write(5,PORTB);
PORTD = EEPROM_Read(5);
do;
while (PORTA.F2 ==0);
}
}
while(1);
- 97 -
- 98 -
Delay_ms(1000);
for(;;)
{
Cnt++;
if(Cnt == 100) Cnt = 0;
Delay_ms(1000);
}
}
Code-source 4.10
/****************************************************************************
MULTIMETRE AVEC LAFFICHEUR LCD
================================
Ce projet illustre l'utilisation d'un cran LCD alphanumrique.
Un message crit en deux lignes apparat sur l'afficheur LCD :
Multimtre
- Mesure de Deux secondes plus tard, le message dans la seconde ligne est modifi et
affiche tension prsent sur l'entre (broche RA2) de convertisseur A / D :
Multimetre
Tension:
Microcontrleur: 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
TRISB4_bit;
TRISB5_bit;
TRISB0_bit;
TRISB1_bit;
TRISB2_bit;
TRISB3_bit;
- 100 -
//
while (1)
{
adc_rd = ADC_Read(2);
// Conversion A / D. Pin RA2 est une entre.
Lcd_Out(2,1,text);
// Ecrire rsultat dans la deuxime ligne
tlong = (long)adc_rd * 5000;// Convertir le rsultat en millivolts
tlong = tlong / 1023;
// 0 .. 1023 -> 0-5000mV
ch = tlong / 1000;
/* Extrait volts (en milliers de millivolts)
partir du rsultat */
Lcd_Chr(2,9,48+ch);
// Ecrire le rsultat en format ASCII
Lcd_Chr_CP('.');
ch = (tlong / 100) % 10;
// Extrait des centaines de millivolts
Lcd_Chr_CP(48+ch);
// Ecrire le rsultat en format ASCII
ch = (tlong / 10) % 10;
// Extrait des dizaines de millivolts
Lcd_Chr_CP(48+ch);
// Ecrire le rsultat en format ASCII
ch = tlong % 10;
// Extrait chiffres pour millivolts
Lcd_Chr_CP(48+ch);
// Ecrire le rsultat en format ASCII
Lcd_Chr_CP('V');
Delay_ms(1);
}
}
- 101 -
Code-source 4.11
/****************************************************************************
COMMUNICATION SERIE RS232
==========================
Cet exemple illustre l'utilisation de fonction Software_UART de la
bibliothque du compilateur mikroC PRO.
Microcontrleur: 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;
- 102 -
- 103 -
Code-source 4.12
/****************************************************************************
Mesure de la temprature 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
temprature dans la plage de -55 C +125 C avec la prcision 0,5 C.
Pour le but de transfrer des donnes vers le microcontrleur, un type
particulier de communication srie appel 1-Wire (1-fil) est utilise
Microcontrleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: TEMPERATURE_One_Wire.c
Date: Juillet 2012
****************************************************************************/
// Configuration des connections d'afficheur LCD avec PIC
sbit LCD_RS at RB0_bit;
sbit LCD_EN at RB1_bit;
sbit LCD_D4 at RB4_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D7 at RB7_bit;
sbit
sbit
sbit
sbit
sbit
sbit
LCD_RS_Direction
LCD_EN_Direction
LCD_D4_Direction
LCD_D5_Direction
LCD_D6_Direction
LCD_D7_Direction
at
at
at
at
at
at
TRISB0_bit;
TRISB1_bit;
TRISB4_bit;
TRISB5_bit;
TRISB6_bit;
TRISB7_bit;
// Fin de configuration
/* Configurer TEMP_RESOLUTION la rsolution correspondante du capteur
utilis DS1822: 12 (rglage par dfaut 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 -
/* Vrification si la temprature
est ngative?*/
{
Lcd_Chr(2,4,'-');
temp2write = ~temp2write + 1;
}
// Extraire de la partie entire (temp_whole) de temprature
temp_whole = temp2write >> RES_SHIFT;
text[0] = '0';
// Conversion temp_whole en caractres
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 units
/* 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 caractres
text[4] =
text[5] =
text[6] =
text[7] =
// Affichage
temp_fraction/1000
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: ");
Lcd_Chr(2,14,'C');
- 105 -
- 106 -
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) ;
// RB7 son
Tone1
if (Button(&PORTB,6,1,1))
Tone2();
while (RB6_bit) ;
if (Button(&PORTB,5,1,1))
Tone3();
while (RB5_bit) ;
if (Button(&PORTB,4,1,1))
Melody2();
while (RB4_bit) ;
if (Button(&PORTB,3,1,1))
Melody();
while (RB3_bit) ;
}
}
- 108 -
- 109 -
Code-source 4.14
/****************************************************************************
Utilisation dafficheur 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
rsolution de l'cran. Ici on a reprsent poussires images : dun camion,
des lignes, des cercles, des caractres.
Microcontrleur: 16F887
Oscillateur : HS, 10.0000 Mhz
Fichier: IMAGE_GLCD.c
Date: Juillet 2012
****************************************************************************/
// Declarations
const code char truck_bmp[1024];
// Connections dafficheur 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
les comparateurs
// Initialiser GLCD
// Effacer lcran de GLCD
//
//
//
//
{
Delay_ms(250);
Glcd_V_Line(2, 54, ii, 1);
Glcd_H_Line(2, 120, ii, 1);
}
delay2S();
Glcd_Fill(0x00);
#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 bote
delay2S();
#ifdef COMPLETE_EXAMPLE
Glcd_Fill(0xFF);
// Remplir GLCD
Glcd_Set_Font(Character8x7, 8, 7, 32); // Changer des caractres
- 111 -
- 112 -
Avant de compiler le fichier IMAGE_GLCD.c il est ncessaire de cocher les fonctions Glcd dans
le gestionnaire de bibliothque du compilateur mikroC PRO.
Pour inclure le fichier truck_bmp.c dans le projet, il faut procder les tapes de 1 8 dans le
compilateur mikroC PRO comme cest montr ci-dessous.
- 113 -
33
8
GLCD Picture name: truck.bmp
Delay_ms(20);
return (Key);
// Sauvegarder la colonne 1
// Mettre anti-rebond
// Dterminer la touche enfonce
}
// Connections de LCD
- 115 -
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;
- 116 -
// Obtenir le fonctionnement
// Afficher Res=
// Effectuer l'opration
// 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);
}
}
Si un blanc
Afficher le rsultat
Temporisation de 5 secondes
- 117 -
- 118 -
de ligne USART
void Newline()
{
Soft_UART_Write(0x0D);
Soft_UART_Write(0x0A);
}
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 = ";
- 119 -
// Calcule
// Si Addition
// Si Soustraction
- 120 -
// 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<j;i++)Soft_UART_Write(kbd[i]); // Afficher le rsultat
}
}
- 121 -
- 122 -