Chapitre 2

Programmation du microcontrôleur PIC 16F877

La programmation des microcontrôleurs PICs peut se faire par plusieurs langages

informatiques tels que l’assembleur et le langage C qui sont les plus répondus dans les
applications à base des PICs.

L'assembleur traduit les instructions écrites en utilisant les mnémoniques du langage

assembleur en code binaire exécutable par le microcontrôleur. L'enchaînement des
mnémoniques s'appelle le listing ou code source du programme alors que le code binaire
s'appelle l'objet ou l'exécutable. Le compilateur, quant à lui, traduit les instructions écrites en
langage évolué en code binaire exécutable. L'ensemble de ces instructions constitue aussi un
listing ou code source et le code binaire est appelé code objet.
Ainsi le développement d'applications à base de microcontrôleur, nécessite un outillage
informatique et éventuellement un programmateur. A chaque microcontrôleur (ou famille de
µc) correspond un outil de développement. On doit toujours passer par les trois phases
suivantes pour pouvoir utiliser un µc dans une application donnée:

Le programmateur : Transfert le programme compilé (langage machine) dans la mémoire

flash du microcontrôleur. Il est constitué d’un circuit branché sur le port série du PC, sur
lequel on implante le PIC, et d’un logiciel permettant d’assurer le transfert.

Dans les systèmes de développement pour microcontrôleur, assembleur et compilateur

doivent cohabiter sans rivalité. Cela est d'autant plus vrai pour les microcontrôleurs que pour
les entrées/sorties performantes et rapides qui se conçoivent en assembleur. Un bon
compilateur permet de pouvoir écrire des sous programmes directement en langage machine
au sein du programme en langage évolué.
En fait, l'assembleur est pénible à utiliser lorsqu'il s'agit de faire des calculs complexes car il
est constitué d'instructions élémentaires. On préfère alors utiliser un langage évolué
notamment le langage C. Par contre, l'assembleur, convient parfaitement lorsqu'il s'agit de
manipuler les données des registres ou de commander les entrées/sorties. On cherche toujours
à faire fonctionner assembleur et compilateur ensemble dans les grandes machines pour
assembler ou compiler le programme de l'application et le transcrire en binaire exécutable.
En pratique, la conception d'une application se déroule en plusieurs étapes. Après avoir choisi
la solution matérielle au problème, on peut commencer à penser à un organigramme puis
viennent le langage et la programmation en elle-même. Par émulation ou simulation, on teste
le programme et l'application. On y apporte les correctifs nécessaires au bon fonctionnement
avant de transférer le programme au PIC. La plupart des constructeurs commercialisent des
Kits de développement à des prix intéressants pour encourager leurs produits. Ces Kits
comprennent un assembleur, un simulateur et une carte de programmation toutes bien
documentées.

1
 Environnement MPLAB IDE pour les PICs
Pour les microcontrôleurs PICs qui nous intéressent, la société Micochip a développé une
plate-forme logicielle appelée MPLAB IDE (Integrated Development Environment). C'est
l’outil de développement principal de l’environnement MPLAB fournit gratuitement par
Microchip.

Environnement MPLAB IDE

MPLAB regroupe l'éditeur de texte, le compilateur MPASM, un outil de simulation et le
logiciel de programmation. Le programmateur lui-même, n'est malheureusement pas fournit
gratuitement.
Ainsi, on utilisera MPLAB pour écrire, compiler et éventuellement simuler les programmes.
Ensuite, pour implanter les programmes dans la mémoire flash du PIC, nous utiliserons
n'importe quel programmateur piloté par l'un des logiciels (ex: Icprog ou WinPic)
disponibles gratuitement sur le Web.
Dans l'environnement MPLAB, Le programme doit être écrit en assembleur, langage proche
de la machine et donc nécessitant un long apprentissage. Alors que le langage de
programmation préféré pour programmer le PIC 16F877 est le langage évolué : Le code
source écrit en langage C doit donc être compilé en assembleur à l'aide d'un compilateur C.
On trouvera sur le marché, le compilateur C : CC5X de la société CCS (Custom Computer
Services) dans sa version gratuite téléchargeable sur www.bknd.com. C'est un compilateur C
adapté aux microcontrôleurs PICs. On peut alors intégrer CC5X dans l'environnement
MPLAB. Ainsi CC5X devient un outil de MPLAB dans lequel l'écriture, la simulation et le
debugging du programme en C devient alors possible et on aura le choix du compilateur
dans l'environnement MLAB comme suit:
La déclaration du compilateur s'effectue une seule fois :
Lancez MPLAB IDE ; ouvrez la fenêtre Projet > Set Language Tool Locations…

2
Nous y reviendrons sur les structures de programmes en C et la programmation en C
ainsi que les logiciels utilisés.
Initialement, l'environnement MLAB utilise le compilateur MPASM et le programme doit
être rédigé en assembleur.

Utilisation de l'assembleur
Les étapes nécessaires permettant de voir un programme s'exécuter sur un PIC sont :
 Écrire un programme en langage assembleur dans un fichier texte et le sauvegarder
avec l'extension .asm
 Compiler ce programme avec l'assembleur MPASM fourni par Microchip. Le résultat
est un fichier exécutable avec l'extension .hex contenant une suite d'instruction
compréhensible par le pic.
 Transplanter le fichier .hex dans la mémoire programme du PIC (mémoire flash) à
l'aide d'un programmateur adéquat. On peut utiliser les programmateurs de Microchip
ou tout autre programmateur acheté ou réalise par soit même.
 Mettre le PIC dans son montage final, mettre sous tension et admirer le travail.

Structure d'un programme écrit en assembleur

Un programme écrit en assembleur doit respecter une certaine syntaxe et un certain nombre
de règles afin qu'il soit facile à lire et à débuguer :
• Tout ce qui commence à la première colonne est considéré comme une étiquette (label)
permettant de faire des renvois et aussi des assignations de constantes et de variables.
• tout ce qui suit un point virgule est considéré comme un commentaire non interprété par le
compilateur
• Un programme apparaît donc comme un texte écrit sur 3 colonnes :
- la colonne de gauche contient les étiquettes
- la colonne du milieu contient les l’instructions
- la colonne de droite contient des commentaires
Il existe différentes façons indiquant comment doit être organisé un programme.
Exemple d'utilisation de MLAB:
Après l'installation, lancer MPLAB et faire les config ci-dessous :
 Configure Select Device PIC16F876 ou PIC16F877
Nous allons réaliser un tout petit programme sans grand intérêt pour voir la
procédure de fonctionnement (avec MPLAB 6.30)
 Ouvrir une nouvelle fenêtre (de l'éditeur) pour commencer a écrire un programme :
file _ new ou cliquez sur l'icone feuille blanche
 Taper le petit programme ci-dessous dans la fenêtre qui vient de s'ouvrir. Ce
programme incrémente sans fin la position mémoire (RAM) 70H
loop incf 70h,1
goto looop
end
 Sauvegarder (file save ) ce programme dans la directory de votre choix
sous le nom bidon.asm
 Lancer la compilation du programme a l'aide de la commande project
Quikbuild
Apparemment il y a un problème, le compilateur nous dit qu'il y une erreur a la ligne
2 Error C:\...\BIDON.ASM 2 : Symbol not previously defined (looop) Évidemment,
le label loop définit dans la ligne précédente prend seulement deux o. Corrigez et

3
 recommencez. Cette fois ça a l'air d'aller. On peut vérifier que le compilateur a crée
le fichier bidon.hex dans la même directory ou se trouve bidon.asm. Les fichiers
bidon.cod, bidon.err et bidon.lst ne nous servent a rien pour l'instant on peut les
détruire.
 Nous pouvons maintenant exécuter notre programme en simulation pour voir s'il
réalise bien la tache demandée :
Pour faire apparaitre la barre d'outil du simulateur :
Debugger Select tool MPLAB SIM
 Ouvrez la fenêtre qui visualise la mémoire RAM : view FileRegisters. et repérer
la case mémoire 70h
 Exécuter maintenant le programme PAS a PAS en cliquant a chaque fois sur le bouton
Step Into { } en observant la case mémoire 70h . (on dirait que ça marche).
 On peut aussi exécuter en continu en cliquant sur le bouton animate  , , pour
arrêter, il faut cliquer sur le bouton halt .
Pour plus de détail, consulter le manuel d'utilisation de MPLAB

4
5
6
7
Utilisation du langage C
L’intérêt principal est la nécessité de développer en langage évolué; nous avons déjà
signalé que l’assembleur est le plus proche au langage machine mais trop peu lisible
est mal adaptés à une architecture complexe de programme.
Nous avons aussi montré la facilité d'intégration du compilateur CC5X dans
l'environnement MPLAB sans oublier que le compilateur doit être déclaré une seule
fois au début.

8
 Avantages de l'utilisation du langage C:
• le C reste proche du matériel (mise à 1 ou 0 d’un bit d’un port d’entrée sortie)
• le C est structuré (prog. Facilement divisible en bloc = fonctions,..)
• 1 seule ligne de C peut produire plusieurs centaines d’instructions assembleur donc
simplification du code source, et fiabilité.
• Souplesse de travail de part la portabilité globale d’un programme en C (hors
gestion entée/sortie)
• Portabilité entre différents types de microcontrôleurs de la même famille
Inconvénients lors de l'utilisation du langage C :
• Le C destiné à l’origine pour de gros ordinateurs à mémoire centrale. Une même
mémoire pour le programme, les données. Dans un microcontrôleur le programme
dans une mémoire à lecture seule, les données dans une mémoire en lecture/écriture
mais volatile (modifiable par événement extérieur autre que programme). Le C n’a
pas d’outils standards pour gérer ces différences.
• Les interruptions doivent et peuvent être écrites en C. les interruptions ne sont pas
des concepts du langage C. Les constructeurs fournissent des extensions pour
fonctionner sur microcontrôleurs
• Différences dans les propriétés des RAM et des ROM pour intégrer la notion
d’entrée/sortie
Les étapes de génération d’un programme écrit en langage C sont :
L’édition du fichier source mon_programme.C avec un éditeur de texte (simple
sans mise en forme du texte).
La compilation du fichier source pour obtenir un fichier objet :
mon_programme.ASM. La compilation est la transformation des instructions C en
instructions assembleur pour microcontrôleur PIC.
L’édition de liens permet d’intégrer des fonctions prédéfinies. Le programme
auxiliaire Éditeur de liens (linker ou binder) génère à partir du fichier
mon_programme.ASM un fichier exécutable mon_programme.HEX compatible avec
le PIC.
Règles de bases:
Toutes instructions ou actions se terminent par un point virgule ;
Une ligne de commentaires doit commencer par /*et se terminer par */ ou commencer par //.
Un bloc d'instructions commence par {et se termine par }.
Un programme en C utilise deux zones mémoires principales :
 La zone des variables est un bloc de RAM où sont stockées des données manipulées
par le programme.
 La zone des fonctions est un bloc de ROM qui reçoit le code exécutable du
programme et les constantes.
Langage C (juste l'essentiel)
Les variables et les constantes
1) Les constantes
Les constantes n’existent pas, c'est-à-dire qu’il n’y a pas d’allocation mémoire, mais
on peut affecter à un identificateur (Nom : Il ne doit pas dépasser 32 caractères, sans
accent) une valeur constante par l’instruction #define.
Syntaxe : < #define> <identificateur> <valeur> ; Exemple: #define PI 3.14

9
 Déclarations spécifiques au compilateur CCS:
#bit id = x,y
Id : identifiant (Nom d’un bit)
X : Nom du variable ou d’une constante
Y : position du bit
Exemple :
#bit RW = PORTA,2
#bit LED_R=PORTB.4
#byte id = X
Id: identifiant
X: valeur 8 bits
Exemple :
#byte PORTA = 5 // adresse du port A
#byte PORTB = 6 // adresse du port B
#byte PORTC = 7 // adresse du port C
#byte PORTD = 8 // adresse du port D
#byte PORTE = 9 // adresse du port E
2) Les Variables
Les variables sont définies par signé ou non signé, le type et l'identificateur.
Syntaxe: <signed> <type> <identificateur1>, …, <identificateurn> L'identificateur :
C’est le nom (Il ne doit pas dépasser 32 caractères, sans accent) affecté à la variable.
Le type : Il détermine la taille de la variable et les opérations pouvant être effectuées.
On peut rajouter le mot signed devant le type du variable, alors la variable devient
signée.
Exemples : Int A,B,C,D ;
Char MESSAGE[10] ;
Signed int A ; // Entier de type signé, de -128 à +127
Les types du compilateur CCS figurent dans le tableau ci-dessous :

3) Représentation des différentes bases du compilateur CCS et du code ASCII

int a = 4 ; // Un nombre seul représente un nombre décimal.
int b = 0b1010 ; // Un nombre précédé de 0best un nombre binaire.
int p = 0x00FF ; // Un nombre précédé de 0xest un nombre hexadécimal.
char c = ‘A’; char c = ‘0x41’; ou char c = ‘65; // Un caractère entre ‘’ représente son
code ASCII.

10
 4) Les fonctions
Avec des paramètres d’entrée et un paramètre de sortie
Syntaxe :
Type de la variable de retour nom de fonction (types nom des paramètres)
{
Instruction 1 ;
.

Instruction n ;
Return (valeur) ; // Valeur à renvoyer
}
Avec :
//Nom de la fonction :
//Description du rôle de la fonction :
//Paramètres d’entrée : Noms et types des paramètres d’entrée
//Paramètre de sortie : Nom et type du paramètre de sortie
Une fonction sans paramètres d’entrée et de sortie
Void nom de fonction (Void)
{
Instruction 1 ;
.

Instruction n ;
}
Remarque : Il peut y avoir aussi des fonctions avec paramètres d’entrées et sans paramètre de
sortie et vice versa.
5) Les Opérateurs

11
Le résultat de la comparaison peut prendre deux valeurs VRAIou FAUX.
-FAUX correspond à 0.
-VRAI correspond à toute valeur différente de 0

a ou b

Ces opérateurs permettent la comparaison de conditions composées telles que (x > y)&& (u >
v). Le résultat fourni est de type logique (0 ou 1).

Exemples : a et b deux entiers tel que :

a = 1100 0111 0101 0011 (0xC753)
b = 0001 1001 1010 1110 (0x19AE)
a & b = 0000 0001 0000 0010 (0x0102)
a | b = 1101 1111 1111 1111 (0xDFFF)
a ^ b = 1101 1110 1111 1101 (0xDEFD)
~ a = 0011 1000 1010 1100 (0x38AC)
~ b = 1110 0110 0101 0001 (0xE651)
a<<2 = 0001 1101 0100 1100 (0x1D4C)
6) Les structures répétitives

12
7) Les fonctions adaptées aux microcontrôleurs PIC
 Les directives
:#use delay
Syntaxe : #use delay(clock=fréquence)
Renseigne le compilateur sur la fréquence du quartz utilisé.
Exemple : #use delay(clock=4000000)
#fuses
Syntaxe : #fuses options
Permet de définir le mot de configuration. Les options sont :
- LP, XT, HS, RC : Choisir le type d'oscillateur
- WDT, NOWDT : Activer/désactiver le chien de garde
- PUT, NOPUT : Activer/désactiver le Power Up Timer PUT( Timer spécial
qui retarde le démarrage de l'exécution du programme aprèsque le PIC a été
réinitialisé. Ce délai donne le temps de PIC oscillateur pour démarrer et se
stabiliser).
- PROTECT, NOPROTECT : Activer/Désactiver la protection du code
Exemple : #fuses XT,NOWDT,NOPUT,NOPROTECT
#int_xxxx
Spécifie la source de l’interruption.
Syntaxe : #int_ext : interruption externe.
8) La gestion des entrées et des sorties
 Configurer un port en entrée ou en sortie
Syntaxe : set_tris_X(valeur)
Avec :
- X : Nom du port : A .. E
13
 - valeur : définie la configuration du port (1 entrée et 0 sortie)
Exemple :
set_tris_A(0b00001111) ; PA0 à PA3 en entrée et P A4 à PA7 en sortie
set_tris_A ( 0x0F ); // B7,B6,B5,B4 en sortie (0)
// B3,B2,B1,B0 en entrée (1)
 Gestion des ports d’entrée ou en sortie
Mise à l’état bas d’une pine d’un port
Syntaxe : output_low(pin)
- pin est une constante définie dans le fichier entête PIC16FXX.h
Exemple : output_low(PIN_A0); // mise à 0 de la broche A0
Mise à l’état haut d’une pine d’un port
Syntaxe : output_high(pin)
Exemple : output_high(PIN_B2); // mise à 0 de la broche B2
Modifier l’état d’une pine d’un port
Syntaxe : output_bit(pin,valeur)
Exemple : output_bit( PIN_B0, 0); // même rôle que output_low(pin_B0);
Modifier l’état d’un port
Syntaxe : output_X(valeur)
Exemple : output_b(0xf0); ); // mise à 1 de B7,B6,B5,B4
// mise à 0 de B3,B2,B1,B0
Lecture de l’état d’une pine
Syntaxe : valeur=input(pin)
Exemple : if( input(PIN_A0) ) // Si A0 est à l’état haut, écrire « A0 est active »
printf("A0 est active \r\n") ;
Lecture de l’état d’un port
Syntaxe : valeur=input_X()
Exemple : Data = input_c(); //data reçoit l’état du port c
Mettre à 0 un bit d’une variable
Syntaxe : BIT_CLEAR(var, bit)
Exemple :
a=0x1F
BIT_CLEAR(a, 3) // a devient 17 hexa.
Mettre à 1 un bit d’une variable
Syntaxe : BIT_SET(var, bit)
Exemple :
a=0x1F
BIT_SET(a, 6) // a devient 3F hexa.

14
 Test de l’état d’un bit d’une variable
Syntaxe : BIT_TEST(var, bit)
Exemple :
a=0x1F
BIT_TEST(a, 2) // Le résultat est 1 car le bit 2 de la variable « a » est à 1.
9) Gestion des temporisations
Le compilateur intègre des fonctions très pratiques pour gérer les délais, à savoir :
delay_us(valeur) ; // temporisation en μS
delay_ms(valeur) ; // temporisation en mS
Pour pouvoir utiliser ces fonctions, il faut indiquer par la ligne ci-dessous la fréquence
du Quartz de votre application. Cette ligne doit être définie au début du programme.
#use delay (clock=fréquence_du_quartz)
Exemples :
#use delay (clock=4000000) // Quartz de 4Mhz
#use delay (clock=20000000) // Quartz de 20Mhz
10) Gestion de la liaison série
Toutes les fonctions d’entrée et de sortie peuvent être redirigées sur le port série
du microcontrôleur, Il suffit d’ajouter la ligne ci-dessous pour configurer le port série :
#use rs232 (BAUD=9600, xmit=PIN_C6, rcv=PIN_C7)
// Cette ligne configure la liaison série du PIC avec une vitesse de 9600 bauds.
Remarque : Cette ligne doit être définie au début du programme, après la ligne qui
définie la Fréquence du quartz.
Alors les fonctions suivantes utiliseront le port série comme moyen de
communication.
La fonction printf
Cette fonction permet d’envoyer une chaîne de caractère formatée sur la liaison
RS232 ou bien vers une fonction bien déterminée.
Syntaxe : printf (chaine) ou printf (Cchaine, valeurs...)
- Chaine peut être une constante de type chaîne ou un tableau de char terminé
par le caractère null.
- Cchaine est une chaîne composée (voir ci-dessous).
- valeurs est une liste de variables séparées par des virgules.
La « Cchaine » doit être composée de chaînes de caractères constante et
d’arguments de mise en forme des valeurs représenté par le symbole %wt
(formatage) avec :
- w est optionnel et peut être compris entre 1 et 9. il indique sur combien de
caractère va être le résultat ou 01-09 ou 1.1 to 9.9 pour les nombres à
virgule.
- t est le type et peut être :
c Caractère ascii
c caractère ou chaîne de caractère
u entier (int8 ou int 16) non signé affiché en base décimale
x entier (int8 ou int 16) affiché en base hexadécimale en minuscules

15
 X entier (int8 ou int 16) affiché en base hexadécimale en majuscules
d entier (int8 ou int 16) signé affiché en base décimale
f Float
Lx entier long (int32) affiché en base hexadécimale en minuscules
LX long (int32 affiché en base hexadécimale en majuscules
lu entier long (int32) non signé affiché en base décimale
ld entier long (int32) signé affiché en base décimale
: entier (int8 ou int 16) signé affiché en base octale
(Pour les autres arguments voir la documentation de CCS-Compiler)
Exemple :
printf("Bonjour !");
printf("\r\nMin: %2X Max: %2X\n\r",min,max);
// \n=LF (saut de ligne), \r=CR (retour à la première colonne)
printf("A/D value = %2x\n\r", value);
La fonction putc
Cette fonction permet d’envoyer un caractère formatée sur la liaison RS232.
Syntaxe : putc (char)
- Char est un caractère 8 bits
La fonction puts
Cette fonction permet d’envoyer une chaîne de caractères sur la liaison RS232,
terminée par le passage à la ligne (LF)
Syntaxe : variable=puts(chaine)
- chaîne est une chaîne de caractère constante terminé par le caractère null
Exemple : puts( " | Salut ! | " );
La fonction getc
Cette fonction permet de recevoir un caractère formatée sur la liaison RS232.
Syntaxe : variable=getc()
- Variable est un caractère 8 bits
Exemple :
void main () {
printf("Continuer (O,N)?");
do
{ reponse=getc(); }
while (reponse!='O' &&reponse!='N'); }
La fonction gets
Cette fonction permet de recevoir une chaîne de caractère sur la liaison RS232
Syntaxe : variable=gets()
-Variable est une chaîne de caractère constante terminé par le caractère null

16
 Structure d’un programme en C
#include <16F84A.H> //fichier de déclaration des registres internes du 16F84A.H
//Déclaration des adresses des ports E/S
#byte PORTA = 5 //adresse du port A
#byte PORTB = 6 // adresse du port B
//Déclaration des constantes
#define NB_MAX 100
//Affectation des entrées et sorties de type bit
#bit BUZZER = PORTD7 //par exemple : Command d’un buzzer
//Fréquence du quartz
#use delay (clock=20000000)
//Configuration de la liaison série de PIC avec une vitesse de 9600 bauds
#use rs232 (BAUD=9600, xmit=PIN_C6, rcv=PIN_C7)
//Déclaration du prototype de toutes les fonctions logicielles
//Nom de la fonction suivi d’un point virgule par exemple :
Void INIT_UC(Void) ;
//Déclaration des variables globales Par exemple :
Long DEBIT ;
Long VOULUME ;
Main() //Programme principale
{
Instruction 1 ;
Instruction n ;
}
//Déclaration des fonctions logicielles Par exemple :
//Nom de la fonction : DECALAGE_DROITE
//Description du rôle de la fonction : décalage à droite de NB bits
//Paramètres d’entrée : entier VAL, entier NB
//Paramètre de sortie : entier RESULTAT
int DECALAGE_DROITE (int VAL ,int NB)
{
Int RESULTAT;
RESULTAT = VAL >> NB;
Return (RESULTAT);}
//Appel de la fonction: Nom de la fonction (nom des paramètres) ;
//Exemple :
A = 16 ;
B = DECALAGE_DROITE (A, 2) ; //la valeur de A sera affectée à VAL
//la valeur 2 sera affectée à NB
//le résultat de la fonction sera affectée à B

17
 Autres environnements pour les PICs
Le logiciel MikroC
Le « MikroC » est un compilateur pour PIC Conçu par la société Mikroelektronika, ce
compilateur de nouvelle génération pour microcontrôleurs PIC bénéficie d'une prise en main
très facile. C'est un logiciel puissant, il permet d’écrire un programme en langage C. Ainsi le
programme source est donc écrit sur l’éditeur de MIKRO C, puis sera compilé. La
compilation délivre bien sûr plusieurs fichiers, le plus important est le code machine du
programme (.hex).
Le Compilateur MikroC pour PIC a trouvé une large application pour le développement de
systèmes embarqués sur la base de microcontrôleur, il permet d’écrire les routines
d’interruptions en assembleur afin de garantir un temps de traitement rapide ce qui convient
bien en commande temps réel. Il assure une combinaison de l'environnement de
programmation avancée IDE (Integrated Développent Environnent), et d‘un vaste ensemble
de bibliothèques pour le matériel, de la documentation complète et d‘un grand nombre des
exemples.
Il comporte plusieurs 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….); Il a une capacité à
pouvoir gérer la plupart des périphériques rencontrés dans l'industrie (Bus I2C, 1Wire, SPI,
RS485, Bus CAN,USB , cartes compact Flash, signaux PWM, afficheurs LCD
alphanumériques et graphiques ,afficheur LED à 7 segments...) de ce fait il est devenu un des
outils de développement incontournable et puissant, 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 etc...
Utilisation
Tout comme les autres logiciels son utilisation commence par la création de projet. Mais de
façon très simple sauf qu'il possède un langage de programmation spécifique qu'il faut
connaitre.
Création d’un 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 peuvent être compilés que si elles font partie d'un projet. Le fichier projet
contient les informations suivantes :
- Nom du projet et une description facultative.
- Composant cible et 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.).
- Autres fichiers.
Le processus de création d'un nouveau projet est vraiment très simple. Sélectionnez New
Project (Nouveau Projet) de puis le menu Project (Projet) et suivre le reste….
Une fois le projet créé et le code source écrit, on peut le compiler. Sélectionnez ProjectBuild à
partir du menu ou cliquez sur l'icône Build dans la barre d'outils du projet…….

18
Conception Assistée par Ordinateur ( Electronic Design Automation EDA)
Le logiciel PROTEUS
Le logiciel PROTEUS est édité par la société Labcenter Electronics. C'est un logiciel
complet et composé de nombreux modules. En général, on utilise souvent les deux principaux
logiciels qui permettent de faire la Conception Assistée par Ordinateur ou Electronic Design
Automation (EDA) ISIS et ARES où le premier (logiciel ISIS) permet le dessin des schémas
électroniques, la simulation en temps réel de façon dynamique et le second (logiciel ARES)
permet de transformer les schémas en PCB (Tracé du circuit imprimé).
Ses deux logiciels principaux sont :
 L’éditeur de schéma ISIS.
 L’outil de conception de circuit imprimé ARES.
Proteus est un outil convivial facile à prendre en main. Il reconnaît et simule beaucoup de
composants ainsi que de nombreux afficheurs, moteurs,…
Dans l’environnement électronique, PROTEUS est très apprécié. Grace à sa capacité de faire
combiner plusieurs circuits, de nombreux entreprises et organismes de formation et beaucoup
de chercheur utilisent et travaillent avec ce logiciel. En plus de la popularité de ses outils,
PROTEUS possède aussi d’autres avantages très intéressant. II est un outil de création de
prototype virtuel permettant de réduire les coûts matériels et logiciels lors de la conception
d’un projet. De plus, il a des supports techniques très performants et il contient aussi des
packs logiciels qui sont faciles et rapides à manipuler.
Le logiciel ISIS (Intelligent Schematic Input System): est principalement connue pour
éditer des schémas électriques. Par ailleurs, le logiciel permet également de simuler ces
schémas ce qui nous permet de déceler certaines erreurs dès l’étape de conception.
Indirectement, les circuits conçus grâce à ce logiciel peuvent être utilisé dans des
documentations car il permet de contrôler la majorité de l’aspect graphique des circuits.

19
Le logiciel ARES (Automatic Rotage Equipment System): est un outil d’édition et de
routage qui complète parfaitement ISIS. Un schéma électrique réalisé sur ISIS peut alors être
importé facilement sur ARES pour réaliser le PCB (Printed Circuit Board qui veut dire circuit
imprime) de la carte électronique. Bien que l’édition d’un circuit imprimé soit plus efficace
lorsqu’elle est réalisée manuellement par routage, ce logiciel permet de placer
automatiquement les composants et de réaliser le routage automatiquement. Cette partie du
travail est la plus importante car elle demande de la concentration et un savoir-faire qu’est
obtenu avec le temps et surtout avec la pratique .

Commencer avec ISIS Proteus

Comme d'habitude, pour créer un nouveau projet, on clique sur «file-new design» puis on
clique sur «Save design» et on donne le nom et l’emplacement de fichier sur PC. Une fois le
nouveau projet est créé, on peut commencer la conception de schéma électrique de projet en
ajoutant les composantes directement de la bibliothèque de composantes. Afin de tester le
montage que nous avons fait, il suffit juste de démarrer la simulation en cliquant sur «Run the
simulation », Proteus dispose aussi d’une boite à outils pour la mesure (Ampèremètre,
Voltmètre, Oscilloscope, …). Pour passer de schéma électrique au design PCB on clique sur
le bouton « ARES » dans la barre d’options, une autre fenêtre apparaître contenant les
composantes que nous avons utilisées dans le schéma avec toutes les connexions que nous
avons fait. Il suffit juste de commencer le routage et la structuration de la carte PCB de la
façon que nous souhaitons.
Les barres d’outils
 Barre de menus

Elle permet de gérer les travaux (ouverture, sauvegarde…) sur vos fichiers.

20
  Barre des outils de commande

Elle reprend ce qui est accessible par les menus.

En fait, c'est la pratique seule qui permet aux étudiants d'apprendre à travailler avec ce
logiciel très très intéressant.
21