Microcontroleurs GAM 2023 2024

Université de Douala | Ecole Nationale Supérieure Polytechnique de Douala |
DépaM Niveau 3 | Ingénieur | Génie Automobile et Mécatronique (GAM)

Microcontrôleurs | Année académique 2023 - 2024
Support de Cours de Microcontrôleurs et

programmation
Génie automobile et mécatronique
Niveau : 3
Année Académique 2023/2024
Par
Arnaud NANFAK
PhD in Electrical Energy, Robotic and Signal Processing
nanfak.arnaud@yahoo.fr
695 262 380 / 678 289 787 / 620 150 808
NB: Le support de cours ne remplace pas le cours
i
CHAPITRE 1 : ....................................................................................................................................... 1
RAPPEL SUR LES MICROPROCESSEURS ...................................................................................... 1
Introduction ........................................................................................................................................ 1
I. Architecture interne des microprocesseurs ..................................................................................... 1
I.1. L’unité de commande .......................................................................................................... 2
I.2. L’unité de traitement ........................................................................................................... 2
I.3. Les registres ......................................................................................................................... 5
I.4. Les autres unités des microprocesseurs ............................................................................... 6
II. Les étapes d’exécution d’une instruction ...................................................................................... 7
II.1. Définition ............................................................................................................................... 7
II.2. Les différents types d’instructions ......................................................................................... 8
II.3. Les étapes de traitement ......................................................................................................... 9
III. Les modes d’adressages ............................................................................................................... 9
III.1. Le mode d’adressage implicite ou inhérent ........................................................................ 10
III.2. Le mode d’adressage immédiat .......................................................................................... 10
III.3. Le mode d’adressage direct ................................................................................................ 10
III.4. Le mode d’adressage indirect ............................................................................................. 10
IV. Les types de microprocesseurs .................................................................................................. 11
V. Les performances d’un microprocesseur .................................................................................... 12
VI. Les familles de microprocesseurs .............................................................................................. 12
CHAPITRE 2 : MICROCONTROLEUR ............................................................................................ 14
Introduction ...................................................................................................................................... 14
I. Architecture des microcontrôleurs................................................................................................ 14
I.1. Architecture de Von Neumann .............................................................................................. 14
I.2. Architecture de Harvard ........................................................................................................ 15
II. Les éléments de base des microcontrôleurs ................................................................................ 17
ii
II.1. L’horloge : ............................................................................................................................ 18
II.2. Mémoires .............................................................................................................................. 18
II.3. Interfaces parallèles .............................................................................................................. 21
II.4. Interfaces série...................................................................................................................... 21
II.5. Convertisseur analogique-numérique ................................................................................... 21
II.6. Convertisseur numérique-analogique ................................................................................... 21
II.7. Timers/Compteurs ................................................................................................................ 21
II.8. Chien de garde (watchdog) .................................................................................................. 21
II.9. Bus ........................................................................................................................................ 22
III. Langage de programmation ....................................................................................................... 23
III.1. Les langages de Haut niveau, bas niveau et machine ......................................................... 23
III.2. Compilation et interprétation .............................................................................................. 24
III.3. Mise au point d’un programme ........................................................................................... 25
CHAPITRE 3 : CAS PRATIQUE D’ETUDE : MICROCONTROLEUR ARDUINO UNO ............... 1
Introduction ........................................................................................................................................ 1
I. Schéma simplifié de la carte Arduino UNO ................................................................................... 1
II. Microcontrôleur ATMEL ATMEGA328 ...................................................................................... 2
III. Les entrées/sorties de l’arduino UNO .......................................................................................... 3
III.1. Les entrées/sorties numériques ............................................................................................. 4
III.2. Les entrées analogiques ........................................................................................................ 5
III.3. Les sorties analogiques ......................................................................................................... 5
III.4. Les tensions de références .................................................................................................... 5
III.5. Le port USB .......................................................................................................................... 6
IV. Transférer un programme dans la carte ....................................................................................... 6
IV.1. Description de l’interface Arduino software ........................................................................ 7
IV.2. Description de la structure d’un programme ........................................................................ 8
TRAVAUX PRATIQUES ................................................................................................................... 10
iii
Manipulation N° 1 : Le chenillard à LED ........................................................................................ 11
Manipulation N°2 : Arduino et afficheur LCD ................................................................................ 14
Manipulation N°3 : Arduino et Capteurs de température ................................................................ 17
Manipulation N° 4 : Arduino - Capteur à ultrasons HC-SR04 ........................................................ 21
Manipulation N° 5 : Émission de données (RTC)/Réception et affichage des données .................. 24
Manipulation N° 6 : Arduino et carte SD ........................................................................................ 27
Manipulation N° 7 : Enregistrement des données des stations météorologiques ............................ 30
Manipulation N° 8 : Commande à distance des LEDs par télécommande infrarouge .................... 33
Manipulation N° 9 : Message défilant sur afficheur matriciel 8x8 .................................................. 36
Manipulation N° 10 : Affichage matriciel P10 commandé par bluetooth ......................................... 1
ANCIENS SUJETS AVEC CORRECTIONS ....................................................................................... 4
iv
Liste des figures
Figure 1. 1 : Architecture interne d’un microprocesseur .................................................................................... 1

Figure 1.2 : Architecture interne de l’unité de commande ................................................................................. 3
Figure 1.3 : Structure de l’UAL ............................................................................................................................... 4
Figure 1.4 : Architecture interne de l’unité de traitement ................................................................................... 4
Figure 1.5 : Les étapes d’exécution d’une instruction.......................................................................................... 9
Figure 2.1 : Architecture Von Neumann............................................................................................................. 15
Figure 2.2 : Architecture Harvard ........................................................................................................................ 16
Figure 2.3 : Le Pipeline d’instructions ................................................................................................................. 17
Figure 2.4 : L’horloge ............................................................................................................................................. 18
Figure 2.5 : Schéma fonctionnel d’un microcontrôleur .................................................................................... 23
Figure 3.1 : Schéma simplifié de la carte arduino UNO ..................................................................................... 1
Figure 3.2 : Vue de dessus de la carte arduino UNO .......................................................................................... 2
Figure 3.3 : Arduino UNO et UNO SMD............................................................................................................ 2
Figure 3.4 : Les différentes parties de la UNO..................................................................................................... 6
Figure 3.5 : Interface arduino software.................................................................................................................. 8
Figure 3.6 : Exemple de programme arduino ....................................................................................................... 9
v
CHAPITRE 1 :
RAPPEL SUR LES MICROPROCESSEURS
Introduction
Un microprocesseur est un circuit intégré complexe caractérisé par une très grande intégration et
doté des facultés d'interprétation et d'exécution des instructions d'un programme. Il est chargé d’organiser
les tâches précisées par le programme et d’assurer leur exécution. A l’heure actuelle, un microprocesseur
regroupe sur quelques millimètres carrés des fonctionnalités toujours plus complexes les unes que les
autres. Leur puissance continue de s’accroître et leur encombrement diminue régulièrement respectant
toujours, pour le moment, la fameuse loi de Moore.
I. Architecture interne des microprocesseurs
Un microprocesseur est construit autour de deux éléments principaux :
▪ Une unité de commande

▪ Une unité de traitement
Ces deux éléments sont associés à des registres chargées de stocker les différentes informations à traiter.
Ces trois éléments sont reliés entre eux par des bus interne permettant les échanges d’informations.
Programme
Unité de Unité de
traitement commande
Données
Figure 1. 1 : Architecture interne d’un microprocesseur
Arnaud NANFAK 1
Ph.D. in Electrical Energy, Robotic & Signal processing
Bus d’adresse
Bus de données
I.1. L’unité de commande
Elle permet de séquencer le déroulement des instructions. Elle effectue la recherche en mémoire
de l'instruction, le décodage de l’instruction codée sous forme binaire. Enfin elle pilote l’exécution de
l’instruction. Pour cela, elle est composée par :
▪ L’horloge : Il génère les signaux qui permettent le cadencement et la synchronisation de toutes

les opérations.
▪ Le compteur de programme (PC : Program Counter) appelé aussi Compteur Ordinal
(CO). Il est constitué par un registre dont le contenu est initialisé avec l'adresse de la première
instruction du programme. Il contient toujours l’adresse de la
prochaine instruction à exécuter. Le compteur programme est incrémenté chaque fois qu'une
instruction est chargée dans le microprocesseur.
▪ Le registre d'instruction et le décodeur d'instruction : Chacune des instructions à exécuter est
transférées depuis la mémoire dans le registre instruction puis est décodée par le décodeur
d’instruction.
▪ 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. Il s'agit d'un automate réalisé de façon micro-programmée, on parle alors de micro-
microprocesseur. Le séquenceur est réalisé avec une structure qui comprend une mémoire ROM
intégrée. Celle-ci contient des micro-instructions (à ne pas confondre avec les instructions
contenues dans la mémoire programme). La mémoire des micro-instructions n’est pas accessible
à l’utilisateur. Chacune des instructions du microprocesseur nécessite plusieurs micro-instructions
et donc plusieurs cycles d’horloge.
I.2. L’unité de traitement
C’est le cœur du microprocesseur. Elle regroupe les circuits qui assurent les traitements nécessaires
à l'exécution des instructions. Il est constitué de :
▪ Les accumulateurs sont des registres de travail qui servent à stocker une opérande au début d'une
opération arithmétique et le résultat à la fin de l'opération.
Arnaud NANFAK 2
Registre d’adresse
PC
Séquenceur
Registre Décodeur
d’instruction d’instruction
Figure 1.2 : Architecture interne de l’unité de commande

▪ L’Unité Arithmétique et Logique (UAL) est un circuit complexe qui assure les fonctions
logiques (ET, OU, Comparaison, Décalage, etc…) ou arithmétique (Addition, soustraction…). Les
données à traiter se présentent aux entrées de l’UAL, sont traités, puis le résultat est fourni en
sortie et généralement stocké dans l’accumulateur.
▪ Le registre d'état 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. Dans un programme le résultat du test de leur
état conditionne souvent le déroulement de la suite du programme. On peut citer par exemple les
indicateurs de :
• Retenue (Carry : C)
• Débordement (Overflow : O ou OV)
• Zéro (Zero : Z)
• Signe (Sign : S)
• Parité (parity : P)
• Soustraction (xxxx : N)
Arnaud NANFAK 3
Figure 1.3 : Structure de l’UAL
Figure 1.4 : Architecture interne de l’unité de traitement

Remarque : En plus des éléments mentionnés ci-dessus, nous rencontrons les éléments suivants :
▪ Unité de calcul en virgule flottante : C’est une unité qui est capable de réaliser les opérations de
calcul pour les réels ainsi que les calculs mathématiques et scientifiques complexes. A l’origine, la
tâche de cette unité était réalisée par tout un processeur à part, en 1989 elle a été intégré dans les
microprocesseurs afin d’optimiser les calculs.
▪ Unité multimédia : C’est une unité qui est chargée d’accélérer l’exécution des programmes
multimédia comportant des vidéos, du son, graphisme en 3D etc.…
Arnaud NANFAK 4
I.3. Les registres
Un registre est une zone mémoire à l’intérieur du microprocesseur de faible taille, qui permet de
mémoriser des mots mémoires ou des adresses d’une façon temporaire lors de l’exécution des instructions.
La structure des registres du CPU varie considérablement d’un constructeur à l’autre. Cependant les
fonctions de base réalisées par les différents registres sont essentiellement les mêmes. On peut citer :
▪ Les registres généraux : Ce sont des mémoires rapides, à l'intérieur du microprocesseur, qui
permettent à l'unité d'exécution de manipuler des données à vitesse élevée. Ils sont connectés au
bus de données interne au microprocesseur. L'adresse d'un registre est associée à son nom (on
donne généralement comme nom une lettre) A,B,C... Ces registres permettent de sauvegarder des
informations utilisées dans les programmes ou des résultats intermédiaires, cela évite des accès à
la mémoire, accélérant ainsi l’exécution des programmes.
▪ Le compteur ordinal : c’est un registre d’adresse. À chaque instant il contient l’adresse de la
prochaine instruction à exécuter. Lors de l’exécution d’une instruction il est prévu, au cours de
cette exécution, la modification du contenu du CO. Ainsi en fin d’exécution de
l’instruction courante le compteur ordinal pointe sur la prochaine instruction à exécuter
et le programme machine peut continuer à se dérouler.
Remarque : La valeur initiale du compteur est fixée par le constructeur du microprocesseur. Elle vaut une
valeur bien définie à chaque mise sous tension ou bien lors d’une remise à zéro (reset).
▪ Le registre d’instruction : c’est un registre de données. Il contient l’instruction en cours

d’exécution et demeure dans ce registre pendant toute la durée de son exécution. Cette instruction
est recherchée en mémoire puis placée dans ce registre pour être décodée par le décodeur et
préparée pour l’exécution.
▪ Le registre d’adresse MAR (Memory address register) : C’est un registre qui contient l’adresse
du mot à accéder en mémoire centrale. Il est connecté au bus d’adresses et permet la sélection d’un
mot mémoire via le circuit de sélection. L’adresse contenue dans le registre MAR est placée sur le
bus d’adresses et devient la valeur d’entrée du circuit de sélection de la mémoire centrale qui va à
partir de cette entrée sélectionner le mot mémoire correspondant. Toute adresse (de donnée ou
d’instruction) doit passer par le MAR, puisqu’il est le seul registre qui gère le bus d’adresse de la
mémoire.
▪ Le registre de données MDR (Memory data register) : Contient le mot mémoire faisant objet
d’une opération de lecture ou d’écriture dans la mémoire centrale. Toute information (donnée ou
Arnaud NANFAK 5
instruction), provenant de, ou allant vers la mémoire doit passer par le MDR, puisque c’est le seul
registre connecté au bus de données de la mémoire.
▪ Le registre accumulateur : C’est un registre de travail très important de l’UAL, dans la plus part
des opérations arithmétiques et logiques, l’accumulateur contient un des opérandes avant
l’exécution et le résultat après. Il peut aussi servir de registre tampon dans les opérations
d’entrée/sortie. Généralement, l’accumulateur a la même taille qu’un mot mémoire.
▪ Le registre d’état: (PSW program status word) : C’est un registre qui contient les différents bits
appelés drapeaux (Flags) indiquant l’état d’une condition particulière dans le CPU. Ces bits peuvent
être testés par un programme et donc décider des suites d’actions à prendre.
▪ Le pointeur de pile (SP) est un registre présent sur les microprocesseurs qui possède une pile. Il
permet de stocker l’adresse du sommet de la pile. Une pile est une partie de la mémoire, elle permet
de stocker des informations (le contenu des registres) relatives au traitement des interruptions et
des sous-programmes. La pile est gérée en LIFO : (Last In First Out) dernier entré premier sorti.
Le fonctionnement est identique à une pile d’assiette. Le pointeur de pile est décrémenté avant
chaque empilement (instruction PUSH) et incrémenté après chaque dépilement (instruction POP).
Remarque : Le processus de lecture et d’écriture en mémoire s’effectue de la façon suivante :
▪ La lecture : L’adresse du mot à lire est transférée au registre d’adresse, le dispositif d’accès à la
mémoire se charge de chercher le mot et de le mettre dans le registre de données.
▪ L’écriture : Le registre d’adresse est chargé par l’adresse mémoire ou on va écrire, le mot à écrire
est placé dans le registre de données. Lorsque l’ordre de l’écriture est donné, le contenu des cases
mémoires sera écrasé et remplacé par la nouvelle valeur.
I.4. Les autres unités des microprocesseurs
On peut citer entre autres :
▪ Unité de mémoire cache : La mémoire cache a pour fonction principale d’optimiser les accès
aux différentes instructions et données que le microprocesseur a besoin lors de l’exécution des
programmes. La tâche de cette unité est de mettre dans la mémoire cache qui est beaucoup plus
rapide d’accès que la mémoire centrale, les informations les plus utilisées et que le microprocesseur
a besoin fréquemment. L’accès aux informations sera donc plus rapide et l’exécution des
programmes optimale.
▪ Unité d’interface de bus : Gère les échanges à travers le bus entre le microprocesseur et les autres
composantes, si le microprocesseur a besoin par exemple d’une donnée en mémoire vive, l’unité
Arnaud NANFAK 6
d’interface de bus se charge de la ramener en contrôlant l’accès mémoire et en mettant le résultat

sur le bus de données qui va l’acheminer vers le registre de données.
▪ Unité de décodage : Elle décompose et analyse l’instruction se trouvant dans le registre
d’instructions, selon le code opération, elle envoie la nature des opérations à effectuer à l’unité de
commande et précisément le séquenceur qui va ensuite générer les microcommandes nécessaires
aux différents composants participant à l’exécution de l’instruction en cours.
▪ Unité d’anticipation et la queue (ou file d’attente) : L’unité d’anticipation a pour rôle d'aller
chercher en mémoire les instructions à exécuter. Ces instructions sont d'abord recherchées dans
la mémoire cache interne du processeur. Si elles ne s'y trouvent pas, l'unité d'anticipation s'adresse
à l'unité d'interface de bus afin qu'elles soient lues dans la mémoire centrale. Lors de cette
opération, le contenu des adresses suivantes de la mémoire est lu également et placé dans la
mémoire cache du processeur. De cette façon, les prochaines instructions recherchées seront
disponibles plus rapidement. L'unité d'anticipation place l'instruction dans une queue et s'occupe
d'aller chercher la suivante. Grâce à ce dispositif, l'unité d'exécution n'a pratiquement jamais à
attendre que les instructions à exécuter lui soient amenées.
Figure 1.5 : Structure simplifiée d’un microprocesseur
II. Les étapes d’exécution d’une instruction

II.1. Définition
Arnaud NANFAK 7
Une instruction est une opération élémentaire d’un langage de programmation, c’est à dire le plus
petit ordre que peut comprendre un ordinateur. Ainsi, une instruction machine est une chaîne binaire
composée essentiellement de deux parties :
▪ Zone opération : Cette zone permet de déterminer la nature de l’opération à effectuer par le
microprocesseur (addition, ou logique, lecture en mémoire) ;
▪ Zone adresse : Cette zone contient les adresses en mémoire des opérandes qui participent dans
une opération, dans certains cas elle contient l’opérande même.
II.2. Les différents types d’instructions
Les instructions du langage machine peuvent être rangées selon six catégories :
▪ les instructions arithmétiques et logiques : ce sont les instructions qui permettent de réaliser
les calculs entre nombres (addition, soustraction, multiplication…) et les opérations logiques (ou,
et, ou exclusif…). Elles mettent en jeu les circuits de l’UAL.
▪ les instructions de transfert de données : ce sont les instructions qui permettent de transférer
une donnée depuis les registres du processeur vers la mémoire centrale et vice versa ainsi qu’entre
registres du processeur.
▪ les instructions d’entrées-sorties : ce sont les instructions qui permettent au processeur de lire
une donnée depuis un périphérique (par exemple le clavier) ou d’écrire une donnée vers un
périphérique (par exemple l’imprimante);
▪ les instructions de rupture de séquence d’exécution encore appelées instructions de saut
ou de branchement : ce sont des instructions qui permettent de rompre l’exécution séquentielle
des instructions d’un programme. L’instruction exécutée à la suite d’un saut n’est pas celle qui suit
immédiatement l’instruction de saut, mais celle dont l’adresse a été spécifiée dans l’instruction de
saut. On distingue ici deux types d’instructions de sauts. Les instructions de sauts inconditionnels
effectuent toujours le débranchement de l’exécution à l’adresse spécifiée. Les instructions de sauts
conditionnels effectuent ce débranchement si et seulement si une condition liée aux indicateurs du
registre d’état de l’UAL est vérifiée.
▪ les instructions d’appels de sous-programmes (CALL, RET) qui permettent de modifier la
valeur courante du compteur ordinal CO pour aller exécuter une suite d’instructions machine
constituant une fonction (c’est l’objet de l’instruction CALL qui effectue l’appel de sous-
programme) puis de revenir exécuter les instructions machine situées juste après l’appel
(instruction RET);
▪ les instructions particulières permettant par exemple d’arrêter le processeur (HALT)
ou encore de masquer/démasquer les interruptions (DI/EI).
Arnaud NANFAK 8
II.3. Les étapes de traitement
Le microprocesseur ne comprend qu’un certain nombre d’instructions qui sont codées en binaire.
Le traitement d’une instruction peut être décomposé en trois phases.
Phase 1: Recherche de l'instruction à traiter
▪ Le PC contient l'adresse de l'instruction suivante du programme. Cette valeur est placée sur le bus
d'adresses par l'unité de commande qui émet un ordre de lecture.
▪ Au bout d'un certain temps (temps d'accès à la mémoire), le contenu de la case mémoire
sélectionnée est disponible sur le bus des données.
▪ L'instruction est stockée dans le registre instruction du processeur.
Phase 2 : Décodage de l’instruction et recherche de l'opérande
Le registre d'instruction contient maintenant le premier mot de l'instruction qui peut être codée sur
plusieurs mots. Ce premier mot contient le code opératoire qui définit la nature de l'opération à effectuer
(addition, rotation,...) et le nombre de mots de l'instruction.
▪ L'unité de commande transforme l'instruction en une suite de commandes élémentaires nécessaires

au traitement de l'instruction.
▪ Si l'instruction nécessite une donnée en provenance de la mémoire, l'unité de commande récupère
sa valeur sur le bus de données.
▪ L’opérande est stocké dans un registre.
Phase 3 : Exécution de l'instruction
▪ Le micro-programme réalisant l'instruction est exécuté.

▪ Les drapeaux sont positionnés (registre d'état).
▪ L'unité de commande positionne le PC pour l'instruction suivante.
Figure 1.5 : Les étapes d’exécution d’une instruction

III. Les modes d’adressages
Arnaud NANFAK 9
On appelle « mode d’adressage » la manière de définir la localisation d’un opérande. Selon le mode
d’adressage la taille de l’instruction peut varier de 1 à 4 octets.
III.1. Le mode d’adressage implicite ou inhérent
Le mode d’adressage implicite correspond à une instruction ne comportant pas d’opérande.

L’instruction est composée du code opération uniquement et sa taille peut varier entre 1 et 2 octet selon
l’opération. Ce type d’instruction porte généralement sur des registres.
III.2. Le mode d’adressage immédiat
On parle de mode d’adressage immédiat lorsque le champ opérande contient une donnée. Ce type
d’instruction met en jeu un registre et une valeur (qu’il s’agisse d’une affectation, une addition, une
soustraction ou bien même une comparaison). On obtient l’opérande sans avoir à faire un accès
supplémentaire à la mémoire puisque ce dernier fait partie intégrante de l’instruction, d’où le qualificatif
immédiat. La taille de l’opérande dépendra donc du type de registre mis en jeu (1 octet pour un registre de
8 bits, 2 pour un registre de 16 bits).
Code opération Opérande

Exemple : ADD A, #127 (A = A + 127)
III.3. Le mode d’adressage direct
L’adressage direct est sans doute le mode d’adressage le plus souvent utilisé et est très simple. Dans
ce mode, le champ opérande d’une instruction contient l’adresse effective d’une donnée en mémoire. Une
adresse étant codée sur 16 bits, la taille du champ opérande est donc de 2 octets. Il peut s’agir par exemple
de l’affectation à un registre d’une donnée contenue dans une case mémoire. Ce code d’adressage provoque
un temps d’exécution de l’instruction plus long car l’accès à la mémoire principale est plus long que l’accès
à un registre.
Code opération Adresse opérande ………….
Opérande
………….
Exemple : ADD A, 7FH (A = A + contenu de l’adresse 7F)
III.4. Le mode d’adressage indirect
Arnaud NANFAK 10
Le mode d’adressage indirect permet d’accéder à une donnée par l’intermédiaire d’un registre qui
contient son adresse ou l’adresse d’une position mémoire qui, elle, contient l’adresse de l’opérande.
Code opération Adresse opérande ………….

Adresse opérande
Opérande
………….
Exemple : ADD A, @R0 (A = A + contenu de l’adresse pointé par R0)
IV. Les types de microprocesseurs
Il existe deux grandes familles de microprocesseurs ayant un jeu d’instruction différent qui ont
tous deux des avantages qui peuvent les rendre complémentaires.
▪ Les microprocesseurs CISC (Complex Instruction Set Computer) qui possèdent un grand
nombre d’instructions (plusieurs dizaines, voire centaines) permettant de réaliser de nombreuses
instructions complexes. Chaque instruction est exécutée en un certain nombre de cycles d’horloge
dépendant de l’instruction elle-même, mais aussi du mode d’adressage utilisé. Les
microprocesseurs CISC privilégient la puissance de traitement au détriment de la rapidité.
▪ Les microprocesseurs RISC (Reduced Instruction Set Computer) possède un nombre
d’instructions bien plus faible (quelques dizaines au maximum) qui permettent de réaliser des
opérations simples, mais chaque instruction est exécutée en un seul cycle d’horloge. Il en résulte
une vitesse de calcul très supérieure à celle de la famille CISC.
Le choix dépendra des applications visées. En effet, si on diminue le nombre d'instructions, on crée des
instructions complexes (CISC) qui nécessitent plus de cycles pour être décodées et si on diminue le nombre
de cycles par instruction, on crée des instructions simples (RISC) mais on augmente alors le nombre
d'instructions nécessaires pour réaliser le même traitement.
Tableau 1.1 : Comparatif entre les architectures CISC et le RISC
Architecture RISC Architecture CISC

Instructions simples ne prenant qu’un seul cycle Instructions complexes prenant plusieurs cycles
Instructions au format fixe Instructions au format variable
Décodeur simple Décodeur complexe
Arnaud NANFAK 11
Beaucoup de registres Peu de registres

Peu de modes d’adressage Beaucoup de modes d’adressage
Compilateur complexe Compilateur simple
seules les instructions LOAD et STORE ont toutes les instructions sont susceptibles
accès à la mémoire d’accéder à la mémoire
V. Les performances d’un microprocesseur
On peut caractériser la puissance d’un microprocesseur par le nombre d’instructions qu’il est
capable de traiter par seconde. Pour cela, on définit :
▪ Le CPI (Cycle Par Instruction) qui représente le nombre moyen de cycles d’horloge nécessaire
pour l’exécution d’une instruction pour un microprocesseur donné.
▪ Le MIPS (Millions d’Instructions Par Seconde) qui représente la puissance de traitement du
microprocesseur.
𝐹𝐻
𝑀𝐼𝑃𝑆 = 𝑎𝑣𝑒𝑐 𝐹𝐻 𝑒𝑛 𝑀𝐻𝑧
𝐶𝑃𝐼
VI. Les familles de microprocesseurs
Il existe aujourd’hui différentes familles de microprocesseurs commercialisés par différentes

marques telles que Intel ou AMD. Ces familles de microprocesseurs sont notamment classés en fonction
du cout, de l’architecture, et de la puissance.
▪ La famille x86 : cette famille de microprocesseurs a été initialement commercialisée par Intel.
Dans cette famille, on retrouve les Intel Pentium et AMD Athlons.
▪ La famille x64 : cette famille de microprocesseurs fait suite à celle des x86.Celle-ci a été créé avec
pour objectif de permettre une meilleur gestion de la mémoire vive des ordinateurs qui ne cesse
d’augmenter ces dernières années.
▪ La famille PowerPC : ces microprocesseurs ont été développés par Motorola et IBM.
▪ La famille ARM : c’est la famille des microprocesseurs la plus répandue du marché et elle est
fabriquée par la société Acorn RISC Machines. Ces processeurs se retrouvent dans les tablettes,
les téléphones ou encore les systèmes embarqués comme le Raspberry PI.
Pour manipuler les données, les processeurs 64 bits possèdent 15 registres de 64 bits à usage généraux
résumés dans le tableau ci-dessus.
Arnaud NANFAK 12
Registres Noms Fonctions Sous-registres (bits)

Utilisé pour les opérations arithmétiques et le
EAX (32), AX (16), AH (8), AL
RAX Accumulateur stockage de la valeur de retour des appels
(8)
systèmes
EBX (32), BX (16), BH (8), BL
RBX Base utilisé comme pointeur de données
(8)
Utilisé dans les instructions shift et rotation, et ECX (32), CX (16), CH (8), CL
RCX Compteur
utilisé pour les boucles (8)
Utilisé pour les opérations arithmétiques et les EDX (32), DX (16), DH (8), DL
RDX Les données
opérations d’E/S (8)
Pointe vers une source en mémoire pour les
RSI La source ESI (32), SI (16), SL (8)
opérations de flux
Pointe vers une destination en mémoire pour les
RDI Destination EDI (32), DI (16), DL (8)
opérations de flux
RBP Pointeur de base Pointe vers la base de la pile EBP (32), BP (16), BPL (8)
RSP Pointeur de pile Pointe vers le haut de la pile ESP (32), SP (16), SPL (8)
R8D-R15D (32), R8W-R15W
R8 - R15 Nouveaux registres
(16), R8B-R15B (8),
Remarque : Les suffixes utilises pour adresser les bits inférieurs des nouveaux registres signifient B octet,
8 bits ; W mot, 16 bits et D double mot, 32 bits.
Arnaud NANFAK 13
CHAPITRE 2 : MICROCONTROLEUR
Introduction
Les microcontrôleurs sont des micro-ordinateurs spéciaux sur puce qui sont adaptés à des
applications spécifiques. Il s'agit généralement de tâches de commande ou de communication qui sont
programmées une seule fois, puis exécutées sur le microcontrôleur pendant toute la durée de vie du
microcontrôleur. Les domaines d'application sont très larges. Les microcontrôleurs travaillent
généralement de manière invisible dans une multitude de domaines, les équipements et installations qui
nous entourent dans notre vie quotidienne. Les domaines d'application typiques sont les suivants :
▪ A la maison (le contrôle de la machine à café, de la machine à laver, du téléphone, de l'aspirateur,

de la télévision, ...)
▪ en automatisation (le contrôle et la régulation des processus, le suivi des processus, le contrôle des
flux de matières, le contrôle des usines de fabrication et de production, ....)
▪ dans le domaine de la technique médicale (le contrôle des dispositifs de perfusion, Moniteurs
cardiovasculaires, Respirateurs, Appareils de dialyse, ......)
En termes simples, un microcontrôleur peut être considéré comme un micro-ordinateur monopuce avec
des périphériques spécialement conçus pour les tâches de contrôle ou de communication.
Plusieurs Constructeurs se partagent le marché des microcontrôleurs, citons INTEL, MOTOROLA,

SEAGATE-THOMSON, AMTEL, ZILOG, PHILIPS et enfin MICROCHIP avec ses PICs très
populaires qui ferons l’objet de ce cours.
I. Architecture des microcontrôleurs
L’architecture d’un microcontrôleur est un élément important qui conditionne directement les
performances du processeur. Pour l’organisation des différentes unités, il existe deux types fondamentaux
de structures dites « Von Neumann » et « Harvard ».
I.1. Architecture de Von Neumann
L’architecture, dite architecture de Von Neumann, est un modèle pour microcontrôleur qui
utilise une structure de stockage unique pour conserver à la fois les instructions et les
données requises ou générées par le calcul. La mémoire programme, la mémoire des données et les
périphériques d’entrées/sorties partagent le même bus d’adresses et de données. Cette architecture est
maintenant principalement utilisée pour la conception des processeurs d’ordinateurs (PC, MAC).
Arnaud NANFAK 14
Figure 2.1 : Architecture Von Neumann

L’inconvénient majeur de cette structure est que 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.
I.2. Architecture de Harvard
L’architecture de type Harvard est une conception de microcontrôleur qui sépare physiquement la
mémoire de données et la mémoire programme. L’accès à chacune des deux mémoires s’effectue via deux
bus distincts. Quoique cette architecture puisse être complexe, elle permet de transférer une instruction et
les données simultanément, ce qui rend l’exécution des programmes plus rapide. En revanche elle nécessite
des instructions différentes pour accéder à la mémoire programme et à la mémoire de données.
L’architecture Harvard est souvent utilisée dans les processeurs numériques du signal ; les
microcontrôleurs notamment les PIC de Microchip et les AVR d’Atmel.
Arnaud NANFAK 15
Figure 2.2 : Architecture Harvard

Ce type d’architecture, plus complexe à fabriquer permet une exécution du programme en PIPELINE. Le
pipeline d'instruction permet d'exécuter une nouvelle instruction à chaque cycle d'horloge.
Arnaud NANFAK 16
Figure 2.3 : Le Pipeline d’instructions

Les instructions ont toujours besoin de 3 étapes mais le débit d'instruction est au rythme de l'horloge.
II. Les éléments de base des microcontrôleurs
Un microcontrôleur est un circuit intégré rassemblant dans un même boitier un microprocesseur

(généralement peu puissant), plusieurs types de mémoires et des périphériques de communication
(Entrées-Sorties). Voici généralement ce que l’on trouve à l’intérieur d’un tel composant :
▪ un microprocesseur (C.P.U.), avec une largeur du chemin de données allant de 4 bits pour les
modèles les plus basiques à 32 ou 64 bits pour les modèles les plus évolués,
▪ de la mémoire vive (RAM) pour stocker les données et variables,
▪ de la mémoire non volatile (ROM) pour stocker les programmes, différentes technologies
EPROM, EEPROM, flash,
▪ souvent un oscillateur pour le ca dencement. Il peut être réalisé avec un quartz, un circuit RC
ou encore une PLL,
▪ des périphériques, capables d'effectuer des tâches spécifiques.
Parmi les périphériques, on peut mentionner entre autre :
▪ les convertisseurs analogiques-numériques (CAN) (donnent un nombre binaire à partir d'une

tension électrique),
▪ les convertisseurs numériques-analogiques (CNA) (effectuent l'opération inverse),
Arnaud NANFAK 17
▪ les générateurs de signaux à modulation de largeur d'impulsion (MLI, ou en anglais, PWM pour
Pulse Width Modulation),
▪ les timers/compteurs (compteurs d'impulsions d'horloge interne ou d'événements externes),
▪ les chiens de garde (watchdog),
▪ les comparateurs (comparent deux tensions électriques),
▪ les contrôleurs de bus de communication (UART, I²C, SSP, CAN, FlexRay, USB, Ethernet, etc.).
II.1. L’horloge :
Le signal d’horloge cadence le fonctionnement du microprocesseur. Il est produit par un oscillateur

à quartz qui est souvent formé d’un circuit actif interne (inverseur et résistance), d’un quartz et de
condensateurs externes. Il existe différents types d’horloge et elle peut être soit interne, soit externe. Quel
que soit l'oscillateur utilisé, l'horloge système dite aussi horloge instruction est obtenue en divisant la
fréquence par 4.
Figure 2.4 : L’horloge

Plus la fréquence d’horloge est élevée, plus le processeur travaille vite.
II.2. Mémoires
C’est le lieu de stockage du programme exécuté et les données manipulées par le microprocesseur.
II.1.1. Mémoire de programme
Elle contient les instructions du programme. C’est une mémoire morte dont le type exact dépend
du modèle de microcontrôleur. On distingue :
▪ ROM (Read Only Memory), ne peuvent être programmé qu’une seule fois par son constructeur
au cours du processus de fabrication ;
▪ PROM (Programmable Read Only Memory), inscrite une seule fois par l’utilisateur grâce à un
programmateur ;
Arnaud NANFAK 18
▪ EPROM (Erasable Programmable Read-Only Memory signifiant mémoire morte

reprogrammable), programmable plusieurs fois par l’utilisateur et pouvant être effacée
par un rayonnement ultraviolet ;
▪ EEPROM (Electrically-Erasable Programmable Read-Only Memory ou mémoire morte effaçable
électriquement et reprogrammable), programmable et effaçable électriquement ;
▪ FLASH, programmable et effaçable électriquement, mais plus rapide.
II.1.2. Mémoire de données
C’est l’endroit où le microprocesseur enregistre temporairement les instructions les données des
programmes qu’il exécute. C’est une mémoire volatile (qui s’efface lorsqu’elle n’est plus alimentée en
courant électrique) accessible en lecture et en écriture. On en trouve trois catégories :
▪ SRAM (Static Random access memory : mémoire statique à accès aléatoire), mémoire volatile dont
les informations sont mémorisées par des bascules. Rapides et onéreuses, elles sont de capacité
limitée ;
▪ DRAM (Dynamic Random access memory : mémoire dynamique à accès aléatoire), mémoire
volatile dont les informations sont mémorisées par des condensateurs. Il faut procéder à un
rafraichissement périodique à cause des courants de fuites. Lentes et peu couteuses, elles sont de
plus grande capacité;
▪ NOURAM, c’est l’association dans un même boitier d’une RAM et d’une EEPROM. Quand le
circuit est alimenté en courant, c’est la RAM qui fonctionne permettant au système de bénéficier
de son temps d’accès très court. Quand l’alimentation est coupée, le contenu de la RAM est
transféré dans la EEPROM. On obtient ainsi une mémoire non volatile présentant une bonne
rapidité.
II.1.3. Organisation des mémoires
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. La figure ci-dessous donne la représentation de la structure des mémoires.
Arnaud NANFAK 19
Figure
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).
Schéma fonctionnel d’une mémoire
La figure ci-dessous présente le schéma fonctionnel d’une mémoire.
Figure
A0 à An-1 : bits d’adresses. Ils sont utilisés pour définir l’adresse d’une case mémoire
CS : Chip Select. Lorsque cette broche est active (état bas), le circuit peut être lu ou écrit. Lorsqu’elle est
inactive (état haut), le circuit est exclu du service.
Arnaud NANFAK 20
Le nombre de lignes d’adresse dépend de la capacité de la mémoire : n lignes d’adresses permettent

d’adresser 2n cases mémoires.
Exemple : 8 bits d’adresses permettent d’adresser 256 octets
II.3. Interfaces parallèles
Elles peuvent être configurées soit en entrées, soit en sorties, ce qui leur permet de :
▪ prendre en compte des états logiques représentant des informations externes, comme les résultats
de mesure par des capteurs ;
▪ générer des états logiques destinés à la commande d’actionneurs.
Les interfaces parallèles sont regroupées en plusieurs ports d’entrées/sorties. La configuration et les états
logiques des différentes broches sont définis dans des registres associés aux ports.
II.4. Interfaces série
Une interface série permet de communiquer avec d’autres systèmes. On rencontre principalement
une liaison RS232 ou une liaison I2C.
II.5. Convertisseur analogique-numérique
Il permet de prendre en compte des informations analogiques, par exemple des résultats issus de
capteurs. Il utilise la méthode des approximations successives.
II.6. Convertisseur numérique-analogique
Il permet de produire un signal analogique (tension) à partir des états logiques internes.
II.7. Timers/Compteurs
Il sert à différentes fonctions :
▪ comptage d’événements,
▪ temporisation,
▪ génération d’une impulsion calibrée,
▪ génération d’un signal périodique.
II.8. Chien de garde (watchdog)
Arnaud NANFAK 21
Les " chiens de garde " sont des composants qui sont souvent utilisés dans le domaine du temps
réel pour surveiller le déroulement du programme d'un microcontrôleur. Leur tâche est de détecter les
bourrages ou les plantages des programmes et d'y réagir.
II.9. Bus
Le microprocesseur échange des informations avec la mémoire et l’unité d’E/S, sous forme de mots
binaires, au moyen d’un ensemble de connexions appelé bus. Un bus permet de transféré des données sous
forme parallèle, c’est-à-dire en faisant circuler n bits simultanément. On distingue trois types de bus :
▪ le bus d’adresses véhicule l’adresse qui spécifie l’origine ou la destination de l’information qui
transite sur le bus de données. C’est un bus unidirectionnel c’est-à-dire que les informations qu’il
véhicule transitent du microprocesseur vers l’un de ses périphériques.
▪ le bus de données transporte les données échangées par les différents périphériques externes du
microcontrôleur. C’est un bus bidirectionnel c’est-à-dire que les informations qu’il véhicule
peuvent transiter du microcontrôleur vers l’un de ses périphériques ou d’un périphérique vers le
microcontrôleur.
▪ le bus de commande. C’est en ensemble de lignes transportant les différents signaux de commande
et de synchronisation nécessaires pour le bon déroulement des échanges entre les divers éléments
du système.
Figure
Remarques :
R1 : Les microprocesseurs peuvent être classés selon la longueur maximale des mots binaires qu’ils peuvent
échanger avec la mémoire et les E/S : microprocesseurs 8 bits, 16 bits, 32 bits, ...
R2 : les bus de données et de commande sont bidirectionnels, le bus d’adresse est unidirectionnel :
Arnaud NANFAK 22
seul le microprocesseur peut délivrer des adresses.
Figure 2.5 : Schéma fonctionnel d’un microcontrôleur

III. Langage de programmation
III.1. Les langages de Haut niveau, bas niveau et machine
Les microcontrôleurs sont des composants microprogrammés. Les programmes peuvent être
écrits à trois niveaux différents :
▪ Langages évolués : Pascal, Basic, Langage C, Etc…

▪ Assembleur
▪ Langage machine (Binaire ou hexadécimal)
Le seul « langage » que le microcontrôleur puisse véritablement « comprendre » est donc très éloigné de ce
que nous utilisons nous-mêmes. C’est une longue suite de 1 et de 0 (les « bits ») souvent traités par groupes
de 8 (les « octets »), 16, 32, ou même 64. Ce « langage machine » est évidemment presque incompréhensible
pour nous. Pour « parler » à un microcontrôleur, il nous faudra utiliser des systèmes de traduction
automatiques, capables de convertir en nombres binaires des suites de caractères formant des mots-clés
(anglais en général) qui seront plus significatifs pour nous. Le système de traduction proprement dit
s’appellera interpréteur ou bien compilateur, suivant la méthode utilisée pour effectuer la traduction.
Le langage de programmation est un ensemble de mots-clés associé à un ensemble de règles très précises
indiquant comment on peut assembler ces mots pour former des « phrases » que l’interpréteur ou le
Arnaud NANFAK 23
compilateur puisse traduire en langage machine (binaire). Suivant son niveau d’abstraction, on pourra dire
d’un langage qu’il est « de bas niveau » (ex : assembleur) ou « de haut niveau » (ex : Pascal, C, C++, Python,
Lisp...). Un langage de bas niveau est constitué d’instructions très élémentaires, très « proches de la machine
». Un langage de haut niveau comporte des instructions plus abstraites, plus « puissantes ». Cela signifie
que chacune de ces instructions pourra être traduite par l’interpréteur ou le compilateur en un grand
nombre d’instructions machine élémentaires. Les avantages que présentent les langages de haut niveau
sont énormes : il est beaucoup plus facile d’écrire un programme dans un langage de haut niveau ; l’écriture
du programme prend donc beaucoup moins de temps ; la probabilité d’y faire des fautes est nettement
plus faible ; la maintenance (c’est-à-dire l’apport de modifications ultérieures) et la recherche des erreurs
(les « bugs ») sont grandement facilitées. De plus, un programme écrit dans un langage de haut niveau sera
souvent portable, c’est-à-dire que l’on pourra le faire fonctionner sans guère de modifications sur des
machines ou des systèmes d’exploitation différents.
III.2. Compilation et interprétation
Le programme tel que rédiger en langage de haut niveau à l’aide d’un logiciel éditeur est appelé
programme source (ou code source). Il existe deux techniques principales pour effectuer la traduction d’un
tel programme source en code binaire (langage machine) exécutable par le microcontrôleur :
l’interprétation et la compilation.
• Dans la technique appelée interprétation, le logiciel interpréteur doit être utilisé chaque fois que
l’on veut faire fonctionner le programme. Dans cette technique en effet, chaque ligne du
programme source analysé est traduite au fur et à mesure en quelques instructions du langage
machine, qui sont ensuite directement exécutées. Aucun programme objet n’est généré ;
• La compilation consiste à traduire la totalité du texte source en une fois. Le logiciel compilateur lit
toutes les lignes du programme source et produit une nouvelle suite de codes que l’on appelle
programme objet (ou code objet). Celui-ci peut désormais être exécuté indépendamment du
compilateur et être conservé tel quel dans un fichier (« fichier exécutable »).
Arnaud NANFAK 24
Figure 2.6 : Principe de l’interprétation et de la compilation
Remarque : Certains langages modernes tentent de combiner les deux techniques afin de retirer le
meilleur de chacune. C’est le cas de Python et aussi de Java. Lorsque vous lui fournissez un programme
source, Python commence par le compiler pour produire un code intermédiaire, similaire à un langage
machine, que l’on appelle bytecode, lequel sera ensuite transmis à un interpréteur pour l’exécution finale.
Figure 2.7 : Principe de la conversion du langage Python
III.3. Mise au point d’un programme
La programmation est une démarche très complexe, et comme c’est le cas dans toute activité
humaine, on y commet de nombreuses erreurs. Les erreurs de programmation s’appellent des « bugs » (ou
« bogues », en Français), et l’ensemble des techniques que l’on met en œuvre pour les détecter et les corriger
s’appelle « debug » (ou « débogage »). En fait, il peut exister dans un programme trois types d’erreurs assez
différentes à savoir : les erreurs de syntaxe, les erreurs sémantiques et les erreurs à l’exécution.
III.3.1. Les erreurs de syntaxe
Le terme syntaxe se réfère aux règles que les auteurs du langage ont établies pour la structure du
programme. Tout langage comporte sa syntaxe. Dans la langue française, par exemple, une phrase doit
toujours commencer par une majuscule et se terminer par un point. « ainsi cette phrase comporte deux
erreurs de syntaxe »
En programmation, la moindre erreur de syntaxe produit invariablement un arrêt de fonctionnement (un

« plantage ») ainsi que l’affichage d’un message d’erreur.
III.3.2. Les erreurs sémantiques
Arnaud NANFAK 25
S’il existe une erreur de ce type dans un de vos programmes, celui-ci s’exécute parfaitement, en ce sens
que vous n’obtenez aucun message d’erreur, mais le résultat n’est pas celui que vous attendiez : vous
obtenez autre chose. En réalité, le programme fait exactement ce que vous lui avez dit de faire. Le
problème est que ce que vous lui avez dit de faire ne correspond pas à ce que vous vouliez qu’il fasse. La
séquence d’instructions de votre programme ne correspond pas à l’objectif poursuivi. La sémantique (la
logique) est incorrecte.
Rechercher des fautes de logique peut être une tâche ardue. Il faut analyser ce qui sort de la machine et
tâcher de se représenter une par une les opérations qu’elle a effectuées, à la suite de chaque instruction.
III.3.3. Les erreurs à l’exécution
L’erreur en cours d’exécution (Run-time error), qui apparaît seulement lorsque votre programme
fonctionne déjà, mais que des circonstances particulières se présentent (par exemple, votre programme
essaie de lire un fichier qui n’existe plus). Ces erreurs sont également appelées des exceptions, parce qu’elles
indiquent généralement que quelque chose d’exceptionnel s’est produit (et qui n’avait pas été prévu).
III.3.4. La recherche d’erreurs
L’une des compétences les plus importantes à acquérir au cours de votre apprentissage est celle qui consiste
à déboguer efficacement un programme. Ce travail ressemble par bien des aspects à une enquête policière.
Vous examinez un ensemble de faits, et vous devez émettre des hypothèses explicatives pour reconstituer
les processus et les événements qui ont logiquement entraîné les résultats que vous constatez. Vous vous
faites une première idée de ce qui ne va pas, vous modifiez votre programme et vous essayez à nouveau.
Vous avez émis une hypothèse, qui vous permet de prédire ce que devra donner la modification. Si la
prédiction se vérifie, alors vous avez progressé d’un pas sur la voie d’un programme qui fonctionne. Si la
prédiction se révèle fausse, alors il vous faut émettre une nouvelle hypothèse.
Arnaud NANFAK 26
CHAPITRE 3 : CAS PRATIQUE D’ETUDE : MICROCONTROLEUR ATMEGA de
l’Arduino UNO
Introduction
La carte arduino est un microcontrôleur open source. Le modèle UNO qui fera l’objet de ce
cours, de la société arduino est une carte électronique dont le cœur est un microcontrôleur ATMEL de
référence ATMega 328. L’ATMega 328 est un microcontrôleur 8 bits de la famille AVR dont la
programmation peut être rédigée en langage C/C++.
L’intérêt principal des microcontrôleurs arduino est leur facilité de mise en œuvre. Un environnement de
développement (IDE) s’appuyant sur des outils opensource est fourni. Entre autre charger le programme
compilé dans la mémoire du microcontrôleur se fait très simplement (via le part USB) dans cet IDE. Enfin
beaucoup de bibliothèques de fonctions sont également fournies pour faciliter l’exploitation des
entrées/sorties, la gestion des convertisseurs analogique-numérique et numérique-analogique, la
génération des signaux PWM, l’exploitation des servomoteurs, d’afficheur LCD,…
I. Schéma simplifié de la carte Arduino UNO
ATMEGA328
Figure 3.1 : Schéma simplifié de la carte arduino UNO
Arnaud NANFAK 1
Figure 3.2 : Vue de dessus de la carte arduino UNO

En regroupant les schémas des figures 3.1 et 3.2, on a les équivalences suivantes :
▪ Les connecteurs numérotés de 0 à 7 correspondent respectivement aux broches PD0 à PD7 du

microcontrôleur ;
▪ Les connecteurs numérotés de 8 à 13 correspondent respectivement aux broches PB0 à PB5 du
microcontrôleur ;
▪ Les connecteurs Analog In numérotés de 0 à 5 correspondent respectivement aux broches PC0 à
PC5 du microcontrôleur ;
Remarque : 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.3 : Arduino UNO et UNO SMD

II. Microcontrôleur ATMEL ATMEGA328
Arnaud NANFAK 2
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…
Le microcontrôleur de la carte Arduino UNO est un ATMega328. C'est un microcontrôleur

ATMEL de la famille AVR 8bits. Les principales caractéristiques sont :
▪ Une mémoire programme FLASH de 32Ko

▪ Une SRAM de 2Ko
▪ Une EEPROM de 1Ko
▪ Des E/S Digitales : 3 ports PortB, PortC, PortD (soit 23 broches en tout I/O)
▪ Timers/Counters : Timer0 et Timer2 (comptage 8 bits), Timer1 (comptage 16bits)
Chaque timer peut être utilisé pour générer deux signaux PWM (6 broches OCxA/OCxB). Les broches
OC0A(PD6), OC0B(PD5), 0C1A(PB1), OC1B(PB2), OC2A(PB3), OC2B(PD3) peuvent servir de
sortie PWM (Pulse Width Modulation), c'est-à-dire des sorties qui joueront le rôle de sorties analogiques.
Elles correspondent aux broches des connecteurs 3,5,6,9,10 et 11 de la carte arduino.
▪ Un ADC de résolution 10 bits (6 entrées multiplexées ADC0(PC0) à ADC5(PC5))

▪ Un gestionnaire de bus I2C. le bus est exploité via les broches SDA(PC5)/SCL(PC4).
▪ Un port série USART. émission/réception série via les broches TXD(PD1)/RXD(PD0)
▪ Un comparateur analogique utilisé pour déclencher des interruptions (broches AIN0(PD6) et
AIN1 (PD7))
▪ Watchdog Timer programmable
▪ Un gestionnaire d’interruption
En résumé nous avons 24 sources d’interruptions possibles :
▪ Interruptions liées aux entrées INT0 (PD2) et INT1 (PD3)

▪ Interruptions sur changement d'état des broches PCINT0 à PCINT23
▪ Interruptions liées aux Timers 0, 1 et 2 (plusieurs causes configurables)
▪ Interruption liée au comparateur analogique
▪ Interruption de fin de conversion ADC
▪ Interruptions du port série USART
▪ Interruption du bus I2C
III. Les entrées/sorties de l’arduino UNO
Arnaud NANFAK 3
Les entrées/sorties (I/O – input/output) représentent le moyen qu’a la carte arduino d’interagir
avec l’extérieur. Les sorties sont contrôlées par la carte, cela permet au programme du microcontrôleur de
déclencher des actions (allumer ou d’éteindre une LED, un ventilateur, un moteur). Les entrées sont lues
par le microcontrôleur, ce qui lui permet de connaitre l’état du système auquel il est relié.
III.1. Les entrées/sorties numériques
Les entrées / sorties numériques ne peuvent prendre que deux valeurs :
▪ la valeur LOW (GND ou 0 V),

▪ la valeur HIGH (VDD ou 5 V).
La valeur d’un port numérique peut donc être codée sur un bit (0 ou 1).
Le microcontrôleur arduino UNO comporte 14 I/O numériques (appelé DIGITAL sur la carte),
numéroté de 0 à 13 et appelés D0, D1, …, D13. Chacun de ces ports peut-être déclaré comme étant une
entrée ou comme une sortie dans le programme du microcontrôleur. Les deux premiers ports (D0 et D1)
sont réservés à la communication série, et ne sont pas à
utiliser. Le dernier port, D13, possède un indicateur lumineux, une LED qui s’allume quand le port est
HIGH, et qui s’éteint quand le port est LOW.
II.1.4. Les sorties numériques
Chacun des 14 ports numériques de la carte peuvent être utilisés en sortie. Si un port est déclaré
comme une sortie, le microcontrôleur contrôle la valeur de ce port. Les sorties numériques ne peuvent pas
fournir une grande puissance électrique (40 mA max sur
5 V). L’instruction de programmation utilisée pour programmer un port en sortie est pinMode(X,
OUTPUT); // définit le port DX comme une sortie ;
Remarques : Les situations suivantes sont à éviter parce qu’elles peuvent endommager la carte :
▪ un port, déclaré comme une sortie, est directement reliée à la masse (port GND) avec une
résistance très faible (un fil), et que le programme bascule la sortie en HIGH (5 V).
▪ un port, déclaré comme une sortie, est directement relié au port 5V et le programme bascule la
sortie en LOW (GND).
II.1.5. Les entrées numériques
Chacun des 14 ports numériques de la carte peuvent être utilisés en entrée. Si un port est déclaré
comme une entrée, l’état du port sera lu par arduino et cette valeur pourra être utilisée par le programme
Arnaud NANFAK 4
pour telle ou telle action. Les tensions inférieures à 1V seront lues comme LOW et les tensions supérieures
à 4V seront lues comme HIGH. Toutefois, il faut eviter les tensions intermédiaires, qui risquent de donner
un résultat indéterminé. L’instruction de programmation utilisée pour programmer un port en entrée est
pinMode(X, INTPUT); // définit le port DX comme une entrée.
Remarque : une entrée numérique non connectée sera flottante (sans tension affectée), son état sera
indéterminé. La lecture de ce port peut donner n’importe quel résultat.
III.2. Les entrées analogiques
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/digital, dit « CAD ». La carte
arduino UNO comporte 6 entrées analogiques (appelés ANALOG IN sur la carte) numérotés de 0 à 5 et
appelés A0,A1,…,A5.
Le convertisseur analogique-numérique de l’arduino UNO travaille sur 10 bits. Il accepte en entrée une
tension comprise entre 0V et Vref (une tension de référence prise par défaut égale à 5V), et fournit au
microcontrôleur un chiffre compris entre 0 et 1023. L’instruction de programmation qui retourne un entier
compris entre 0 et 1023 selon la valeur appliquée sur le port AX est : analogRead(X).
III.3. Les sorties analogiques
La carte arduino ne possède pas de vraies sorties analogiques capable de produire une tension
d’une valeur arbitraire choisie par l’utilisateur. Certains ports numériques peuvent cependant servir de
sorties analogiques en utilisant la technique PWM. Il s’agit des ports numériques D3, D5, D6, D9, D10 et
D11 (signalés par un ~ sur la carte). La carte arduino est capable de faire varier la valeur moyenne de ces
ports entre 0 et 5V avec une sensibilité de 8 bits, c’est-à-dire on fournit un nombre entier compris entre 0
et 255 et le port délivre une tension moyenne comprise entre 0 et 5V (0V à 0 et 5V à 255). L’instruction
de programmation qui retourne une tension moyenne de 2.5V sur port D3 par exemple est :
analogWrite(3,127).
III.4. Les tensions 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 par rapport à laquelle toutes les différences de tensions sont mesurées. Si la carte
est reliée à l’ordinateur par un câble USB, cette tension est celle de la
terre.
Arnaud NANFAK 5
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 5V 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.
VIN est la tension de l’alimentation externe, quand il y en a une.
Remarque : 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 !
III.5. Le 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 !). L’IDE permet de scanner le port COM et de récupérer les messages éventuels de
la carte.
Figure 3.4 : Les différentes parties de la UNO

IV. Transférer un programme dans la carte
La façon dont le microcontrôleur gère ses entrées/sorties est fixée par un programme, contenu
dans le microcontrôleur. Ce programme doit être écrit par l’utilisateur. En pratique, l’utilisateur écrit le
programme en langage C, en utilisant un environnement de développement spécialisé (IDE) installé sur
Arnaud NANFAK 6
un ordinateur. Ce programme est ensuite compilé et téléversé dans le microcontrôleur par liaison série
(USB).
Arduino fournit un environnement de développement avec un éditeur de source, les opérations de

compilation et de changement dans la mémoire du microcontrôleur étant ramenées à des clicks sur des
boutons de l’IDE. La carte doit être reliée à l’ordinateur par un câble USB. La modèle de la carte arduino
(il y a plusieurs type de carte) ainsi que le port série sur lequel elle est branchée doivent être déclarés dans
le menu de l’IDE Outils/type de carte et Outils/port série.
IV.1. Description de l’interface Arduino software
Le logiciel Arduino a pour fonctions principales :
▪ de pouvoir écrire et compiler des programmes pour la carte Arduino

▪ de se connecter avec la carte Arduino pour y transférer les programmes
▪ de communiquer avec la carte Arduino
Cet espace de développement intégré (EDI) dédié au langage Arduino et à la programmation des cartes
Arduino comporte :
▪ une BARRE DE MENU comme pour tout logiciel une interface graphique (GUI),
▪ une BARRE DE BOUTONS qui donne un accès direct aux fonctions essentielles du logiciel et
fait toute sa simplicité d'utilisation,
▪ un EDITEUR (à coloration syntaxique) pour écrire le code de vos programme, avec onglets de
navigation,
▪ une ZONE DE MESSAGES qui affiche indique l'état des actions en cours,
▪ une CONSOLE TEXTE qui affiche les messages concernant le résultat de la compilation du
programme
▪ un TERMINAL SERIE (fenêtre séparée) qui permet d'afficher des messages textes reçus de la
carte Arduino et d'envoyer des caractères vers la carte Arduino. Cette fonctionnalité permet une
mise au point facilitée des programmes, permettant d'afficher sur l'ordinateur l'état de variables, de
résultats de calculs ou de conversions analogique-numérique : un élément essentiel pour améliorer,
tester et corriger ses programmes.
Arnaud NANFAK 7
Figure 3.5 : Interface arduino software

IV.2. Description de la structure d’un programme
Un programme utilisateur arduino se décompose en trois grandes parties :
▪ L’initialisation des variables et constantes du programme ;

▪ La fonction principale void setup() : Cette fonction n’est exécutée qu’une seule fois au démarrage
du programme. Elle permet la configuration des entrées et sorties de la carte et les éléments à
configurer ;
▪ La fonction boucle void loop() : Cette fonction s’exécute en boucle sans fin. C’est dans cette partie
qu’on définit les opérations à effectuer.
Arnaud NANFAK 8
Figure 3.6 : Exemple de programme arduino

Une fois le programme écrit, le programme doit être compilé pour vérifier si le code contient des erreurs
de syntaxes. En cas d’anomalie de compilation, le compilateur renseigne sur le type d’erreur et la ligne ou
elle se trouve. Si la compilation se déroule sans erreur, le message «Done compilling » apparaît, suivi de la
taille du programme.
Une fois que vous avez sélectionné le bon port série et la bonne carte Arduino, cliquez sur le bouton
UPLOAD (Transfert vers la carte) dans la barre d'outils, ou bien sélectionner le menu File>Upload to
I/O board (Fichier > Transférer vers la carte). Sur la plupart des cartes, vous devez voir les LEDs des
lignes RX et TX clignoter rapidement, témoignant que le programme est bien transféré. Durant le transfert,
le bouton devient jaune et le logiciel Arduino affiche un message indiquant que le transfert est en cours.
Arnaud NANFAK 9
TRAVAUX PRATIQUES
Arnaud NANFAK 10
Manipulation N° 1 : Le chenillard à LED

Objectifs : Cette manipulation vise à familiariser les étudiants avec l’environnement de
programmation IDE arduino. Dans le cadre de cette manipulation, les étudiants apprendrons à
utiliser les I/O digitales pour l’allumage d’une LED. Ils vont s’inspirer du principe de commande
d’une LED pour construire un chenillard
Durée du TP : 03 heures
Liste du matériel
Pour cette manipulation, vous aurez besoin de :
▪ un ordinateur et l’IDE Arduino installé : « Installation de l’IDE Arduino »

▪ l’arduino UNO et son câble USB
▪ des fils et une plaque de prototypage
▪ 6 DEL ainsi que 6 résistances : 220 ohms
Manipulation
Réaliser le câblage ci-dessous :
Faire vérifier le montage par le professeur

Programme 1
Dans l’environnement de développement Arduino, ouvrir le programme mis à votre disposition
par l’enseignent Le téléverser dans la carte Arduino Uno. Observer le fonctionnement.
1 /*
2 * Programme pour arduino uno
3 * Projet commande d’une LED
4 int pinLed = 13 ;
5
6 void setup () {
7 pinMode (pinLed, OUTPUT) ;
Arnaud NANFAK 11
8}
9
10 void loop () {
11 digitalWrite (pinLed, HIGH) ;
12 delay(1000) ;
13 digitalWrite (pinLed, LOW) ;
14 delay(1000) ;
15 }

Programme 2
Dans l’environnement de développement Arduino, ouvrir le programme mis à votre disposition
par l’enseignent Le téléverser dans la carte Arduino Uno. Observer le fonctionnement
1 /*
2 * Programme pour arduino uno
3 * Projet Chenillard à LED
4
5 void setup () {
6 pinMode (4, OUTPUT) ;
Arnaud NANFAK 12

12 }
13
14 void loop () {
15 for (byte i = 4 ; i <= 9 ; i++) {
16 digitalWrite (i, LOW) ;
17 }
18
19 for (byte i = 4 ; i <= 9 ; i++) {
20 digitalWrite (i, HIGH) ;
21 delay (500) ;
22 }
23 digitalWrite (4, LOW) ;
29 delay (1000) ;
30 }
Compte rendu
1. Décrire le principe de fonctionnement d’une LED

2. Quelle sont les parties d’un programme arduino
3. Associer les commentaires du tableau aux lignes correspondantes du programme 1, en
notant le numéro de la ligne du programme dans les cases de la colonne vide.
Commentaires Lignes du programme 1
Attendre 1 seconde
Faire en boucle
Initialisation
Définir la broche 13 comme une sortie
Eteindre la LED
Allumer les 6 LEDs
Allumer successivement les 6 LEDs à intervalle de temps de 0.5s
Initialiser l’état des LEDs en les éteignant
Définir la broche 4 à 9 comme des sorties
Eteindre les 6 LEDs
5. Indiquer comment modifier la ligne 15 du programme 2 pour commencer l’allumage des
LEDs par celle de la broche 9
6. Modifier le programme pour que lorsqu’une LED et une seule soit allumer à la fois.
7. Proposer le schéma de câblage et le programme pour faire s’allumer les LEDs lorsque
l’on appuie sur un bouton poussoir
Arnaud NANFAK 13
Manipulation N°2 : Arduino et afficheur LCD

Objectifs : Dans ce TP nous allons commander avec un Arduino UNO un afficheur LCD
(Liquid Cristal Display) alphanumérique de 2 lignes de 16 caractères. Il ne permet donc pas
d'afficher de graphismes mais uniquement des caractères alphanumériques. On le rencontre
souvent dans les systèmes de contrôle d'accès ou les interphones.
Liste du matériel
Pour la réalisation de ce TP vous aurez besoin de :
▪ Une carte arduino Uno

▪ Un afficheur LCD
▪ Des câbles de connexion
▪ Une plaque à essai
▪ Un potentiomètre de 10k et une résistance de 220R
Manipulation

Programme 1
Installer la bibliothèque LiquidCrystal mis à votre disposition par l’enseignant. Pour ce faire suivre
la procédure suivante : Dans l’IDE Arduino cliquez sur croquis, allez sur inclure une bibliothèque
Arnaud NANFAK 14
puis cliquez sur » ajouter la bibliothèque .ZIP « .Sélectionnez alors le dossier .zip de la bibliothèque.
Une fois la bibliothèque installée et le logiciel Arduino redémarré, vous devriez la voir apparaître
dans la liste des bibliothèques installées. Dans le logiciel, cliquer sur « Ouvrir » puis « LiquidCrystal
et sélectionner enfin « HelloWorld ». Compiler et téléverser le programme dans la carte Arduino.
Vérifier que votre programme fonctionne et sur l’écran LCD.
#include <LiquidCrystal.h> // Include the library:
// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
void setup() {
// Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
lcd.begin(16, 2);
}
void loop() {
// Set the cursor on the third column and the first row, counting starts at 0:
lcd.setCursor(2, 0);
// Print the string 'Hello World!':
lcd.print("Hello World!");
// Set the cursor on the third column and the second row:
// Print the string 'LCD tutorial':
lcd.print("TP LCD ENSPD");
}
Programme 2
Dans l’environnement de développement Arduino Saisir le programme ci-dessous.

#include <LiquidCrystal.h>
const int pinRS = 12;

const int pinEnable = 11;
const int pinD4 = 5;
LiquidCrystal lcd(pinRS, pinEnable, pinD4, pinD5, pinD6, pinD7);
void setup() {
lcd.begin(16, 2);
}
void loop() {
lcd.print("'Hello World!");
delay(1000);
lcd.print("TP LCD ENSPD");
delay (1000);
for (int i = 0; i < 16; i++) {
lcd.scrollDisplayLeft();
Arnaud NANFAK 15
delay(300);
}
lcd.clear();
Compiler, téléverser et observer le fonctionnement.
Compte rendu
1. Définir bibliothèque
2. Définir la nature des broches de l’écran LCD
3. Quel est le rôle de la ligne

: lcd.setCursor(0, 2); ?
4. Modifier le programme de manière à
obtenir l'affichage ci-dessus :
5. Expliquer comment fonctionne le
programme 2
6. Quel est le sens de déplacement su message
dans le programme 2 ?
7. Modifier le programme pour qu’il défile dans le sens contraire
Arnaud NANFAK 16
Manipulation N°3 : Arduino et Capteurs de température

Objectifs : Cette manipulation vise à familiariser les étudiants à l’utilisation des capteurs avec
l’arduino. Dans le cadre de cette manipulation, les étudiants apprendrons à utiliser le capteur de
température LM35 et le capteur d’humidité DTH11. Ces capteurs sont généralement utilisés dans
les chaines d’acquisition solaire.
Fonctionnement des capteurs
Le LM35 est un capteur de température de précision avec une plage de température de

fonctionnement de 0°C à 100°C et qui délivre 10mV pour chaque augmentation de la température
d’un degré Celsius. La tension de sortie maximale du capteur LM35DZ est de 100 × 10mV, soit
un volt. Le convertisseur analogique-numérique (ADC) Arduino convertit une tension en valeur
numérique entre 0 et 1023.
Le capteur d'humidité et de température DHT11 mesure les températures entre 0°C et 50°C et une
humidité relative entre 20 et 90 %. Les mesures sont effectuées toutes les secondes, avec une
précision de ±2°C pour la température et de ±5% pour l'humidité relative. À une humidité relative
de 0 %, l'air est complètement sec, et à 100% de condensation se produit.
L'Arduino a trois valeurs de référence analogiques :
▪ analogReference(DEFAULT) equates 5V to 1023

▪ analogReference(INTERNAL) equates 1.1V to 1023
analogReference(EXTERNAL) equates 3.3V to 1023
Manipulation
Liste du matériel
Pour la réalisation de ce TP vous aurez besoin de :
▪ Une carte arduino Uno

▪ Capteur de température LM35
▪ Capteur de température et d’humidité DTH11
▪ Des câbles de connexion
▪ Une plaque à essai
▪ Une résistance de 220R
Réaliser le câblage comme indiqué sur le schéma ci-dessous :
Arnaud NANFAK 17

Programme 1 :
Dans l’environnement de développement Arduino, saisir le programme ci-dessous.
01 int tempPin = A0;

02 int min =20;
03 int max = 30;
04 int reading;
05 float temp;
06
07 void setup() {
08 Serial.begin(9600);
09 analogReference(INTERNAL);
10 }
11
12 void loop() {
13 reading = analogRead(tempPin);
14 temp = (reading * 110.0)/1023;
15 String axis = String(min) +" "+ String(temp) +" "+ String(max);
16 Serial.println(axis);
17 delay(10);
18 }
Compiler, téléverser et observer le fonctionnement. La lecture de la température LM35 peut être

affichée graphiquement à l'aide du traceur série Arduino IDE en sélectionnant Tools ➤ Serial
Plotter. La vitesse de communication entre l'Arduino et le traceur série peut être réglée à 9600
bauds.
Réaliser le câblage comme indiqué sur le schéma ci-dessous :
Arnaud NANFAK 18

Programme 2 :
Dans l’environnement de développement Arduino, ajouter la bibliothèque DTHlib mis à votre
disposition par l’enseignant. Saisir le programme ci-dessous.
01 #include <dht.h> // include dht library

02
03 dht DHT;
04 int DHTpin = 12;
05 int PCBpin = 7;
06 int check;
07
08 void setup() {
10 }
11
12 void loop() {
13 check = DHT.read11(DHTpin);
14 Serial.print("DHT11 Unit temp: ");
15 Serial.print(DHT.temperature,0);
16 Serial.print("\thumidity: ");
17 Serial.println(DHT.humidity,0);
18 check = DHT.read11(PCBpin);
19 Serial.print("DHT11 PCB temp: ");
20 Serial.print(DHT.temperature,0);
21 Serial.print("\thumidity: ");
22 Serial.println(DHT.humidity,0);
23 delay(1000);
24 }
Compiler, téléverser et observer le fonctionnement.
Arnaud NANFAK 19
Compte rendu
1. Donner la différence entre le DTH11 et le LM35

2. Calculer la sensibilité du CAN dans le cas d’une référence analogique interne
lire la broche du capteur de température
régler la tension du CAN à 1,1V au lieu de 5V
Définir temp comme un réel
Lire la valeur du pin A0
4. Donner 2 applications de ces capteurs dans la vie courante
Arnaud NANFAK 20
Manipulation N° 4 : Arduino - Capteur à ultrasons HC-SR04

Objectifs : Cette manipulation vise à familiariser les étudiants à l’utilisation des capteurs avec
l’arduino. Dans le cadre de cette manipulation, les étudiants apprendrons à utiliser le capteur de
distance à ultrason HC-SR04. Ce capteur est utilisé pour mesurer la distance par rapport à un objet.
Fonctionnement du capteur
Lorsqu'une impulsion d'au moins 10 μS (10 microsecondes) est appliquée à la broche de

déclenchement, tout démarre. En réponse à cela, le capteur émet huit impulsions sonores à 40KHz.
Ce mode à 8 impulsions confère à l'appareil des «caractéristiques ultrasoniques» uniques,
permettant au récepteur de distinguer le mode transmis du bruit ultrasonique ambiant. Huit
impulsions ultrasoniques sont transmises via l’émetteur. Dans le même temps, la broche Echo
passe à un niveau élevé et commence à former un signal d'écho. Si ces impulsions ne sont pas
réfléchies, le signal d'écho expirera après 38 ms (38 millisecondes) et reviendra à un niveau bas. Par
conséquent, une impulsion de 38 mS signifie qu'il n'y a pas d'obstacle dans la portée du capteur. Si
ces impulsions sont réfléchies, une fois le signal reçu, la broche Echo devient faible. Cela produit
une impulsion dont la largeur varie entre 150 μS et 25 mS, en fonction du temps nécessaire pour
recevoir le signal.
Le principe de fonctionnement du capteur est entièrement basé sur la vitesse du son. Voilà
comment se déroule une prise de mesure :
1. On envoie une impulsion HIGH de 10µs sur la broche TRIGGER du capteur.

2. Le capteur envoie alors une série de 8 impulsions ultrasoniques à 40KHz (inaudible pour
l'être humain, c'est quand plus agréable qu'un biiiiiiiip).
3. Les ultrasons se propagent dans l'air jusqu'à toucher un obstacle et retourne dans l'autre
sens vers le capteur.
4. Le capteur détecte l'écho et clôture la prise de mesure.
Le signal sur la broche ECHO du capteur reste à HIGH durant les étapes 3 et 4, ce qui permet de
mesurer la durée de l'aller-retour des ultrasons et donc de déterminer la distance.
Liste du matériel

▪ le capteur de distance SRF-05
Arnaud NANFAK 21
Manipulation

Programme
Dans l’environnement de développement Arduino, ajouter la bibliothèque NewPing_v1.7 mis à
votre disposition par l’enseignant. Saisir le programme ci-dessous.
01 #include <NewPing.h>
02 #define TRIGGER_PIN 12
03 #define ECHO_PIN 11
04 #define MAX_DISTANCE 200
05
06 NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
07
08 void setup() {
10 }
11
12 void loop() {
13 delay(50);
14 Serial.print("Ping: ");
15 Serial.print(sonar.ping_cm());
16 Serial.println("cm");
17 }
Pour visualiser la distance mesurée on utilise le moniteur série (console). Pour ce faire, dans l’IDE
Arduino cliquez sur outil, allez sur Moniteur série. Régler la même vitesse de transmission dans la
console que celle qui a été initialisé dans la fonction « Setup ».
Compte rendu
Arnaud NANFAK 22
1. Donner le rôle des broches Trig et Echo

2. Compléter le tableau suivant
Distance (mm) Mesure Erreur (mm) Erreur (%)
50
70
80
100
120
150
170
180
200
220
250
300
350
400
500
3. Tracer la courbe Mesure = f(Distance)
4. Calculer la sensibilité de ce capteur
5. Compléter le montage et le programme pour afficher les distances sur un écran LCD
Arnaud NANFAK 23
Manipulation N° 5 : Émission de données (RTC)/Réception et affichage

des données
Objectifs : Cette manipulation vise à faire communiquer l’horloge avec l’écran LCD afin que ce
dernier affiche l’heure et la date. Dans le cadre de cette manipulation, les étudiants apprendrons à
utiliser l’horloge RTC (Real Time Clock). Ce genre d'horloge est très utile dans des projets de
mesure de grandeurs physiques avec horodatage par exemple.
Le circuit DS1307 est une horloge temps réel (Real Time Clock), qui fournit secondes, minutes,
heures, jours, dates, mois et années. C'est une horloge numérique autonome qui donne l'heure
quand on la lui demande. Ce module RTC est capable de gérer l'heure (heures, minutes, secondes)
et la date (jours, mois, année) tout en s'occupant des mois de 30 ou 31 jours, des années bissextiles,
etc. Le calendrier intégré dans le module DS1307 est valable de l'an 2000 à l'an 2100. La
communication avec le microcontrôleur maître se fait via un bus I²C. Le module dispose de tout
le nécessaire pour garder en mémoire l'heure en cas de coupure d'alimentation grâce à une batterie
externe. Une simple pile bouton permet de garder l'heure et la date à jour durant plusieurs années
sans alimentation.
Liste du matériel

▪ une horloge RTC avec module I2C
▪ Un potentiomètre de 10k et une résistance de 220R
▪ Un afficheur LCD
Manipulation
Arnaud NANFAK 24

Programme
Dans l’environnement de développement Arduino, ajouter les bibliothèques LiquidCrystal_I2C et
RTClib mis à votre disposition par l’enseignant. Saisir le programme ci-dessous.
01 #include <Wire.h>
02 #include <LiquidCrystal_I2C.h>
03 #include <RTClib.h>
04 #if defined(ARDUINO) && ARDUINO >= 100
05 #define printByte(args) write(args);
06 #else
07 #define printByte(args) print(args,BYTE);
08 #endif
09 uint8_t clock[8] = {0x0,0xe,0x15,0x17,0x11,0xe,0x0};

10 RTC_DS1307 RTC;
11 LiquidCrystal_I2C lcd(0x27,16,2);
12 void setup()
13 {
14 lcd.init();
15 lcd.backlight();
16 lcd.print("Initialising...");
17 lcd.createChar(2, clock);
18 Wire.begin();
19 RTC.begin();
20 RTC.adjust(DateTime(__DATE__, __TIME__));
21 }
22 void loop()
23 {
Arnaud NANFAK 25
24 lcd.clear(); //code pour afficher heure et date de la clock (du RTC) sur l'écran LCD
25 DateTime now = RTC.now();
26 lcd.printByte(2);
27 lcd.print(" ");
28 lcd.print(now.hour(), DEC);
29 lcd.print(':');
30 lcd.print(now.minute(), DEC);
31 lcd.print(':');
32 lcd.print(now.second(), DEC);
33 lcd.setCursor(0, 1);
34 lcd.print(now.day(), DEC);
35 lcd.print('/');
36 lcd.print(now.month(), DEC);
37 lcd.print('/');
38 lcd.print(now.year(), DEC);
39 lcd.print(' ');
40 delay(1000);
41 }
Compte rendu
1. Donner le rôle de la bibliothèque Wire

2. Qu’elle est le module RTC utilisé pour cette manipulation ?
3. Commenter la ligne de code 10
5. Comparer l’heure de votre ordinateur et l’heure affichée sur le LCD. Expliquer votre
observation
6. Modifier l’heure de votre ordinateur et comparer à celle affichée sur le LCD. Expliquer
votre observation
7. Avec l’heure modifier de votre ordinateur, téléverser de nouveau votre code et comparer
les heures de l’ordinateur et du LCD. Expliquez votre observation
Arnaud NANFAK 26
Manipulation N° 6 : Arduino et carte SD

Objectifs : Cette manipulation vise à familiariser les étudiants à l’utilisation des shields. Dans le
cadre de cette manipulation, les étudiants apprendrons à utiliser le module SD-shield. Ce module
est utilisé dans les projets pour la sauvegarde des données.
Le module de carte SD présente 6 broches pour permettre d’établir la connexion. 2 connexions

pour l’alimentation et 4 pour établir la liaison SPI (Serial Peripheral Interface)
▪
5V ou 3.3V pour l’alimentation du module
▪
GND la masse du module
▪
CS ou ChipSelect pour activer la communication
▪
MISO (Master Input, Slave Output) broche de transmission équivalent à la borne Tx d’un
port série. Sortie du module.
▪ MOSI (Master Output, Slave Input) broche de réception équivalent à la borne Rx d’un
port série. Entrée du module.
▪ SCK (Clock) horloge permettant de synchroniser la communication
Liste du matériel

▪ Un module SD-shield
▪ Une micro-carte SD
Compte rendu
Arnaud NANFAK 27

Programme
Dans l’environnement de développement Arduino, ajouter la bibliothèque SD mis à votre
01 #include SPI.h
02 #include SD.h
03 int SELECTED_CHIP = 4;
04 int count = 0;
05 void setup() {
07 if (SD.begin(SELECTED_CHIP)) {
08 Serial.println("SD-Card initialized.");
09 } else {
10 Serial.println("SD-Card failed or is missing");
11 }
12 }
03 void loop() {
14 String line = String("Bonjour le monde #") + String(count);
15 writeToSD(line);
16 count = count + 1;
17 delay(1000);
18 }
19 void writeToSD(String line) {
20 File dataFile = SD.open("test.csv", FILE_WRITE);
21 if (dataFile) {
22 dataFile.println(line); // Enregistrer sur la carte
23 dataFile.close(); // Fermer le fichier
24 Serial.println(line);
25 } else {
26 Serial.println("Error opening datafile");
27 }
28 }
Arnaud NANFAK 28
Compte rendu
1. Donner le rôle de la bibliothèque SPI

3. L’enregistrement dans la carte s’effectue à quelle ligne du code
4. On souhaiterait ajouter au montage une horloge RTC DS1307 et un capteur de
température DTH11. Proposer un schéma
5. Modifier le code pour enregistrer sur un fichier dans la carte SD l’heure et la température
toute les 10 secondes.
Arnaud NANFAK 29
Manipulation N° 7 : Enregistrement des données des stations

météorologiques
Objectifs : Cette manipulation vise à l’enregistrement de données météorologiques
(Température, humidité et intensité lumineuse) dans une carte SD avec indicateur du temps. Dans
le cadre de cette manipulation, les étudiants consoliderons les acquis des manipulations précédentes
pour la réalisation d’un projet.
Liste du matériel

▪ une horloge RTC avec module I2C
▪ Capteur de température et d’humidité DTH11
▪ Un module SD-shield avec micro-carte SD
▪ Un photorésistance
Manipulation
Arnaud NANFAK 30

Programme
Dans l’environnement de développement Arduino, ajouter les bibliothèques SD, DS3231 et dth
mises à votre disposition par l’enseignant. Saisir le programme ci-dessous.
01 #include <SD.h>
02 File file;
03 String filename = "data.csv";
04 #include <DS3231.h>
05 DS3231 rtc(SDA, SCL);
06 #include <dht.h>
07 dht DHT;
08 int CSpin = 10;
09 int lightPin = A3;
10 int PCBpin = 6;
11 int i = 0;
12 int check, light, temp, humid;
13 String data, date, time;
14
15 void setup()
16 {
18 rtc.begin();
19 Serial.println("checking SD card");
20 if(SD.begin(CSpin) == 0)
21 {
22 Serial.println("Card fail");
23 return;
24 }
25 Serial.println("Card OK");
26 if(SD.exists(filename)>0) SD.remove(filename);
27 file = SD.open(filename, FILE_WRITE);
28 if(file == 1)
29 {
30 String header = "record, time, light, temp, humid, on ";
31 header = header + String(rtc.getDateStr());
32 file.println(header);
33 file.close();
34 }
35 else Serial.println("Couldn't access file");
36 }
37
38 void loop()
39 {
40 i++;
41 Serial.print("record ");Serial.println(i);
42 light= analogRead(lightPin);
43 check = DHT.read11(PCBpin);
44 temp = DHT.temperature;
45 humid = DHT.humidity;
46 time = rtc.getTimeStr();
47 data = String(i) + "," + String(time) + "," + String(light);
48 data = data + "," + String(temp)+ "," + String(humid);
49 file = SD.open(filename, FILE_WRITE);
50 file.println(data);
51 file.close();
52 delay(1000);
53 }
Arnaud NANFAK 31
Compte rendu
8. Donner le rôle de la bibliothèque Wire

9. Qu’elle est le module RTC utilisé pour cette manipulation ?
12. Comparer l’heure de votre ordinateur et l’heure affichée sur le LCD. Expliquer votre
observation
13. Modifier l’heure de votre ordinateur et comparer à celle affichée sur le LCD. Expliquer
votre observation
14. Avec l’heure modifier de votre ordinateur, téléverser de nouveau votre code et comparer
les heures de l’ordinateur et du LCD. Expliquez votre observation
Arnaud NANFAK 32
Manipulation N° 8 : Commande à distance des LEDs par télécommande

infrarouge
Objectifs : Cette manipulation vise à commander à distance des leds à partir d’une
télécommande infrarouge.
Liste du matériel
▪ un ordinateur et l’IDE Arduino installé

▪ un récepteur infrarouge
▪ une télécommande infrarouge
▪ plaque à essai, câbles de connexion
▪ des résistances, 03 LEDs (une verte, une rouge et une oranger)
Manipulation

Programme
Arnaud NANFAK 33
Dans l’environnement de développement Arduino, ajouter la bibliothèque IRremote mise à votre

#include <IRremote.h>
Const int RECV_PIN = 5;
IRrecv irrecv(RECV_PIN);
decode_results results;
const int led_verte = 2;

const int led_oranger = 3;
const int led_rouge = 4;
int allumer_vert,allumer_rouge,allumer_oranger;
void setup()
{
Serial.begin(9600) ;
irrecv.enableIRIn(); // Initialise le recepteur infrarouge
allumer_vert=0;
allumer_rouge=0;
allumer_oranger=0;
pinMode(led_verte, OUTPUT);
pinMode(led_oranger, OUTPUT);
pinMode(led_rouge, OUTPUT);
}
void loop()
{
if (irrecv.decode(&results)) {
Serial.println(results.value,HEX);
if (results.value == 0xFF30CF) {
if (allumer_vert == 0) {
allumer_vert = 1;
digitalWrite(led_verte, HIGH); }
else {
allumer_vert = 0;
digitalWrite(led_verte, LOW); }
}
if (results.value == 0xFF18E7) {
if (allumer_oranger == 0) {
allumer_oranger = 1;
digitalWrite(led_oranger, HIGH); }
else {
allumer_oranger = 0;
digitalWrite(led_oranger, LOW); }
}
if (results.value == 0xFF7A85) {
if (allumer_rouge == 0) {
allumer_rouge = 1;
digitalWrite(led_rouge, HIGH); }
else {
allumer_rouge = 0;
digitalWrite(led_rouge, LOW); }
}
}
irrecv.resume();
}
Arnaud NANFAK 34
Compte rendu
1. Déterminer le code des différentes touches de la télécommande

2. Indiquer les touches qui allument les LEDs verte, rouge et oranger
3. Modifier le programme pour que la touche 5 allume toute les LEDs séquentiellement à
intervalle de temps de 2 secondes
Arnaud NANFAK 35
Manipulation N° 9 : Message défilant sur afficheur matriciel 8x8

Objectifs : Cette manipulation vise à faire défiler sur un afficheur matriciel 8x8 un message.
Liste du matériel

▪ 4 afficheurs matriciel 8x8 avec module MAX7219
Manipulation

Programme 1
Dans l’environnement de développement Arduino, ajouter les bibliothèques MD_Parola et
MD_MAX72XX misent à votre disposition par l’enseignant. Saisir le programme ci-dessous.
01 #include <MD_Parola.h>
02 #include <MD_MAX72xx.h>
03 #include <SPI.h>
04 // Define hardware type, size, and output pins:
05 #define HARDWARE_TYPE MD_MAX72XX::FC16_HW
06 #define MAX_DEVICES 4
07 #define CS_PIN 3
08 // Create a new instance of the MD_Parola class with hardware SPI connection:
09 MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
10 // Setup for software SPI:
11 // #define DATAPIN 2
12 // #define CLK_PIN 4
13 // MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN,
MAX_DEVICES);
Arnaud NANFAK 36
14
15 void setup() {
16 // Intialize the object:
17 myDisplay.begin();
18 // Set the intensity (brightness) of the display (0-15):
19 myDisplay.setIntensity(0);
20 // Clear the display:
21 myDisplay.displayClear();
22 }
23
24 void loop() {
25 myDisplay.setTextAlignment(PA_CENTER);
26 myDisplay.print("Center");
27 delay(2000);
28 myDisplay.setTextAlignment(PA_LEFT);
29 myDisplay.print("Left");
30 delay(2000);
31 myDisplay.setTextAlignment(PA_RIGHT);
32 myDisplay.print("Right");
33 delay(2000);
34 myDisplay.setTextAlignment(PA_CENTER);
35 myDisplay.setInvert(true);
36 myDisplay.print("Invert");
37 delay(2000);
38 myDisplay.setInvert(false);
39 myDisplay.print(1234);
40 delay(2000);
41 }
Programme 2
Dans l’environnement de développement Arduino, saisir le programme ci-dessous.
01 #include <MD_Parola.h>
02 #include <MD_MAX72xx.h>
03 #include <SPI.h>
04 // Define hardware type, size, and output pins:
05 #define HARDWARE_TYPE MD_MAX72XX::FC16_HW
06 #define MAX_DEVICES 4
07 #define CS_PIN 3
08 // Create a new instance of the MD_Parola class with hardware SPI connection:
09 MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
10 // Setup for software SPI:
11 // #define DATAPIN 2
12 // #define CLK_PIN 4
13 // MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN,
MAX_DEVICES);
14
15 void setup() {
16 // Intialize the object:
17 myDisplay.begin();
18 // Set the intensity (brightness) of the display (0-15):
19 myDisplay.setIntensity(0);
20 // Clear the display:
21 myDisplay.displayClear();
22 myDisplay.displayText("Scrolling text", PA_CENTER, 100, 0, PA_SCROLL_LEFT, PA_SCROLL_LEFT);
23 }
24
25 void loop() {
26 if (myDisplay.displayAnimate()) {
27 myDisplay.displayReset();
Arnaud NANFAK 37
28 }
29 }
Compte rendu
1. Expliquer les lignes de code 25, 28 31 et 34 du programme 1

2. Modifier la luminosité et le fixer à 5
3. Expliquer la ligne de code 22 du programme 2
4. Modifier le texte défilant pour afficher « TP DE MICROCONTROLEUR ENSPD »
Arnaud NANFAK 38
Manipulation N° 10 : Affichage matriciel P10 commandé par bluetooth

Objectifs : Cette manipulation vise à faire défiler sur un afficheur P10 un message modifiable à volonté
à travers une application android.
Liste du matériel

▪ 4 afficheurs P10 avec câbles
▪ Un module HC-05
▪ APK Bluetooth terminal HC-05
Manipulation
Arnaud NANFAK 1
Programme 1
Dans l’environnement de développement Arduino, ajouter les bibliothèques DMD et TimerOne et Wire
misent à votre disposition par l’enseignant. Saisir le programme ci-dessous.
#include <SPI.h>
#include <DMD.h>
#include <TimerOne.h>
#include "SystemFont5x7.h"
#include "Arial_black_16.h"
#include <Wire.h>
#define ROW_MODULE 4
#define COLUMN_MODULE 1
DMD p10(ROW_MODULE, COLUMN_MODULE);
char message[500];
char char_read;
byte pos_index = 0;
int i;
char welcome_screen[] = "Ecole national polytechnique de Douala";
void p10scan()
{
p10.scanDisplayBySPI();
}
void setup()
{
Serial.begin(9600);
delay(1000); // wait for console opening
Timer1.initialize(1000);
Timer1.attachInterrupt(p10scan);
p10.clearScreen( true );
strcpy(message,welcome_screen);
}
void loop()
{
if(Serial.available())
{
for(i=0; i<199; i++)
{
message[i] = '\0';
Serial.print(message[i]);
}
pos_index=0;
}
while(Serial.available() > 0)
{
if(pos_index < (199))
{
char_read = Serial.read();
message[pos_index] = char_read;
pos_index++;
}
}
Arnaud NANFAK 2
p10.selectFont(Arial_Black_16);
p10.drawMarquee(message,45,(32*ROW_MODULE)-1,0);
long start=millis();
long timer_start=start;
boolean flag=false;
while(!flag)
{
if ((timer_start+250) < millis())
{
flag=p10.stepMarquee(-1,0);
timer_start=millis();
}
}
}
Télécharger et installer l’application android « bluetooth terminal HC-05 » mise à votre disposition par l’enseignant.
Compte rendu
1. Envoyer par bluetooth le texte défilant suivant « TP DE MICROCONTROLEUR ENSPD »

2. Ajouter un module RTC et afficher l’heure et la date sur le texte défilant
Arnaud NANFAK 3
ANCIENS SUJETS AVEC CORRECTIONS
Arnaud NANFAK 4
EXAMEN SESSION NORMALE

Intitulé de l’U.E. : MICROCONTROLEURS 1, 2, 3 Filière : ROI
Code U.E. : FGI-ROI-341 Niveau : III
Documents non autorisés Durée : 2h
Enseignant : M. NANFAK Arnaud
1ère Partie : Connaissances générales (50 points)
1. Définir les termes suivants : Timer, Registre, Microcontrôleur, Bus, et Watchdog (10 points)
2. Donner la signification des acronymes suivants : USB, I2C, UAL, RAM et CPU (10 points)
3. Donner les différences entre un microprocesseur et un microcontrôleur ? (5 points)
4. Décrire le processus de lecture et d’écriture en mémoire centrale (5 points)
5. Décrire étape par étape le traitement d’une instruction (6 points)
6. Expliquer le principe de l’adressage indirect (4 points)
7. Faites une étude comparative entre les architectures RISC et CISC (10 points)
2ème Partie : QCM (10 points)
1. Qu'est-ce qu'un WatchDog (chien de garde) ?

a. Un dispositif de correction d'erreur (comme le CRC).
b. Un dispositif réagissant au plantage du µC
c. un programme de radio-réveil digital
2. De combien de bus est équipé un microcontrôleur?
a. 1
b. 2
c. 3
3. Qu'est-ce que le pointeur d'instruction ?
a. Le registre contenant l'instruction en cours.
b. Le registre contenant l'adresse de l'instruction en cours.
c. Le registre contenant l'adresse de l'instruction suivante.
4. Un microprocesseur dit RISC a pour principales caractéristiques :
a. Un jeu d'instructions étendu et un nombre de cycles par instruction élevé
b. Des jeux d'instructions et nombre de cycles par instruction réduits
c. Un jeu d'instructions réduit et un nombre de cycles par instruction élevé
Arnaud NANFAK 5
5. Parmi les périphériques du microcontrôleur, CAN signifie :

a. Controller Area Network
b. Convertisseur Analogique Numérique
c. Capteur Analogique ou Numérique
3ème Partie : Cas pratique (35 points)
Dans le cadre de votre projet de fin d’étude, vous devez réaliser un dispositif de relevé de la température
dans un séchoir de fruit. Pour la réalisation, vous optez pour le microcontrôleur UNO de la famille Arduino.
Votre dispositif doit remplir le cahier de charge suivant : Alimentation par batterie, relevé toutes les 60
secondes de la température dans le séchoir avec enregistrement dans une carte mémoire SD (Date, temps et
température) et un affichage temps réel de la température dans le séchoir sur un afficheur LCD (la
communication entre la carte arduino et l’afficheur LCD se fera par l’intermédiaire du module I2C).
1. Citer les grandes parties d’un programme arduino (3 points)

2. Définir les termes : Compiler et Téléverser (2 points)
3. Indiquer les parties de la figure ci-dessous (8 points)
4. Citer les différents éléments donc vous aurez besoin pour la réalisation de votre projet (10 points)
5. Citer les bibliothèques que vous allez utiliser lors de la rédaction de votre programme (préciser le
composant concerné) (8 points)
6. Quel est la référence du composant de numéro 3 ? (2 points)
7. Quel est l’avantage d’utiliser le
module I2C ? (2 points)
Présentation : 5 points
Arnaud NANFAK 6
CORRECTION SESSION NORMALE

Intitulé de l’U.E. : MICROCONTROLEURS 1, 2, 3 Filière :
ROI
Code U.E. : FGI-ROI-341 Niveau : III
Documents non autorisés Durée : 2h
Enseignant : M. NANFAK Arnaud
1ère Partie : Connaissances générales (50 points)
1. Définition des termes suivants :
Un timer est un compteur qui sert à la temporisation et a créer des interruptions. (2 points)
Un registre est une zone mémoire à l’intérieur du microprocesseur de faible taille, qui permet de
mémoriser des mots mémoires ou des adresses d’une façon temporaire lors de l’exécution des instructions.
(2 points)
Un microcontrôleur est un circuit intégré qui rassemble les éléments essentiels d’un ordinateur à savoir
un microprocesseur (généralement peu puissant), plusieurs types de mémoires et des périphériques de
communication (Entrées-Sorties). (2 points)
Un bus est un ensemble de lignes transportant des informations codées binaires. (2 points)
Un watchdog est un composant qui est souvent utilisé dans le domaine du temps réel pour surveiller le
déroulement du programme d'un microcontrôleur. (2 points)
2. Signification des acronymes suivants :
USB : Universal Serial Bus (2 points)
I2C : Inter-Integrated Circuit (2 points)
UAL : Unité Arithmétique et Logique (2 points)
RAM : Random Access Memory (2 points)
CPU : Central Processing Unit (2 points)
3. Différences entre un microprocesseur et un microcontrôleur
Arnaud NANFAK 1
Un microprocesseur est un calculateur qui pour son fonctionnement à besoin de mémoires ou

seront stocké le programme et les données tandis que le microcontrôleur tout comme le
microprocesseur est un circuit intégré mais qui regroupe en son sein un microprocesseur, des
mémoires et des entrées/sorties lui permettant d’interagir avec son environnement. (5 points)
4. Description des processus de lecture et d’écriture en mémoire centrale
La lecture : L’adresse du mot à lire est transférée au registre d’adresse, le dispositif d’accès à la mémoire
se charge de chercher le mot et de le mettre dans le registre de données. (2.5 points)
L’écriture : Le registre d’adresse est chargé par l’adresse mémoire ou on va écrire, le mot à écrire est placé
dans le registre de données. Lorsque l’ordre de l’écriture est donné, le contenu des cases mémoires sera
écrasé et remplacé par la nouvelle valeur. (2.5 points)
5. Décrire étape par étape le traitement d’une instruction
Phase 1: Recherche de l'instruction à traiter (2 points)
▪ Le PC contient l'adresse de l'instruction suivante du programme. Cette valeur est placée sur le bus
d'adresses par l'unité de commande qui émet un ordre de lecture.
▪ Au bout d'un certain temps (temps d'accès à la mémoire), le contenu de la case mémoire
sélectionnée est disponible sur le bus des données.
▪ L'instruction est stockée dans le registre instruction du processeur.
Phase 2 : Décodage de l’instruction et recherche de l'opérande (2 points)
Le registre d'instruction contient maintenant le premier mot de l'instruction qui peut être codée sur
plusieurs mots. Ce premier mot contient le code opératoire qui définit la nature de l'opération à effectuer
(addition, rotation,...) et le nombre de mots de l'instruction.
▪ L'unité de commande transforme l'instruction en une suite de commandes élémentaires nécessaires

au traitement de l'instruction.
▪ Si l'instruction nécessite une donnée en provenance de la mémoire, l'unité de commande récupère
sa valeur sur le bus de données.
▪ L’opérande est stocké dans un registre.
Phase 3 : Exécution de l'instruction (2 points)
▪ Le micro-programme réalisant l'instruction est exécuté.

▪ Les drapeaux sont positionnés (registre d'état).
Arnaud NANFAK 2
▪ L’'unité de commande positionne le PC pour l'instruction suivante.

6. Principe de l’adressage indirect
Le mode d’adressage indirect permet d’accéder à une donnée par l’intermédiaire d’un registre
qui contient son adresse ou l’adresse d’une position mémoire qui, elle, contient l’adresse de
l’opérande. (4 points)
7. Etude comparative entre les architectures RISC et CISC
Comparatif entre les architectures CISC et le RISC (10 points)
Architecture RISC Architecture CISC

Instructions simples ne prenant qu’un seul cycle Instructions complexes prenant plusieurs cycles
Instructions au format fixe Instructions au format variable
Décodeur simple Décodeur complexe
Beaucoup de registres Peu de registres
Peu de modes d’adressage Beaucoup de modes d’adressage
Compilateur complexe Compilateur simple
seules les instructions LOAD et STORE ont toutes les instructions sont susceptibles
accès à la mémoire d’accéder à la mémoire
2ème Partie : QCM (10 points)
1. Qu'est-ce qu'un WatchDog (chien de garde) ?

a. Un dispositif de correction d'erreur.
b. Un dispositif réagissant au plantage du µC (2 points)
c. un programme de radio-réveil digital
2. De combien de bus est équipé un microcontrôleur?
a. 1
b. 2
c. 3 (2 points)
3. Qu'est-ce que le pointeur d'instruction ?
a. Le registre contenant l'instruction en cours.
b. Le registre contenant l'adresse de l'instruction en cours.
c. Le registre contenant l'adresse de l'instruction suivante. (2 points)
4. Un microprocesseur dit RISC a pour principales caractéristiques :
Arnaud NANFAK 3
a. Un jeu d'instructions étendu et un nombre de cycles par instruction élevé

b. Des jeux d'instructions et nombre de cycles par instruction réduits
c. Un jeu d'instructions réduit et un nombre de cycles par instruction élevé (2 points)
5. Parmi les périphériques du microcontrôleur, CAN signifie :
a. Controller Area Network
b. Convertisseur Analogique Numérique (2 points)
c. Capteur Analogique ou Numérique
3ème Partie : Cas pratique (35 points)
1. Les grandes parties d’un programme arduino

▪ L’initialisation des variables et constantes du programme ; (1 points)
▪ La fonction principale void setup() (1 points)
▪ La fonction boucle void loop() (1 points)
2. Définition les termes : Compiler et Téléverser
Compiler c’est traduire un langage (appelé le langage source) en un autre (le langage cible), généralement
dans le but de créer un fichier exécutable. (1 points)
Téléverser c’est transférer vers la carte le fichier exécutable (1 points)
3. Parties de la figure ci-dessous
1 : Témoin de communication série ; 2 : Entrées/sorties digitales ; 3 : Microcontrôleur ; 4 :

Entrées analogiques ; 5 : Tensions de références ; 6 : Entrée Jack ; 7 : Connecteur USB ; 8 :
Bouton réset (1x8 points)
4. Eléments nécessaires pour la réalisation du projet
Batterie avec connexion Jack ; capteur de température LM35 ; afficheur LCD ; bus I2C ; arduino
UNO ; RTC DS1307 ; Shield carte SD ; Machine avec l’IDE installé (10 points)
5. Citer les bibliothèques que vous allez utiliser lors de la rédaction de votre programme
(préciser le composant concerné)
Bibliothèque Wire.h (bus I2C) ; LiquidCrystal.h (afficheur LCD) ; DS1307.h (RTC DS1307) et
SD.h (Shield SD). (2x4 points)
6. Référence du composant de numéro 3 : Atmel ATMega 328 (2 points)

7. Avantage d’utiliser le module I2C
Arnaud NANFAK 4
Le principal avantage à utiliser le module I2C est de réduire le nombre de port nécessaire pour
communication entre le microcontrôleur UNO et l’afficheur LCD. (2 points)
Présentation : 5 point
Arnaud NANFAK 5

Microcontroleurs GAM 2023 2024

Transféré par

Informations du document

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

Microcontroleurs GAM 2023 2024

Transféré par

Droits d'auteur :

Formats disponibles

Université de Douala | Ecole Nationale Supérieure Polytechnique de Douala |

DépaM Niveau 3 | Ingénieur | Génie Automobile et Mécatronique (GAM)

Support de Cours de Microcontrôleurs et

Génie automobile et mécatronique

Année Académique 2023/2024

PhD in Electrical Energy, Robotic and Signal Processing

695 262 380 / 678 289 787 / 620 150 808

NB: Le support de cours ne remplace pas le cours

RAPPEL SUR LES MICROPROCESSEURS ...................................................................................... 1

I. Architecture interne des microprocesseurs ..................................................................................... 1

I.1. L’unité de commande .......................................................................................................... 2

I.2. L’unité de traitement ........................................................................................................... 2

I.3. Les registres ......................................................................................................................... 5

I.4. Les autres unités des microprocesseurs ............................................................................... 6

II. Les étapes d’exécution d’une instruction ...................................................................................... 7

II.1. Définition ............................................................................................................................... 7

II.2. Les différents types d’instructions ......................................................................................... 8

II.3. Les étapes de traitement ......................................................................................................... 9

III. Les modes d’adressages ............................................................................................................... 9

III.1. Le mode d’adressage implicite ou inhérent ........................................................................ 10

III.2. Le mode d’adressage immédiat .......................................................................................... 10

III.3. Le mode d’adressage direct ................................................................................................ 10

III.4. Le mode d’adressage indirect ............................................................................................. 10

IV. Les types de microprocesseurs .................................................................................................. 11

V. Les performances d’un microprocesseur .................................................................................... 12

VI. Les familles de microprocesseurs .............................................................................................. 12

CHAPITRE 2 : MICROCONTROLEUR ............................................................................................ 14

I. Architecture des microcontrôleurs................................................................................................ 14

I.1. Architecture de Von Neumann .............................................................................................. 14

I.2. Architecture de Harvard ........................................................................................................ 15

II. Les éléments de base des microcontrôleurs ................................................................................ 17

II.1. L’horloge : ............................................................................................................................ 18

II.2. Mémoires .............................................................................................................................. 18

II.3. Interfaces parallèles .............................................................................................................. 21

II.4. Interfaces série...................................................................................................................... 21

II.5. Convertisseur analogique-numérique ................................................................................... 21

II.6. Convertisseur numérique-analogique ................................................................................... 21

II.7. Timers/Compteurs ................................................................................................................ 21

II.8. Chien de garde (watchdog) .................................................................................................. 21

II.9. Bus ........................................................................................................................................ 22

III. Langage de programmation ....................................................................................................... 23

III.1. Les langages de Haut niveau, bas niveau et machine ......................................................... 23

III.2. Compilation et interprétation .............................................................................................. 24

III.3. Mise au point d’un programme ........................................................................................... 25

CHAPITRE 3 : CAS PRATIQUE D’ETUDE : MICROCONTROLEUR ARDUINO UNO ............... 1

I. Schéma simplifié de la carte Arduino UNO ................................................................................... 1

II. Microcontrôleur ATMEL ATMEGA328 ...................................................................................... 2

III. Les entrées/sorties de l’arduino UNO .......................................................................................... 3

III.1. Les entrées/sorties numériques ............................................................................................. 4

III.2. Les entrées analogiques ........................................................................................................ 5

III.3. Les sorties analogiques ......................................................................................................... 5

III.4. Les tensions de références .................................................................................................... 5

III.5. Le port USB .......................................................................................................................... 6

IV. Transférer un programme dans la carte ....................................................................................... 6

IV.1. Description de l’interface Arduino software ........................................................................ 7

IV.2. Description de la structure d’un programme ........................................................................ 8

TRAVAUX PRATIQUES ................................................................................................................... 10

Manipulation N° 1 : Le chenillard à LED ........................................................................................ 11

Manipulation N°2 : Arduino et afficheur LCD ................................................................................ 14

Manipulation N°3 : Arduino et Capteurs de température ................................................................ 17

Manipulation N° 4 : Arduino - Capteur à ultrasons HC-SR04 ........................................................ 21

Manipulation N° 5 : Émission de données (RTC)/Réception et affichage des données .................. 24

Manipulation N° 6 : Arduino et carte SD ........................................................................................ 27

Manipulation N° 7 : Enregistrement des données des stations météorologiques ............................ 30