Leçon N°1: Presentation de L'Informatique Industrielle Et Des Systemes Micro-Programmes I - L'Informatique Industrielle

Cours Microcontrôleurs
Leçon N°1
PRESENTATION DE L’INFORMATIQUE INDUSTRIELLE ET

DES SYSTEMES MICRO-PROGRAMMES
I – L’INFORMATIQUE INDUSTRIELLE
1. Définition
« L'informatique industrielle est une branche de l'informatique appliquée qui couvre l'ensemble des
techniques de conception et de programmation, de systèmes informatisés à vocation industrielle,
qui ne sont pas des ordinateurs. »
(Source : Wikipédia)
2. Domaines d'applications
Alarme, automobile, aviation, instrumentation, médicale, téléphonie mobile, terminaux de paiement
pour carte bancaire, etc.
Applications
Automates, robotique,
Mesures de grandeurs physiques,
Systèmes temps-réel,
Systèmes embarqués.
1
Cours Microcontrôleurs
II- LES DIFFERENTS SYSTEMES PROGRAMMABLES

1. Les circuits spécialisés ou ASIC (Application Specific Integrated Circuit)
Les circuits spécialisés sont des circuits spécialisés dès leur conception pour une application
donnée.
Exemples :
- DSP (Digital Signal Processing),
- co-processeur arithmétique,
- processeur 3-D,
- contrôleur de bus, ...
Avantages
- Très rapide
- Consommation moindre
- Optimisé pour une application
Inconvénients
- Faible modularité
- Possibilité d'évolution limité
- Coût
2. Les systèmes en logique programmée

Ils sont connus sous la désignation de PLD (programmable logic device, circuit logique
programmable)
- FPGA (field-programmable gate array, réseau de portes programmables),
- PAL (programmable array logic, réseau logique programmable),
- Etc.
2
« Un circuit logique programmable, ou réseau logique programmable, est un circuit intégré
logique qui peut être reprogrammé après sa fabrication. Il est composé de nombreuses cellules
logiques élémentaires pouvant être librement assemblé. »
(Wikipédia)
Avantages
- Forte modularité
- Rapidité
Inconvénients
- Mise en oeuvre plus complexe
- Coûts de développement élevé
3. Les systèmes micro-programmés

Les micro-contrôleurs sont typiquement des systèmes micro-programmés.
Un micro-contrôleur est un :
« Circuit intégré comprenant essentiellement un microprocesseur, ses mémoires, et des éléments
personnalisés selon l'application. »
Un micro-contrôleur contient un microprocesseur.
Avantages
- Mise en oeuvre simple
- Coûts de développement réduits
Inconvénients
- Plus lent
- Utilisation sous optimale
III – ÉVOLUTION ET LOI DE MOORE

Intel 8086 (1978)
architecture interne 16 bits
Mr Nizar TOUJENI 3
Cours Microcontrôleurs Iset de Nabeul
bus 16 bits
fréquence d'horloge 4,77/10 Mhz
39 000 transistors, gravés en 3µm
0,33/0,75 MIPS
Intel Pentium 4 Northwood C (2002)

fréquence d’horloge 2,4/3,4 Ghz
(bus processeur : 200Mhz)
plus de 42 millions de transistors, gravés en 0,13 µm
450 MIPS
Intel Core i7 Gulftown (2011)

4/6 coeurs
fréquence d'horloge 3,46 Ghz
Fréquence de bus: 3,2 GHz
Fréquence de transfert des données 25.6 Gb/sec.
Mr Nizar TOUJENI 4
1,17 Milliards de transistors, gravés en 32nm

6000 MIPS
IV – LES DIFFERENTS BUS D’UN SYSTEME MICRO-PROGRAMME

« Un bus est un jeu de lignes partagées pour l’échange de mots numériques. »
1. Définition
Un bus permet de faire transiter (liaison série/parallèle) des informations codées en binaire entre
deux points. Typiquement les informations sont regroupées en mots : octet (8 bits), word (16 bits)
ou double word (32 bits).
2. Caractéristiques d'un bus

- Nombres de lignes,
Mr Nizar TOUJENI 5
- Fréquence de transfert.
Issu de la documentation technique du PIC16F628

Il existe 3 Types de bus :
- Bus de données : permet de transférer entre composants des données,
Exemple : résultat d'une opération, valeur d'une variable, etc.
- Bus d'adresses : permet de transférer entre composants des adresses,
Exemple : adresse d'une case mémoire, etc.
- Bus de contrôle : permet l'échange entre les composants d'informations de contrôle [bus
rarement représenté sur les schémas].
Exemple : périphérique prêt/occupé, erreur/exécution réussie, etc.
Mr Nizar TOUJENI 6
Leçon N°2
INTRODUCTION SUR LES MICROCONTROLEURS
I – INTRODUCTION
Dans la chaîne de traitement de l’information, le programme informatique (firmware ou microcode)
réalise une fonction importante et est toujours associée à un composant programmable (hardware)
équipé d’éléments de sauvegarde ou de mémorisation : le microcontrôleur.
II – MICROPROCESSEUR ET MICROCONTROLEUR
Il y a une différence fondamentale entre un microprocesseur et un microcontrôleur :
- le microcontrôleur intègre dans un même boîtier, un microprocesseur, de la mémoire, et des
interfaces entrées/sorties.
- le microprocesseur se présente sous la forme d’un boîtier qui nécessite des éléments
externes, comme de la mémoire et des circuits d’interfaces.
Ils sont présents dans la plupart des systèmes électroniques embarqués ou dédiés à une application
unique (exemple : téléphone portable).
Mr Nizar TOUJENI 7
Il en existe de nombreux modèles :

- 68HC11 de Motorola,
- 8051 de Intel,
- les ARM qui sont très utilisés en électronique embarquée
- et les PIC de Microchip.
III – GENERALITES SUR LES PIC
1. Trois grandes familles
- Base-Line (mots d’instructions de 12 ou 14 bits comme les 12Cxxx, 12Fxxx),
- Mid-Range (mots de 14 bits comme le 16F628, 16F877, etc.),
- High-End (mots de 16 bits).
2. Identification
Prenons l’exemple du PIC : PIC16F877A-I/P., 07514KQ
Les 2 premiers chiffres indiquent la catégorie du PIC : 16 = Mid-Range.
F indique que la mémoire programme est de type FLASH ; on retrouve CR pour ROM
(ROM : Read Only Memory) et C pour EPROM (EPROM : Erasable ROM) ou EEPROM
EEPROM : Electrical Erasable ROM).
Remarque :
Un composant qu’on ne peut reprogrammer est appelé OTP pour One Time
Programming.
Mr Nizar TOUJENI 8
Les mémoires de type FLASH et EEPROM peuvent être écrites et effacées mais pas
la ROM.
877A indique le modèle du PIC.
Parfois, un suffixe supplémentaire comme 20 est indiqué. Il s’agit de la fréquence d’horloge
maximale. 20 pour 20 MHz. Les PIC sont des composants statiques, ainsi, on peut abaisser
la fréquence d’horloge jusqu’à l’arrêt complet sans perte de données et sans
dysfonctionnement.
I est la gamme de température industrielle (-40°C à +85°C).
P est le type de boîtier PDIP, boîtier 40 broches Plastique DIL (Dual In Line).
07 est l’année de fabrication 2007 et 51, la semaine 51, donc fin décembre. 4KQ est un code
de traçabilité.
3. Architecture interne
Tous les microcontrôleurs utilisent l’une des 2 architectures nommées Harvard et Von Neumann.
Elles représentent les différentes manières d’échange de données entre le CPU (microprocesseur
interne) et la mémoire.
3.1. Architecture Von Neumann
L’architecture VON NEUMANN employée par la plupart des microcontrôleurs actuels
(INTEL80XX, Motorola HC05, HC08 et HC11, ou ZILOG Z80) est basée sur un bus de
données unique. Celui-ci véhicule les instructions et les données.
1 bloc mémoire et 1 bus de données sur 8 bits (1 octet). Toutes les données sont échangées sur ce
bus qui, surchargé, rend la communication très lente.
3.2. Architecture Harvard

L’architecture HARVARD utilisée par les microcontrôleurs PIC est basée sur deux bus de
données. Un bus est utilisé pour les données et un autre pour les instructions.
2 blocs mémoire distincts et 2 bus différents : 1 bus 8 bits pour communiquer avec la RAM, 1 bus
14 bits pour communiquer avec la ROM, qui contient le programme.
Mr Nizar TOUJENI 9
Le CPU peut lire une instruction (en ROM) et accéder à la mémoire de données (en RAM) en même
temps.
Remarque : la mémoire RAM (Random Access Memory) est utilisée pour stocker temporairement
les données utilisées dans le programme ; ces données sont en effet perdues lors d’une coupure de
courant.
Avantages et inconvénients
VON NEUMANN HARVARD

(MOTOROLA, INTEL, ZILOG...) (MICROCHIP PICs)
Avantages - Jeu d’instructions riches - Jeu d’instructions pauvre, mais facile

- Accès à la mémoire facile. à mémoriser.
- Le codage des instructions est facile,
chaque instruction est codée sur un
mot et dure un cycle machine.
- Le code est plus compact.
Inconvénients - Le temps pour exécuter une instruction - Le jeu d’instruction est très pauvre,
est variable. par exemple pour effectuer une
- Le codage des instructions se fait sur comparaison il faut faire une
soustraction.
plusieurs octets.
- Les accès aux registres internes et la
mémoire sont très délicats.
4. Jeu d’instructions
Toutes les instructions compréhensibles par les microcontrôleurs forment ce que l’on appelle le jeu
d’instructions.
On distingue 2 types :
Mr Nizar TOUJENI 10
composants dits RISC (Reduced Instructions Set Computer), par exemple les PIC. Dans ce
cas, le microcontrôleur reconnaît et exécute seulement des opérations simples (addition,
soustraction, etc.) et des opérations plus complexes sont réalisées en les combinant.
Tous les PIC Mid-Range ont un jeu de 35 instructions.
composants dits CISC (Complex Instructions Set Computer).
Les microcontrôleurs de ce type possèdent 200 instructions différentes et peuvent réaliser de
nombreuses opérations à grande vitesse. Les instructions sont plus complexes.
Remarque :
La taille mémoire spécifiée pour un PICs s’exprime en Kilo Mots (14 bits pour la famille 16F87X)
et non en kilo octets. Comme chaque instruction est codée par un mot de 14 bits, comparées aux
microcontrôleurs classiques (1, 2 ou 3 octets par instruction), les PICs ont un code plus compact et
ils utilisent moins de mémoire.
5. Nombre d’instructions par secondes
Les PIC stockent et exécutent chaque instruction en 1 cycle d’horloge. On peut atteindre de très
grandes vitesses. L’horloge est la fonction qui cadence le fonctionnement des microcontrôleurs en
délivrant un signal de fréquence fixe. On utilise généralement un quartz.
Exemple :
Avec un quartz de 4MHz, la fréquence du signal est d’abord divisée par 4 ; c’est ce signal de 1MHz
qui cadence les opérations et qui permet d’obtenir la durée d’1 cycle, soit 1 million de cycles par
seconde.
Pour 1 instruction par cycle, cela donne une puissance de traitement de 1 million d’instructions par
seconde, soit 1MIPS.
Mr Nizar TOUJENI 11
6. Quelques caractéristiques importantes
Family ROM RAM Pins Clock A/D Inputs Resolution Comp- 8/16 – bit Serial PWM Others
[Kbytes] [bytes] Freq. of A/D arators Timers Comm. Output
[MHz] Converter s
Base-Line 8 - bit architecture, 12-bit Instruction Word Length
PIC10FXXX 0.375 - 0.75 16 - 24 6-8 4-8 0-2 8 0-1 1x8 - - -
PIC12FXXX 0.75 - 1.5 25 - 38 8 4-8 0-3 8 0-1 1x8 - - EEPROM
PIC16FXXX 0.75 - 3 25 - 134 14 - 44 20 0-3 8 0-2 1x8 - - EEPROM
PIC16HVXXX 1.5 25 18 - 20 20 - - - 1x8 - - Vdd = 15V
Mid-Range 8 - bit architecture, 14-bit Instruction World Length
PIC12FXXX 1.75 - 3.5 64 - 128 8 20 0-4 10 1 1-2x81x - 0-1 EEPROM
16
PIC12HVXXX 1.75 64 8 20 0-4 10 1 1-2x81x - 0-1 -
16
PIC16FXXX 1.75 - 14 64 - 368 14 - 64 20 0 - 13 8 or 10 0-2 1-2x81x USART 0-3 -
16 I2C SPI
PIC16HVXXX 1.75 - 3.5 64 - 128 14 - 20 20 0 - 12 10 2 2 x 8 1 x 16 USART - -
I2C SPI
High-End 8 - bit architecture, 16-bit Instruction Word Length
PIC18FXXX 4 - 128 256 - 18 - 80 32 - 48 4 - 16 10 or 12 0-3 0-2x82-3 USB2.0 0-5 -
3936 x 16 CAN2.0
USART
I2C SPI
PIC18FXXJXX 8 - 128 1024 - 28 - 100 40 - 48 10 - 16 10 2 0-2x82-3 USB2.0 2-5 -
3936 x 16 USART
Ethernet
I2C SPI
PIC18FXXKXX 8 - 64 768 - 28 - 44 64 10 - 13 10 2 1 x 8 3 x 16 USART
3936 I2C SPI
Mr Nizar TOUJENI 12
IV – PIC 16F877A
1. Synoptique simplifié
Le CPU exécute les instructions du programme (codées sur 14 bits), traite et produit des
opérations sur des informations numériques.
La mémoire vive (RAM) de 368 octets est utilisée pour le stockage temporaire des
données et résultats.
Mr Nizar TOUJENI 13
La mémoire morte (EEPROM) de 256 octets permet de conserver des données très utiles
de manière semi-permanente.
La mémoire FLASH de 8k x 14bits permet de stocker le programme (les instructions).
L’horloge génère le signal qui cadence l’exécution des instructions.
Les ports (A – E) bidirectionnels permettent de communiquer avec l’extérieur ; les lignes
de chaque port peuvent être programmées en entrée ou en sortie.
Les timers (3), modules programmables dont les fonctions sont : astable (signaux
périodiques), monostable (impulsion), compteur, signaux PWM (commande de moteurs à
courant continu).
Le CAN convertisseur analogique/numérique 10 bits – 8 entrées disponibles de 0 à 5V ; les
résultats des conversions sont stockés dans des registres internes.
2. Brochage physique des différentes versions de µC
PDIP, SOIC
Mr Nizar TOUJENI 14
3. Synoptique complet
Mr Nizar TOUJENI 15
Mr Nizar TOUJENI 16
Mr Nizar TOUJENI 17
Mr Nizar TOUJENI 18
Mr Nizar TOUJENI 19
4. Les éléments de choix d’un µC

4.1. Architecture
- ALU (8, 16, 32, 64 bits)
- Structure du processeur (Harvard, Von Neumann)
- Type de processeur (RISC, CISC)
- Taille des mémoires programme et donnée
- Nombre de ports d’entrée/sortie
4.2. Fonctionnalités
- Fonctions analogiques : CAN, CNA, Comparateur, etc.
- Fonctions de timing : Timer, Watchdog, etc.
- Fonctions de communication : UART (Communication série), USB, I2C, etc.
- Facilité de programmation : In-Circuit Serial Programming, Self Programming, etc.
4.3. Caractéristiques électriques :
- Fréquence d’horloge
- Tensions d’alimentation
- Consommation d’énergie, modes faible consommation d’énergie, etc.
4.4. Caractéristiques physiques :
- Type de boîtier : DIL, PLCC, etc.
V – LA PROGRAMMATION
Le microcontrôleur exécute le programme chargé dans sa mémoire FLASH. Les mots binaires (sur
14 bits pour le PIC16F877A) sont considérés par le CPU comme une commande.
Mr Nizar TOUJENI 20
Mais programmer en binaire ou même en hexadécimal est impossible. Les programmeurs utilisent
des langages comme l’assembleur ou le C, qui utilise des abréviations.
Le passage de ce code plus lisible en code binaire prêt à être mis en mémoire s’appelle la
compilation.
Remarque :
L’assembleur est un langage bas niveau étroitement lié au type de microcontrôleur.
Le C est un langage de plus haut niveau que l’assembleur et permet en théorie d’être
portable, donc de s’adapter à n’importe quel microcontrôleur.
Mr Nizar TOUJENI 21
Microcontrôleurs Iset de Nabeul
Leçon N°3
LE COMPILATEUR MIKROC ET LE SIMULATEUR ISIS
I. LE COMPILATEUR MIKROC ET LES PIC

Un microcontrôleur est un circuit électronique encapsulé dans un circuit de haut niveau
d’intégration. Les microcontrôleurs sont commercialisés par différents fabricants comme Motorola,
Intel, Philips, Microchip, etc.
Microchip en particulier, est un fabricant des circuits électroniques. Dans leurs lignes de production,
on trouve les microcontrôleurs PIC, qui sont disponibles dans des différentes familles, certaines
d'entre elles sont : 12F, 16F, 18F, 24F, 30F, 33F etc. Le promoteur du projet choisit la famille et la
référence qui répondent à ses besoins, comme un PIC12F675 ; microcontrôleur 8 broches avec des
modules intégrés de base tels que le Timer et l’ADC. Un microcontrôleur comme le 16F877 dispose
de 40 broches et des modules tels que : Timer, ADC, USART, I2C, PWM, entre autres. On peut
facilement voir la différence entre ces deux PIC.
Figure 1
La documentation technique, la commercialisation massive et l'incroyable quantité d'informations
publiées sur les microcontrôleurs PIC, les rendent idéals pour l’enseignement. L’entreprise
Microchip a le portail web www.microchip.com où on peut télécharger des informations et des
applications logicielles qui facilitent le développement avec ses microcontrôleurs.
Le développement d’une application à base de microcontrôleur PIC consiste à identifier les
problèmes de développement, éditer, déboguer le programme machine et programmer le
microcontrôleur avec un programmateur spécifique pour PICmicro. Microchip fournit des
programmateurs spécialisés dans différentes échelles, peut-être le plus populaire est le PICSTART
plus, mais il y a d'autres comme PICkit2, PICkit3. Bien qu'il existe des programmateurs
commerciaux, un développeur peut construire ou acheter un programmateur éducatif à faible coût.
Un microcontrôleur a une architecture de base similaire à celle d'un PC, dispose d'un bloc OTP ou
mémoire Flash dans lequel sont stockées les instructions du programme, cette section est similaire
au disque dur de l'ordinateur, le PICmicro a une RAM, qui joue le même rôle de la mémoire vive
d'un ordinateur personnel, le microcontrôleur possède des ports d'entrée et de sortie qui sont
similaires aux périphériques d'entrée et de sortie pour ordinateur tel que souris, une imprimante, un
écran, un clavier, et autres.
Mr Nizar TOUJENI 22
Figure 2
Ces caractéristiques du microcontrôleur le rendent idéal pour la création de petites applications qui ont une
interface utilisateur, comme des claviers, des boutons, des lecteurs de la mémoire de stockage de masse, et
des capteurs de différentes grandeurs telles que la température, l'humidité, la pression, la lumière, la
proximité, etc. De même, il est possible de créer des environnements de visualisation avec des afficheurs
numériques, alphanumériques et graphiques. Les ports série comme USART et l'USB peuvent créer des
communications série et des communications sans fil avec d'autres appareils. En bref, les possibilités sont
sans fin.
II. LE COMPILATEUR MIKROC PRO

La programmation des microcontrôleurs est basée sur le code machine, qui est connu comme code
assembleur, ce code contient les instructions du programme, le code assembleur est bien détaillé et
difficile à écrire. Le programme en code assembleur est très long et difficile à comprendre.
La création des compilateurs de haut niveau a rendu facile la création et l'édition de programmes,
bien entendu les microcontrôleurs ne font pas exception. Dans le commerce, il y a plusieurs variétés
de compilateurs des différents fabricants et avec différents langages de haut niveau.
On peut acheter les compilateurs PICC, CCS, PIC Basic, entre autres. Ce cours se concentre sur le
compilateur MikroC PRO, qui est un compilateur de langage C pour les microcontrôleurs PICmicro
famille 12F, 16F, 18F etc.
MikroC PRO est un logiciel avec une grande variété des helps, supports et d'outils, qui facilite la
création des projets et des applications pour les microcontrôleurs PICmicro.
L'étude de cet environnement de développement est possible, parce que l'étudiant peut télécharger
une démo ou version étudiant, qui a les mêmes caractéristiques que la version complète, la seule
limite est la taille du code machine ne peut pas excéder 2Koctets, une capacité suffisante pour un
premier apprentissage. La version de démonstration peut être téléchargée à partir du site Web :
www.mikroe.com.
La figure suivante montre l'aspect visuel de l'environnement de développement.
Le compilateur de haut niveau en langage C utilise des structures, facilitant la programmation,
optimisant les opérations mathématiques, et les processus grâce à l'utilisation de fonctions
prédéfinies et des fonctions que le développeur peut créer et l'utilisation d'un ensemble de variables,
caractère, nombre entier, et réel. Le compilateur crée automatiquement le code assembleur et un
Mr Nizar TOUJENI 23
code enregistré dans un fichier avec l'extension *. Hex, ce fichier est le résultat principal de la
compilation, avec lequel le microcontrôleur sera programmé électriquement ou pour être utilisé
pour une simulation sur ordinateur.
Figure 3
III. LE SIMULATEUR ISIS PROTEUS
Le simulateur ISIS de Proteus est un logiciel puissant, développé par la compagnie électronique
Labcenter, qui s'est positionné pour plus de 10 ans comme l'un des outils les plus utiles pour
simuler les microcontrôleurs PIC.
L'ISIS permet la simulation des familles des PIC les plus populaires. En plus des PIC, ISIS peut
simuler une variété de dispositifs numériques et analogiques, comme les afficheurs sept segments,
les LCD des caractères et graphiques, les capteurs de température, d'humidité, la pression, etc. Il
peut aussi simuler les actionneurs tels que des moteurs à courant continu, les servomoteurs, les
lampes à incandescence, etc. Il est possible de simuler des périphériques d'entrée et de sortie comme
les claviers, ordinateur et les ports physiques tels que RS232 et USB. Ce simulateur a une grande
variété d'instruments de mesure tels que voltmètres, ampèremètres, oscilloscopes et analyseurs de
signaux.
En conclusion, ces caractéristiques font d'ISIS de Proteus, un outil idéal pour la conception et
l'étude des PIC. Une version de démonstration du logiciel peut être téléchargée à partir du site web :
www.labcenter.com. Sur la photo suivante, on peut voir la page d’accueil de l'environnement de
développement d'ISIS :
Mr Nizar TOUJENI 24
Figure 4
IV. CREATION DU PREMIER PROGRAMME EN MIKROC PRO
Le processus suivant doit être appris par cœur, pour mettre en œuvre à chaque fois des nouveaux
projets ou programmes pour les PIC. En lançant MikroC PRO, on identifie dans le menu supérieur
l’outil Project, et on choisit New Project… avec cette action, le programme affiche un assistant
facile à utiliser pour créer un nouveau projet.
Figure 5
Mr Nizar TOUJENI 25
La prochaine action est de cliquer sur le bouton Next, à cette étape de l'assistant affiche une case
pour sélectionner la référence de PIC, qu’on souhaite utiliser. Dans ce champ, on sélectionne le PIC
P16F84A.
L'étape suivante est de définir la fréquence d'oscillation avec laquelle travaillera le PIC ; dans cet
exemple on sélectionne 4.000000 MHz. L'option suivante permet de définir le répertoire où le
développeur enregistrera le projet, dans ce répertoire le programme enregistrera tous les fichiers
nécessaires, parmi lesquels le code source qui sera archivé avec l’extension .c, et l’exécutable du
PIC avec l’extension. hex.
Enfin, la configuration est terminée et le projet est créé, à la fin la fenêtre doit apparaître comme
suit :
Figure 6
A chaque modification effectuée sur le code du programme, on doit compiler le code. Cette action
produit des résultats de la compilation qu’on trouve dans la partie inférieure de la fenêtre du
programme. Les messages doivent se terminer par un texte « Finished successfully ».
Pour commencer l’édition d’un projet, on configure les ports du PIC, puis on insère le programme
dans une boucle infinie. Le PIC 16F84A dispose de deux ports A et B, on manipule le registre TRIS
pour configurer les ports en sortie ou entrée.
Les registres TRIS ont le même nombre de bits que les ports, par exemple le port B ou PORTB de
ce PIC est de 8 bits, donc le TRISB comporte également 8 bits. Les bits des registres TRIS
correspondent à ceux des ports, et définissent bit à bit l'état du port.
- Si un bit du TRIS est 0, le même bit du port est en sortie,
- et Si un bit du TRIS est 1 le même bit du port est en entrée ou en haute impédance.
Mr Nizar TOUJENI 26
Pour voir ce concept plus clairement, on observe et on analyse l'exemple suivant. Cet exemple
utilise un bouton et deux LED pour afficher le comportement du programme. On observe et on
analyse le programme ci-dessous :
void main ( void )
{
unsigned int COMPTEUR=0;
TRISB = 0b11110000;
PORTB=0b00000000;
while( 1 )
{
if( PORTB.F7==0 )
{
if( PORTB.F0==1 )
PORTB.F0=0;
else
PORTB.F0=1;
while( PORTB.F7==0 );
}
COMPTEUR++;
if(COMPTEUR&0x0100 )
PORTB.F1=1;
else
PORTB.F1=0;
}
}
L’étape suivante est de faire la simulation sur ISIS, les résistances des LED doivent être changées à
330Ω, l’entrée Master CLeaR, MCLR doit être connecté à Vcc pour que le PIC ne redémarre pas, à
la fin on devrait voir la forme suivante :
Mr Nizar TOUJENI 27
Figure 7
Avant de lancer la simulation, on doit charger le fichier. Hex. Pour procéder, on double clique sur le
PIC, et une fenêtre qui permet de rechercher le fichier. Hex et on peut également ajuster la
fréquence d'oscillation. Par défaut, cette valeur est de 1 MHz. Cette fenêtre se présente comme suit :
Figure 8
Mr Nizar TOUJENI 28
Microcontrôleurs
Leçon N°4
INTRODUCTION AU LANGAGE MIKROC
I. STRUCTURE D’UN PROGRAMME EN MIKROC

La structure la plus simple d'un programme en mikroC, c’est le programme représenté dans le code-
source 4.1, qui nous permettra de faire clignoter une LED connectée au PORTB (par exemple bit 0
du PORTB) du microcontrôleur PIC avec une période de 2 secondes (1 seconde allumée et une
seconde éteinte).
1. Règles générale d’écriture en mikroC
Les instructions propres au langage mikroC doivent être écrites en minuscule (void main
(void)).
Les instructions particulières aux microcontrôleurs doivent être écrites en majuscule (TRISB).
Les retours à la ligne et les espaces servent uniquement à aérer le code
Toutes instructions ou actions se terminent par un point virgule « ; ».
Code-source 4.1 (LED.c)
/********************************************************************
LED clignotante
==============
Ce programme fait clignoter une LED connectée à la broche RB0 du PIC 16F84A
********************************************************************/
void main( )
{
for( ; ; ) // Boucle sans fin
{
TRISB = 0; // Configuration du PORTB en sortie
PORTB.F0 = 0; // RB0 = 0
Delay_Ms(1000); // Pause d’une seconde
PORTB.F0 = 1; // RB0 = 1
Delay_Ms(1000); // Pause d’une seconde
} // Fin de la boucle
}
Examinons le fichier LED.c du code-source
Mr Nizar TOUJENI 29
2. Commentaires
En mikroC, les commentaires de programmes peuvent être de deux types : de longs commentaires,
s’étendant sur plusieurs lignes, et de courts commentaires, occupant une seule ligne.
Comme montre le Code-source 4.1 les longs commentaires commencent par le caractère « /* » et se
terminent par le caractère « */ ». De même, de courts commentaires commencent par le caractère « //
» et il n’a pas besoin d'un caractère de terminaison.
3. Début et fin d'un programme
En mikroC, un programme commence avec les mots-clés :
void main()
Après cela, une accolade ouvrante est utilisée pour indiquer le début du corps de programme. Le
programme se termine par une accolade fermante. Ainsi, comme indiqué dans le Code-source 4.1, le
programme a la structure suivante :
void main()
{
// Votre code ici
}
II. ELEMENTS DE PROGRAMMATION EN MIKROC
1. Les variables
Une variable est une portion réservée d’une mémoire à laquelle on a donné un nom. Toute variable
utilisée dans un programme doit auparavant être définie.
La définition d’une variable consiste à la nommer et lui donnée un type et éventuellement lui donner
une valeur initiale (initialiser). C’est cette définition qui réserve (alloue) la place mémoire nécessaire
en fonction du type.
La position de la déclaration ou de la définition d’une variable détermine sa portée c’est-à-dire sa
durée de vie et sa visibilité.
Les variables globales sont déclarées en dehors de toute fonction.
Les variables locales sont déclarées à l’intérieur des fonctions et ne sont pas visible à
l’extérieur de la fonction dans laquelle celle-ci est définie.
Les noms des variables ne peuvent contenir que des lettres de a à z et à partir de A à Z, le trait de
soulignement "_" et les chiffres de 0 à 9.
Les noms des variables dans mikroC n'est pas sensible à la casse, de sorte que Som, som et soM
représente le même identifiant.
Certains noms sont réservés pour le compilateur lui-même et ne peut pas être utilisés comme noms de
variables dans un programme. Le tableau 4.1 donne une liste alphabétique de ces noms réservés.
Mr Nizar TOUJENI 30
Tableau 4.1 Noms réservés en mikroC
ASM ENUM SIGNED AUTO EXTERN SIZEOF
BREAK FLOAT STATIC CASE FOR STRUCT
CHAR SWITCH CONST IF TYPEDEF CONTINUE
GOTO INT UNION LONG DEFAULT UNSIGNED
DOUBLE RETURN VOLATILE DO REGISTER VOID
ELSE SHORT WHILE
2. Les constantes
Les constantes représentent des valeurs fixes (numérique ou caractère) dans des programmes qui ne
peuvent pas être changées. En mikroC, les constantes peuvent être entiers, flottants, caractères,
chaînes ou des types énumérés.
2.1. Integer Constants
Les constantes entières (Integer Constants) peuvent être en décimal, hexadécimal, octal ou binaire.
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). L’utilisation de U (ou u) et L (ou l) oblige la constante d'être unsigned long.
Les constantes sont déclarées en utilisant le mot-clé const et sont stockées dans le flash de mémoire
du microcontrôleur PIC. Par exemple, MAX est déclaré comme la constante 100 :
const MAX =100;
Les constantes hexadécimales commencent par les caractères 0x ou 0X et peuvent contenir des
données numériques de 0 à 9 et les caractères hexadécimaux de A à F. Dans l'exemple suivant,
TOTAL est la constante de la valeur hexadécimale FF:
const TOTAL = 0xFF;
Les constantes octales ont un zéro au début du nombre et peuvent contenir des données numériques
de 0 à 7. Dans l'exemple suivant, une constante CNT est affectée une valeur octale 17 :
const CNT = 017;
Les constantes binaires commencent par 0b ou 0B et ne peuvent contenir que 0 ou 1. Par exemple
une constante nommée Min est déclarée comme ayant la valeur binaire 11110000 :
const Min = 0b11110000
2.2. Floating Point Constants
Les constantes à virgule flottante (Floating Point Constants) se compose de :
Entier décimal
Point décimal
Partie décimale fractionnaire
Mr Nizar TOUJENI 31
e ou E et l'ordre du signe
Dans l'exemple suivant, une constante nommée TEMP est déclarée comme ayant la valeur
fractionnelle 37.50 :
const TEMP = 37.50 ou const TEMP = 3.750E1
2.3. Character Constants
Une constante de caractère (Character Constants) est un caractère renfermé dans des guillemets
simples. Par exemple, une constante nommée First_Alpha est déclarée comme ayant la valeur du
caractère ‘A’:
const First_Alpha = ‘A’;
2.4. String Constants
Les constantes de chaîne (String Constants) sont des séquences fixes de caractères stockées dans la
mémoire flash du microcontrôleur. La chaîne doit commencer et se terminer par un guillemet « " ».
Un exemple d’une constante de type chaîne est la suivante :
"Il s'agit d'un exemple de chaine constante"
2.5. Enumerated Constants
Les constantes énumérées (Enumerated Constants) sont de type entier et sont utilisées pour faire un
programme plus facile à suivre. Dans l'exemple suivant, une constante nommée couleur stocke les
noms de couleurs. Le premier élément de couleur a la valeur 0:
enum couleur {noir, marron, rouge, orange, jaune, vert, bleu, gris, white};
3. Séquences d'échappement
Les séquences d'échappement sont utilisées pour représenter les caractères ASCII non imprimables.
Par exemple, la combinaison de caractères « \n » représente le caractère de nouvelle ligne.
4. Les Tableaux
Les tableaux sont utilisés pour stocker des éléments liés dans le même bloc de mémoire. Un tableau
est déclaré en spécifiant son type, le nom, et le nombre d’éléments à stocker. Par exemple :
unsigned int Total [5] ;
Dans le langage de programmation mikroC, nous pouvons aussi déclarer des tableaux aux
dimensions multiples. Tableaux unidimensionnels sont généralement appelés vecteurs, et des
tableaux bidimensionnels sont appelés matrices. Un réseau bidimensionnel est déclaré en spécifiant le
type de données de la matrice, le nom de tableau, et la taille de chaque dimension.
Dans l'exemple suivant, réseau bidimensionnel Q a deux rangées et deux colonnes, ses éléments
diagonaux sont mis à 1, et de ses éléments non diagonaux sont remis à 0 :
unsigned char Q[2][2] = { {1,0}, {0,1} };
Mr Nizar TOUJENI 32
5. Les Pointeurs
5.1. Notion de pointeur
Les pointeurs (Pointers) sont une partie importante du langage mikroC, car ils occupent les adresses
mémoire des autres variables. Les pointeurs sont déclarés de la même manière que d’autres variables,
mais avec le caractère « * » en face du nom de variable.
Dans l'exemple suivant, un pointeur de caractère non signé du nom pnt est déclaré :
unsigned char *pnt;
Quand un nouveau pointeur est créé, son contenu est d'abord indéterminé et il ne tient pas l'adresse
d'une variable. Nous pouvons attribuer l'adresse d'une variable à un pointeur à l'aide le « & » :
pnt = &Count;
Maintenant pnt affecte l'adresse de variable Count. La variable Count peut être affectée à une valeur
en utilisant le caractère « * » en avant de son pointeur. Par exemple, le Count peut être attribuée à 10
à l'aide de son pointeur :
* pnt = 10; // Count = 10
c’est la même chose que
Count = 10; // Count = 10
ou, la valeur du Count peut être copié à la variable Cnt en utilisant son pointeur :
Cnt = *pnt; // Cnt = Count
5.2. Pointeurs et tableaux
Dans le langage mikroC, 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 élément de
la matrice. Ainsi, les deux énoncés suivants sont égaux :
Total[2] = 0;
et
*(Total + 2) = 0;
6. Les Structures
Une structure peut être utilisée pour recueillir des éléments connexes, qui sont ensuite traités comme
un seul objet. Contrairement à un tableau, une structure peut contenir un mélange de types de
données. Par exemple, une structure permet de stocker les données personnelles (nom, prénom, âge,
date de naissance, etc.) d'un étudiant.
Une structure est créée en utilisant le mot-clé struct, suivi d'une structure de nom et d’une liste des
déclarations de membre. Éventuellement, des variables de même type que la structure peuvent
déclarer à l'extrémité de la structure.
L'exemple suivant déclare une structure nommée Personne :
Mr Nizar TOUJENI 33
struct Personne
{
unsigned char nom[20];
unsigned char prenom[20];
unsigned char nationalite[20];
unsigned char age;
}
Nous pouvons attribuer des valeurs aux élements d'une structure en spécifiant le nom de la structure,
suivi d'un point «.» et le nom de l'élément.
III. OPERATEURS ET EXPRESSIONS EN MIKROC
Les opérateurs sont appliqués aux variables et d'autres objets dans les expressions pour assurer
certaines conditions ou des calculs.
Une expression est un objet syntaxique obtenu en assemblant des constantes, des variables et des
opérateurs.
1. Opérateur d’affectation
L’opérateur la plus importante dans un langage de programmation est celle qui consiste à donner une
valeur à une variable. Cette opération est désignée par le symbole « = ».
2. Les opérateurs arithmétiques
Opérateur Nom Notation
+ addition x+y
- soustraction x-y
* multiplication x*y
/ division x/y
% modulo x%y
Les opérateurs +, -, *, fonctionnent comme en arithmétique. Par contre, l’opérateur / (division) se

comporte de manière différente selon que les opérandes sont des entiers ou des nombres flottants.
3. Autres opérateurs unaires d’affectation
Opérateur Equivalent Notation
++ x=x+1 x++ ou ++x
-- x=x-1 x-- ou --x
Mr Nizar TOUJENI 34
4. Les autres opérateurs binaires d’affectation
+= x=x+y x += y
-= x=x-y x -= y
*= x=x*y x *= y
/= x=x/y x /= y
%= x=x%y x %= y
= x=xy x=y
<<= x = x << y x <<= y
&= x=x&y x &= y
|= x=x|y x |= y
^= x=x^y x ^= y
5. Les opérateurs de comparaison
== test d’égalité x == y
!= test de non égalité x != y
<= test inférieur ou égal x <= y
>= test supérieur ou égal x >= y
< test inférieur strict x<y
> test supérieur strict x>y
En mikroC, le résultat d’une comparaison est 1 (!= 0) ou 0 selon que cette comparaison est vraie ou
fausse. Il n’existe pas de type booléen en mikroC : la valeur entière 0 sera considérée comme
équivalente à la valeur faux et toute valeur différente de 0 équivalente à la valeur vraie.
6. Les opérateurs logiques
Une variable booléenne est une variable pouvant prendre la valeur vrai ou faux. La valeur d’une
expression booléenne est, comme le résultat des comparaisons, une valeur entière.
Mr Nizar TOUJENI 35
&& ET x && y
|| OU x || y
!(unaire) NON !x
7. Les opérateurs de manipulation de bits
& ET bit à bit x&y
| OU bit à bit x|y
^ OU exclusif bit à bit x^y
! (unaire) NON bit à bit !x
>> décalage à droite >> x
<< décalage à gauche << x
8. Opérateur de dimension
Cet opérateur donne l’occupation mémoire (en octets) d’une variable ou d’un type de donné.
sizeof opérateur de dimension sizeof (e)
Exemple :
La valeur de l’expression sizeof(c) est 1 si c est une variable de type char.
IV. LES STRUCTURES DE CONTROLE

Les instructions sont normalement exécutées séquentiellement à partir du début à la fin d’un
programme. Nous pouvons utiliser des instructions de contrôle pour modifier ce flux séquentiel
normal dans un programme C. Les instructions de contrôle suivantes sont disponibles dans les
programmes en mikroC :
De sélection if et switch
D'itération ou bouclage for
Modifications inconditionnels d’exécution
Instructions de sélection if et switch
Mr Nizar TOUJENI 36
1. Instruction if
Cette instruction conditionnelle permet d’exécuter des instructions de manière sélective en fonction
du résultat d’un test. La déclaration du format général de l’instruction if est la suivante :
if (expression)
instruction1
else
instruction2
Si l’expression est vraie, l’instruction1 s’exécute sinon, dans le deuxième cas, c’est l’istruction2 qui
s’exécute.
Exemple:
if (x> 0 && x <10)
{
Total + = Sum;
Sum++;
}
else
{
Total = 0;
Sum = 0;
}
2. Instruction switch
L'instruction switch est utilisée pour assurer la commutation entre des différentes déclarations si un
certain nombre des conditions est vrai ou faux.
La syntaxe de commutation :
switch (condition)
{
case condition1: Instructions1; break;
case condition2: Instructions2; break;
.....................
case conditionN: InstructionsN; break;
default: InstructionsN+1;
}
Mr Nizar TOUJENI 37
Exemple:
switch (Cnt)
{
case 1: A=1; break;
case 10: B=10; break ;
case 100: C=100; break;
default: D=1;
}
3. Instructions d'itération for, while, do, goto, continue et break
Les instructions d'itération nous permettent d'effectuer des boucles dans un programme, où une partie
d'un code doit être répétée un certain nombre de fois. Dans mikroC, l'itération peut être effectuée de
quatre façons :
Utilisation de for
Utilisation de while
Utilisation de do
Utilisation de goto, continue et break
3.1. Instruction for
La syntaxe d'une instruction for est :
for (expression initiale; expression de condition; expression increment)
{
Instructions;
}
Exemple:
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++) Sum = Sum + M[i][j];
}
3.2. Instruction while
La syntaxe d'une instruction while est la suivante :
while (condition)
{
Instructions;
}
Mr Nizar TOUJENI 38
Ici, les instructions sont exécutées jusqu'à ce que la condition devienne fausse, ou les instructions
sont exécutées de façon répétée aussi longtemps que la condition est vraie. Si la condition est fausse à
l'entrée de la boucle, la boucle ne sera pas exécutée et le programme continue de l'extrémité de la
boucle while. Il est important que la condition change à l’intérieur de la boucle, sinon une boucle sans
fin sera formée.
Le code suivant montre comment mettre en place une boucle d'exécuter 10 fois :
// Une boucle qui s'exécute 10 fois
k = 0;
while (k <10)
{
Instructions;
k++;
}
Une boucle sans fin peut également être formée par réglage de la condition qui doit être toujours vrai
:
// Une boucle sans fin
while (k == k)
{
Instructions;
}
Il est possible d'avoir une déclaration while sans corps. Une telle déclaration est utile, pour par
exemple, si nous attendons un port d'entrée pour changer sa valeur.
Voici un exemple où le programme va attendre aussi longtemps que le bit 0 de PORTB (PORTB.0)
est au niveau logique 0. Le programme se poursuivra jusqu’au changement à la valeur logique 1 sur
les broches du port.
while (PORTB.F0 == 0); // Attendre jusqu'a ce que PORTB.0 devient un
ou
while (PORTB.F0);
3.3. Instruction do
Une déclaration do est similaire à une déclaration while sauf ce que la boucle s’exécute jusqu'à ce
que la condition devienne fausse, ou, la boucle s'exécute tant que la condition est vraie. La condition
est testée à la fin de la boucle. La syntaxe d'une déclaration do est la suivante :
do
{
Instructions;
Mr Nizar TOUJENI 39
} while (condition);
La première itération est toujours effectuée si la condition est vraie ou fausse. Il s'agit de la principale
différence entre une déclaration while et une déclaration do.
Le code suivant montre comment mettre en place une boucle d'exécuter 10 fois en utilisant la
déclaration do :
/*Exécution 10 fois */
k = 0;
do
{
Instructions;
k++;
} while (k <10);
La boucle commence avec k = 0, et la valeur de k est incrémenté à l’intérieur de la boucle après
chaque itération. À la fin de boucle k est testé, et si k n'est pas inférieur à 10, la boucle termine.
Une boucle sans fin peut également être créée si la condition est réglée pour être vrai tout le temps:
/* Une boucle sans fin */
do
{
Instructions;
} while (k == k);
3.4. Instructions goto, continue et break
Une instruction goto peut être utilisée pour modifier le flux normal de contrôle dans un programme.
Elle provoque le programme à sauter à une étiquette spécifiée.
Une étiquette peut être n'importe quel jeu de caractères alphanumériques commençant par une lettre
et se terminant par le caractère « : ».
L’instruction goto peut être utilisée conjointement avec une instruction if.
L'exemple suivant montre comment mettre en place une boucle pour l’exécuter 10 fois en utilisant
goto et if :
/ * Exécution 10 fois * /
k = 0;
Boucle:
Instructions;
k++;
if (k < 10) goto Boucle;
Mr Nizar TOUJENI 40
La boucle commence par l’étiquette Boucle et la variable k = 0. Les instructions sont exécutées à
l'intérieur de la boucle et k est incrémenté de 1. La valeur de k est alors comparée à 10 et le
programme retourne à l’étiquette Boucle si k <10. Ainsi, la boucle est exécutée 10 fois jusqu'à ce que
la condition à la fin devienne fausse. À la fin de la boucle la valeur de k est 10.
Les instructions continue et break peuvent être utilisés à l'intérieur d’itérations pour modifier le flux
de commande. Une instruction continue est généralement utilisée avec une instruction if et provoque
le saut de la boucle d’itération.
Voici un exemple qui calcule la somme des nombres de 1 à 10, sauf le nombre 5 :
/* Calculer la somme des nombres 1, 2, 3, 4, 6, 7, 8, 9, 10 */
Sum = 0;
i = 1;
for (i = 1; i <= 10; i++)
{
if (i == 5) continue; // Passer le numéro 5
Sum = Sum + i;
}
De même, une instruction break peut être utilisé pour mettre fin à une boucle à l'intérieur de la
boucle.
Dans l'exemple suivant, la somme des nombres de 1 à 5 est calculée, même si les paramètres de la
boucle sont mis à parcourir 10 fois :
/ * Calculer la somme des nombres 1, 2, 3, 4, 5 * /
Sum = 0;
i = 1;
for (i = 1; i <= 10; i++)
{
if (i > 5) break; // Stopper la boucle si i > 5
}
Mr Nizar TOUJENI 41
Leçon N°5
AFFICHAGE DES DONNEES
I- INTRODUCTION
La conception des systèmes à microcontrôleurs implique parfois l’affichage des données à
l’utilisateur. A cet effet, on peut utiliser des afficheurs 7 segments, l’afficheur de caractère à cristaux
liquides LCD et l’afficheur LCD à écran graphique. Dans ce chapitre, on étudie et on illustre ces
dispositifs par des exemples.
II- AFFICHAGE 7 SEGMENTS
Un afficheur 7 segments est un dispositif qui permet de visualiser un nombre limité de caractères
essentiellement numériques, mais il est possible de visualiser quelques caractères comme : A, B, C,
D, E ou F. L'afficheur 7 segments est un ensemble de LED, disposées de sorte qu’on visualise les
caractères en activant les segments convenables. A chaque segment, on attribue une lettre de "a"
jusqu’à "g". La description et l'apparence physique de ces afficheurs sont illustrées sur les images
suivantes :
Figure 1
Les afficheurs 7 segments sont fabriqués en deux formats ; anode commune et cathode commune. Ils
existent également dans un format dynamique. Ces derniers utilisent deux chiffres ou plus dans un
seul boitier reliant tous les segments en parallèle, mais avec des bornes communes séparées. Les
figures suivantes montrent des afficheurs 7 segments dans leur forme dynamique :
Figure 2
Mr Nizar TOUJENI 42
L’entrée DP, qu’on peut voir sur la figure ci-dessus, est le huitième segment. Il est mis en œuvre dans
certains affichages et correspond à la virgule, il est utilisé si la demande l'exige.
1. Contrôle de l'affichage à 7 segments
Pour effectuer le premier exemple avec cet afficheur, on doit savoir comment réaliser l’affectation
des broches du PIC. A chaque segment de l'afficheur, on doit relier une broche du PIC. Pour faire une
conception optimale, on peut attribuer les broches en ordre consécutif d’un port, par exemple le
segment "a" est relié à la broche RB0, le "b" à la broche RB1, et ainsi de suite, jusqu'au segment "g"
à la broche RB6. Cependant, le développeur peut faire l’affectation des broches d’une manière
arbitraire.
Il est important de connaitre un outil contenu dans le logiciel MikroC PRO qui permet d’éditer les
digits de l’afficheur. Pour cela, on utilise Tools dans la barre de menu, et on choisit l’outil Seven
Segment Editor.
Avec cette action, ressort une nouvelle fenêtre où on peut éditer d’une manière simple les segments
de l'afficheur à 7 segments.
Figure 3
L’utilisation de cet outil signifie que toutes les broches de l’afficheur sont attribuées au même port, et
dans un ordre consécutif comme on a vu ci-dessus. Pour la visualisation des chiffres dans l’afficheur,
on doit organiser les informations de ces digits dans un ordre consécutif, dans le cas de cet exemple
de 0 à 9. A cette fin, la forme la plus simple est l'utilisation d'un tableau de données contenant les
codes des 10 chiffres. Dans l'exemple suivant, on déclare un tableau constant avec les codes des 10
chiffres, et on utilise un afficheur à cathode commune.
const unsigned short DIGITS[] =
{
0x3F, //Code du digit 0
0x06, // Code du digit 1
0x5B, // Code du digit 2
Mr Nizar TOUJENI 43
0x4F, // Code du digit 3

0x6D, // Code du digit 5
0x7D, // Code du digit 6
};
Pour afficher les chiffres dans l'afficheur à 7 segments, cet exemple va utiliser le port B du PIC
16F84A. La visualisation des numéros est contrôlée par une routine, qui change le chiffre après une
temporisation réalisée par une fonction delay_ms, cette fonction qui est prédéfinie dans les
bibliothèques du compilateur. Cette fonction a pour paramètre d’entrée un entier représentant le
temps en millisecondes, pendant lequel le PIC effectue un retard, de la même manière on peut utiliser
la fonction delay_us, qui est identique à delay_ms mais en microsecondes.
Alors, le code source du PIC pour cet exemple est le suivant :
{
0x06, //Code du digit 1
0x5B, //Code du digit 2
0x6D, //Code du digit 5
};
void main ( void )
{
unsigned short COMPTEUR=0;
TRISB = 0; // Configuration du port B en sortie
while (1) //Boucle infinie
{
Mr Nizar TOUJENI 44
PORTB = DIGITS[COMPTEUR]; //Visualisation du chiffre correspondant

// à la valeur de la variable COMPTEUR.
COMPTEUR++; //Incrémentation la valeur de compteur.
delay_ms(1000); //Retard de 1 seconde.
}
}
L'étape suivante consiste à effectuer la simulation dans ISIS, pour cet effet, les dispositifs suivants
sont découverts : 16F84A, RES, et 7SEG-COM-CATHODE. Pour la liaison entre le PIC et
l'afficheur, on devrait utiliser les résistances de 330Ω. Par la suite, on réalise le circuit suivant :
Figure 4
A l’exécution de la simulation, on doit voir sur l’afficheur un comptage des nombres de 0 à 9, avec
une cadence d’une seconde entre chiffres et chiffre.
2. Contrôle de l'affichage dynamique 7 segments
La mise en œuvre des afficheurs dynamiques utilise la même théorie d'un seul afficheur. L’affichage
dynamique consiste à afficher un seul chiffre à la fois. Par exemple, si on veut afficher quatre
chiffres, on active l’afficheur des unités, ensuite on l’éteint et on active le chiffre des dizaines, puis
on l'éteint et le chiffre des centaines est activé, enfin on fait la même chose avec l’afficheur des
milliers.
Ce processus doit être effectué à une vitesse de manière à tromper l'œil humain, de sorte à voir
comme si tous les chiffres ont été actifs. Cette gestion d’affichage minimise les connexions
électriques et la consommation d'énergie, car en réalité un seul afficheur est actif à la fois.
Vue la perception de l’œil humain, les modifications doivent être de 25Hz ou plus. Donc, tous les
chiffres doivent être montrés pendant une durée égale à l'inverse de 25Hz qui est 40ms.
Mr Nizar TOUJENI 45
Pour cet exemple, on utilise 4 afficheurs donc le temps d’affichage de chaque chiffre doit être un
quart de la période qui est 10ms. Le moyen le plus efficace pour afficher les chiffres est d’utiliser une
fonction.
On réalise la simulation sur ISIS avec les dispositifs suivants 16F84A, RES, 7SEG-MPX4-CC,7404.
Le circuit est le suivant :
Figure 5
Pour des raisons pratiques, les inverseurs 7404 peuvent être remplacés par un réseau de transistors,
comme on le voit dans l'image ci-dessous :
Figure 6
Lorsque la simulation est en marche, ce circuit devrait afficher un nombre de 0 à 9999 avec une
cadence de 500ms entre chaque incrément.
Avec 4 digits, il est possible d’afficher un nombre de 0 à 9999, à ce nombre on associe une variable
de type entier. Pour voir chaque chiffre séparément, il est nécessaire de calculer chacun des chiffres,
par exemple pour déduire le chiffre des milliers on divise le nombre par mille, puis soustraire les
Mr Nizar TOUJENI 46
milliers du nombre entier, ce processus est répété jusqu'à atteindre les unités. L’activation des
afficheurs doit se faire par un autre port, dans cet exemple elle est faite par le port A.
Pour comprendre ce processus, on observe et on analyse la fonction suivante :
// Déclaration des constantes pour l’afficheur.
{
0x5B, //Code du digit 2
};
//Fonction pour l’un affichage dynamique.
void Affichage( int Nombre )
{
unsigned short U; //Variable pour les unités.
unsigned short D; //Variable pour les dizaines.
unsigned short C; //Variable pour les centaines.
unsigned short M; //Variable pour les milliers.
M = Nombre/1000; //Calcul des milliers.
C = (Nombre-M*1000)/100; //Calcul des centaines.
D = (Nombre-M*1000-C*100)/10; //Calcul des dizaines.
U = (Nombre-M*1000-C*100-D*10); //Calcul des unités.
PORTB = DIGITS[U]; //Visualisation des unités.
PORTA.F0=1; //Activer le premier afficheur
delay_ms(10); //Retard de 10ms
PORTA=0; //Désactiver tous les afficheurs.
Mr Nizar TOUJENI 47
PORTB = DIGITS[D]; // Visualisation des dizaines.

PORTA.F1=1; //Activer le second afficheur
delay_ms(10); // Retard de 10ms
PORTA=0; // Désactiver tous les afficheurs.
PORTB = DIGITS[C]; //Visualisation des centaines.
PORTA.F2=1; //Activer le troisième afficheur
PORTB = DIGITS[M]; //Visualisation des centaines.
PORTA.F3=1; // Activer le troisième afficheur
}
void main ( void )
{
unsigned short N=0; //Variable de comptage.
int Nombre=0;
TRISB = 0; //Configurer le port B en sortie
TRISA = 0; // Configurer le port A en sortie
PORTA = 0; //Désactiver tous les afficheurs
while( 1 ) //Boucle infinie
{
//Visualiser la valeur du Nombre.
Affichage(Nombre); //cette fonction dure approximativement 40ms.
//On compte 12 incrémentations de N pour faire une incrémentation
//du Nombre approximativement chaque 500ms.
N++;
if( N==12 )
{
N=0; //Initialiser le compteur N.
Nombre++; //Incrémentation de la valeur Nombre.
if(Nombre==10000 ) //Test si Nombre vaut 10000
Mr Nizar TOUJENI 48
Nombre=0; //Initialisation à 0 si nombre = 10000.

}
}
}
III. AFFICHEURS LCD

Les afficheurs de caractères à cristaux liquides LCD sont des modules préfabriqués qui contiennent
des pilotes inclus. Ces écrans disposent d'un bus de données et un bus de commande, pour la
manipulation de ces appareils, le compilateur MikroC PRO dispose d'une bibliothèque prédéfinie
pour contrôler les LCD. L'apparence physique des LCD et celle dans ISIS sont présentées dans la
figure suivante :
Figure 7
Les afficheurs LCD, permettent de visualiser les caractères figurant dans le code ASCII. En plus du
code ASCII, LCD affiche jusqu'à 8 caractères conçus par le développeur. Une autre caractéristique
fondamentale des afficheurs LCD, tenant physiquement sur 8 bits, est la possibilité de configurer les
connexions avec seulement 4 bits. La connexion 8-bit implique un plus grand nombre de fils à
utiliser, pour une meilleure vitesse de travail, par conséquent les connexions de 4 bits réduits le
nombre de fils, mais diminue la vitesse. La bibliothèque prédéfinie dans MikroC PRO fonctionne
avec une configuration de 4 bits.
Pour voir la bibliothèque prédéfinie pour ce dispositif et d'autres, contenues dans MikroC PRO, on
choisit View dans la barre de menu, et on appuie sur l’un onglet : Library Manager. Lorsqu’on appuie
sur cet onglet un menu montrant les différentes bibliothèques qu’on peut utiliser avec les PIC.
Dans ce nouveau menu, on identifie la bibliothèque Lcd, par la suite on peut appuyer sur une des
fonctions contenues dans la bibliothèque pour voir l'aide. L'aspect visuel de cet outil est illustré dans
la figure suivante :
Mr Nizar TOUJENI 49
Figure 8
L'implémentation de l'afficheur LCD, requiert l'utilisation des instructions et des commandes
séquentielles pour la configuration et l’utilisation de l’afficheur, cependant, la bibliothèque de
MikroC PRO minimise ce travail, car elle se charge de faire tous ces réglages, ce qui rend beaucoup
plus facile le travail développeur.
Comme première étape pour l'utilisation du LCD, il est nécessaire de définir les broches de
connexion, puis l’exécution de la fonction d’initialisation du LCD : Lcd_Init(). La définition des
broches de connexion est assurée par le développeur d’une façon arbitraire selon son choix. Pour
répondre à cet objectif, on utilise la déclaration suivante des constantes :
//Broches de sortie du LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
Mr Nizar TOUJENI 50

//Bits de configuration TRIS
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
Pour changer les broches, il suffit de changer les noms des sorties du port utilisé dans l'exemple
précédent. Comme on peut le voir dans la présentation ci-dessus seulement 6 broches sont
nécessaires pour faire fonctionner le LCD, avec 4 bits de données et 2 bits de contrôle.
A la fin, on doit appeler la fonction d’initialisation dans la fonction main après configuration des
ports.
La fonction main doit être comme suit :
void main( void )
{
Lcd_Init(); //Initialisation du LCD.
while(1) //Boucle infinie.
{
}
}
Après l’édition du code ci-dessus, l'afficheur LCD est initialisé et devrait être prêt à commencer
l’affichage des caractères, se positionnant dans la première ligne et la première colonne, montrant le
curseur clignotant.
Les LCD sont fabriqués dans différentes formes et couleurs, ils sont disponibles avec des écrans
verts, bleu et jaune, avec des distributions de caractères sous forme de matrice comme les LCD 2
lignes, 16 colonnes. Ceux-ci sont connus comme 2x16, de la même manière on peut trouver des
1x16, 2x16, 2x8, 2x20, 4x20, entre autres. Pour les exemples de ce chapitre, on utilisera l'afficheur
4x20.
Pour démarrer la simulation de l'afficheur LCD, on cherche le dispositif de LM044L, et PIC 16F84A
dans le simulateur ISIS. La référence LM044L dans ISIS correspond à un LCD de 4x20. Enfin, on
effectue les connexions comme indiqué dans le circuit suivant :
Mr Nizar TOUJENI 51
Figure 9
L’afficheur LCD a une broche nommée VEE, cette broche fonctionne comme contrôleur du contraste
de l'écran, mais dans la simulation, elle n'a pas d'effet. Cette broche peut être reliée à la masse pour
générer le contraste le plus élevé, certains grands écrans nécessitent une tension négative externe
pour contrôler le contraste. Pour des raisons pratiques, le contraste peut être ajusté par l'intermédiaire
d'un potentiomètre, comme indiqué dans le circuit suivant :
Figure 10
La prochaine étape consiste à afficher à l'écran des informations. A cet effet, on peut utiliser quatre
fonctions. Deux de ces fonctions permettent d'afficher des caractères, et les deux autres des chaînes
de caractères.
Mr Nizar TOUJENI 52
Pour afficher les caractères, on peut procéder de deux façons, la première affiche simplement les
caractères dans l'ordre consécutif pris par l'afficheur et la seconde fonction imprime les caractères
dans la ligne et la colonne désignées par le développeur.
1. Fonctions d’affichage des caractères
La première fonction d’affichage des caractères est Lcd_Chr_Cp (char out_char) ; lorsque cette
fonction est invoquée affiche sur l'écran le caractère qui correspond au code ASCII, qui est le
paramètre d'entrée out_char. Avec l'impression d'un nouvel caractère sur l’afficheur LCD, le curseur
se déplace automatiquement d'une position. Pour voir le fonctionnement de cette fonction, on observe
l'exemple suivant :
void main( void )
{
Lcd_Chr_Cp(‘S’); //cette fonction affiche lettre à lettre le mot “Salut”.
Lcd_Chr_Cp(‘a’);
Lcd_Chr_Cp(‘l’);
Lcd_Chr_Cp(‘u’);
Lcd_Chr_Cp(‘t’);
{
}
}
Après l'exécution de la simulation, on devrait observer ce qui suit sur l'afficheur LCD :
Figure 11
Pour l'affichage des caractères au moyen des cordonnées ligne, colonne, la fonction mise en œuvre :
Lcd_Chr(char row, char column, char out_char); cette fonction imprime le caractère out_char, dans
la colonne column et la ligne row. Dans l'exemple ci-dessous, on peut voir comment utiliser cette
fonction :
Mr Nizar TOUJENI 53
void main( void )

{
Lcd_Init(); //Initialisation du LCD
Lcd_Chr_Cp(‘S’); //Ces fonctions impriment lettre à lettre le mot “Salut”.
Lcd_Chr_Cp(‘a’);
Lcd_Chr_Cp(‘l’);
Lcd_Chr_Cp(‘u’);
Lcd_Chr_Cp(‘t’);
Lcd_Chr( 1, 6, ‘1’); //Imprime le caractère 1, dans la ligne 1, colonne 6
Lcd_Chr( 2, 7, ‘2’); // Imprime le caractère 2, dans la ligne 2, colonne 7
{
}
}
Après l'exécution de la simulation, on devrait observer ce qui suit sur l'afficheur LCD :
Figure 12
2. Fonctions d'affichage des chaînes de caractères
L'utilisation de chaînes est similaire aux deux fonctions précédentes, pour cela on peut afficher des
chaines de caractères à un point arbitraire à l'aide des coordonnées ligne et colonne. Pour imprimer
une chaîne de caractères à la position courante du curseur, on utilise la fonction suivante :
Lcd_Out_Cp (char * text) ; elle a un paramètre d'entrée unique qui est un pointeur vers la chaîne.
Pour voir comment utiliser cette fonction, on observe l'exemple suivant :
void main( void )
Mr Nizar TOUJENI 54
{
Lcd_Out_Cp(“salut tout le Monde”);
{
}
}
La mise en œuvre de cette fonction peut être faite avec des chaînes de caractères constantes ou
variables, des chaines constantes sont indiquées par des guillemets au début et à la fin du texte, par
exemple "Salut tout le Monde ", la forme variable est déclarée : char texte [20] = "Salut tout le
Monde ". Après avoir exécuté la simulation, on a comme montré dans la figure suivante :
Figure 13
Pour imprimer une chaîne de caractères avec une coordonnée comme point de départ, on implémente
la fonction : Lcd_Out(char row, char column, char *text);. Cette fonction est similaire à la
précédente, à la différence qu’on inclut les données row et column, qui font référence respectivement
à la ligne et la colonne. Pour bien comprendre le fonctionnement de cette fonction d'observe et on
analyse l'exemple suivant :
void main( void )
{
Lcd_Out( 1, 1, “Ligne 1, Colonne 1” );
Lcd_Out( 2, 2, “Ligne 2, Colonne 2” );
{
}
}
Après la compilation et la simulation de cet exemple, on devrait observer sur l'écran LCD comme
suit:
Mr Nizar TOUJENI 55
Figure 14
3. Affichage des valeurs numériques
La visualisation des valeurs numériques est indispensable dans de nombreux développements. Par
exemple, lorsqu’on souhaite afficher l'état d'une variable, ou un capteur tel que : température,
humidité, la pression, etc.
Pour atteindre cet objectif, on peut recourir aux fonctions de conversion prédéfinies par le
compilateur. Pour cela, on peut utiliser la bibliothèque : Conversions, qui contient des fonctions qui
convertissent une valeur numérique en une chaîne de caractères.
Si on veut afficher une valeur de type entier, on utilise la fonction : IntToStr(int input, char *output);
cette fonction a deux paramètres d'entrée sont: input, qui est une valeur entière à afficher, et output,
qui est un pointeur sur une chaîne où on veut écrire la forme texte de la valeur intput. Pour
comprendre ce type de conversion, on observe et on analyse l'exemple suivant :
void main( void )
{
int ENTIER=123; //Déclaration d’une variable entière avec valeur initiale 123.
char Text[20]; //Chaine de caractères pour l’affichage des données.
IntToStr( ENTIER,Text ); //Fonction de conversion.
Lcd_Out_Cp(Text); //Impression du texte dans l’écran LCD.
{
}
}
L’impression des nombres entiers en chaîne de caractères avec cette fonction, réserve toujours un
champ fixe de 7 caractères, c'est à dire si le nombre est inférieur à 7 chiffres le reste du texte est
complété par des espaces vides. Après compilation du programme et simulation sur ISIS, on a un
résultat comme dans la figure suivante :
Mr Nizar TOUJENI 56
Figure 15
L’impression des nombres décimaux (avec virgule) peut être fait avec la fonction : FloatToStr (float
fnum, char *str);. La philosophie de fonctionnement de cette fonction est identique à la précédente,
qui fait des conversions d'entiers. Pour réaliser l'exemple suivant, on doit modifier la référence du
microcontrôleur, cela est dû à la capacité de mémoire du PIC 16F84A, qui n'est pas suffisante pour
les exercices suivants.
void main( void )
{
int ENTIER=123; //Déclaration d’une variable entière avec la valeur initiale 123.
float DECIMAL=12.76543; //Déclaration d’une variable avec point décimal
//initialisation à 12,76543.
char Text[20]; // Chaine de caractères pour l’affichage des données.
IntToStr( ENTIER,Text ); //Fonction de conversion entière .
Lcd_Out(1,1,Text); //Impression du texte en sur l’écran LCD.
FloatToStr( DECIMAL,Text ); //Fonction de conversion décimale.
Lcd_Out(2,1,Text); // Impression du texte en sur l’écran LCD.
{
}
}
Après la simulation, on a le résultat sur la figure suivante :
Mr Nizar TOUJENI 57
Figure 16
Le même processus peut être suivi pour autres types de variables telles que : short avec la fonction :
ShortToStr(short input, char *output);
Les variables long avec la fonction : LongToStr(long input, char *output);
Des variables unsigned short avec la fonction : ByteToStr(unsigned short input, char *output);
Variables unsigned long avec la fonction : LongWordToStr(unsigned long input, char *output);
Les variables unsigned int avec la fonction : WordToStr(unsigned int input, char *output);
Mr Nizar TOUJENI 58
Leçon N°6
SYSTEMES D’ENTREE DES DONNEES
I- INTRODUCTION
L'interaction de l’utilisateur avec les systèmes à microcontrôleurs nécessite des systèmes d’entrée de
données. Pour ce faire, on utilise des périphériques tels que des interrupteurs, des claviers et même
des claviers PS2 utilisés par les ordinateurs de bureau. Ce chapitre se concentre sur l'étude des
boutons, interrupteurs et les Dip-Switch.
II- UTILISATION DES BOUTONS
La mise en œuvre des boutons est l'un des alternatives les plus populaires dans les interfaces avec les
utilisateurs. Les boutons sont simples à utiliser, et ils ont un coût, de mise en œuvre, économique. Le
bouton-poussoir peut être normalement ouvert ou normalement fermé. L’implémentation de ces
dispositifs est sujette aux effets de rebonds ou de bruit, quand ils changent d'état. Compte tenu du
traitement rapide des microcontrôleurs, ces effets de bruit, font que le PIC peut détecter des
changements et des états logiques indéfinis. Pour comprendre ce concept, on regarde le graphique ci-
dessous qui montre le comportement de ce bruit :
Figure 1
Lorsque des changements de tension traversent la zone indéfinie, génèrent des rebondissements de
l’état haut à l’état bas et vice versa. Le microcontrôleur les détecte comme des impulsions. Pour
éviter l'effet du bruit ou des rebonds, on devrait faire une temporisation en attendant la stabilisation
de l'état du signal. La durée moyenne d'un rebond est de 1 à 5 millisecondes, indique qu'un retard doit
être effectué supérieur à ce temps pour attendre la stabilisation. Un retard convenable à cet effet est
supérieur ou égal à 10 millisecondes. Ce délai devrait s'appliquer après la détection du premier
changement sur le bouton.
Pour le traitement des boutons et l’élimination des rebondissements, le compilateur MikroC PRO
dispose d’une bibliothèque Button, qui peut être trouvé dans la palette ou l'onglet des bibliothèques.
Cette bibliothèque contient la seule fonction : unsigned short Button (unsigned short *port,
unsigned short pin, unsigned short time, unsigned short active_state) ; où port est le port où le
bouton est connecté, pin est le bit du port où le bouton est connecté, time est le temps d'attente en
millisecondes du bruit et active_state est l'état logique pour lequel on souhaite l'activation du bouton.
La fonction retourne 0 si le bouton n'est pas actif et 255 si elle est active. Installation des boutons
peut être effectuée de deux manières, actif à l’état haut ou actif à l’état bas, la figure suivante montre
comment configurer les deux possibilités :
Mr Nizar TOUJENI 59
Figure 2
La décision d'utiliser l'activation à l’état haut ou bas, dépend du développeur qui doit analyser la
manière la plus simple au moment de la conception. On rappelle que dans tous les cas l'activation
finale peut être inversée avec la fonction de la bibliothèque. Pour analyser et étudier l'utilisation de
cette bibliothèque, on crée un nouveau projet avec les composants : PIC 16F877A, BUTTON, RES,
et LED-RED. Le circuit correspondant dans ISIS est le suivant :
Figure 3
Le programme respectif du microcontrôleur est le suivant :
void main( void )
{
TRISB=0xF0; //Configuration des ports.
Mr Nizar TOUJENI 60
PORTB=0;
while(1) //Boucle infinie
{
if(Button(&PORTB, 7, 100, 0)) //Test de d’état du bouton sur RB7, activé à l’état bas
PORTB.F0=1; // Allumer le voyant si le bouton est actif.
else
PORTB.F0=0; //Eteindre la LED s’il est relâché.
}
}
A l’exécution de la simulation, la LED doit s'allumer lorsque le bouton est pressé, et s’éteindre
lorsqu'il est relâché.
L'exemple suivant commute l’état de la LED :
void main( void )
{
TRISB=0xF0; //Configuration des ports.
PORTB=0;
{
if(Button(&PORTB, 7, 100, 0)) //Test de l’état actif du bouton.
{
if( PORTB.F0==1 ) // Commutation de l’état de la LED.
PORTB.F0=0;
else
PORTB.F0=1;
//Attente que le bouton soit no actif.
while( Button(&PORTB, 7, 100, 0) );
}
}
}
III- UTILISATION DES DIP-SWITCH

Les Dip-Switch, sont des dispositifs mécaniques contenant plusieurs interrupteurs dans un seul
boitier. Ces dispositifs permettent de configurer de façon simple les caractéristiques binaires des
systèmes à microcontrôleurs. Les Dip-Switch, sont disponibles dans le commerce dans des tailles,
Mr Nizar TOUJENI 61
des couleurs, et des nombres d’interrupteurs différents. Leurs aspects physiques et leurs schémas
dans le simulateur ISIS sont les suivants :
Figure 4
L’utilisation du Dip-Switch est similaire au bouton. Il peut être configuré de la même manière avec
activation sur l’état haut ou bas. Ces configurations peuvent être appréciés dans le circuit suivant :
Figure 5
Pour comprendre l'utilisation du Dip-Switch avec les microcontrôleurs PIC, on observe et on analyse
l'exemple suivant :
void main( void )
{
TRISB = 0; //Configuration de ports.
PORTB = 0;
Mr Nizar TOUJENI 62
TRISC = 255;
{
PORTB = ~PORTC; //Sortir dans le port B le complément du port C.
}
}
Pour exécuter la simulation dans ISIS, on utilise les dispositifs suivants : 16F877A, RES, LED-RED,
DIPSW_8. Puis le circuit suivant est mis en œuvre dans ISIS :
Figure 6
En exécutant la simulation, les LED montrent l'état du Dip-Switch.
IV- UTILISATION DU CLAVIER MATRICIEL
Les applications de microcontrôleur exigent dans certains cas la saisie à l'aide des touches de saisie
de données, des fonctions et des chaines de caractères. La méthode la plus pratique consiste à utiliser
des claviers matriciels, constitués de boutons alignés en lignes et en colonnes, ce qui minimise le
nombre de connexions électriques. Dans la figure ci-dessous, vous pouvez voir l'apparence physique
d'un clavier matriciel 4x4 et son schéma équivalent :
Mr Nizar TOUJENI 63
Figure 7
Le compilateur MikroC PRO dispose d’une bibliothèque qui contrôle et lit un clavier 4x4, cette
bibliothèque possède trois fonctions qui sont :
- Keypad_Init (void) : permet d’initialiser le clavier.
- char Keypad_Key_Press (void) : c’est une fonction qui retourne une valeur de 0 à 16, dont le 0
représente le clavier totalement inactif, les résultats 1 à 16 représentent les 16 clés possibles.
- char Keypad_Key_Click (void) : son comportement est identique à la fonction précédente, la
différence essentielle est que si la fonction détecte une combinaison de touches, elle ne retourne
pas sa valeur jusqu'à ce que cette touche est relâchée.
Mr Nizar TOUJENI 64
Leçon N°7
COMMUNICATION SERIE
I- INTRODUCTION
Les nouveaux microcontrôleurs exigent dans certains cas, la mise en œuvre des communications en
série pour établir le transport de données avec d'autres appareils tels que des mémoires, des capteurs,
des ordinateurs, et même d'autres microcontrôleurs.
Afin d'effectuer des communications série, certains microcontrôleurs ont des modules série comme
I²C, SPI, USART et USB. Chacun de ces formats de communication permettent la communication
avec les différents modules.
Le module I²C est idéal pour communiquer avec des mémoires série comme 24LC64,
24LC128, 24LC512, etc.
Le protocole SPI permet la communication avec les périphériques de stockage de masse tels
que la mémoire SD.
Le module USART est l'un des plus utilisés ; Ce module permet la communication avec des
dispositifs tels que des capteurs, la transmission et la réception des modules XBee,
ordinateurs personnels, les modules GPS, et d'autres microcontrôleurs.
Le module USB, construit autour de quelques microcontrôleurs comme le 18F2550 et
18F4550, permet la communication avec un ordinateur personnel par l'intermédiaire d'un port
USB.
II- LE MODULE USART
Le USART est un module de communication série standard, de manière asynchrone. Il nécessite un
seul support de transmission pour envoyer des informations et ne nécessite pas un moyen pour
l'horloge.
Le signal d'horloge ou de synchronisation doit prendre, indépendamment l'un de chacun des
éléments, l'émetteur et le récepteur.
Un autre avantage de ce module est qu'il a une communication full-duplex, ce qui signifie qu'il peut
transmettre et recevoir des informations en même temps. A cet effet, deux moyens de transmission
dédiés sont utilisés, un pour émettre et un pour recevoir.
Remarque : en général, une communication comprend 4 phases :
- Etablissement d’un circuit entre 2 correspondants
- Initialisation de la transmission
- Transmission proprement dite
- Libération de la transmission
La transmission étant du type asynchrone (pas d'horloge commune entre l'émetteur et le récepteur),
des bits supplémentaires sont indispensables au fonctionnement : bit de début de mot (start), bit(s) de
fin de mot (stop).
Ce protocole est utilisé par les ordinateurs personnels et d'autres dispositifs, et est connu comme
RS232, pour le cas spécifique des niveaux de tension sont différents au microcontrôleur. Le protocole
RS232 représente la valeur d'un 0 logique à une tension de +12 volts, et la valeur d'un 1 logique à -12
Mr Nizar TOUJENI 65
volts. Les ordinateurs personnels et autres appareils qui mettent en œuvre le port RS232 à l'aide d'un
connecteur DB9, qui dispose de 9 broches, qui sont identifiés dans la figure suivante :
Figure 1
Pin Nom
1 DCD
2 RXD
3 TXD
4 DTR
5 GND
6 DSR
7 RTS
8 CTS
9 Non utilisé
Aux fins de connexions de communication asynchrones doivent être configurés comme suit :
Figure 2
Pour établir et joindre une communication PIC avec un dispositif RS232, il faut utiliser un
convertisseur connu comme MAX232. La mise en œuvre de cela, il doit être comme indiqué dans la
figure suivante :
Mr Nizar TOUJENI 66
Figure 3
Pour utiliser ce protocole de communication du mikroC PRO, la bibliothèque UART est disponible
dans les librairies et la palette a les fonctions suivantes pour l'utilisation :
UART1_Init (const unsigned long BAUD_RATE) : cette fonction initialise le module USART
et établit la vitesse de communication défini dans le paramètre : BAUD_RATE.
char UART1_Data_Ready( ) : cette fonction détermine s'il y a des données prêtes à être lues à
l'arrivée du module de mémoire tampon, la fonction renvoie 1 si les données peuvent être lues,
sinon pas de nouvelles données dans la mémoire tampon.
char UART1_Tx_Idle ( ) : cette fonction permet de définir si le tampon de transmission est
occupé à envoyer des données, car il renvoie 1 si le tampon est occupé, ou 0 si le module est
disponible pour envoyer de nouvelles données.
char UART1_Read ( ) : cette fonction retourne la valeur de la mémoire tampon d'entrée qui est
utilisé pour lire une entrée.
UART1_Read_Text (char *Sortie, char *x, char y) : cette fonction lit une chaine de caractères.
Mr Nizar TOUJENI 67
UART1_Write (omble de _data) : transmet les données saisies dans le paramètre d'entrée pour
le USART.
UART1_Write_Text (char *UART_text) : transmet une chaîne de texte terminée par le
caractère nul ou une chaîne de texte nulle est fournie par le paramètre UART_text.
Pour l'exemple suivant doit être mis en œuvre dans ISIS, le circuit avec les appareils suivants :
16F877A PIC et l'instrument virtuel : TERMINAL VIRTUEL. Avec ces deux éléments, le circuit
suivant est construit:
Figure 4
L'outil terminal virtuel, est une communication série de simulateur et dispose d'un outil similaire pour
le comportement de Windows HyperTerminal. Cet outil vous permet de modifier les fonctions de
communication telles que: le nombre de bits de données, la vitesse de transmission, le nombre de bits
d'arrêt, entre autres. Cependant, l'instrument est configuré avec un taux de défaut de 9600 bps, et prêt
à utiliser avec des fonctionnalités PIC USART.
Pour vérifier le fonctionnement de ce module, vous pouvez compiler et simuler l'exemple suivant:
void main( void )
{
//Declaración de variables.
char DATO;
UART1_Init(9600); //Inicio del módulo USART.
//Se transmite el texto: de bienvenida.
UART1_Write_Text("Bienvenido al simulador:");
Mr Nizar TOUJENI 68
UART1_Write(13); //Se transmite el ASCII del ENTER.

UART1_Write(10); //Se transmite el ASCII del retroceso del carro.
//Se trasmite el texto de pulsar tecla.
UART1_Write_Text("Pulse una tecla!...");
while(1)//Bucle infinito.
{
//La sentencia if evalúa si un dato está listo para leer.
if(UART1_Data_Ready()==1)
{
//Se lee el DATO del bufer.
DATO = UART1_Read();
//Se imprime el texto de realimentación.
UART1_Write_Text("Usted pulso la tecla: ");
UART1_Write(DATO); //Se transmite el DATO recibido.
}
}
}
Pendant la simulation, l'utilisateur peut envoyer des données à travers le terminal virtuel et voir les
commentaires que le PIC, il émet.
III- LE MODULE I²C SERIE
Certains microcontrôleurs ont ce module et de la même manière MikroC PRO dispose d’une
bibliothèque pour une utilisation facile de cette bibliothèque de protocole. Cette bibliothèque a 7
fonctions principales pour le fonctionnement du module.
I2C1_Init (const unsigned long clock) : initialise broches de communication dans le PIC et
ajuste la vitesse de communication.
unsigned short I2C1_Start (void) : cette fonction génère la condition de démarrage et renvoie 0
si aucune erreur dans la transmission, une autre forme retourne une valeur autre que 0.
void I2C1_Repeated_Start (void) : cette fonction génère début de répétition.
unsigned short I2C1_Is_Idle (void) : cette fonction est utilisée pour déterminer si le bus de
données est occupé, et renvoie 1 si le bus est disponible ou retourne 0 si elle est occupée.
Mr Nizar TOUJENI 69
unsigned short I2C1_Rd (unsigned short ack) : cette fonction lit des données de bus de
données et envoie la confirmation ack pour le bus. Si ack=1 la confirmation est positif et si
ack=0 la confirmation est négatif ou NO ACK.
unsigned short I2C1_Wr (unsigned short data) : cette fonction envoie les données via le bus
de données et renvoie 0 si la transmission a réussi, ou quelque chose autre que 0 si des erreurs se
produisent.
void I2C1_Stop (void) : génère la condition finale dans le bus de communication.
Figure 5
Le programme de simulation correspondant de code est le suivant :
void main( void )
{
unsigned short DIRECTION;
unsigned short DATA;
//Configuration des ports.
ADCON1 = 6;
TRISE = 7;
TRISB = 0;
PORTB = 0;
Mr Nizar TOUJENI 70
I2C1_Init(100000);
while(1)
{
DIRECTION = (~PORTA)&0x0F;
I2C1_Start();
I2C1_Wr(0b10100000);
I2C1_Wr(DIRECTION);
I2C1_Repeated_Start();
I2C1_Wr(0b10100001);
DATO=I2C1_Rd(0);
I2C1_Stop();
PORTB = DATA;
delay_ms(100);
if( Button( &PORTA, 4, 50, 0) )
{
DATA = ~PORTD;
I2C1_Start();
I2C1_Wr(0b10100000);
I2C1_Wr(DIRECTION);
I2C1_Wr(DATA);
I2C1_Stop();
delay_ms(50);
}
}
}
Après l'édition et la simulation dans ISIS, vous pouvez voir les valeurs spécifiées dans la direction de
l'ADRESSE DIP-SWITCH sur les LEDs. Lorsque le bouton REC est pressé, la valeur du DIP-
SWITCH, DATA est enregistré dans le sens du courant. Broches d'horloge et de données pour ce
PIC, sont déjà prédéfinis par le fabricant pour le RC3 broches et RC4, respectivement.
Mr Nizar TOUJENI 71
Leçon N°8
CONVERTISSEUR AD ET DA
I- INTRODUCTION
La conversion analogique-numérique et numérique analogique est un processus par lequel on peut
prendre ou délivrer un échantillon d'un signal continu de tension. L’utilisation des conversions est
très utile pour le traitement numérique des signaux. La conversion analogique numérique, ou ADC,
peut être faite avec des microcontrôleurs qui intègrent ce type de convertisseur. Le processus de
conversion numérique-analogique est possible avec des éléments externes faciles à implémenter,
même on peut effectuer cette conversion par des modules PWM incorporés dans certains des
microcontrôleurs.
II- CONVERSION AD OU ADC
Ce processus est réalisé avec un convertisseur interne du microcontrôleur. Ce module est intégré dans
la plupart des microcontrôleurs de moyenne et haute gamme. La conversion implémentée sur les PIC
a une résolution de 10 bits, ce qui permet un nombre allant de 0 à 1023, proportionnel aux valeurs de
référence, qui sont par défaut 0 volts et 5 volts.
Cela signifie que si une entrée analogique a une tension de 0 volt, le résultat est à 0, et si la tension
est de 5 volts, le résultat de la conversion est de 1023, de la même façon si la tension est de 2,5 volts,
le résultat est de 512. En fonction de la complexité d'un microcontrôleur, le PIC peut avoir jusqu'à
huit entrées du signal analogique. Cependant, il est à noter que le microcontrôleur a un seul module
interne de conversion, mais plusieurs canaux de lecture des tensions analogiques mais pas
simultanément.
Pour effectuer ces conversions le compilateur MikroC PRO offre une bibliothèque prédéfinie : ADC
pour faire la conversion. Cette bibliothèque contient une fonction appelée ADC_Read (unsigned
short channel). Cette fonction retourne le résultat de la conversion de la chaine spécifiée par le
paramètre channel. Pour utiliser cette bibliothèque, on peut observer et analyser l'exemple suivant :
void main( void )
{
//Déclaration des variables.
unsigned int Donnee;
//Initialisation des ports.
TRISB = 0;
TRISC = 0;
PORTB = 0;
PORTC = 0;
{
Mr Nizar TOUJENI 72
Donnee = ADC_Read(0); //Conversion sur le canal 0.

//Sortir les 8 bits de poids le plus faible sur le port B.
PORTB = Donnee&0xFF;
// Sortir les 2 bits de poids le plus fort sur le port C.
PORTC = (Donnee>>8)&0x03;
}
}
Pour simuler cet exemple, on doit utiliser les dispositifs suivant : 16F877A, RES, LED-RED, POT-
HG, le circuit suivant sur ISIS :
Figure 1
Après l'exécution de la simulation, les LED montrent le code binaire correspondant à la valeur de la
conversion analogique-numérique de la tension appliquée par le potentiomètre à l’entrée analogique
0.
III- CONVERSION DA OU DAC
Cette conversion est possible grâce à deux stratégies, la première consiste à utiliser le module PWM
du microcontrôleur, et la seconde est la mise en œuvre d'un ensemble externe de résistance pour
obtenir la valeur analogique.
III-1. Conversion DA avec PWM
La conversion numérique-analogique, avec le module de PWM, consiste à prendre le signal modulé
en largeur d'impulsion et d'effectuer la démodulation par l'intermédiaire d'un filtre passe-bas. Ce filtre
doit avoir la fréquence de coupure très inférieure à la fréquence d'échantillonnage avec un rapport
proche de 10, car son but est d'éliminer la fréquence d'échantillonnage. Le calcul de la fréquence de
coupure de ce filtre est régi par la formule suivante :
Mr Nizar TOUJENI 73
1
FC = (Equation 1)
2π RC
Le circuit suivant met en œuvre un filtre passe-bas du premier ordre :
Figure 2
L’implémentation d’un filtre passe bas second ordre :
Figure 3
L’expression de la fréquence de coupure de ce filtre est :
1
FC = (Equation 2)
2π RC 2
La fréquence attribuée à la porteuse PWM, doit être beaucoup plus grande que la fréquence du signal
modulant. Pour expliquer le fonctionnement de cette conversion, on désigne 20 échantillons
Mr Nizar TOUJENI 74
correspondant à une période d'un signal sinusoïdal. Les échantillons et la forme d'onde peut être vu
dans la figure suivante :
Figure 4
La mise en œuvre de la bibliothèque PWM, fait au moyen de quatre fonctions sont :
PWM1_Init(const long freq);, cette fonction initialise le module PWM à la fréquence de la
porteuse freq.
PWM1_Set_Duty(unsigned short duty_ratio);, Cette fonction définit le rapport cyclique de
travail par le paramètre duty_ratio, ce paramètre peut prendre des valeurs de 0 à 255, où 0 est
0% et 255 est 100% de la période de la porteuse.
La figure suivante illustre le comportement d'un signal PWM, selon la période de travail, la relation
fpwm et Tpwm :
Figure 5
Enfin, il y a des fonctions : PWM1_Start () et PWM1_Stop ();, Qui active et désactive respectivement
le signal PWM.
Pour la simulation doit créer un projet en MikroC PRO, avec le code source suivant :
Mr Nizar TOUJENI 75
const unsigned short Sinus[20] =//Déclaration des constantes pour le signal sinus.
{ 127, 146, 163, 177, 185, 189, 185, 177, 163, 146, 127, 107, 90, 76, 68, 65, 68, 76, 90, 107};
void main( void )
{
unsigned short n=0; //Déclaration des variables.
PWM1_Init(15625); //Configuration du module PWM à Fpwm=15.625KHz.
//Initialisation de signal PWM.
PWM1_Start();
{
for( n=0; n<20; n++ ) // Parcourir les 20 échantillons d’une période du signal sinus.
{
PWM1_Set_Duty( Sinus[n] ); //Modification du rapport cyclique du PWM.
delay_us(50); //Retard de 50us.
}
}
}
L'exécution de la simulation nécessite les dispositifs : 16F877A, RES, PAC, OP1P et des instruments
virtuels: OSCILLOSCOPE. Ce dernier est un oscilloscope virtuel 4 canaux simultanés, idéal pour
l'affichage des signaux analogiques et même numériques.
Ce circuit met en œuvre un filtre passe-bas pour éliminer fpwm fréquence porteuse dans ce cas est
15.6KHz, le filtre a une fréquence de coupure d'environ 1,5 kHz.
Dans les applications futures, il est recommandé de calculer les filtres, définir une valeur arbitraire
pour le condensateur C, entre 100 pF et 100nF et calculer la valeur de R, en utilisant les équations ci-
dessus.
Avec les éléments ci-dessus, on construit le circuit suivant :
Mr Nizar TOUJENI 76
Figure 6
Au cours de la simulation, on peut voir sur l’oscilloscope le signal analogique de forme sinusoïdale,
produit de la reconstitution numérique du PIC, par l'intermédiaire du module PWM, et le filtre passe-
bas.
Le signal visualisé par l'oscilloscope peut être apprécié sur la figure suivante :
Figure 7
Mr Nizar TOUJENI 77
III-2. Conversion DA à réseau R-2R

Le réseau des résistances R-2R, permet la conversion d'un nombre binaire en une valeur de tension
proportionnelle. Cette disposition permet de mettre en œuvre un nombre indéterminé de bits, à la
différence du module PWM, qui est limité à 8 bits. Cela signifie que, avec le réseau R-2R, on peut
effectuer des conversions de 8, 16, 32, 64, ou d'un nombre de n bits en fonction du nombre de
broches disponibles dans un microcontrôleur.
La mise en œuvre du convertisseur R-2R est facile à réaliser, car il est constitué d'un réseau de
résistances où l’une est le double de l'autre, d'où le nom de R-2R.
Il est à noter que plus on utilise de bits, plus la résolution est meilleure, donc une plus grande qualité
du signal reconstruit.
L’inconvénient notable de cette disposition est l'augmentation du matériel exigé, et par conséquent,
l'utilisation d'un plus grand nombre de broches du port.
Dans le circuit ci-dessous, on peut voir la configuration des résistances pour une conversion de 8 bits
:
Figure 8
Cette disposition peut être étendue avec la même architecture de réalisation pour un convertisseur
d'une résolution plus élevée, ce qui augmente le nombre d'entrées D, qui est le même nombre de bits.
Une autre caractéristique de ce type de conversion est qu'il ne nécessite pas des bibliothèques
spécialisées, il suffit simplement de placer la valeur numérique à convertir sur un port, et la valeur
analogique sera présente dans la sortie.
De la même façon qu’on a procédé pour la conversion avec PWM, il est important de supprimer la
fréquence d'échantillonnage pour éviter les composantes de signal.
Le schéma complet du convertisseur avec un suiveur pour l’adaptation d’impédances, suivi d’un
filtre passe-bas de fréquence de coupure 1.5KHz :
Mr Nizar TOUJENI 78
Figure 9
Pour montrer l'application de cette technique de conversion, on modifie l'exemple de la conversion
PWM, à cet effet, on observe et on analyse le code source suivant :
const unsigned short Sinus[20] = //Déclaration des constantes pour le signal sinus.
{ 127, 146, 163, 177, 185, 189, 185, 177, 163, 146, 127, 107, 90, 76, 68, 65, 68, 76, 90, 107};
void main( void )
{
unsigned short n=0; //Déclaration des variables.
TRISB = 0; //Configuration des ports.
PORTB = 127;
{
for( n=0; n<20; n++ ) //Parcourir les 20 échantillons d’une période du signal sinus.
{
PORTB = Sinus[n];
delay_us(50); //Retard de 50us.
}
}
}
On édite et on compile ce programme, on procède à la simulation dans ISIS, du circuit suivant :
Mr Nizar TOUJENI 79
Figure 10
Le résultat attendu est cette simulation est similaire à la simulation du convertisseur avec PWM, la
sortie de l'oscilloscope devrait montrer une courbe identique.
Mr Nizar TOUJENI 80
Leçon N°9
LES TIMERS EN MIKROC
1. Principe de fonctionnement
Rôle : Réaliser une temporisation
Elément essentiel : Compteur qui s'incrémente à chaque front montant du signal qui lui est appliqué
:
Lorsque le compteur dépasse la valeur maximale qu'il peut contenir (par exemple : 256 pour
un compteur sur 8 bits), un drapeau (flag en anglais) se lève.
Ce drapeau a pour but d'indiquer au programme que le compteur a débordé (c'est à dire qu'il a
fini de compter). De la même manière que pour la boite aux lettres, c'est au programme de
rebaisser le drapeau pour recommencer un cycle de comptage (ça ne se fait pas tout seul !).
2. Méthodes de configuration
Un Timer doit pouvoir compter un temps défini par le programme (par exemple 1ms, 10ms, 50ms,
etc.). Pour cela, 2 paramètres peuvent être modifiés :
La fréquence du signal applique au compteur : Le compteur s'incrémentera ainsi plus ou
moins vite.
Le nombre d'impulsions à compter : Le drapeau se lève toujours lorsqu'il y a débordement, on
peut donc faire partir le compteur d'une valeur non nulle pour réduire le temps de comptage.
Modification de la fréquence du signal applique au compteur : le pré-diviseur (prescaler en anglais)
Mr Nizar TOUJENI 81
Exemple : pour compter 4 fois moins vite
Modification du nombre d'impulsions à compter

Si le compteur démarre à 0, il mettra beaucoup de temps à atteindre sa valeur maximale.
Pour réduire le temps de comptage, on peut donc charger une valeur initiale non nulle dans le
compteur.
Exemple : Valeur initiale égale à 250
3. Les Timers du PIC 16F877

Composition générale d'un Timer sur un microcontrôleur PIC :
Calcul du temps mis par le Timer pour faire lever son drapeau :
Les Timers sont internes au microcontrôleur.

Le 16F877 en compte 3 :
– Timer0 et Timer2 sur 8 bits
– Timer1 sur 16 bits
Mr Nizar TOUJENI 82
3.1. Le Timer0 du 16F877

Composition du Timer0
Le pré-diviseur peut prendre une valeur parmi la liste suivante : 1, 2, 4, 8, 16, 32, 64, 128 ou
256.
La valeur initiale peut prendre n'importe quelle valeur entière comprise entre 0 et 255.
Calcul du temps maximum

Pour que le drapeau se lève le plus tard possible, il faut que la fréquence du signal applique au
compteur soit la plus faible possible. Il faut donc configurer le pré-diviseur le plus grand :
256.
Il faut également faire démarrer le compteur avec la valeur la plus petite possible pour qu'il
compte le nombre d'impulsion le plus grand : valeur initiale = 0.
Mr Nizar TOUJENI 83
Calcul d'un temps de 10

ms
Registre de configuration du Timer0 : OPTION_REG
Registres associés au Timer0

TMR0 : c'est le registre de comptage. C'est donc dans ce registre que nous allons rentrer la
valeur de départ de notre compteur.
INTCON : seuls les bits 7, 6, 5 et 2 sont utiles pour le Timer 0 (ce sont les seuls non grises).
Dans ce chapitre, nous ne nous intéresserons qu'au bit 2 appelé T0IF et qui correspond au flag
Mr Nizar TOUJENI 84
permettant de tester la fin du comptage. Les bits 7, 6 et 5 seront vus lors du chapitre sur les
interruptions.
OPTION_REG : Nous venons de le voir ...
Exemple de programme
void tempo_timer0 ( void ); // tempo de 10ms avec le timer0
void init ( void ); // initialisation des périphériques
void main ( void )
{
init(); // initialisation des périphériques
while ( 1 ) // boucle infinie
{
PORTB.F1 = !PORTB.F1; // on change l'état de RB1
tempo_timer0(); // tempo de 10 ms
}
}
void tempo_timer0 ( void ) // tempo de 10ms avec le timer0
{
TMR0 = 100; // initialisation du registre de comptage
T0IF = 0; // initialisation du drapeau lié au timer0
while ( T0IF == 0 ); // attente de la levée du drapeau
}
void init ( void ) // initialisation des périphériques
{
TRISB = 0; // RB1 configuré en sortie
OPTION_REG = 0x85; // configuration du timer0 : pré-diviseur à 64
}
Mr Nizar TOUJENI 85

Il est légèrement diffèrent du Timer 0 puisque le début de comptage est en principe 0x00 et
que la fin de comptage est la valeur à entrer.
Il possède comme le Timer 0 un pré-compteur fixe et un pré-compteur variable (3 valeurs
possibles : 1, 4 et 16). C'est aussi un compteur 8 bits.
Calcul de la durée de comptage
Durée de comptage maximale
Originalité de ce Timer
Le flag ne se lève pas systématiquement à chaque fin de comptage.
Existence d'un post-compteur.
Ce post-compteur peut prendre chaque valeur entière entre 1 et 16.
Exemple pour un post-compteur de 4 :
La temporisation max de ce Timer est donc :

TMAX = 16 * 4,096 ms soit 65,536 ms
La formule permettant de calculer la durée de la temporisation est donc :
Mr Nizar TOUJENI 86
Registres associés au Timer2

TMR2 : c'est le registre de comptage. C'est donc dans ce registre que nous allons rentrer la
valeur de départ de notre compteur.
Mr Nizar TOUJENI 87
Exemple de programme
void tempo_timer2 ( void ); // tempo avec le timer2
void init ( void ); // initialisation des périphériques
void main ( void )
{
init(); // initialisation des périphériques
while ( 1 ) // boucle infinie
{
PORTB.F1 = !PORTB.F1; // on change l'état de RB1
tempo_timer2(); // tempo de 50 ms
}
}
void tempo_timer2 ( void ) // tempo avec le timer2
{
TMR2IF = 0; // initialisation du drapeau lié au timer2
while ( TMR2IF == 0 ); // attente de la levée du drapeau
}
void init ( void ) // initialisation des périphériques
{
TRISB = 0; // RB1 configuré en sortie
PR2 = 239; // Valeur définie de fin de comptage
T2CON = 0x66; // configuration du timer2
}
Les particularités du Timer 1 sont :
Principe de fonctionnement similaire au Timer0
Le pré-compteur ne peut prendre que quatre valeurs : 1, 2, 4 ou 8.
Le compteur est un compteur 16 bits : Registre de comptage compose de deux registres de 8
bits (TMR1H et TMR1L).
Mr Nizar TOUJENI 88
4. Fonctions particulières des Timers

Les Timers 0 et 1 peuvent être utilisés en compteur d’évènements extérieurs.
Exemples :
Compteur de pièces dans une machine industrielle
Affichage de la vitesse d’un véhicule
Timer 0 :
Signal à appliquer sur la broche RA4/T0CKI
4.1. Timer 0 en compteur d'évènements

T0SE = 0 : les fronts montants attaquant le Timer0 correspondent aux fronts montants de
RA4/T0CKI
T0SE = 1 : les fronts montants attaquant le Timer0 correspondent aux fronts descendants de
RA4/T0CKI
4.2. Timer 1 en compteur d'évènements

La broche du PIC associée au Timer 1 est la ligne RC0/T1OSO/T13CKI :
Mr Nizar TOUJENI 89
La ligne RC1/T1OSI est aussi associée au Timer 1, mais ne joue pas de rôle dans le comptage
d'événements extérieurs.
Compte tenu de la remarque ci-dessus, il faut déconnecter la ligne RC1 / T1OSI en invalidant
la porte logique inverseuse.
bit T1OSCEN = 0
4.3. Timer 1 associe à un quartz
Il est possible de connecter un quartz sur le Timer 1 et de compter les impulsions de celui-ci
pour générer des temps plus precis comme par exemple pour créer une horloge de secondes,
minutes, heures ou un chronomètre.
Très utile pour gérer le mode sommeil du microcontrôleur.
En général, on prend un quartz dit d'”horloger” de 32768 Hz (on divise ensuite par 215 pour
avoir 1s).
T1OSCEN = 1
5. Exemples
Exemple 1 : RELAI
Dans ce projet la minuterie, sur la base de registre TMR0, est utilisée comme un compteur. L'entrée
de comptage est reliée à un bouton-poussoir Input de sorte que toute pression sur Input provoque
TMR0 à compter une impulsion. Lorsque le nombre d'impulsions correspond au nombre stocké dans
le registre nommé TEST, la valeur logique 1 (5V) apparaît sur le pin3 de PORTD. Cette tension
active un relais électromécanique, et ce bit est appelé « RELAI » dans le programme.
Mr Nizar TOUJENI 90
Dans le registre de TEST est stocké un nombre de 5 pour cet exemple. Bien sûr, il peut être n'importe
quel nombre défini comme une constante. Par ailleurs, le microcontrôleur peut activer un autre
appareil au lieu de relais, tandis que le capteur peut être utilisé à la place du bouton-poussoir. Cet
exemple illustre l'une des applications les plus courantes du microcontrôleur dans l'industrie ; quand
quelque chose est effectué autant de fois que nécessaire, puis quelque chose d'autre doit être activé ou
désactivé, etc.
Code-source 1
void main()
{
char TEST = 5; // Constante TEST = 5
enum sortie {RELAI = 3}; // Constante RELAI = 3
ANSEL = 0; // Les E/S sont configurées en numériques
ANSELH = 0;
PORTA = 0; // Initialisation du porte A
TRISA = 0xFF; // Port A est configure en entrée
PORTD = 0; // Initialisation du PORTD
TRISD = 0b11110111; // Broche 3 du PORTD3 est configure en sortie
OPTION_REG.F5 = 1; // Compteur TMR0 reçoit des impulsions par la broche RA4
OPTION_REG.F3 = 1; // Taux de prédiviseur est de 1:1
TMR0 = 0; // Initialisation du compteur TMR0
do
{
if (TMR0 == TEST) PORTD.RELAI = 1;
// Est-ce que le nombre d’impulsion TMRO est égal à constante TEST?
// Nombre est égal à TEST. La broche RD3 est en 1 (RELAIS est active)
}
while (1); // Restez dans la boucle sans fin
}
Exemple 2. Registres TMR0 et TMR1 comme minuteries
Dans l'exemple précédent, le microcontrôleur ne fait rien entre des impulsions de comptage en
utilisant des boucles sans fin. Ces déchets du temps sont un luxe inadmissible et par conséquent une
autre méthode doit être appliquée. Considérons le schéma à microcontrôleur 16F887 de la figure 4
qui sera toujours le même pour réaliser les nouvelles fonctions.
Le fichier INTERRUP_TMR0.C du code-source 2 montre l’utilisation du registre TMRO avec pré
diviseur pour générer une interruption. Une fois que le registre TMR0 est « trop-plein » le routin
Mr Nizar TOUJENI 91
d’interruption incrémente automatiquement la variable cnt par 1. Lorsque sa valeur atteint 400, le
PORTB est incrémenté de 1. L'ensemble de la procédure est « masqué », qui permet au
microcontrôleur de faire autre chose.
Code-source 2
unsigned cnt; // Définir la variable cnt
void interrupt( )
{
cnt++; // Interruption cause l’incrémentation par 1 de la variable cnt
TMR0 = 100; // Valeur initiale du TMR0
INTCON = 0x20; // Bit T0IE est positionné à 1, bit T0IF est en 0
}
void main()
{
OPTION_REG = 0x84; // Prédiviseur pour TMR0
ANSEL = 0; // Toutes les broches E/S sont configuré en digital
ANSELH = 0;
TRISB = 0; // PORTB est configuré en sortie
PORTB = 0x0; // Initialisation du PORTB
Mr Nizar TOUJENI 92
TMR0 = 100; // TMR0 compte de 100 à 255

INTCON = 0xA0; // Interruption par TMR0 est autorisés
cnt = 0; // Variable cnt est initialisée à 0
do
{
if (cnt == 400)
{ // Incrémenter port B après 400 interruptions
PORTB = PORTB++; // Incrémenter PORTB par 1
cnt = 0; // Initialiser la variable cnt
}
}
while(1);
}
On voit que l’Interruption se produit sur chaque débordement du registre TMR0. Le nombre
d’interruption à 400, dans cet exemple, provoque l’incrémentation du PORTB comme indique la
figure ci-dessous.
Dans le code-source 3 (fichier INTERRUP_TMR1) on utilise l’interruption produit par le

débordement de registre TMR1(TMR1H, TMR1L). Après 76 d’interruption se produit l’évolution sur
le PORTB comme indique la figure ci-dessous.
Code-source 3
unsigned short cnt; // Définir la variable cnt
void interrupt()
{
cnt++ ; // Interruption cause l’incrémentation par 1 de la variable cnt
PIR1.TMR1IF = 0; // Remise à 0 bit TMR1IF
TMR1H = 0x80;
Mr Nizar TOUJENI 93
TMR1L = 0x00; // Valeurs initiales du TMR1H and TMR1L

}
void main()
{
ANSEL = 0; // Broches E/S sont configure en numériques
ANSELH = 0;
PORTB = 0xF0; // Initialisation de PORTB
TRISB = 0; // PORTB est configuré en sortie
T1CON = 1; // Remise à 1 du TMR1
PIR1.TMR1IF = 0; // Remise à 0 du TMR1IF
TMR1H = 0x80; // Initialisation du TMR1
TMR1L = 0x00;
PIE1.TMR1IE = 1; //Activer l’interruption en cas de débordement du TMR1
cnt = 0; // Remis à 0 la variable cnt
INTCON = 0xC0; // Activer interruption (bits GIE et PEIE)
do
{ // Boucle sans fin
if (cnt == 76)
{
PORTB = ~PORTB; //Bits du PORTB sont inversés après 76 d’interruptions
cnt = 0; // Initialisation de la variable cnt
}
}
while (1);
}
Mr Nizar TOUJENI 94
Leçon N°10
LES INTERRUPTIONS EN MIKROC
I- INTRODUCTION
Une interruption est un événement imprévisible qui provoque l’arrêt d’un programme en cours
d’exécution pour aller exécuter un autre programme appelé programme (ou routine) d’interruption. A
la fin du programme d’interruption, le microcontrôleur reprend le programme principal à l’endroit où
il s’est arrêté.
On distingue deux types d’interruptions :
Les interruptions externes, qui sont déclenchées lorsqu’un événement extérieur se produit tels
que le changement d’état d’une entrée destinée à l’interruption.
Les interruptions internes, qui sont déclenchées par le déroulement du programme tel que le
résultat d’un calcul ou le débordement d’un Timer.
Toute interruption est gérée à l’aide de 3 bits :
Un bit indicateur ou drapeau (Flag bit). Ce bit est mis à 1 lorsque l’interruption
correspondante survient.
Un bit d’activation (Enable bit). Ce bit permet d’activer ou de désactiver l’interruption
correspondante.
Un bit d’activation globale (Global Enable bit). Ce bit permet d’activer ou de désactiver
toutes les interruptions.
Ces bits sont regroupés suivant le microcontrôleur cible dans des registres appelés registres de
configuration des interruptions tels que : INTCON, PIE1, PIE2, PIR1 et PIR2. Le nombre de
sources d’interruptions dépend du microcontrôleur utilisé.
En MikroC, le sous-programme d’interruption est déclaré en tant que fonction avec le nom spécial «
Interrupt ». Cette fonction s’exécute automatiquement en réponse aux évènements déclencheurs des
interruptions activées par l’utilisateur.
II- REGISTRE DE CONFIGURATION DES INTERRUPTIONS

Le registre INTCON (INTerrupt CONtroller) est le registre principal de contrôle et de gestion des
interruptions.
Suivant le type du microcontrôleur donc du nombre de sources d’interruptions, le registre
INTCON est parfois accompagné par d’autres registres tels que (PIE, PIR1, etc.) pour gérer la
totalité des sources d’interruptions disponibles.
Le registre INTCON est parfois différent d’un PIC à un autre. Il est impératif de revenir au
document constructeur pour chaque type de microcontrôleur.
Mr Nizar TOUJENI 95
Registre INTCON pour PIC16F87x :
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
GIE PEIE T0IE INTE RBIE T0IF INTF RBIF
Registre INTCON pour PIC16F84A :
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
GIE EEIE T0IE INTE RBIE T0IF INTF RBIF
Bit 7: GIE = Global Interrupt Enable bit

1 = Autorise toutes les interruptions non masquées par leur bit individuel.
0 = Désactive toutes les interruptions.
Bit 6 (PIC16F87x): PEIE = Peripheral Interrupt Enable bit.
1 = Autorise les interruptions causées par les périphériques non masqués par leur bit
individuel dans les registres PIE1 et PIE2 (PIE : Peripheral Interrupts Enable)
0 = Désactive les interruptions causées par les périphériques.
Bit 6 (PIC16F84A): EEIE = EEPROM Interrupt Enable bit.
1 = Autorise les interruptions causées par la fin d’écriture dans l’EEPROM.
0 = Désactive les interruptions causées par la fin d’écriture dans l’EEPROM.
Bit 5: T0IE = Timer TMR0 Overflow Interrupt Enable bit.
1 = Autorise l’interruption du Timer TMR0.
0 = Désactive l’interruption du Timer TMR0.
Bit 4: INTE = RB0/Int Interrupt Enable bit.
1 = Autorise l’interruption sur la broche RB0.
0 = Désactive l’interruption sur la broche RB0.
Bit 3: RBIE = RB Port Change Interrupt Enable bit.
1 = Autorise l’interruption par changement d’état du Port B (RB4 à RB7).
0 = Désactive l’interruption par changement d’état du Port B (RB4 à RB7).
Bit 2: T0IF = Timer TMR0 Overflow Interrupt Flag bit.
Ce bit est un indicateur ou drapeau (Flag); il est mis à 1 si une interruption est générée par le
débordement du TMR0.
1 = Le Timer a débordé.
0 = Le Timer n’a pas débordé.
Ce drapeau doit être remis à zéro par le programme de traitement de l’interruption.
Mr Nizar TOUJENI 96
Bit 1: INTF = RB0/Int Interrupt Flag bit.

1 = Une interruption sur la broche RB0 est survenue.
0 = Pas d’interruption sur la broche RB0.
Ce drapeau doit être remis à zéro par le programme de traitement de l’interruption.
Bit 0: RBIF = RB Port Change Interrupt Flag bit. Ce drapeau doit être remis à zéro par le
programme.
1 = Quand au moins une entrée du port B (de RB4 à RB7) a changé d’état.
0 = Aucune entrée de RB4 à RB7 n’a changé d’état.
III- EXEPLE D’APPLICATION
1. Exemple 1
Soient 4 LEDs connectés sur les pins RA0, RA1, RA2 et RA3 du Port A. Utiliser l’interruption sur
(RB4-RB7) pour faire basculer l’état des LEDs (RB4 commande RA0, RB5 commande RA1 et ainsi
de suite).
Mr Nizar TOUJENI 97
2. Exemple 2
Utiliser l'interruption pour changer la vitesse de clignotement de la diode Led connecté sur la pin
RA0 selon le schéma de la figure ci-dessous.
Mr Nizar TOUJENI 98
3. Exemple 3
- Si on appui sur RB4 alors le décompteur réalise le cycle suivant : F, E, D, …, 0
- Si on appui sur RB5 alors le décompteur réalise le cycle suivant : A, 9, 8, …, 0
- Si on appui sur RB6 alors le décompteur réalise le cycle suivant : 5, 4, 3, …, 0
- Sinon le décompteur réalise le cycle par défaut : 7, 6, 5, …, 0.
Mr Nizar TOUJENI 99
Mr Nizar TOUJENI 100

TRAVAUX DIRIGES N° : 1
AFFICHAGE DES DONNEES
Exercice 1.1 :
Soit le montage suivant permettant de commander 8 diodes LED :
On veut maintenant réaliser plusieurs animations sur les LEDs commandées par les boutons
poussoirs B1 et B2 selon le tableau suivant :
N° séquence B1 B2 Séquence
0 1 1 L0-L1-L2-L3-L4-L5-L6-L7
1 1 0 L7-L6-L5-L4-L3-L2-L1-L0
2 0 1 L7/L0-L6/L1-L5/L2-L4/L3
3 0 0 L0/L1-L2/L3-L4/L5-L6/L7
Ecrire un programme en C permettant de commander les diodes LED.
Exercice 1.2 :
Soit le montage suivant permettant de commander 8 diodes LED :

Question 1 :
On propose de faire clignoter LEDs branchées au port B du microcontrôleur de deux façons

différentes :
- Si RA0 = 0, tous les LEDs clignotent avec une période d’une seconde.
- Si RA0 = 1, les LEDs doivent clignoter chaque 500 ms comme indiqué dans la figure ci-
dessous.

Question 2 :
- Si RA0=0, les 8 diodes LED clignotent pendant 2 secondes,
- Si RA0=1, on obtient le cycle répétitif suivant :

Diodes LED allumés Durée
D0D1 1s
D2D3 2s
D4D5 3s
D6D7 4s
Aucune diode 1s
Exercice 1.3 :
On désire commander un afficheur à 7 segments afin de réaliser un compteur modulo 10 à l’aide d’un
microcontrôleur 16F84A.
1. Ecrire un programme C qui permet de réaliser le fonctionnement suivant :
- Compteur modulo 10 commandé par la position 1 du switcher (RA0).
- Décompteur modulo 10 commandé par la position 2 du switcher (RA1).
2. Ecrire un programme C qui permet de réaliser le fonctionnement suivant :
- Compteur des nombres pairs commandé par la position 1 du switcher.
- Compteur des nombres impairs commandé par la position 2 du switcher.

Exercice 1.4 :
Soit le montage suivant :
Ecrire un programme en C qui affiche sur l’écran LCD le message ci-dessus.
Exercice 1.5 :
Soit le montage de la figure ci-après. Ecrire un programme en C qui répond au fonctionnement
suivant :
Un appui sur le bouton B1 seul, l’afficheur affiche ’BONJOUR’ et la diode D1 clignote.
Un appui sur le bouton B2 seul, l’afficheur affiche ‘BONSOIR’ et la diode D2 clignote.
Un appui sur le bouton B3 seul, l’afficheur affiche ‘SALAM’ et la diode D3 clignote.
Pour les autres cas, rien ne se passe.


SYSTEMES D’ENTREE DES DONNEES (1)

Exercice 2.1 :
Soient les équations suivantes d’un système logique combinatoire :
S1 = A + B + C.B ,
S2 = A.B + C.B + C ,
S 3 = A + B + C .B
S4 = A + C.B ,
S5 = B.C. A
On propose le schéma de simulation suivant :
Ecrire un programme en C qui permet d’implanter le système combinatoire précédent.
Exercice 2.2 :
On désire commander une LED par plusieurs endroits à l’aide d’un microcontrôleur 16F84A via des
boutons poussoir BPi (BP1, BP2 et BP3).
Une impulsion sur l’un des boutons poussoir BPi, la LED D s’allume, une deuxième impulsion la
LED s’éteint.
Ecrire un programme C qui répond au cahier de charge.

Exercice 2.3 :
On désire réaliser une minuterie d’escalier à 3 temps réglable (1min, 3min, 5min) à l’aide d’un
microcontrôleur 16F84A.
Le principe de fonctionnement est le suivant :

- Une impulsion sur l’un des boutons poussoir BPi, la LED D s’allume pendant un temps T
puis s’éteint.
- Deux impulsions successives est sans effet.
- Le temps est réglable par un commutateur C à trois positions.
Ecrire un programme C qui répond au cahier de charge.

SYSTEMES D’ENTREE DES DONNEES (2)
Exercice 3.1 :
Ce circuit illustre l'utilisation d'un clavier et un écran LCD alphanumérique.
Ecrire un programme qui lit un caractère à partir du clavier et l’affiche sur l’écran LCD.
Exercice 3.2 :
On désire commander un afficheur à 7 segments à l’aide d’un microcontrôleur 16F877A via un

clavier à 12 touches.
Le principe de fonctionnement est le suivant :
- L’appui sur une touche de 0 à 9 affiche sa valeur sur l’afficheur 7 segments.
- L’appui sur la touche (*) affiche la lettre E sur l’afficheur 7 segments.
- L’appui sur la touche (#) affiche la lettre F sur l’afficheur 7 segments.
Ecrire un programme qui répond à ce cahier des charges.

Exercice 3.3 :
Soit le circuit suivant composé d’un microcontrôleur PIC 16F877A muni d’un afficheur LCD et 16
boutons poussoirs jouant le rôle d’un clavier matriciel :
Ecrire un programme qui lit un caractère à partir du clavier et l’affiche sur l’écran LCD.

CONVERTISSEUR ANALOGIQUE NUMERIQUE
Exercice 4.1
On veut réaliser un comparateur entre les valeurs de deux tensions analogiques appliquées sur
chacune des pins RA0 et RA1 via deux potentiomètres.
Ecrire un programme en C qui répond au cahier des charges suivant :
- Si tension 0 > tension 1 alors afficher la lettre S.
- Si tension 0 = tension 1 alors afficher la lettre E.
- Si tension 0 < tension 1 alors afficher la lettre I.
L’affichage des résultats se fera sur un afficheur 7 segments comme le montre la figure ci-dessus.
Exercice 4.2

Ecrire un programme en C qui répond au fonctionnement suivant :

- Si RA0 < RA1, on doit faire un comptage modulo 20.
- Si RA0 > RA1, on doit faire un décomptage modulo 20.
- Si RA0 = RA1, on affiche la lettre H sur les deux afficheurs.
L’affichage des résultats se fera sur un afficheur 7 segments.
Exercice 4.3 :
Soit le montage ci-après. Ecrire un programme en C qui répond au fonctionnement suivant :
- Si tension 0 > tension 1 alors afficher sur chaque afficheur 7 segments la lettre S.
- Si tension 0 = tension 1 alors afficher sur chaque afficheur 7 segments la lettre E.
- Si tension 0 < tension 1 alors afficher sur chaque afficheur 7 segments la lettre I.
Le programme doit afficher aussi sur le LCD 16x4 :
- Ligne 1 : le message « Comparateur »,
- Ligne 2 : la valeur de la tension 0,
- Ligne 3 : la valeur de la tension 1,
- Ligne 4 : la valeur de la tension maximale.


MODULATION A LARGEUR D’IMPULSION
Exercice 5.1 :
Pour faire varier la vitesse d’un moteur à courant continu, on vous propose le circuit de la figure ci-
dessous :
Ecrire un programme qui lit une valeur numérique sur le PORTB sous forme d’un nombre codé sur 8
bits. Ce nombre constituera le rapport du cyclique d'un signal PWM qui va être généré pour
commander un moteur à courant continu.
Exercice 5.2 :
Pour rendre les choses plus intéressantes, la durée d’impulsions à la sortie CCP1 (PORTC, 2) peut
être changée avec les touches symboliquement marqués comme "BRILLANT" et "NOIR", tandis que
la durée est considérée comme la combinaison binaire sur le PORTD.
La diode D1 signale que le module CCP1 est activé. Dans le montage réel son état corresponde à
l’état de la diode D2 pendant la simulation.
- Un appui sur le bouton BRILLANT fait augmenter le rapport cyclique,
- Un appui sur le bouton NOIR fait diminuer le rapport cyclique.

Ecrire un programme en MikroC qui répond au cahier des charges.
Exercice 5.3 :
Soit le schéma de la figure ci-après. Quatre commutateurs (SW1, SW2, SW3 et SW4) sont reliés aux
quatre bits de poids faible du PORTB du microcontrôleur avec les résistants à tirage vers le haut de
10K. Ces commutateurs sont utilisés pour commander le rapport cyclique du PWM qui est généré par
les modules CCP.
- Un appui sur SW1 augmente le rapport cyclique du PWM produit par CCP1,
- Un appui sur SW2 diminue le rapport cyclique du PWM produit par CCP1,
- Un appui sur SW3 augmente le rapport cyclique du PWM produit par CCP2,
- Un appui sur SW4 diminue le rapport cyclique du PWM produit par CCP2.

Ecrire un programme en MikroC qui répond au cahier des charges ci-dessus.

LES TIMERS EN MIKROC
Exercice 6.1 :
On désire réaliser un compteur modulo 10 en utilisant le Timer TMR0 d’un PIC 16F84A. Le
compteur est incrémenté à chaque front montant. On propose le schéma de la figure ci-dessous :
1. Indiquer si le mode de fonctionnement du TMR0 est compteur ou temporisateur.
2. Ecrire un programme en MikroC permettant de compléter la fonction désirée.
5. Modifier le programme précédent pour réaliser un compteur modulo 16 et l’incrémentation se fait

chaque 2 fronts descendants.
Exercice 6.2 :
Selon le circuit de la figure ci-dessous, écrire un programme en C qui permet de compter par le
module TIMER0 les fronts montants arrivant sur la broche RA4 et d'allumer la diode chaque fois que
10 fronts sont comptés.

Exercice 6.3 :
On désire réaliser un compteur modulo 100 en utilisant le Timer TMR0 d’un PIC 16F84A. Le
compteur est incrémenté à chaque front descendant de RA4. On adopte l’affichage multiplexé
puisqu’on dispose d’un seul décodeur BCD – 7Segments et deux afficheurs. Ecrire un programme en
MikroC.

LES INTERRUPTIONS EN MIKROC

Exercice 7.1 :
On donne le montage de la figure suivante :
Ecrire un programme qui accepte une interruption sur RB0 et à chaque impulsion sur le bouton
poussoir B0 inverse l’état de la diode LED.
Exercice 7.2 :
Soit le montage de la figure suivante :
Ecrire un programme qui accepte des interruptions sur RB4 et RB7 et :

- A chaque impulsion sur le bouton poussoir B4 allume la diode LED,
- A chaque impulsion sur le bouton poussoir B4 éteint la diode LED.

Exercice 7.3 :
1. On désire réaliser un compteur binaire 8 bits et afficher le résultat sur 8 diodes LED. Pour réaliser
ce cahier des charges, on propose le circuit de la figure suivante.
Ecrire un programme en MikroC qui à chaque impulsion sur le bouton lié à l’entrée RB0 incrémente
le compteur et affiche le résultat sur le PORTD.
2. Modifier le programme précédent afin d’afficher le résultat du comptage sur un afficheur LCD
selon le montage suivant :

Exercice 7.4 :
Le but est de réaliser un décompteur dont le point de départ est géré par des interruptions généré par
le changement d’état sur RB4, RB5 et RB6.
- Si on appui sur RB6 alors le décompteur réalise le cycle suivant : F, E, D, …, 0
- Si on appui sur RB5 alors le décompteur réalise le cycle suivant : A, 9, 8, …, 0
- Si on appui sur RB4 alors le décompteur réalise le cycle suivant : 7, 6, 5, …, 0
- Sinon le décompteur réalise le cycle par défaut : 5, 4, 3, …, 0.
Pour réaliser ce cahier des charges, on vous propose le montage de la figure 2. Pour simplifier
l’affichage des résultats du décomptage, on utilise un afficheur 7 segments-BCD.
En effet, cet afficheur affiche les valeurs de 0 à F (en hexadécimal) directement sans passer par la
table de décodage des 7 segments.
Ecrire un programme C qui accepte des interruptions sur les entrées RB4, RB5 et RB6 et affiche sur
l’afficheur 7 segments-BCD le cycle de décomptage correspondant.

Leçon N°1: Presentation de L'Informatique Industrielle Et Des Systemes Micro-Programmes I - L'Informatique Industrielle

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Leçon N°1: Presentation de L'Informatique Industrielle Et Des Systemes Micro-Programmes I - L'Informatique Industrielle

Transféré par

Droits d'auteur :

Formats disponibles

Cours Microcontrôleurs

PRESENTATION DE L’INFORMATIQUE INDUSTRIELLE ET

II- LES DIFFERENTS SYSTEMES PROGRAMMABLES

2. Les systèmes en logique programmée

3. Les systèmes micro-programmés

III – ÉVOLUTION ET LOI DE MOORE

Intel Pentium 4 Northwood C (2002)

Intel Core i7 Gulftown (2011)

1,17 Milliards de transistors, gravés en 32nm

IV – LES DIFFERENTS BUS D’UN SYSTEME MICRO-PROGRAMME

2. Caractéristiques d'un bus

Issu de la documentation technique du PIC16F628

Il en existe de nombreux modèles :

3.2. Architecture Harvard

VON NEUMANN HARVARD

Avantages - Jeu d’instructions riches - Jeu d’instructions pauvre, mais facile

6. Quelques caractéristiques importantes

4. Les éléments de choix d’un µC

I. LE COMPILATEUR MIKROC ET LES PIC

II. LE COMPILATEUR MIKROC PRO

I. STRUCTURE D’UN PROGRAMME EN MIKROC

Tableau 4.1 Noms réservés en mikroC

ASM ENUM SIGNED AUTO EXTERN SIZEOF

BREAK FLOAT STATIC CASE FOR STRUCT

CHAR SWITCH CONST IF TYPEDEF CONTINUE

GOTO INT UNION LONG DEFAULT UNSIGNED

DOUBLE RETURN VOLATILE DO REGISTER VOID

ELSE SHORT WHILE

Opérateur Nom Notation

Les opérateurs +, -, *, fonctionnent comme en arithmétique. Par contre, l’opérateur / (division) se

Opérateur Equivalent Notation

++ x=x+1 x++ ou ++x

-- x=x-1 x-- ou --x

4. Les autres opérateurs binaires d’affectation

Opérateur Equivalent Notation

<<= x = x << y x <<= y

&= x=x&y x &= y

5. Les opérateurs de comparaison

Opérateur Nom Notation

!= test de non égalité x != y

<= test inférieur ou égal x <= y

>= test supérieur ou égal x >= y

< test inférieur strict x<y

> test supérieur strict x>y

Opérateur Nom Notation

7. Les opérateurs de manipulation de bits

Opérateur Nom Notation

& ET bit à bit x&y

| OU bit à bit x|y

^ OU exclusif bit à bit x^y

! (unaire) NON bit à bit !x

>> décalage à droite >> x

<< décalage à gauche << x

Opérateur Equivalent Notation

sizeof opérateur de dimension sizeof (e)

IV. LES STRUCTURES DE CONTROLE

0x4F, // Code du digit 3

PORTB = DIGITS[COMPTEUR]; //Visualisation du chiffre correspondant

PORTB = DIGITS[D]; // Visualisation des dizaines.

Nombre=0; //Initialisation à 0 si nombre = 10000.

III. AFFICHEURS LCD

sbit LCD_D4 at RB0_bit;

void main( void )