Ecole Supérieure de Technologie Oujda (ESTO)

MICROPROCESSEURS
&
MICROCONTROLEURS

Sanae Dahbi
Avant-propos
Ce cours est dédié aux étudiants de L’ESTO inscrits en première année Licence d’éducation
(Spécialité Enseignement Secondaire- Sciences industrielles). Il est enseigné en tant que cours
intégré en semestre 2 pour une charge horaire totale de 48 heures soit une séance d’une 3h par
semaine. Il porte sur des notions de bases sur les microprocesseurs, ainsi que sur des notions
avancées de l’étude & de la programmation des microcontrôleurs et des microcontrôleurs
Arduino où nous avons attribué une attention particulière au PIC16F877 et Arduino UNO.

Nous avons volontairement découpé ce cours en quatre parties indépendantes mais

complémentaires. L'étudiant ou l'étudiante devrait avoir une connaissance de base en systèmes
logiques et informatique. Toutefois Dans la première partie nous avons fait un rappel sur les
systèmes numériques. C'est un pré requis nécessaire pour le reste du cours.

Bonne lecture et bon cours!

1
Table des matières
Chapitre I : Représentation Binaire .........................................................................................................4
1. Présentation du binaire .................................................................................................................5
1.1 Le bit ..........................................................................................................................................5
1.2 L’octet .......................................................................................................................................6
1.3 Unités standards ........................................................................................................................7
2. Représentation des nombres naturels en binaire .........................................................................7
2.1 Numérations en base dix, base deux, base seize .......................................................................7
2.2 Conversion d’une base à autre ...................................................................................................9
2.3 Les opérations en binaire ...................................................................................................... 11
2.4 Représentation d'un nombre dans un ordinateur .................................................................. 12
3. Représentation des entiers relatifs et des nombres à virgule ...................................................... 14
3.1 Nombre entier relatif ............................................................................................................. 14
3.2 Nombre à virgule .................................................................................................................... 15
4. Représentation des textes ............................................................................................................. 16

Chapitre II : Microprocesseur ............................................................................................................... 18

1. Définition d'un microprocesseur ................................................................................................ 19
2. Structure d’un microprocesseur ................................................................................................ 19
2.1 Unité Arithmétique et Logique (UAL) ................................................................................... 20
2.2 Unité de contrôle ou séquenceur .......................................................................................... 20
2.3 Les bus .................................................................................................................................... 21
2.4 Les registre ............................................................................................................................. 22
3. Les mémoires ............................................................................................................................... 22
3.1 Les mémoires ROM ............................................................................................................ 23
3.2 Mémoire RAM ..................................................................................................................... 23
4. Principe de Fonctionnement d'un microprocesseur .................................................................. 24
4.1 Instruction ........................................................................................................................... 24
4.2 Traitement des instructions ................................................................................................. 26
5. Architecture d’un microprocesseur ............................................................................................ 27
5.1 Architecture de Von Neuman ............................................................................................... 27
5.2 Architecture de Harvard....................................................................................................... 28

Chapitre III : Microcontrôleur.......................................................................................................29

1. Microcontrôleur ...............................................................................................................30
1.1 Définition d’un microcontrôleur ....................................................................................30

2
 1.2 Architecture interne d’un microcontrôleur.....................................................................30
1.3 Familles d’un microcontrôleur .......................................................................................31
2. Les microcontrôleurs de type PIC ......................................................................................32
2.1 Définition de PIC ..........................................................................................................32
2.2 Différentes familles de PIC ............................................................................................32
3. Le microcontrôleur PIC16f877 ...........................................................................................33
3.1 Caractéristiques du PIC16F877 .......................................................................................33
3.2 Alimentation du PIC16F877 ...........................................................................................34
3.3 Cadencement de PIC16F877 ..........................................................................................34
3.4 Circuit Reset MCLR ........................................................................................................35
3.5 Chien de garde..............................................................................................................35
3.6 Ports E/S ......................................................................................................................36
3.7 Les Timers ...................................................................................................................40
3.8 Le module capture comparaison CCP1/CCP2 ..................................................................43
3.9 Convertisseur analogique numérique CAN ......................................................................44
3.10 Interruption ................................................................................................................46
Chapitre IV : Arduino ...................................................................................................................48
1. Système Arduino..............................................................................................................49
1.1 Définition d’un système Arduino .......................................................................................... 49
1.2 Les différentes cartes Arduino .............................................................................................. 49
2. Carte Arduino UNO ................................................................................................................. 51
2.1 Constituants de la carte ........................................................................................................ 51
2.2 Le logiciel Arduino ................................................................................................................. 55

3
 CHAPITRE I
Représentation Binaire

4
Introduction
Un ordinateur est composé de différentes parties, dont des entrées (input) : un clavier, un port
USB, un lecteur CD... Et de sortie : carte graphique (CGU en anglais), un graveur, un port
USB, imprimante, … Il contient aussi d'autres composants tout aussi importants (si ce n'est
plus) tels que la mémoire et le processeur (CPU en anglais). La communication entre ces
différents composants se fait par l’envoi d’une information. Une information est une
connaissance qui fait sens pour les personnes concernées et qui peut être représentée par des
symboles. Bien sûr, la notion de sens n’est pas pertinente pour un ordinateur, qui n’est qu’une
machine, et c’est uniquement la représentation de l’information “donnée” sur laquelle il va
agir. Ainsi un traitement d’informations par un ordinateur consiste-t-il en des transformations
de leurs représentations. Ces transformations peuvent être des calculs, des réagencements, des
ajouts, des suppressions, des copies et toute autre opération consistant en des manipulations
de symboles. Cependant, quel que soit leur type, ces contenus sont manipulés par la machine
au travers d’une représentation n’utilisant que des 0 et des 1, qui est dite « binaire ». Nous
présentons dans ce chapitre les principes de cette représentation pour les nombres et les textes.

1. Présentation du binaire
Vers la fin des années 30, Claude Shannon démontra qu'à l'aide de « contacteurs »
(interrupteurs) fermés pour « vrai » et ouverts pour « faux » il était possible d'effectuer des
opérations logiques en associant le nombre 1 pour « vrai » et 0 pour « faux ».

Ce codage de l'information est nommée base binaire. C'est avec ce codage que fonctionnent
les ordinateurs. Il consiste à utiliser deux états (représentés par le chiffre 0 et 1) pour coder les
informations.

1.1 Le bit
Le terme bit (b avec une minuscule dans les notations) signifie « binary digit », c'est-à-dire 0
ou 1 en numérotation binaire. Il s'agit de la plus petite unité d'information manipulable par
une machine numérique. Il est possible de représenter physiquement cette information binaire:

 par un signal électrique, magnétique ou lumineux, qui, au-delà d'un certain seuil,
correspond à la valeur 1 ;
 grâce à des bistables, c'est-à-dire des composants électroniques qui ont deux états
d'équilibre (l'un correspond à l'état 1, l'autre à 0).
- Avec 1 bit il est ainsi possible d'obtenir deux états : soit 1, soit 0.
- Grâce à 2 bits, il est possible d'obtenir quatre états différents (2*2) :

5
 0 0

0 1

1 0

1 1

- Avec 3 bits, il est possible d'obtenir huit états différents (2*2*2) :

Valeur binaire sur 3 bits

0 0 0

0 0 1

0 1 0

0 1 1

1 0 0

1 0 1

1 1 0

1 1 1

- Pour un groupe de n bits, il est possible de représenter 2n valeurs.

1.2 L’octet

L'octet est une unité d'information composée de 8 bits allant de 0 à 255. Il permet de stocker
un caractère, telle qu'une lettre, un chiffre ... Ce regroupement de nombres par série de 8
permet une lisibilité plus grande. Une unité d'information composée de 16 bits est
généralement appelée mot. Une unité d'information de 32 bits de longueur est appelée double
mot. Pour un octet, le plus petit nombre est 0 (représenté par huit zéros 00000000), et le plus
grand est 255 (représenté par huit chiffres « un » 11111111), ce qui représente 256
possibilités de valeurs différentes.

27 =128 26 =64 25 =32 24 =16 23 =8 22 =4 21 =2 20 =1

6
 0 0 0 0 0 0 0 0

1 1 1 1 1 1 1 1

1.3 Unités standards

Longtemps l'informatique s'est singularisée par l'utilisation de différentes valeurs pour les
unités du système international. Ainsi beaucoup d'informaticiens ont appris que 1 kilooctet
valait 1024 octets. Or, depuis décembre 1998, l'organisme international IEC a fixé les
nouvelles valeurs. Voici donc les unités standardisées :

• Un kilooctet (ko ou kB) = 1000 octets

• Un Mégaoctet (Mo ou MB) = 1000 ko = 1 000 000 octets

• Un Gigaoctet (Go ou GB) = 1000 Mo = 1 000 000 000 octets

• Un Téraoctet (To) = 1000 Go = 1 000 000 000 000 octets

Attention ! De nombreux logiciels (parfois même certains systèmes d'exploitation) utilisent

toujours la notation antérieure à 1998 pour laquelle :

• Un kilooctet (ko) = 210 octets = 1024 octets

• Un Mégaoctet (Mo) = 220 octets = 1024 ko = 1 048 576 octets

• Un Gigaoctet (Go) = 230 octets = 1024 Mo = 1 073 741 824 octets

• Un Téraoctet (To) = 240 octets = 1024 Go = 1 099 511 627 776 octets

2. Représentation des nombres naturels en binaire

Les nombres naturels sont les nombres entiers positifs ou nuls : zéro, un, deux trois, quatre,
etc. Afin d’expliquer comment sont représentés ces nombres en binaire et en hexadécimale,
nous revenons d’abord sur l’écriture usuelle des nombres, appelée représentation décimale.

2.1 Numérations en base dix, base deux, base seize

a. base décimale (10) :
Le système décimal, appelé aussi base dix, est notre système de calcul quotidien. Compter en
base dix signifie d’abord utiliser dix symboles pour écrire les nombres. Ce sont les chiffres de
0 à 9. Cela signifie ensuite « compter par paquets de dix ». Avec la notation habituelle de

7
gauche à droite, cela se traduit par le fait que chaque chiffre dans un nombre est associé à une
puissance de dix, selon sa position.

Par exemple, 2019 est le nombre composé de neuf unités, une dizaine (une dizaine est un
paquet de dix unités), zéro centaine (une centaine est composée de dix paquets de dix unités)
et deux milliers (un millier correspond à dix paquets de dix paquets de dix unités).
Autrement dit :
2019 = 2*1000 + 0*100 + 1*10 + 9*1
= 2* 10* 10* 10 + 0* 10*10 + 1*10 + 9*1
ce qui donne (écrit avec les puissances de dix correspondantes) :
2019 = 2* 103 + 0* 102 + 1* 101 + 9 *100
Par convention, 1 = a0 pour n’importe quel nombre a.

b. base binaire (2) :

Pour représenter un nombre en binaire, nous n’avons que deux symboles, 0 et 1, mais toujours
le même principe : « compter par paquets de deux ». Ainsi, toujours avec la notation usuelle
de gauche à droite, cela se traduit par le fait que chaque chiffre dans un nombre binaire est
associé à une puissance de deux.
Par exemple 11110011110 est le nombre composé de zéro unité, une « dizaine » (un paquet
de deux unités), une quatraine (deux paquets de deux), une huitaine (deux paquets de deux
paquets de deux), une seizaine (deux paquets de deux paquets de deux paquets de deux), zéro
paquet de trente-deux, zéro paquet de soixante-quatre, un paquet de cent vingt-huit, un paquet
de deux cent cinquante-six, un paquet de cinq cent douze et un paquet de mille vingt-quatre.
Autrement dit, en revenant pour le calcul par commodité à l’écriture habituelle en base dix :

11111011110 = 1*210 + 1*29 + 1*28 + 1*27 + 0*26 + 0*25 + 1*24 + 1*23 + 1*21 + 1*21 + 0*20

c. base hexadécimale (16) :

On utilise aussi très souvent le système hexadécimal en informatique (base 16) du fait de sa
simplicité d'utilisation et de représentation pour les mots machines (il est bien plus simple
d'utilisation que le binaire). La base hexadécimale consiste à compter sur une base 16, c'est
pourquoi au-delà des 10 premiers chiffres on a décidé d'ajouter les 6 premières lettres : 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F. Le tableau ci-dessous montre la représentation des nombres
de 0 à 15 dans les bases 10, 2 et 16:
Base 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

8
décimale
Base 0 1 2 3 4 5 6 7 8 9 A B C D E F
hexadéc
imale
Base 00 00 00 00 01 01 01 01 10 10 10 10 11 11 11 11
binaire 00 01 10 11 00 01 10 11 00 01 10 11 00 01 10 11

Un entier s'écrit comme la concaténation de ces chiffres, et sa lecture s'effectue de droite à

gauche. Sa valeur vaut la somme des chiffres affectés de poids correspondant aux puissances
successives du nombre 16. Par exemple :
4D5= 4 × 16 2 + 13 × 161 +5 × 160

2.2 Conversion d’une base à autre

a. Conversion de la base 10 aux bases 2 et 16
Pour convertir un nombre décimale à un nombre binaire où hexadécimale, on doit utiliser
l’algorithme de la division euclidienne par 2 (en binaire) où par 16 (en hexadécimale). C'est
un algorithme très simple qui consiste à faire une suite de division avec reste jusqu'à qu'on
arrive avec un quotient égal à 0. On va diviser notre nombre en base 10 par notre base B. On
va ensuite prendre nos restes à chaque fois et on aura notre chiffre en base B.

Comme un exemple est beaucoup plus explicite qu'un paragraphe théorique, on va appliquer
l'algorithme d'Euclide pour passer le nombre 241 en base 2 et en base 16.
En base 2 :
 Notre nombre est 241
 241 ÷ 2 = 120 + 1
 120 ÷2 = 60 + 0
 60 ÷2 = 30 + 0
 30 ÷2 = 15 + 0
 15 ÷2 = 7 + 1
 7 ÷2 = 3 + 1
 3 ÷2 = 1 + 1
 1 ÷2 = 0 + 1

On a donc 241 = (11110001)2. (La lecture est toujours du bas vers le haut)

En base 16 :
 Notre nombre est 241
 241 ÷ 16 = 15 + 1
 15 ÷16 = 0 + 15

9
 On a donc 241 = (F1)16. En base 16, 15 est symbolisé par la lettre F.

b. Conversion de bases 2 et 16 à la base 10

Pour convertir un nombre d'une base B à la base 10. On multiplie chaque chiffre par la base
exposant sa position. Exemples :
(1010110)2 = 0×20 + 1×21 + 1×22 + 0×23 + 1×24 + 0×25 + 1×26= (86)10.
(4F2C)16= 4×163 + F×162 + 2×161 + C×160= 4×163 + 15×162 + 2×161 + 12×160=(20268)10.

c. Conversion de bases 2 et 16 aux bases 2 et 16 :

Pour passer d'une base B1 a une base B2, il suffit de repasser par la base 10 au milieu. En
prenant en considération que 4 bits en binaire seront représentés par un rang en hexadécimal.
Exemples :
101 0011 1011?
On prend chaque rang que l'on convertit individuellement en hexadécimale en repassant par la
base 10:
• (1011)2 <=> (11)10 <=> (B) 16
• (0011)2 <=> (3)10 <=> (5)16
• (0101)2 <=> (5)10 <=> (3)16
(101 0011 1011)2 = (53B)16
BE57?
On prend chaque rang que l'on convertit individuellement en binaire en repassant par la base
10:
:
• (B)16 <=> (11)10 <=> (1011)2
• (E)16 <=> (14)10 <=> (1110)2
• (5)16 <=> (5)10 <=> (0101)2
• (7)16<=> (7)10 <=> (0111)2
Prenez bien soin de mettre 0101 au lieu de 101, car il ne faut pas se tromper quand on va
mettre les quadruplets bout à bout :
(BE57)16 <=> (1011 1110 0101 0111)2.

10
2.3 Les opérations en binaire
a. L'addition en binaire
Additionner en binaire n’est pas compliqué : c’est le même principe que dans la base
décimale. Il suffit de poser l’opération et de faire attention aux retenues. Il n’y a rien de mieux
qu’un exemple pour comprendre, donc en voici un :

Sur l’opération du milieu, 1+1 en binaire donne 10, donc 0 et une retenue.

Voici un autre exemple, avec des nombres un peu plus grands. La difficulté n’est pas plus
grande, mais il faut parfois faire attention aux retenues qui se propagent :

b. Soustraction en binaire

Pour soustraire des nombre en binaire, il faut raisonner comme on raisonne en décimale, il
suffit de bien faire attention aux retenues. Mais il existe une autre méthode, qui transforme les
soustractions en additions, et simplifie alors toute cette histoire de retenues.

En fait, au lieu de faire A–B, on fera A+(𝐵̅+1). Ici, 𝐵̅ (prononcer « B barre ») est le
complément à 1 de B

- Le complément à 1
Le complément à 1 est un nombre qui existe dans toutes les bases, mais en binaire il est très
facile à trouver : il suffit de changer les 1 en 0 et les 0 en 1. C'est tout :
Nombre (B) Complément (B)
0 1
1 0
0011 1100

11
 - Soustraction
Maintenant qu'on a le complément à 1 d'un nombre, il est possible de faire des soustractions.
Souvenez-vous de ce qu'il faut faire : au lieu A – B, on fera A + (B + 1).
Exemple : calculons 001001 – 1010.
Premièrement, il faut commencer à donner le même nombre de rangs à chaque terme : le
premier nombre s'écrit sur 6 bit et le second seulement sur 4. Il faut donc écrire le second sur
6 bit aussi : 1010 devient 001010. C'est de ce nombre qu’il faudra inverser les bits.
 On écrit le plus petit nombre avec autant de bits que le grand : 1010 devient 001010.
 En inversant tous les bits de 001010 on obtient 110101.
 On ajoute 1, ce qui fait 110110.
 On fait maintenant 001001 + 110110. Cela donne : 111111.

c. La multiplication en binaire
La multiplication se fait exactement la même chose qu’on base décimale, chaque nombre de
la ligne du bas sera distribué à la ligne du haut. Ensuite, chaque ligne sera sommée (ne pas
oublier les retenues à ce moment-là) et le résultat sera alors obtenu.
Exemple : calculons (1010)b x (101010)b:

2.4 Représentation d'un nombre dans un ordinateur

On appelle représentation (ou codification) d'un nombre la façon selon laquelle il est décrit
sous forme binaire. La représentation des nombres sur un ordinateur est indispensable pour
que celui-ci puisse les stocker et les manipuler. Toutefois le problème est qu'un nombre
mathématique peut être infini (aussi grand que l'on veut), mais la représentation d'un nombre
dans un ordinateur doit être fait sur un nombre de bits prédéfini. Il s'agit donc de prédéfinir un
nombre de bits et la manière de les utiliser pour que ceux-ci servent le plus efficacement
possible à représenter l'entité.

12
a. Mémoire d’un ordinateur
Puisqu’un ordinateur ne manipule en fin de compte que des mots composés de 0 et de 1, on
dit que le bit est l’unité de base de sa mémoire. En très simplifié, on peut se représenter la
mémoire d’un ordinateur comme un tableau ayant une seule ligne et autant de cases qu’il peut
mémoriser de bits.
Par exemple, on peut imaginer la mémoire d’un ordinateur pouvant stocker huit bits ainsi :
Portion de mémoire stockant la donnée 147 :
1 0 0 1 0 0 1 1

Cependant, il est clair que disposer de dix bits de mémoire est largement insuffisant pour
pouvoir stocker des données intéressantes. Par exemple pour stocker le nombre 2014 par
11111011110 nous aurons besoin de onze bits. Comme 2014 reste un nombre assez petit, on
peut imaginer qu’il faudra beaucoup plus de place dans la mémoire d’un ordinateur.
Ainsi, pour faciliter la lecture par les humains de ces nombres dont la représentation en
binaire est très longue, on a décidé de grouper les bits par paquets de huit « un octet ».
Attention, un octet se dit « byte » en anglais : un byte est un groupe de huit bits, et non pas un
seul bit.
Lorsque l’ordinateur mémorise un nombre, il lui réserve toujours un nombre entier d’octets,
en comblant les cases inutilisées à gauche de la représentation du nombre par des 0. Ainsi
pour stocker 111 11011110, qui est la représentation binaire de 2014, un octet ne peut pas
suffire, puisqu’il y a onze bits. On utilise donc deux octets c’est-à-dire seize bits, et on écrit en
fait 00000111 11011110.
Sur deux octets, c’est-à-dire seize bits, on peut représenter 216 = 65536 nombres différents : le
plus petit d’entre eux est représenté par 00000000 00000000, c’est le nombre 0, et le plus
grand est représenté par 11111111 11111111, c’est le nombre 65535. En résumé, si l’on
dispose de deux octets (16 bits) en mémoire, on peut stocker toute valeur comprise entre 0 et
216- 1 = 65535.
Un processeur 64 bits manipule des paquets de 8 octets, soit 64 bits :

En conclusion, il faut retenir que les nombres manipulés par un ordinateur sont limités par le
nombre d’octets utilisés pour stocker leur représentation binaire.

13
3. Représentation des entiers relatifs et des nombres à virgule
3.1 Nombre entier relatif

Un nombre entiers relatif est un entier qui peut prendre exactement deux valeurs (positif ou
négatif), par conséquent, il suffit d’un bit supplémentaire pour le représenter. On convient que
0 correspond à un nombre positif et 1 à un nombre négatif.

a. entier relatif positif ou nul :

La façon la plus simple de représenter un entier relatif positif ou nul en binaire (base 2)
consiste à le faire présenter comme un entier naturel, à la seule différence que le bit de poids
fort (le bit situé à l'extrême gauche) représente le signe. Il faut donc s'assurer pour un entier
positif ou nul qu'il est à zéro (0 correspond à un signe positif, 1 à un signe négatif). Ainsi si on
code un entier naturel sur 4 bits, le nombre le plus grand sera 0111 (c'est-à-dire 7 en base
décimale). D'une manière générale le plus grand entier relatif positif codé sur n bits sera 2n-1-1.

b. un entier relatif négatif

La méthode utilisée par les ordinateurs pour représenter un entier négative est le codage en
complément à deux selon les étapes suivants:

- Prenons son opposé (son équivalent en positif)

- On le représente en base 2 sur n-1 bits

- On complémente chaque bit (on inverse, c'est-à-dire que l'on remplace les zéros par des 1
et vice-versa)

- On ajoute 1

Exemple : On désire coder la valeur -3 sur 8 bits. Il suffit :

- d'écrire 3 en binaire: 00000011

- de complémenter à 1: 11111100

- d'ajouter 1: 11111101

- la représentation binaire de -3 sur 8 bits est 11111101

On remarquera qu'en ajoutant le nombre et son complément à deux on obtient 0 avec une
retenue de 1

14
3.2 Nombre à virgule
La représentation binaire des nombres à virgule utilisée en informatique est du même type que
la notation dite « scientifique » utilisée par les calculatrices : le nombre 201,4 s’écrit ainsi 2,
014˟102. L’exposant peut-être négatif si le nombre est compris entre -1 et 1 : par exemple 0,
00214 s’écrit 2,014˟10-3. On va donc utiliser l'écriture scientifique pour représenter nos
nombres couplés à la norme IEEE. Cette norme se propose de définir trois composantes : On
se place maintenant dans le cas où chaque nombre occupe 4 octets, soit 32 bits :

• On réserve toujours le premier bit pour le signe (0 pour un nombre positif et 1 pour un
nombre négatif).
• Les huit bits suivants sont utilisés pour l’exposant, qui est un nombre relatif compris
entre -126 à 127.
• 23 bits pour la mantisse (les bits situés après la virgule).

Certaines conditions sont toutefois à respecter pour les exposants :

- l'exposant 00000000 est interdit

- l'exposant 11111111 est interdit. On s'en sert toutefois pour signaler des erreurs, on
appelle alors cette configuration du nombre NaN, ce qui signifie Not a number
- les exposants peuvent ainsi aller de -126 à 127

Exemple : On désire coder la valeur 123,44 en binaire avec la norme IEEE:

123,44 s'écrit en base 2 de la façon suivante : 1111011,110111100. On veut l'écrire sous la

forme : +1,111011110111100*106.

A partir de là nous avons déjà deux éléments sur trois : le signe, +, qui est codé par 0. Et la
mantisse, 111011110111100, auquel nous ajoutons des 0 jusqu'à arriver à 23 bits. Ce qui nous
donne : 11101111011110000000000.

Il nous reste à calculer l'exposant : 127 + 6 = 133 = 10000101

Nous avons tous nos composants. On assemble le tout :

15
 123,444 = 01000010111101111011110000000000.

4. Représentation des textes

Pour terminer, nous nous intéressons à la représentation des textes. Un texte est vu comme
une suite de caractères qui ont chacun un code numérique, c’est-à-dire un nombre
correspondant. Ensuite, il suffit de représenter ce code numérique en binaire pour obtenir la
représentation du caractère.
Les caractères sont non seulement les lettres de l’alphabet, majuscules et minuscules, mais
aussi les signes de ponctuation, l’espace, les chiffres, les parenthèses, etc. En français, il faut
encore ajouter les lettres accentuées, le ç, le oe, et d’autres caractères spéciaux pour d’autres
langues (ñ ou ˇo). Il y a aussi des langues qui n’utilisent pas l’alphabet latin, comme le grec, le
russe, le chinois, le japonais, le coréen, l’arabe...
Nous présentons ci-dessous un format, qui est de moins en moins utilisé, mais qui a
l’avantage d’être simple à comprendre : le code ASCII (American Standard Code for
Information Interchange). Dans la version la plus simple, chaque caractère est codé sur 7 bits
(en réalité sur un octet, mais avec le premier bit toujours à 0). Il y a donc 27 = 128 caractères
possibles, correspondant aux nombres de 0 à 127. La liste de ces 128 caractères est donnée ci-
dessous.
On observe que les lettres majuscules A, B, C, . . ., Z sont codées par les nombres consécutifs
65, 66, 67, . . ., 90. Les lettres minuscules a, b, c, . . ., z correspondent aux nombres 97 à 122.
Il est intéressant de noter que les chiffres de 0 à 9 sont codés par les nombres de 48 à 57. Les
codes de 0 à 31 ne correspondent pas à des caractères du clavier, mais à des symboles de mise
en page comme le retour à la ligne (« CARRIAGE RETURN »).
Par exemple, l’expression « Le code ASCII » se code numériquement par 76 101 32 99 111
100 101 32 65 83 67 73 73, et en binaire elle devient 01001100 01100101 01000000
01100011 01101111 01100100 01100101 01000000 01000001 01010011 01000011
01001001 01001001.
On note que ce format très limité ne permet pas de représenter tous les caractères utilisés en
français, puisqu’il est limité aux 26 lettres majuscules et minuscules.

16
Les codes ASCII en décimal (base 10), hexadécimal (base 16), octal (base 8) et binaire (base 2). La dernière
colonne donne le caractère correspondant.

Conclusion
Nous avons vu dans ce chapitre le principe du codage de l'information sous forme binaire,
quand cette information est de type numérique ou textuel.
C'est avec ce codage (le langage machine) que fonctionnent tous les systèmes micro-
programmés par l’utilisation des microprocesseurs.

17
 CHAPITRE II

Microprocesseur

18
Introduction
Un système numérique, intégrant de l’électronique, fait souvent apparaître des fonctions ayant
pour rôle le traitement d’informations : opérations arithmétiques (addition, multiplication...)
ou logiques (ET, OU...) entre plusieurs signaux d’entrée permettant de générer des signaux de
sortie.
Ces fonctions peuvent être réalisées par des circuits intégrés analogiques ou logiques. Mais,
lorsque le système devient complexe, et qu’il est alors nécessaire de réaliser un ensemble
important de traitements d’informations, il devient plus simple de faire appel à une structure à
base de : microcontrôleur ou microprocesseur.

1. Définition d'un microprocesseur

Un microprocesseur ou processeur ou encore CPU (Central Processing Unit) est l'unité

intelligente de traitement des informations. C’est un circuit intégré complexe chargé
d’organiser les tâches précisées par le programme, de les décoder et d’assurer leur exécution.
Il doit aussi prendre en compte les informations extérieures au système et assurer leur
traitement.

2. Structure d’un microprocesseur

Un microprocesseur est construit autour de :
- une Unité Arithmétique et Logique (UAL)
- une Unité de Contrôle (UC)
- des registres
- des bus

Figure.1 Structure de base d'un microprocesseur

19
2.1 Unité Arithmétique et Logique (UAL)
Elle dispose de circuits réalisant des opérations des fonctions logiques (ET, OU, comparaison,
décalage,...) ou arithmétique (addition, soustraction,...).
En entrée de l’UAL, on a des commandes permettant d’activer les opérations, venant de
l’unité de contrôle En sortie, on a les résultats des opérations et les conditions qui sont en fait
les entrées de l’unité de contrôle. L'UAL est composé de :
• Les accumulateurs : Ce sont des registres de travail qui servent à stocker un opérande
au début d'une opération arithmétique et le résultat à la fin de l'opération.
• L’Unité Arithmétique et Logique: C'est un circuit complexe qui assure les fonctions
logiques (ET, OU, Comparaison, Décalage, etc...) ou arithmétique (Addition, soustraction...)
• Le registre d'état: Il est généralement composé de 8 bits à considérer
individuellement. Chacun de ces bits est un indicateur dont l'état dépend du résultat de
la dernière opération effectuée par l’UAL. On les appelle indicateur d’état ou flag ou
drapeaux (Retenue (C), signe (S), zéro (Z), ...).

Figure.2 unité arithmétique et logique d’un microprocesseur

2.2 Unité de contrôle ou séquenceur

L’unité de contrôle est un circuit logique séquentiel chargée de séquencer l’algorithme et de
générer les signaux de contrôle pour piloter les éléments du chemin de données.
Elle envoie des commandes à l’unité de traitement qui va exécuter les traitements. L'unité de
control contient:
 Le compteur de programme (PC: Programme Counter ou compteur ordinal :
CO) : Il comporte un registre dont le contenu est initialisé avec l'adresse de la première
instruction du programme. Ce registre contient toujours l’adresse de la prochaine instruction à
exécuter.

20
  Le registre d'instruction et le décodeur d'instruction : Chacune des instructions à
exécuter est transférée depuis la mémoire dans le registre d’instruction puis est décodée par le
décodeur d’instruction.
 Le bloc logique de commande (ou séquenceur) : Il organise l'exécution des
instructions au rythme d’une horloge. Il élabore tous les signaux de synchronisation internes
ou externes (bus de commande) du microprocesseur en fonction de l’instruction qu’il a à
exécuter.

Figure.3 unité de contrôle ou séquenceur d’un microprocesseur

2.3 Les bus

Un bus est un ensemble de lignes de communications groupées par fonction. Il permet de faire
transiter (liaison série/parallèle) des informations codées en binaire entre deux points.
Il est caractérisé par le nombre de lignes et la fréquence de transfert. Il existe 3 Types de bus :
 Bus d'adresses (unidirectionnel): Le µP positionne sur ce bus l’adresse du circuit avec
lequel il désire échanger des informations. Un bus d’adresse est unidirectionnel, il est une
sortie pour le µp et une entrée pour les autres circuits. Ce bus peut prendre 3 états : ‘0’, ‘1’ ou
‘Haute impédance’. En haute impédance, ce bus est comme s’il n’est pas connecté aux autres
circuits. Selon les µP courants, le bus d’adresses peut avoir 16, 20, 24 ou 32 lignes. Un bus
d’adresses peut adresser jusqu’à 2n cases mémoires.
 Bus de données (bidirectionnel) : Ce bus permet la transmission des données entre le
µP et le circuit du système dont l’adresse est présente sur le bus d’adresses. Il est
bidirectionnel et réalisé en logique 3 états. Le bus de données contient couramment 8, 16 ou
32 lignes.
 Bus de contrôle (bidirectionnel) : Ce bus assure la synchronisation, la commande et le
contrôle des échanges sur les bus entre le µP et son environnement externes. Ce bus est réalisé
aussi en logique 3 états.

21
2.4 Les registres
C'est un espace mémoire interne au processeur. On distingue deux types : à usage général qui
permettent à l'UAL de manipuler des données et les registres d'adresses qui sont connectés au
bus d'adresse.

Figure.4 Structure interne d'un microprocesseur

3. Les mémoires
Le processeur exécute les instructions machines présente dans la mémoire et traite les données
qu'elle contient : le fonctionnement du microprocesseur est entièrement conditionné par le
contenu de celles-ci et sa capacité de mémoriser, c'est-à-dire le nombre d’octet (mot de 8 bits)
ou de bits qu’elle peut stocker. Une mémoire de 2048 octets a pour capacité 2048x8 bits

La mémoire peut être vue comme un ensemble de cellules ou cases contenant chacune une
information : une instruction ou une donnée. Chaque case mémoire est repérée par un numéro
d’ordre unique : son adresse.

Une case mémoire peut être lue ou écrite par le microprocesseur (cas des mémoires vives) ou
bien seulement lue (cas des mémoires mortes).

22
 Figure.5 Structure générale d'une mémoire

Indépendamment de sa structure interne et des détails de la technologie concernée, une

mémoire est caractérisée par son mode de programmation et sa faculté de retenir l’information
quand l’alimentation est interrompue.

3.1 Les mémoires ROM (read only memory)

C’est des mémoires qui gardent en permanence les données sans les perdre quand il n’y a pas
d’alimentation : mémoires non volatiles. Elles sont utilisées pour stocker des données qui sont
rarement modifiées. Leurs principales utilisation est le stockage des programme système, des
tables de correspondance (conversion de code), ... Il existe plusieurs type de ROM :

• MROM: le contenu est initialise au moment de la fabrication et ne peut plus être

Modifie.
• PROM (programmable ROM) ou OTP ROM (one-time programmable): le contenu
peut être modifie une fois par l'utilisateur, à l'aide d'un équipement spécialisé.
• EPROM (erasable PROM): le contenu peut être efface et modifie plusieurs fois:
- UV EPROM: le contenu est efface par des rayons ultra-violets (plusieurs minutes)
- EEPROM (electrically EPROM) ou E2PROM: le contenu est effacé électriquement
(quelques millisecondes)
- Flash: le contenu est effacé électriquement et plus rapidement que sur les EEPROM.
3.2 Mémoires RAM
Les mémoires RAM sont des mémoires dans lesquelles on peut écrire ou lire des données en
un temps très court (ce n’est pas le cas des ROM). Cependant ces mémoires ne sont pas
permanentes donc volatiles une fois la tension d’alimentation coupée. Elles sont utilisées pour

23
stocker temporairement des programmes et des données au cours de l’exécution d’un
programme. Il distingue deux types RAM :

• SRAM : Ce sont des mémoires qui gardent leur contenu en utilisant des transistors.
Exemple : 6264 est RAM CMOS.

• DRAM : Ce sont des mémoires qui stockent leurs contenus sous formes des charges
dans des petits condensateurs MOS. Une cellule de DRAM est donc très simple, ce qui permet
la construction de très grandes mémoires à bas prix. Cependant, le condensateur se décharge
avec le temps et l'information est perdue si la charge n'est pas rafraichie périodiquement
(rafraichissement 2 à 10 ms). Leurs avantages sur les SRAM est leur grande capacité et la
faible consommation, mais les SRAM sont beaucoup plus rapides.

4 Principe de Fonctionnement d'un microprocesseur

Le programme que doit exécuter un microprocesseur est une succession d'instructions
ordonnées (chaque instruction pouvant prend plusieurs octets) qui se trouve rangé dans une
zone mémoire, généralement à des adresses successives.
4.1 Instruction
a. Format d’une instruction :
Une instruction est composée de deux éléments :
 Le code opération : C’est un code binaire qui correspond à l’action à effectuer par le
processeur (ADD (pour addition), SUB (pour soustraction), NEG (pour complémenter à deux), COM
(pour complémenter à 1), MOVE (pour le transfert de donnée), AND (pour effectuer un "et" logique
bit à bit), OR (pour effectuer un "ou" logique bit à bit), XOR (pour effectuer un "ou exclusif" bit à
bit)).
 Le champ opérande : Donnée ou bien adresse de la donnée.
Exemple.1 : "ADD D1,47", signifie que le registre D1 sera additionné au contenu de la case mémoire
47 et le résultat sera sauvegardé dans la case mémoire 47. Par contre "ADD 47, D1" sauvegarde le
résultat dans le registre D1.
Exemple.2 : "NEG D6" signifie que l'inverse de D6 est sauvegardé (chargé) dans D6.
b. Durée d'une instruction :
L'exécution complète d'une instruction n'est pas instantanée. L'unité de mesure est la période
de l'horloge encore appelé "Cycle Machine". La durée d’une instruction dépend de la
complexité de l'instruction. Son expression est :
Tinstruction = [Link]

24
Où n est le nombre de cycle que peut prendre l’instruction.

c. Architecture des instructions :

Actuellement l’architecture des microprocesseurs se composent de deux grandes familles :
 L’architecture CISC (Complex Instruction Set Computer) : Ce type de
microprocesseur possède un nombre important d’instructions. Chacune d’elles s’exécute en
plusieurs périodes d’horloges.
 L’architecture RISC (Reduced Instruction Set Computer) : Ces microprocesseurs
possèdent un nombre réduit d’instructions. Chacune d’elles s’exécute en une période
d’horloge.
d. Modes d’adressage d’une instruction
 Modes d’adressage indirect : Le champ adresse de l’instruction contient
l’adresse d’une case mémoire qui contient l’adresse effective de l’opérande.
Ex: MOV(102), R2

 Modes d’adressage direct : Le champ adresse de l’instruction contient

l’adresse effective de l’opérande
Ex: MOV 100, R2

25
  Modes d’adressage immédiat : Le champ adresse contient la valeur de
l’opérande
Ex: MOV #100, R1

4.2 Traitement des instructions

L’exécution d’une instruction se fait en trois étapes :
• Recherche de l'instruction (Fetch) ;
• Décodage (décode) ;
• Exécution (exécuté).

Figure.6 Fonctionnement d'un microprocesseur

a. Recherche de l'instruction
Pour exécuter les instructions dans l’ordre établi par le programme, le microprocesseur doit
savoir à chaque instant l’adresse de la prochaine instruction à exécuter. Le microprocesseur
utilise un registre contenant cette information : Le pointeur d’instruction
Le contenu de PC est placé sur le bus des adresses. L'unité de contrôle (UC) émet un ordre de
lecture, au bout d'un certain temps (temps d'accès à la mémoire) le contenu de la case

26
mémoire sélectionné est disponible sur le bus des données. L'unité de contrôle charge la
donnée dans le registre d'instruction pour décodage.

b. Décodage
Pour savoir quel type d’opération doit être exécuté (addition, soustraction, ...), le
microprocesseur lit le premier octet de l’instruction pointée par le pointeur d’instruction (code
opératoire) et le range dans le registre d’instruction. Le code opératoire est décodé par des
circuits de décodage contenus dans le microprocesseur. Des signaux de commande pour
l’UAL sont produits en fonction de l’opération demandée qui est alors exécutée.
Pendant que l’instruction est décodée, le pointeur d’instruction est incrémenté de façon à
pointer vers l’instruction suivante. Puis, le processus de lecture et de décodage des
instructions recommence.

c. Exécution
Après l’exécution de l’instruction par micro-programme, les indicateurs sont positionnés (O,
S, Z, C). L'unité de commande positionne le compteur ordinal (PC) pour l'instruction
suivante.

5. Architecture d'un microprocesseur

Pour l’organisation des différentes unités, il existe deux architectures possibles:

5.1 Architecture de Von Neuman

La mémoire programme, la mémoire données et les périphériques d’entrées/sorties partagent
le même bus s’adresses et de données.
Inconvénient: L’exécution d’une instruction nécessite plusieurs échanges de données sur le
seul et unique bus dévolu à cet usage puisqu’il faut tout d’abord aller chercher le code de
l’instruction puis le ou les données qu’elle doit manipuler.

Figure.7 Architecture de Von Neuman

27
5.2 Architecture de Harvard
Cette architecture sépare systématiquement la mémoire de programme de la mémoire des
données : l'adressage de ces mémoires est indépendant. Ce type d’architecture est utilisé sur
des microcontrôleurs qui ont connu un développement important ces dernières années.

Figure.8 Architecture de Harvard

Quoique cette architecture puisse être complexe mais elle est performante: Gain en terme de
vitesse d’exécution des programmes :
L’exécution d’une instruction ne fait plus appel qu’à un seul cycle machine puisque l’on peut
simultanément, grâce au deux bus, rechercher le code de l’instruction et la ou les données
qu’elle manipule.

Conclusion
A partie de ce que nous avions dit précédemment, on conclure qu’un microprocesseur muni
de mémoire peut être, dans une première approche, considéré comme un « cerveau » capable
d’effectuer des opérations diverses (opérations arithmétiques, logiques) et de les enchaîner
dans un processus cohérent. Tel quel, un microprocesseur (on parle aussi du CPU : Central
Processing Unit) n’a aucune utilité puisqu’il ne peut pas communiquer avec le milieu
extérieur. Pour pouvoir être efficace, un microprocesseur doit disposer d’organes d’entrée-
sortie comme le cerveau qui dispose d’organes d’entrée (oreilles, yeux) et de sortie (paroles,
gestes). Nous appelons "microcontrôleur" cette structure "microprocesseur + périphériques".

28
 CHAPITRE III

Microcontrôleur

29
Introduction

La partie principale d’un micro-ordinateur est la « carte mère » sur laquelle sont montés le
microprocesseur, les contrôleurs de périphériques et les lignes qui les connectent entre eux
sous forme de circuit imprimé. Avec les progrès de la miniaturisation, et la généralisation de
l’utilisation des ordinateurs, les besoins les plus courants se sont standardisés et on a pu
disposer toute une carte mère au sein d’une seule et même puce, appelée microcontrôleur.
L’usage de microcontrôleurs est actuellement en plein développement dans toute
l’informatique industrielle, et à tous les degrés de complexité (de 8 pattes à près de 200
pattes). 7 Un système informatique complet regroupe autour d'un microcontrôleur un
ensemble de composants qui lui permettent de fonctionner (essentiellement mémoires) et de
communiquer avec le milieu extérieur (contrôleurs de périphériques)

1. Microcontrôleur
1.1 Définition d’un microcontrôleur
On définit ainsi un microcontrôleur comme étant une unité de traitement de l’information de
type microprocesseur à laquelle on a ajouté des périphériques internes permettant de réaliser
des montages sans nécessiter l’ajout de composants externes.
Il intègre également un certain nombre de périphériques spécifiques des domaines ciblés (bus
série, interface parallèle, convertisseur analogique numérique, ...). Les microcontrôleurs
améliorent donc l'intégration et le coût (lié à la conception et à la réalisation) d'un système à
base de microprocesseur en rassemblant les éléments essentiels d’un tel système dans un seul
circuit intégré. On parle alors de "système sur une puce" (en anglais : "System On chip").
Les microcontrôleurs sont plutôt dédiés aux applications qui ne nécessitent pas une grande
quantité de calculs complexes, mais qui demandent beaucoup de manipulations
d’entrées/sorties. C’est le cas de contrôle de processus.

a. Architecture interne d’un microcontrôleur

La structure interne d'un microcontrôleur comporte typiquement :
 Une unité de calcul et de commande (CPU).
 De la mémoire de donnée (RAM, EEPROM).
 De la mémoire programme (ROM, PROM, EPROM, EEPROM).
 Un compteur/temporisateur (timer) pour générer ou mesurer des signaux avec une
grande précision temporelle.
 Des interfaces parallèles pour la connexion des entrées/sorties.

30
  Des interfaces série (synchrones et asynchrones) pour le dialogue avec d’autres unités.
Il peut aussi posséder :
 Un chien de garde (Watchdog) qui assure la surveillance du programme.
 Une sortie PWM (Pulse Width Modulation) pour la modulation d’impulsion.
 Un convertisseur analogique-numérique et numérique-analogique (CAN/CNA) pour le
traitement des signaux analogiques.

Figure. 1 Architecture interne d'un microcontrôleur

1.3 Familles d’un microcontrôleur

Il existe plusieurs familles de microcontrôleurs, se différenciant par la vitesse de leur
processeur et par le nombre de périphériques qui les composent. Toutes ces familles ont un
point commun c’est de réunir tous les éléments essentiels d’une structure à base de
microprocesseur sur une même puce. Parmi les familles de microcontrôleurs les plus connues
sont :
– Atmel : AT; familles AT89Sxxxx, AT90xxxx, …
– Motorolla : famille 68HCxxx, …
– Microship : PIC ; familles 12Cxxx, 16Cxxx, 16Fxxx, 18Fxxx, …
– Intel : famille 80C186XX
– STMicroelectronics : famille STX
– Analog Devices : famille ADuC
Nous allons nous intéresser dans le cadre de ce cours à la famille Microchip PIC
(Programmable Integrated Circuit) de moyenne gamme (MIDRANGE).

31
2. Les microcontrôleurs de type PIC
2.1 Définition de PIC
Un PIC n’est rien d’autre qu’un microcontrôleur. La dénomination PIC est sous copyright de
Microchip. Ses caractéristiques principales sont :
 Séparation des mémoires de programme et de données (architecture Harvard) :
On obtient ainsi une meilleure bande passante et des instructions et des données pas
forcément codées sur le même nombre de bits.
 Communication avec l'extérieur seulement par des ports : il ne possède pas de bus
d'adresses, de bus de données et de bus de contrôle comme la plupart des microprocesseurs.
 Utilisation d'un jeu d'instructions réduit, d'où le nom de son architecture : RISC
(Reduced Instructions Set Construction). Les instructions sont ainsi codées sur un nombre
réduit de bits, ce qui accélère l'exécution (1 cycle machine par instruction sauf pour les sauts
qui requièrent 2 cycles). En revanche, leur nombre limité oblige à se restreindre à des
instructions basiques, contrairement aux systèmes d'architecture CISC (Complex Instructions
Set Construction) qui proposent plus d'instructions donc codées sur plus de bits mais réalisant
des traitements plus complexes.

2.2 Différentes familles de PIC

La famille des PIC à processeur 8 bits est subdivisée à l’heure actuelle en 3 grandes
catégories :
 Base-Line : ils utilisent des mots d’instruction de 12 bits.
 Mid-Range : ils utilisent des mots d’instruction de 14 bits.
 High-End : ils utilisent des mots d’instruction de 16 bits.
Il existe aussi des PIC à processeur 16 bits (PIC24F/PIC24H) et 32 bits (PIC32M) aussi.

2.3 Identification d’un PIC

Pour identifier un PIC, on utilise simplement son appellation du type : ww(L)XXyy-zz
 ww: Représente la catégorie du composant (12, 14, 16, 17, 18),
 L: Tolérance plus importante de la plage de tension.
 XX: Type de mémoire de programme:
- C: EPROM ou EEPROM.
- CR: PROM.
- F: FLASH.
 YY: Identification.

32
  ZZ: Vitesse maximum tolérable.
Dans la suite du chapitre, on va prendre comme exemple le PIC 16F877 et présenter sa
structure interne et externe.

3. Le microcontrôleur PIC 16F877

Le PIC16F877A est un microcontrôleur de la famille mid-range qui se présente sous la forme
d’un circuit intégré disponible en boîtier DIL de 40 broches. Il est réalisé en technologie
HCMOS FLASH, et est cadencé par une horloge interne ou externe pouvant avoir une
fréquence de 0 à 20MHz.

Figure.2 brochage PIC 16F877

3.1 Caractéristiques du PIC16F877

Les principales caractéristiques du PIC16F877 sont :
 Caractéristiques de la CPU
- CPU à architecture RISC (8 bits)
- Mémoire programme de 8 Kmots de 14 bits (Flash),
- Mémoire donnée de 368 Octets,
- EEPROM donnée de 256 Octets,
- 14 sources interruptions
- Générateur d'horloge de type RC ou quartz (jusqu’à 20 MHz)
- 05 ports d'entrée sortie - Fonctionnement en mode sleep pour réduction de la
consommation,
 Caractéristiques des périphériques

33
 - Timer0 : Timer/Compteur 8 bitsavec un prédiviseur 8 bits
- Timer1 : Timer/Compteur 16 bits avec un prédivision de 1, 2, 4, ou 8 ; il peut
être incrémenté en mode veille (Sleep), via une horloge externe,
- Timer2 : Timer 8 bits avec deux diviseurs (pré et post diviseur)
- Deux modules « Capture, Compare et PWM » : Module capture 16 bits avec
une résolution max. 12,5ns, Module Compare 16 bits avec une résolution max.
200ns, Module PWM avec une résolution max. 10 bits,
- Convertisseur Analogiques numériques multi-canal (8 voies) avec une
conversion sur 10 bits,
- Synchronous Serial Port (SSP) SSP, Port série synchrone en mode I2C (mode
maitre/escalve),
- Universel Synchronous Asynchronous Receiver Transmitter (USART) : Port
série universel, mode asynchrone (RS232) et mode synchrone.

Figure.3 Architecture interne du PIC 16F877

3.2 Alimentation du PIC16F877

L’alimentation du circuit est assurée par les pattes VDD et VSS. Elles permettent à
l’ensemble des composants électroniques du PIC de fonctionner. Pour cela on relie VSS (patte
12) à la masse (0 Volt) et VDD (patte 11) à la borne positive de l’alimentation qui doit
délivrer une tension continue comprise entre 3 et 6 Volts.

3.3 Cadencement du PIC16F877

Le PIC16F877 peut fonctionner suivant quatre modes d’oscillateurs différents : 1. Le mode
LP (Low Power Crystal) : Oscillateur à quartz faible consommation. 2. Le mode XT
(Crystal/Resonator) : Oscillateur à quartz. 3. Le mode HS (High Speed Crystal/Resonator):

34
Oscillateur à quartz de haute fréquence. 4. Le mode RC (Resistor/Capacitor): Oscillateur RC.
Avec l'oscillateur à Quartz, on peut avoir des fréquences allant jusqu'à 20 MHz selon le type
de µC. Le filtre passe bas (Rs, C1, C2) limite les harmoniques dus à l’écrêtage et réduit
l’amplitude de l’oscillation, il n'est pas obligatoire.

Quel que soit l'oscillateur utilisé, l'horloge système dite aussi horloge instruction est obtenue
en divisant la fréquence par 4. Dans la suite de ce document on utilisera le terme Fosc/4 pour
désigner l'horloge système. Avec un quartz de 20 MHz, on obtient une horloge instruction de
5MHz, soit 0.2µs le temps pour exécuter une instruction.

3.4 Circuit Reset MCLR

Le PIC16F877A peut être réinitialisé lorsque la broche MCLR (Master Clear) est connectée à
0. Lorsque le signal de “RESET” est activé, tous les registres sont initialisé et le compteur
programme se place à une adresse spécifique appelée “Vecteur de RESET”.

Figure.4 Circuit RESET et oscillateur d'un PIC 16F877

3.5 Chien de garde

Le watchdog, ou chien de garde est un mécanisme de protection de votre programme. Il sert à
surveiller si celui-ci s’exécute toujours dans l’espace et dans le temps que vous lui avez
attribués. C'est une protection destinée généralement à redémarrer le système, si une action
définie n'est pas exécutée dans un délai imparti.

Dans le PIC, il s’agit un compteur 8 bits incrémenté en permanence (même si le μC est en

mode sleep) par une horloge RC intégrée indépendante de l'horloge système. Lorsqu’il
déborde, deux situations sont possibles :

35
  Si le μC est en fonctionnement normal, le WDT time-out provoque un RESET. Ceci
permet d’éviter de rester planté en cas de blocage du microcontrôleur par un processus
indésirable non contrôlé
 Si le μC est en mode SLEEP, le WDT time-out provoque un WAKE-UP, l'exécution
du programme continue normalement là où elle s'est arrêtée avant de rentrer en mode SLEEP.
Cette situation est souvent exploitée pour réaliser des temporisations.

3.6 Ports E/S

Le PIC16F877A dispose de cinq ports bidirectionnels d’E/S (port A à port E). Certaines
broches de ces ports sont multiplexées avec d’autres fonctions de périphériques internes
(comparateur et référence de tension par exemple). A chaque port correspondent deux
registres :

 Un registre direction pour programmer les lignes soit en entrée, soit en sortie TRISA,
TRISB, TRISC, TRISD et TRISE.
 Un registre de données pour lire ou modifier l’état des broches. PORTA, PORTB,
PORTC, PORTD et PORTE
Pour déterminer les modes des ports (I/O), il faut sélectionner leurs registres TRISX:
 Le positionnement d’un bit à « 1 » place le pin en entrée.
 Le positionnement de ce bit à « 0 » place le pin en sortie.
La plupart des broches des PORTs sont partagées avec des périphériques. En général si un
périphérique est utilisé, les broches correspondantes ne peuvent pas être utilisées comme
broches d’entrée/sortie.
Au Reset, les lignes des ports A et E sont configurées en entrées analogiques, les autres lignes
sont configurées en entrées digitales. Le courant absorbé ou fourni peut atteindre 25 mA.

a. Port A
Le tableau ci-dessous décrit les différentes fonctions multiplexées sur le port A.

- RA0 à RA5 : Entrée / Sortie numérique.

36
 - AN0 à AN3 : Entrées analogiques.
- Vref : Tension de référence, on la fixe par programmation.
- T0CKI : Timer Clock In ; entrée d’horloge du TMR0.
- 𝑆𝑆̅̅̅̅̅̅ : Entrée de sélection esclave pour la communication série synchrone.

b. Port B
Le port B peut être programmé pour un tirage à 5V (pull up) de toutes ses lignes que l'on peut mettre
ou non en service en mode entrée uniquement. Elles sont automatiquement désactivées quand le port
est configuré en sortie. En mode entrée, chaque broche du PORTB doit être maintenue à un niveau
haut par l'intermédiaire de résistances de 10 k pour ne pas déclencher d'interruptions imprévues. Cette
possibilité d'interruption sur un changement d'état associé à la fonction de tirage configurable sur ces 4
broches, permet l'interfaçage facile avec un clavier. Cela rend possible le réveil du PIC en mode
SLEEP par un appui sur une touche du clavier. Le tableau ci-dessous décrit les différentes fonctions
multiplexées sur le port B.

- RB0 à RB7 : Entrée / Sortie numérique.

- INT : Entrée d’interruption externe.
- PGM : Broche de programmation en mode LVP.
- PGC : Entrée d’horloge en mode programmation.
- PGD : Entrée de donnée en mode programmation

37
c. Port C
Le port C est partagé avec liaisons, les timers 1 et 2 et les modules CCP. Le tableau ci-
dessous décrit les différentes fonctions multiplexées sur le port C.

- RC0 à RC7 : Entrée / Sortie numérique.

- T1OSO : Timer 1 Oscillateur Out ; sortie de l’oscillateur du TMR1.
- T1OSI : Timer 1 Oscillateur In ; entrée de l’oscillateur du TMR1.
- T1CKI : Timer 1 Clock Int ; entrée d’horloge du Timer 1.
- CCP2: Capture 2 input / Capture 2 output / PWM 2 output.
- SCK/SCL: Horloge en mode SPI/I2C.
- SDI/SDA : Entrée ou sortie de donnée en mode SPI/ I 2C.
- SDO : Sortie de donnée en mode SSP (Synchronous Serial Port).
- TX/RX : Transmission/Réception en mode USART asynchrone.
- CK/DT : Horloge/Entrée-Sortie de donnée en mode USART synchrone.

d. Port D et E

En plus de leur utilisation comme PORTS E/S; les ports D et E, permettent au

microcontrôleur de travailler en mode PSP (Parallel Slave Port) c’est-à-dire, qu’il peut être
interfacé avec un autre microprocesseur. Dans ce cas le PORTD représente le bus de données
et le PORTE les signaux de contrôle (RD\, WR\ et CS\). Le PORTE peut être aussi, configuré
en mode analogique pour former avec le PORTA les 8 entrées du convertisseur analogique
numérique. Par défaut, le PORTE est configuré comme port analogique, et donc, comme pour
le PORTA. Les tableaux ci-dessous décrivent les différentes fonctions multiplexées sur le port
D et le port E.

38
3.7 Les Timers
Le Timer permet de réaliser les fonctions suivantes :
- Génération d’un signal périodique modulé ou non en largeur d’impulsion,
- Gé né ration d’une impulsion calibrée,
- Temporisation,
- Comptage d'événements.
Le Pic16F877 comporte trois timers qui sont :
a. Le module TMR0 :
Le timer 0 qui est un compteur sur 8 bits dont on peut choisir le front de déclenchement, le
rapport de division et l’horloge interne ou externe. Tous les bits de configuration de TMR0
sont dans le registre OPTION :

39
 • Mode TIMER : Le choix de ce mode se fait par : TOCS = 0 (b5 de OPTION). TMR0
est incrémenté à chaque cycle instruction (Fosc/4), en considérant le pré-diviseur avec
un rapport de 1.
• Mode COMPTEUR : Ce mode est sélectionné si TOCS = 1. TMR0 est alors
incrémenté à chaque front montant ou descendant sur la broche PA4/CLK (pin3). Le
choix du front est fait par le bit TOSE (bit4 de OPTION). Si TOSE = 0 le compteur
s'incrémente à chaque front montant. Si TOSE = 1 c'est le front descendant qui
incrémente le compteur.
• LE PREDIVISEUR : Il est partagé entre le Watchdog et TMR0. L'affectation se fait
par le bit PSA (bit3 d’OPTION).
- Si PSA = 0 le pré-diviseur est affecté à TMR0. Le choix du rapport de division se
fait avec les bits PS2, PS1 et PS0 (bit 2, b1 et b0 de OPTION).
- Si PSA = 1 le pré-diviseur est affecté au Watchdog et le rapport de division pour
TMR0 est fixé à 1.
• INTERRUPTION : Elle est générée quand TMR0 passe de la valeur FF à 00. Le Flag
TOIF (bit2 de INTCON) passe à "1". On peut masquer la génération de l'interruption
en mettant le bit TOIE (bit5 de INTCON) à "0".
Le Flag TOIF dit être remis à zéro par soft dans le sous-programme d'interruption,
avant de re-autoriser cette interruption.

b. Le module TMR1 :
Le timer 1 qui est un compteur sur 16 bits. Ce module peut fonctionner en mode TIMER,
quand il s'incrémente à chaque cycle instruction (Fosc/4 avec le pré diviseur considéré à "1")
ou en mode compteur, quand il s'incrémente à chaque front montant de l'horloge externe. Le
contrôle du TIMER 1 se fait par le registre T1CON :

Au reset : T1CON = 00000000

• Bit 7 et bit 6 : bits non implémentés.

• Bit 5 et bit 4 : T1CKPS = Sélection du prédiviseur placé avant le TIMER.

40
 • Bit 3 : T1OSCEN : Bit d'autorisation de l'oscillateur du Timer 1.
- 1 = oscillateur autorisé
- 0 = oscillateur stoppé.
• Bit 2 : T1SYNC : Bit de contrôle de la synchronisation du CLK externe.
- 1 = Pas de synchronisation de l'horloge externe.
- 0 = Synchronisation de l'horloge externe.
• Bit1 : TMR1CS : Bit de sélection de la source horloge.
- 1 = Mode Compteur: Clk externe sur la broche PC0 ou Quartz entre PC0 et
PC1
- 0 = Mode Timer: Clk interne = Fosc/4.
• Bit 0 : TMR1ON : Bit d'autorisation du Timer 1. 1 = Timer 1 en service. 0 = Timer 1
stoppé.

c. Le module TMR2 :
Le module Timer 2 est un compteur 8 bits avec pré-diviseur et post diviseur.
L'entrée du compteur est l'horloge cycle interne : Fosc/4 qui passe à travers un pré-diviseur
programmable par 1, 4 ou 16.
La sortie du compteur passe dans un post diviseur programmable sur 4 bits entre 1 et 16.
Le contrôle du Timer 2 se fait par le registre T2CON :

Au reset : T2CON = 00000000

• bit 7 : bit non implémenté.
• bit 6 à bit 3 : TOUTPS : Programmation du Post diviseur.
- 0 0 0 0 = post divise par 1.
- 0 0 0 1 = post divise par 2.
- 0 0 1 0 = post divise par 3.

41
 - ....
- ....
- 1 1 1 1 = post divise par 16.
• bit 2 : TMR2ON : mise en service du Timer 2.
- 1= Timer 2 : On.
- 0= Timer 2 : Off.
• bit 1 et bit0 : T2CKPS : Programmation du pré diviseur.
- 0 0= pré divise par 1.
- 0 1= pré divise par 4.
- 1 X= pré divise par 16.

3.8 Le module capture comparaison CCP1/CCP2

Il y a deux modules identiques CCP1 et CCP2 composés chacun d'un registre 16 bits. Ils
peuvent opérer soit comme un registre 16 bits de capture, soit comme un registre 16 bits de
comparaison, soit enfin comme un registre 8 bits pour générer du PWM. En mode
COMPARE ou CAPTURE, les modules utilisent le TIMER 1. En mode PWM, ils utilisent le
TIMER 2.
Le module CCP1 est constitué de deux registres de 8 bits : CCPR1L et CCPR1H. Ce module
est contrôlé par le registre CCP1CON.
Le module CCP2 est constitué de deux registres de 8 bits : CCPR2L et CCPR2H. Ce module
est contrôlé par le registre CCP2CON.
Les registres de contrôles CCP1CON et CCP2CON sont identiques. On ne décrira que
CCP1CON.

Au reset : CCP1CON = 00000000

• bit 7 et bit 6 : bits non implémentés.
• bit 5 et bit 4 : CCP1X et CCP1Y : Bits non utilisés en modes Compare et Capture. Ce
sont les 2 bits LSB pour le Duty cycle en mode PWM.
• bit 3 à bit 0 : CCP1M3 à CCP1M0 : bits de sélection du mode.
- 0 0 0 0 = Module CCP stoppé.
- 0 1 0 0 = Mode Capture à chaque front descendant.
- 0 1 0 1 = Mode Capture à chaque front montant.

42
 - 0 1 1 0 = Mode Capture tous les 4 fronts montants.
- 0 1 1 1 = Mode Capture tous les 16 fronts montants.
- 1 0 0 0 = Mode Compare. Pin de sortie mise à "1" et Flag CCP1IF = 1 à l'égalité.
- 1 0 0 1 = Mode Compare. Pin de sortie mise à "0" et Flag CCP1IF = 1 à l'égalité.
- 1 0 1 0 = Mode Compare. Génération d'une Interrup. et Flag CCP1IF = 1 à
l'égalité.
- 1 0 1 1 = Mode Compare. Evénement spécial généré et Flag CCP1IF = 1 à
l'égalité.

- 1 1 x x = Mode PWM.
3.9 Convertisseur analogique numérique CAN

Les PIC16F877 travaille avec un convertisseur analogique/numérique qui permet de

transformez une valeur analogique (qui peut donc prendre une infinité de valeur) en une
valeur numérique (qui contient un nombre fini d’éléments) sur 10 bits. Le signal numérique
peut donc prendre 1024 valeurs possibles. Les PIC considèrent par défaut que la valeur
minimale qui peut prendre une grandeur correspond à leur Vss d’alimentation, tandis que la
valeur maximale correspond à la tension positive d’alimentation Vdd. Le PIC16F877 contient
huit ports pour la conversion analogique numérique : Les 5 premières entrées sont sur le Port
A en RA0, RA1, RA2, RA3 et RA5 et les autres 3 entrées sont en RE0, RE1 et RE2. Le
registre qui gère les interruptions est le registre INTCON qui est un registre de 8 bits. Le CAN
du PIC16F877 est géré par 4 registres :

- ADRESH et ADRESL : des registres de données contenant le résultat de la

conversion,
- ADCON0 et ADCON1 : des registres de contrôles permettant de lancer et de surveiller
la conversion.
a. ADCON0

Au reset : ADCON0 = 00000000

• Bit 7 et bit 6 : ADSC1 et ADSC0 = Clock Select bits. Ces 2 bits permettent de
choisir la vitesse de conversion :
00= Fosc/2.

43
01= Fosc/8.
10= Fosc/32.
11= Oscillateur RC interne.
Le temps de conversion d'un bit est TAD. Pour une conversion totale des 10 bits il faut :
[Link].

Pour que la conversion soit correcte il faut que TAD soit au minimum de 1,6µs. Avec
l'oscillateur interne RC on a : TAD = 4 µs typique (entre 2 et 6 µs).

Figure.5 Temps de conversion TAD en fonction du Quartz et des bits du Clock select

• Bit 5 bit4 et bit 3 : CHS2 CHS1 et CHS0 = Channel Select bits.

Ces 3 bits permettent de choisir l'entrée qui va être convertie.

• Bit 2: GO/DONE: Status bit si ADON=1.

1 = Démarre la conversion A/N. Ce bit est remis à "0" par hard.
0 = La conversion A/N est terminée.
• Bit 1 : Bit non implanté.
• Bit 0 : ADON : A/N on bit.
44
1= Convertisseur A/N en service.
0 = Convertisseur A/N à l'arrêt.
b. ADCON1:

Au reset : ADCON1 = 00000000

• Bit 7: ADFM = A/N Result format.

• Bit 6 bit 5 et bit 4 : Bits non implémentés.
• Bit 3 bit 2 bit 1 et bit 0 : PCFG3 PCFG2 PCFG1 et PCFG0 Bits de contrôle de la
configuration des Ports. Ces bits permettent de choisir le partage entre entrées analogiques et
numérique sur les PORTS A et E. Ils permettent également de choisir pour VREF+ entre VDD
et RA3 et pour et VREF - entre VSS et RA2.

3.10 Interruption
L’interruption est un mécanisme fondamental dans le fonctionnement des microcontrôleurs,
elle permet de prendre en compte des événements extérieurs et de leurs associer un traitement
spécifique. La séquence classique de fonctionnement d’une interruption :

Figure.6 la séquence classique de fonctionnement d’une interruption

Dans le cas du 16F877 les différentes sources d’interruption sont au nombre de 4:

- INT: interruption externe broche RB0/INT
- TMR0: interruption interne fin du comptage
- PORTB: interruption externe changement d’état du PORTB (RB4 à RB7)

45
 - EEPROM: interruption interne fin d’écriture en EEPROM
Le registre qui gère les interruptions est le registre INTCON qui est un registre de 8 bits:

- GIE : permet la validation générale des interruptions

- EEIE: permet la validation de l’interruption d’EEPROM
- TOIE: permet la validation de l’interruption TMR0
- INTE: permet la validation de l’interruption sur la broche RB0/INT
- RBIE: permet la validation de l’interruption RB4 à RB7
- TOIF: bit signal le débordement du TMR0
- INTF: bit signal une transition sur RB0/INT
- RBIF: bit signal un changement d’état de l’une des entrées RB4 à RB7

Les 3 bits de signal doivent être remis à 0 par le programme.

Conclusion
Ce chapitre se veut être une aide à la compréhension de l’architecture et le fonctionnement de
microcontrôleurs. Nous avons donné une attention particulière au microcontrôleur PIC16F877
de micro-Chip. Ce composant intègre un microcontrôleur de 8bits, c.à.d un processeur et des
périphériques, dans un boitier de 40 broches. Il est réalisé en technologie CMOS et peut
cadencer par une horloge allant de 0 à 20 MHZ ; il doit être alimenté par une tension allant de
3 à 5.5Volts.
Cependant, les microcontrôleurs sont en général programmés en C/C++ et nécessitent des
connaissances approfondies en électronique. En revanche, La plate-forme Arduino a apporté
une avancée majeure dans l'accessibilité de cette technologie au plus grand nombre par sa
simplicité d'utilisation et son coût abordable.

46
CHAPITRE IV

Arduino

47
Introduction

L’histoire de l’Arduino a commencé en 2005 avec Massimo Banzi et ses collègues de

l’Interaction Design Institute d’Ivrea, en Italie. L’objectif de l’équipe est de permettre à des
non-spécialistes en informatique et en électronique qui ne veulent pas forcément être des
programmeurs, d’utiliser la programmation pour faire de l’acquisition et traitements de
données à l’aide de capteurs et de commander des systèmes de manière simple. En outre, le
système Arduino donne la possibilité d'allier les performances de la programmation à celles
de l'électronique. Plus précisément, pour programmer des systèmes électroniques. Le gros
avantage de l'électronique programmée c'est qu'elle simplifie grandement les schémas
électroniques et par conséquent, le coût de la réalisation, mais aussi la charge de travail à la
conception d'une carte électronique.

1. Système Arduino
1.1 Définition d’un système Arduino
Arduino est un circuit imprimé en matériel libre (dont les plans de la carte elle-même sont
publiés en licence libre mais dont certains composants sur la carte, comme le microcontrôleur
par exemple, ne sont pas en licence libre) sur lequel se trouve un microcontrôleur qui peut être
programmé pour analyser et produire des signaux électriques, de manière à effectuer des
tâches très diverses comme la domotique (le contrôle des appareils domestiques – éclairage,
chauffage…), le pilotage d’un robot, etc. Le système Arduino est composé de deux choses
principales : le matériel et le logiciel.

 Le matériel : Il s'agit d'une carte électronique basée autour d'un

microcontrôleur dont le prix est relativement bas pour l'étendue possible des applications.
 Le logiciel : il permet de programmer la carte Arduino. Il offre une multitude
de fonctionnalités.
Le système Arduino est en open source sous licence libre. C’est à dire que n’importe qui a le
droit de prendre un arduino, le modifier, et le revendre avec de nouveaux ajouts (seule
obligation, elles ne doivent plus porter le nom d’arduino). De cela découle une multitude de
cartes nommées Duinomite, Netduino, Iteaduino… ne pensez pas que c’est de la contrefaçon,
c’est simplement des sociétés ayant modifiées les cartes de base. Il en est de même pour le
logiciel de programmation qui lui aussi en open source.

1.2 Les différentes cartes Arduino

48
Arduino n’est pas en soi un type de carte ou un microcontrôleur spécifique. Arduino désigne
plutôt toute une famille. Dans le marché, on peut trouver différentes type de carte mais il faut
choisir celle qui convient à votre projet.

 La carte Arduino UNO : C’est la carte idéale pour découvrir l’environnement

ARDUINO. Elle permet à tout débutant de se lancer dans tous ses premiers petits projets.
Comme c’est la carte la plus utilisée, il est très facile de se référer aux tutoriels très nombreux
sur le net et ainsi de ne pas rester seul dans son exploration. Sa simplicité devient par contre
un handicap lorsqu’il s’agit de multiplier les périphériques, de manipuler des algorithmes
lourds ou d’interagie avec les OS Androïd pour lesquels d’autres cartes arduino sont plus
adaptées.
 La carte Arduino Lenardo : C’est la carte qui est prévue pour succéder à la
carte Arduino Uno en présentant des caractéristiques équivalentes mais une ergonomie revue
et une stabilité plus éprouvée. Sa diffusion moins importante limite le support utilisateur
disponible sur le net.
 La carte Arduino Mega: La carte Arduino Mega est la carte la plus diffusée
après la carte Arduino Uno. Elle offre un nombre d’entrées/sorties beaucoup plus important
(54 contre 14), un processeur plus puissant doté d’une mémoire plus vaste qui permet
d’exploiter des algorithmes plus complexes.
 La carte Arduino Due: La carte Arduino Due est une évolution de la carte
Arduino Mega et offre des performances réputées 3 fois supérieures. Elle permet de
manipuler rapidement des algorithmes lourds particulièrement utiles dans le monde de la
robotique par exemple.
 La carte Arduino Nano : La carte Arduino nano n’est ni plus ni moins qu’une
carte Arduino uno miniaturisée. Sa taille et son poids réduits la destinent à une utilisation dans
des espaces réduits (en textile par exemple) ou dans des applications de robotique ou de
modélisme pour lesquels le poids et la taille sont des facteurs déterminant (hélicoptères,
drônes…)
 La carte Arduino Mini Pro : La carte arduino Mini Pro est une carte Arduino
Uno simplifiée à l’extrême permettant néanmoins de piloter de petits projets ou certains
éléments d’un projet. Attention, cette carte n’intègre pas de port USB ce qui rends sa
connectivité délicate.
 La carte Arduino Yun: La carte Arduino Yun, récemment proposée par
Arduino, est conçue pour contrer les avantages de la carte Raspberry. Elle est un dérivé de la

49
carte Leonardo et a pour objectif de combiner la puissance de Linux avec la facilité
d’utilisation d’une carte Arduino. Elle est également la première carte Arduino à être dotée
nativement d’un wifi intégré.

Figure.1 les différentes cartes Arduino

Pour ce cours, nous nous baserons sur le plus connu: l'Arduino Uno

2. Carte Arduino UNO

2.1 Constituants de la carte UNO

L’Arduino Uno est basée sur un ATMega328 cadencé à 16 MHz et il dispose de 14

entrées/sorties numériques, 6 entrées analogiques, une mémoire flash de 32 KB, un de SRAM
2 KB, un EPPROM de 1 KB et d’autres caractéristiques techniques suffisantes pour bien
commencer dans la programmation.

50
 Figure 2. Constituants de la carte arduino UNO

a. Microcontrôleur

Le microcontrôleur C’est le cerveau de notre carte. Il va recevoir le programme que nous

allons créer et va le stocker dans sa mémoire avant de l’exécuter. Grâce à ce programme, il va
savoir faire des choses, qui peuvent être : faire clignoter une LED, afficher des caractères sur
un écran, envoyer des données à un ordinateur, mettre en route ou arrêter un moteur… Il
existe deux modèles d’Arduino Uno: l’un avec un microcontrôleur de grande taille, et un autre
avec un microcontrôleur dit SMD (SMD: Surface Mounted Device, soit composants montés
en surface, en opposition aux composants qui traversent la carte électronique et qui sont
soudés du côté opposé). D’un point de vue utilisation, il n’y a pas de différence entre les deux
types de microcontrôleurs.

Figure.3 (a) carte arduino UNO avec un microcontrôleur de grande taille (b) carte arduino UNO SMD

51
Lorsqu'on observe une carte Arduino Uno sous rayons X, on constate que la grande puce
contient en réalité un microcontrôleur SMD. Noter aussi les pistes qui relient les broches au
microcontrôleur:

Figure.4 carte arduino UNO observé sous rayons X

b. Alimentation
Pour fonctionner, une carte Arduino UNO a besoin d'une alimentation. Le microcontrôleur
fonctionnant sous 5V, la carte peut être alimentée en 5V par le port USB ou bien par une
alimentation externe qui est comprise entre 7V et 12V. Un régulateur se charge ensuite de
réduire la tension à 5V pour le bon fonctionnement de la carte.

c. Tension de références
La carte arduino fournit des ports permettant d’accéder à certaines tensions de référence.
GND est la référence de la carte arduino par rapport à laquelle toutes les différences de
tension sont mesurées. Si la carte est reliée à l’ordinateur par un câble USB, cette tension est
celle de la terre.

Les ports 5V et 3V3 donnent accès aux tensions de 5 V et de 3.3 V. Ces tensions sont
normalement régulées et précises. Une exception : quand la carte est branchée sur un port
USB sans alimentation externe, le port 5 V ne provient plus de la carte arduino mais
directement du câble USB, la tension de référence 5 V n’est alors plus aussi bien régulée.

Figure.5 Tensions de références de la carte arduino UNO

VIN est la tension de l’alimentation externe, quand il y en a une.

52
Attention : si vous reliez directement le port 5 V au port GND (ou le port 3V3 au port GND,
ou le port 5V au port 3V3), vous provoquerez un court-circuit qui endommagera la carte !

d. Entrées/Sorties Numérique
La carte "ARDUINO Uno" dispose de 14 broches ("pin" en anglais, numérotées de 0 à 13) qui
peuvent être configurées en "entrées digitales" ou en "sorties digitales" susceptibles de
délivrer une intensité maximale de 40 mA sous une tension égale à 0V ou 5V. Les deux
premiers ports sont réservés à la communication série, il ne faut pas les utiliser. Le dernier
port, port 13, possède un indicateur lumineux, une LED qui s’allume quand le port est HIGH,
et qui s’éteint quand le port est LOW.

Figure.6 entrées/sorties numérique de la carte arduino UNO

e. Entrées/Sorties Analogique
Une entrée analogique est une sorte de voltmètre : la carte lit la tension qui est appliquée sur
le port. Cependant le microcontrôleur ne travaille qu’avec des chiffres : il faut donc
transformer la tension appliquée en sa valeur numérique. C’est le travail du convertisseur
analogue/numérique, dit « CAN ».

Figure.7 entrées analogiques d’une carte Arduino UNO

Le CAN de la carte arduino travaille sur 10 bits : il accepte en entrée une tension comprise
entre 0V et Vref une tension de référence, et fournit au microcontrôleur un chiffre entier
compris entre 0 et 1023 (=210-1). Une tension inférieure à 0V est lue comme 0, une tension
supérieure à Vref est lue comme 1023, une tension intermédiaire est lue comme un entier entre
0 et 1023, avec une relation linéaire. La tension Vref est 5 V par défaut, mais cette valeur peut
être changée dans le programme.

La carte arduino ne possède pas de vraie sortie analogique, capable de produire une tension
d’une valeur arbitraire choisie par l’utilisateur. Certains ports numériques peuvent cependant
servir de sortie analogique en utilisant la technique de PWM (Pulse Width Modulation) : il

53
s’agit des ports 3, 5, 6, 9, 10 et 11 (signalés par un ~ sur la carte). Ces ports peuvent simuler
une tension entre 0 et 5V en basculant rapidement entre leur état LOW (0V) et HIGH (5V).
La valeur moyenne de la tension est alors 2.5V si le port passe autant de temps dans un état
que dans l’autre, mais en changeant ce rapport, la valeur moyenne de la tension peut être
contrôlée de 0 à 5V.

Figure.8 Sorties PWM d’une carte Arduino UNO

La carte arduino est capable de faire varier la valeur moyenne de ces ports avec une sensibilité
de 8 bits : on fournit un chiffre entier compris entre 0 et 255 (=28-1), et le port délivre une
tension moyenne entre 0 et 5 V (0=0V, 255=5V).

f. Port USB
Le port USB permet à la fois l’alimentation de la carte Arduino et la communication série
entre la carte et l’ordinateur. Une fois connectée, la carte Arduino apparaît dans le
gestionnaire de matériel de votre ordinateur, connecté à un port série (COM1, COM4, …).
Vous devez vérifier que l’IDE (le programme fourni par Arduino) est bien configuré pour
dialoguer sur le bon port COM (et pour le bon type de carte Arduino !).

2.2 Le logiciel Arduino

Le logiciel Arduino IDE est un environnement de développement intégré fonctionnant sur
divers systèmes d’exploitation (Windows, Mac OS, Gnu/Linux) et permette de programmer
dans un langage s’apparentant à du C/C++, bien plus commun que l’assembleur. L’IDE
Arduino permet :
 d’éditer un programme : des croquis (sketch en Anglais),
 de compiler ce programme dans le langage « machine » de l’Arduino,
 de téléverser le programme dans la mémoire de l’Arduino,
 de communiquer avec la carte Arduino grâce au terminal

54
 Figure.9 l’interface du logiciel Arduino

Cependant, le projet Arduino a développé des fonctions spécifiques à l'utilisation de la carte

qui ont été listées ci-dessous :
Structure Constants Functions
• setup() • HIGH, LOW E/S numérique
• loop() • INPUT, OUTPUT, INPUT_PULLUP • pinMode()
• LED_BUILTIN • digitalWrite()
• digitalRead()

E/S analogique
• analogReference()
• analogRead()
• analogWrite() - PWM

E/S avancée
• tone()
• noTone()
• shiftOut()
• shiftIn()
• pulseIn()

Temps
• millis()
• micros()
• delay()

55
 • delayMicroseconds()

Bits et octets
• lowByte()
• highByte()
• bitRead()
• bitWrite()
• bitSet()
• bitClear()
• bit()

Interruptions externes
• attachInterrupt()
• detachInterrupt()

Interruptions
• interrupts()
• noInterrupts()

Communication
• Serial
• Stream

Conclusion
Maintenant vous devriez avoir une idée un peu plus précise de ce qu’est (et ce que n’est pas)
un arduino, alors pour résumer:
 Un arduino n’est pas un petit PC.
 Ses domaines de prédilections sont les systèmes embarqués.
 C’est un microcontrôleur simplifié.
 L’idéal pour commencer est l’arduino UNO.
 Il est possible d’ajouter des cartes offrant des options ou connectiques
supplémentaires à votre arduino (appelé Shield).
 Ce projet est open source et sous licence libre, il y a donc des cartes
ressemblant aux arduino (et ayant souvent « duino » dans leurs noms) mais vendu sous une
autre dénomination. Ce ne sont pas des contrefaçons.

56
Bibliographie

- K1wy, « Représentation de l'information sur un ordinateur », 2010.

- Mazoughou GOEPOGUI, « Circuits programmables et microprocesseurs », 2014

- Christian Tavernier , « Microcontroleur PIC C », 3ème Edition DUNOD.

- J.-C. Bajard et J.-M. Muller, « Calcul et arithmétique des ordinateurs ». 2004.

- Patrick Cohen, « Le microprocesseur Pentium : Architecture et programmation »,1998

- Henri LILEN, « Microprocesseurs du CISC au RISC », 1998.

- Erik Bartmann, « Le grand livre d'Arduino », 2018.

- [Link]

- [Link]

57