Ces TD/TP se composent de 3 parties:

1- Partie I : Programmation du microcontroleur ATmega 2560 en utilisant le langage et

l’IDE Arduino.
a. TP1 : Prise en main de l’IDE Arduino
b. TD/TP2 : Le langage Arduino (I) : Les E/S digitales
c. TD/TP3 : Le langage Arduino (II) : Les Entrées analogiques/Sorties PWM
d. TD/TP5 : Le langage Arduino (III) : Les Librairies Arduino (mini projet)
e. TD/TP6 : Le langage Arduino (IV) : Les interruptions
f. TD/TP7 : Le langage Arduino (V) : Les modes de veilles
2- Partie II : Programmation du microcontroleur ATmega 2560 avec Atmel Studio.
a. TD/TP5 : Prise en main de l’Atmel Studio 7 (Limitations de l’IDE Arduino)
b. TD/TP6 : Les E/S digitales - Les interruptions
c. TD/TP7 : Les timers (temporisations matérielles - générateurs PWM)
d. TD/TP8 : Les convertisseurs analogiques numériques
e. TD/TP9: Les modules de communications série
3- Partie III : L’utilisation d’un noyau temps réel avec Atmel Studio.
a. TD/TP10 : Configuration et utilisation de RTOS
b. TD/TP11 : Applications
 Partie I
Programmation du microcontroleur ATmega 2560 en utilisant
le langage Arduino.
 TP N°1
Prise en main de l’IDE Arduino

1. Etudier les caractéristiques de la carte Arduino Mega;

2. S’initier à l’utilisation de l’IDE Arduino.

1. La carte Arduino Mega

2. L’IDE Arduino
3. Manipulation
Dans ce TP, nous découvrirons la carte Arduino Mega et l’IDE Arduino. Nous
apprendrons comment alimenter la carte puis la programmer à travers une application
simple : faire clignoter une LED (Blink).

1.1 Materiel Arduino

1.1.1 La carte Arduino Mega 2560 R3

Figure 1.1 : La carte Arduino Mega 2560

1
 Les principales caractéristique dela carte Arduino Mega:
▪ Microcontrôleur : ATmega2560
▪ Tension de fonctionnement : 5 V
▪ Gamme de tension d’entrée recommandée: 7-12 V
▪ Gamme de tensions d’entrée limite: 6-20 V
▪ Fréquence d’horloge de l’oscillateur à quartz : 16 MHz
▪ Mémoire flash : 256 KB dont 8 KB réservé au Bootloader (il permet de télécharger
les programmes entre l’IDE Arduino (interface de développement).
▪ Mémoire SRAM : 8 KB
▪ Mémoire EEPROM : 4 KB
▪ Ports digitaux I/O : 54 dont 14 PWM
▪ Ports d’entrée analogique : 16
▪ Ports série UART: 4
▪ Bus I2C et SPI
▪ 6 entrées à interruptions
▪ Port USB (fiche B) géré par le MCU ATmega 16U
▪ Un connecteur ICSP (programmation "in-circuit"),
▪ Un bouton de réinitialisation (Reset)
Visualisation
▪ LED ‘ON’ : indique que la carte est sous tension.
▪ LED ‘Tx’ et LED ‘Rx’: servent à visualiser l'activité sur la voie série (pendant
l'émission et la réception de données ou le chargement du programme dans le
microcontrôleur par le port USB).
▪ LED ‘L’: elle est connectée à la broche 26 du microcontrôleur (port 13
d’Arduino). Cette LED clignote quelques secondes après l’initialisation de la
carte ( et après le branchement de la carte au PC). Cette LED peut être utilisée
dans des applications et sert souvent comme LED de signalisation pour vérifier
le fonctionnement de la carte.
Les connecteurs d’entrées/sorties :
▪ Les ports E/S numérique 0-53 peuvent être configurés en entrée ou en sortie
▪ Les ports PWM 0-13 codée sur 8 bits (0 à 255)
▪ Les ports d’entrée analogiques A0-A15 (résolution 10bits)
▪ Ports de communication : UART1/USB utilise les broches : 0(RX0), 1(TX0),
UART2 : 18(TX1), 19(RX1), UART3: 16(TX2), 17(RX2), UART4 : 14(TX3), 15(RX3).
▪ SPI est accessible via les broches ICSP ou les broches: 50(MISO), 51(MOSI),
52(SCK), 53(SS).
▪ I²C accessible via les broches: 20(SDA), 21(SCL).

Shéma
La figure 1.2 donne le shéma électrique de la carte Mega 2560 montrant les différents
éléments de la carte et leurs interconnexions.

2
Figure 1.2 : Shéma de la carte Arduino Mega 2560

3
1.1.2 Alimentation de la carte Arduino
la carte Arduino, qui demande une alimentation de fonctionnement de 5v, peut être
alimentée via le port USB ou avec une alimentation externe. Les figure 1.1 et 1.2 montre les
différentes entrées d’alimentation. L’entrée d’alimentation est sélectionnée
automatiquement et doit fournir l’intensité de courant nécessaire:
 à l’alimentation de l’Arduino et aux entrées/sorties ;
 aux shields et modules alimentés par la carte ;
 au régulateur 3.3V.
Pour mieux comprendre les interdépendances entre les différentes entrées et sorties
d’alimentation, on se reportera au schéma de la figure 1.3, qui rassemble les circuits
d’alimentation de la carte Arduino Mega:

Figure 1.3 : Circuits d’alimenation de la carte Arduino Mega 2560

L'alimentation externe (non-USB) peut être soit un adapteur secteur (pouvant fournir
typiquement de 7V à 12V sous 500mA) ou des piles. L'adaptateur secteur peut être
connecté en branchant une fiche 2.1mm positif au centre au connecteur jack de la carte. En
défaut d’alimentation dotée de la fiche adéquate, il est possible d’insérer les fils (+) et (-)
d'un bloc d’alimentation ou de piles dans les broches de la carte appelées Gnd (masse ou
0V) et Vin (Tension positive en entrée) du connecteur d'alimentation (POWER).
NB : les limites de la tension d’alimentation externe est 6 et 20 volts . En cas
d’utilisation de plus de 12V, le régulateur de tension peut surchauffer et endommager la
carte. La plage recommandée est de 7 à 12V. Si la carte est alimentée avec moins de 7V, la
broche 5V peut fournir moins de 5V et la carte peut être instable. L’origine de ces tensions
limites est :

4
 Pour 6V : le régulateur utilisé possède une chute de tension minimum de 1V. Par
conséquent, en deçà de 6V de tension d’entrée, la tension de sortie sera égale à la tension
d’entrée moins la chute de tension et l’Arduino sera alimenté en dessous de la tension
nominale de 5V. La conséquence est un fonctionnement qui peut être erratique.
Pour 20V : la carte Arduino fonctionne sous 5V, le régulateur qui reçoit cette tension
d’entrée l’abaisse pour fournir du 5V. la puissance que ce régulateur dissipe est la
différence de tension entre Vin et 5V multipliée par le courant que consomme la carte et
les dispositifs externes alimentés par elle. Par conséquent plus la différence de tension est
élevée et plus le régulateur se chauffe. Le régulateur ayant une protection contre la
surchauffe, il coupe l’alimentation si la température devient trop élevée.
Desciption usuelle du connecteur POWER : Les broches d’alimentation pour la carte
Arduino Mega sont les suivantes:
• Vin Tension d'entrée positive lorsque la carte Arduino est utilisée avec une source
de tension externe (à distinguer du 5V de la connexion USB ou autre source 5V
régulée).
• 5V tension de sortie régulée fournie par le régultaur intégré
• 3V3 tension de sortie régulée fournie par le adaptateur intégré
• GND Broche de masse (ou 0V).
Pour plus de comodité d’utilisation, la carte contient d’autres broches d’alimentation
(5V, Gnd) disponibles avec les connecteurs d’E/S (figure 1.4).

Figure 1.4 : Toutes les broches d’alimentation de la carte Arduino Mega 2560

[Link] Alimentation par USB avec ou sans ordinateur

Dans ce cas, la tension 5v (régulée) sera fourni directement, en passant par un transistor
MosFET T1 dont le rôle est la selection automatique de la source d’alimentation entre
USB et Vin (Jack) (figure 1.3). L’ensemble des composants de la carte et les modules
externes connectés ne devront pas consommer plus de 500mA. Cette limitation protège le
port USB de l’ordinateur à travers l’utlisation d’un fusible électronique à réarmement
automatique qui coupe l’alimentation si la limite de 500mA est dépassée. Cette méthode
limite donc la consommation totale du montage à 500mA (figure 1.2). Cette alimentation
peut être générée à partir d’un PC ou une alimentation régulée (d’un smartphone par
exemple).

[Link] Alimentation par connecteur Jack

la carte comprend un connecteur d’alimentation de type Jack femelle. Il faut donc un
connecteur jack mâle. Ce type de connecteur possède 2 fils dont le fil + est à l’intérieur et
le fil - à l’extérieur. Sur cette entrée, une diode de protection, évite les mauvais

5
branchements (inversion de polarité). Comme source, il faut appliquer une tension entre 7
et 12V continu (tension recommandée). Nous pouvons utiliser plusieurs sources :
▪ un bloc d’alimentation AC/DC, 9V est une tension fréquente et idéale ;
▪ une pile 9V ;
▪ un ensemble de 7 piles 1.5V…
La tension 5V est obtenu par le régulateur et les intensités acceptable seront les mêmes,
en tenant compte toutefois de la puissance dissipée par la diode. Pour le régulateur 5V de
l’Arduino utilisé, la limite d’intensité délivrable sont:
 Alimentation 12 V: I = 2 / (12-5) = 2 / 7 = 285mA
 Alimentation 9 V: I = 2 / (9-5) = 2/4 = 500mA
 Alimentation 7 V: I = 2 / (7-5) = 2/2 = 1A

[Link] Alimentation par les broches Vin et GND du connecteur POWER

Cette méthode nécessite une vigilance accrue compte tenu des possibilités d’erreur de
branchement. Il va falloir vérifier le branchement à plusieurs reprises avant de mettre sous
tension. Il faut relier le fil + à la borne Vin de l’arduino et le fil – à une des broches GND.
Une erreur de branchement risque d’endommager la carte. Après avoir répéré les fils + et -,
il faut les relier à l’arduino par les deux broches nommées, à savoir :
▪ le + (habituellement le fil rouge) est relié à la broche Vin
▪ le – (habituellement le fil noir) est relié à GND.
Tout comme le cas d’alimentation par connecteur Jack , la tension optimale de ce
courant continu se situe entre 7 et 12V. Dans ce contexte et afin de protéger l’arduino d’un
mauvais branchement le + sur le – et le – sur le +, nous pouvons intercaler une diode qui
ne laissera passer le courant que si il est dans le bon sens. La référence de diode est de type
1N400x.

[Link] Alimentation par les broches 5V et GND du connecteur POWER

Dans ce cas, il faut impérativement que le jack ne soit pas alimenté, mais l’USB peut
l’être (utilisation de la transmission de données), le circuit constitué du comparateur IC7B
et du MOSFET T1 évitera le court-circuit entre la tension 5v du port USB et la tension
délivrée sur la broche 5V. Il faudra protéger l’entrée contre les surtensions, inversions, ….
Aucun régulateur ne limite la puissance fournie par cette entrée 5v.

[Link] Les sources de la carte

▪ si la carte est alimentée par Vin ou le jack d’alimantation, on pourra alimenter des
composants extérieurs via le 5v dans la limite des intensités vues plus haut
(échauffement du régulateur)
▪ si la carte est alimentée par USB, on pourra alimenter des composants extérieurs
via le 5v dans la limite de la capacité de l’appareil connecté et du fusible, soit
500mA maximum.
▪ si la carte est alimentée par le 5v, on pourra relier celui-ci aux éléments extérieurs
sans influence sur la carte.
Dans tous les cas, on pourra utiliser la sortie 3.3V pour alimenter des éléments qui
necessitent une telle tension , mais l’intensité de sortie est très limitée (50mA).

6
1.2 L’IDE Arduino
1.2.1 Description
Avant de commencer, installer l’IDE 1.8.9 Arduino et le pilote de la carte si c’est
necessaire. Cet environnement de développement intégré, dédié au langage Arduino et à la
programmation des cartes Arduino, permet :
 d’écrire et compiler des programmes pour la carte Arduino
 de programmer la carte Arduino ( y transférer les programmes )
 de communiquer avec la carte Arduino (debogage…)
comme pour tout logiciel une interface graphique (GUI), l’IDE Arduino comporte les
éléments suivants :
• une Barre de Menus
• une Barre de Boutons qui donne un accès direct aux fonctions essentielles.
• un Editeur (à coloration syntaxique) pour écrire le code des programmes, avec
onglets de navigation, Le programme écrit avec le logiciel Arduino est appelé
sketch (ou croquis - en français), le fichier correspondant est d’extension « .ino ».
L’IDE permet de gérer un projet de plus d'un fichier. Ces fichiers doivent être des
fichiers Arduino normaux, des fichiers C (extension .c ), des fichiers C++ (.cpp) ou
des fichiers d'entête (.h).
• une Zone de messages indiquant l'état des actions en cours (compilation, transfert
du programme vers la carte ..)
• une Console d’affichage qui affiche les messages concernant le résultat de la
compilation du programme( taille programme compilé, erreurs …).

Barre de Menu

Barre de Boutons

Onglets de fichiers ouverts

Fenêtre d’édition des programmes

Zone de messages des action en cours

Console d’affichage des messages de compilation

Informations sur la carte et le port utilisés

Figure 1.5 : Les éléments de l’interface d’Arduino IDE

Le logiciel Arduino intègre également un Moniteur et un Traceur série (fenêtres
séparées) qui permettent principalement d'afficher des données reçus de la carte Arduino
sous formes de liste ou de graphe. L’utilisation de ces outils sera détaillée aux prochains
TPs.

7
1.2.2 Description de la barre des boutons
Vérifier/Compiler Sauvegarder sketch Moniteur série

Nouveau sketch

Ouvrir sketch

Téléverser

 Vérifier/compiler : Vérifie le code à la recherche d'erreur de syntaxe.

 Nouveau : Crée un nouveau code (ouvre une fenêtre d'édition vide)
 Ouvrir : Ouvre la liste de tous les programmes exemples
 Sauvegarder : Enregistre le programme.
 Téléverser : Compile le code et le transfère vers la carte Arduino.
 Moniteur Série : Ouvre la fenêtre du moniteur série.

1.2.3 Description des menus

Des commandes complémentaires sont disponibles dans cinq menus : Fichier - Edition –
Croquis - Outils - Aide.
Menu Fichier: Propose toutes les
fonctionnalités usuelles pour
gérer les fichiers :
• Carnet de croquis: est une
fonctionnalité permettant
d'avoir accès direct à tous les
programmes réalisés et
sauvegarder dans le repertoire
de travail (par defaut :
doduments/Arduino).
• Exemples: Ce menu déroulant
vers toute une série de
programmes d'exemples
disponibles.
Menu Edition : On y trouve tous
les outils d’édition des
programmes : copier, sélectionner,
commenter et indenter les
instructions….

8
 Menu Croquis :
• Vérifier/compiler: Vérifie le
code à la recherche d'erreurs
• Téléverser : permet de charger
le programme
• Inclure une bibliothèque :
permet de voir les bibliothèques
déjà installées et les gérer, et
aussi en inclure de nouvelles.
• Afficher le dossier des croquis :
Ouvre le répertoire courant du
programme .
• Ajouter un fichier…: Ajoute un
fichier source au programme (il
sera copier à partir de sa
localisation courante. Le
nouveau fichier apparaît dans
un nouvel onglet.
Menu Outils:
• Formatage Automatique: Cette
fonction formate le code de
façon à le rendre plus clair.
• Moniteur série : permet d’ouvrir
le moniteur de l’IDE (voir
figure) qui est une fenêtre dans
laquelle on peut afficher des
données reçu de la carte
Arduino (dans le cadre bleu) ou
d’envoyer des données à la carte
(à partir du cadre jaune).
• Traceur série : permet d’afficher
une représentation graphique
Moniteur série
des données reçu de la carte.
• Type de carte : pour
sélectionner la carte Arduino
utilisée.
Traceur série • Port Série: Ce menu contient
tous les ports séries (réels ou
virtuels) présents sur
ordinateur.
Menu Aide
• Le menu d’aide permet d’ouvrir
le site Arduino, notamment la
référence du langage en anglais,
qui permet de retrouver la
syntaxe des différentes
fonctions et leur mode de
fonctionnement.

9
1.3 Manipulation
1.3.1 Programmation de la carte Arduino
1. Saisir le programme et vérifier le code.
Pour commencer nous utilisons un programme très simple qui consiste à faire clignoter
la LED L de la carte. Le programme correspondant est le suivant :

Programme : Blink
/* by Colby Newman
This example code is in the public domain.
[Link] */
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Ce programme peut aussi être ouvert à partir Fichier>Exemples>Basics>Blink ou à partir
de la barre d’outils:

2. Sélectionner le bon port série (et la bonne carte Arduino...)

Avant de transférer votre programme vers la carte Arduino, vous devez vérifier que
vous avez bien sélectionné la bonne carte Arduino depuis le menu Outils>Type de carte. la
carte doit évidemment être connectée à l'ordinateur via un câble USB.
10
 Vous devez également sélectionner le bon port série depuis le menu Outils > Port
(Outils > Port Série) : delectionner le port COMx dédié à la carte.
Appuyez alors sur le bouton Verifier de la barre d'outils pour lancer la vérification du
code: Si tout va bien, aucun message d'erreur ne doit apparaître dans la console et la zone
de message doit afficher Compilation terminé attestant que la vérification s'est bien
déroulée.

3. Transfert du programme (Programmation de la carte)

Une fois le bon port série et la bonne carte Arduino sélectionnés, cliquer sur le bouton
" Téléverser" (Transfert vers la carte) dans la barre d'outils, ou bien sélectionner le menu
Croquis>téléverser : La carte Arduino alors se réinitialise automatiquement et démarre le
transfert. Sur la carte, 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.

Après le transfert du programme, le logiciel Arduino affiche un message indiquant que

le transfert est bien réalisé, ou afficher des messages d'erreurs... (Reprendre dans ce cas la
procédure). A la fin, le message "Téléversement terminée" indique la fin du transfert du
programme suivi d'un rapport sur la taille des mémoires occupées.

11
 TP N°2
Le langage Arduino (I) :
Les E/S digitales

1. Se familiariser avec le langage Arduino;

2. Manipuler les ports d’entrée/sortie numériques;
3. Apprendre à utiliser le moniteur série (comme un moyen de debogage).

1. Eléments de base du langage Arduino;

2. Exemples (Manipulation des Entrées/sorties numériques)
3. Moniteur série
4. Applications
5. Exercices

2.1 Eléments de base du langage Arduino

Le langage Arduino est basé sur le langage C et C++. l’ensemble des éléments qui
constitu un programme Arduino peuvent être classés en 3 parties : la structure , les
variables et constantes et les fonctions
Une référence des éléments de base est disponible à partir de l’IDE Arduino :
Aide→Référence (figure 2.1)

Fig 2.1 : Référence langage Arduino

12
2.1.1 Structure
Dans le langage Arduino, le programme est constitué de deux fonctions qui doivent
toujours être présentes et porter exactement les noms setup() et loop(). Un programme
Arduino comporte alors les trois parties suivantes:

Fig 2.2 : Structure d’un programme Arduino

1. La partie déclaration des variables (optionnelle)

2. la partie initialisation et configuration des entrées/sorties : la fonction setup()
3. la partie principale qui s'exécute en boucle infinie: la fonction loop()
Ces parties du programme utilisent différentes instructions issues de la syntaxe du
langage Arduino. La raison pour laquelle tout programme Arduino rend obligatoire la
présence des deux fonctions setup() et loop() est que cela permet de séparer les actions
qui ne doivent être réalisées qu'une fois au démarrage du croquis (configuration) de celles
qui doivent pouvoir se dérouler plusieurs fois (traitement).
La coloration syntaxique du code permet de clarifier le type des différents éléments :
▪ En orange, apparaissent les mots-clés reconnus par le langage Arduino comme des
fonctions existantes : un clic droit sur la fonction permet d’afficher sa description en
choisissant « trouver dans référence » : cette commande ouvre directement la
documentation de la fonction sélectionnée.
▪ En bleu, apparaissent les mots-clés reconnus par le langage Arduino comme des
constantes.
▪ En gris, apparaissent les commentaires. Il est utile de bien commenter son code pour s'y
retrouver facilement ou pour le partager.

13
La syntaxe du langage est celle du langage C :
▪ toute ligne de code se termine par un point-virgule « ; »
▪ le contenu d'une fonction est délimité par des accolades « { » et « } »
▪ les paramètres d'une fonction sont délimités par des parenthèses « ( » et « ) ».
▪ « // » est un commentaire ligne.
▪ « /* » et « */ » encadrer des commentaires sur plusieurs lignes.
▪ Tous les opérateurs du langage C sont utlisables : les opérateurs arithmétiques,
logiques, bit par bit, de comparaison, composés, pointeurs et références.

2.1.2 Les variables et les constantes

Les valeurs litérales de type entier peuvent être exprimé en :
▪ decimal - exemple : 123
▪ binary avec le prefixe (B) - exemple : B1111011 avec les valeurs 8bits seulement
▪ hexadecimal avec le prefixe (0x) - exemple : 0x7B
Les valeurs réelles peuvent être exprimées en notation normale ou sicientifique. exemples :
▪ 10.0 (10)
▪ .005 (0.005)
▪ 2.34E5 (234000)
▪ 67e-6 (0.000067)
En langage Arduino, on peut utliser tout les types de données du C simple est composés.
Le tableau suivant donne l’étendu de chaque type :

Type Etendu de valeurs Abrégé

boolean (1octet) true ou false, 1 ou 0, HIGH ou LOW (notations
équivalentes). Occupe un octet de mémoire pas 1 bit.
char (1 octet) Entier non signé 8bits ou caractère donné entre ' ' uint8_t
int (2 octet) entier signé 16bits, soit une valeur de -32 768 à 32 767. int16_t
Unsigned(2octet) entier non-signé 16bits, soit une valeur: 0 à 65535. uint16_t
Long (4 octet) entier signé 32bits : -2 147 483 648 à + 2 147 483 647. int32_t
unsigned long Entier signé 32bits : 0 à 4 294 967 295 uint32_t
Float (4 octet) Réels 32bits : -3.4028235E+38 à +3.4028235E+38.
Double (4 octet) Equivalent à float
Chaine " " Tableau d’élément de type char
Chaine String Chaînes de caractères
Byte (1 octet) Entier non-signé 8bits : 0 à 255. uint8_t
Word (2 octet) Entier 16bits non signée : 0 à 65535. Uint16_t

2.1.3 Les fonctions

En langage Arduino, certaines fonctions sont préprogrammées, telles que
digitalWrite() et delay() qui seront utilisées ultérieurement, mais on peut aussi définir
d’autes fonctions personalisées. Les deux fonctions setup() et loop() sont particulières :
leur nom est invariable, mais leur contenu est défini selon l’application.

14
En langage Arduino, on peut utilisé les fonctions mathématiques suivantes :
Math
• min(x, y)
• max(x, y)
• abs(x)
• constrain(x, a, b)
• map(valeur, toLow, fromHigh, toLow, toHigh)
• pow(base, exposant)
• sq(x)
• sqrt(x)
Trigonométrie
• sin(rad)
• cos(rad)
• tan(rad)
• degrees(rad)
• radians(deg)
• PI

Les fonctions les plus imporantes sont les fonctions qui permettent de manipuler les
différents périphériques intégrés au microcontrôleurs (tels que les ports d’E/S, les
convertisseurs analogique numérique…) et les périphériques externes les plus utilisé tels
que les moteurs, les afficheurs…

Les fonctions de bases sont les fonctions de manipulations des E/S digitales. Grâce à
ces fonctions on peut par exemple allumer des lampes, faire fonctionner des moteurs ou
encore vérifier l’état d’un capteur. Dans ce TP nous introduisons ces fonctions avec
quelques fonctions utiles pour réaliser des temporisations.
Fonctions de Maniplations des Entrées/sorties numériques
▪ void pinMode(uint8_t pin, uint8_t mode): Cette fonction sert à définir une
broche spécifique de l’Arduino, par le biais de son numéro dans la carte, comme
étant une entrée (sans ou avec résistance de pull up) ou une sortie en utlisant les
constantes: INPUT , INPUT _PULLUP et OUTPUT respectivement.
▪ void digitalWrite(uint8_t pin, uint8_t val) : sert à définir l’état d’une
sortie en utilisantles constantes : HIGH ( 1 logique = 5V) ou LOW (0 logique = 0V).
▪ int16_t digitalRead(uint8_t pin) : sert à lire l’état d’une broche. Si celle-ci est
reliée à un potentiel 5V, le résultat de la lecture sera HIGH (1) ou LOW (0) si elle
est reliée à un potentiel nul.
Exemples :
 digitalWrite(4,HIGH) : met le port N°4 à 1 ( même que digitalWrite(4,1))
 digitalWrite(5,LOW) : met le port N°5 à 0.
Fonctions de Temporisations
les fonctions définies qui permettent de réaliser des temporisations en langage Arduino
utilisent les timers du microcontrôleur (temporisations matérielles) :
• void delay(uint32_t ms): cette fonction sert à effectuer une pause d’une certaine
durée fixée par un entier passé dans la fonction à son appel. Cette fonction est une

15
 fonction bloquante, et donc pendant qu’elle se déroule, les opérations de
manipulation des ports ne sont pas possible.
• void delayMicroseconds(uint16_t us): Identique à la fonction delay(), sauf que
l’entier passé en paramètre est prit en compte comme des microsecondes et non
plus comme des millisecondes.
• uint32_t millis() : permet de retourner un nombre de millisecondes qui
correspond au temps depuis lequel le programme a été démarré (revient à zero
après dépassement).
• uint32_t micros() : exactement la même fonctino que millis(), sauf que micro()
renvoi un entier qui correspond à des microsecondes et non plus à des
millisecondes.

La carte Arduino mega possède 54 entrées/sorties numériques, repérées de 0 à 53;

chacune d’entre elles pouvant fonctionner en entrée ou en sortie sous le contrôle du
programme. Ces entrées/sorties admettent et délivrent des signaux logiques compatibles
TTL ( tension comprise entre 0 et 5V ). Elles peuvent fournir ou délivrer un courant
maximum de 40 mA , mais l’ensemble des sorties ne peuvent pas en aucun cas délivrer 200
mA (5 sorties à 40mA ou 10 sorties à 20mA….).
Dans ce qui suit tous les programmes (Exemples et applications) doivent être testés sur la carte.

2.2 Exemples de manipulation des ports d’E/S:

1) Toujours le programme Blink
L’instruction de configuration du port par pinMode() est insérée dans la fonction
setup() parce qu'il n'est nécessaire qu'une fois. Cela fonctionnerait toujours si nous
déplacions l'appel dans la boucle, mais il serait inutile de répéter cette action de
configuration . les instructions qui aggissent sur le port pour faire clignoter la LED sont
insérées dans Loop ( exécution répétée).
Programme 1:
/* clignoter une LED */
void setup()
{
pinMode(13, OUTPUT); // port 13 = builtin LED ( La LED L)
digitalWrite(13, HIGH);
}
void loop()
{
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
2) Quelques bonnes manières de programmation
Dans l’exemple précédent, la broche 13 est utilisée en trois endroits différents du
programme. Pour travailler avec une autre broche, il faudrait donc modifier le numéro de
broche à trois endroits. De même, pour modifier la vitesse de clignotement (utilisée
comme argument de la fonction delay()), il faudrait modifier la valeur 1000 à deux
endroits différents.

16
 L’utilisation des variables et des constantes est une bonne manière de programmation
car elle permet de produire des programmes plus génériques qui faciliteront les
modifications:
Programme 2:
/* clignoter une LED */
const byte brocheLED = 13;
const unsigned dureePause = 1000;
void setup()
{
pinMode(brocheLED, OUTPUT); // port 13 = builtin LED ( La LED L)
}
void loop()
{
digitalWrite(brocheLED, HIGH);
delay(dureePause);
digitalWrite(brocheLED, LOW);
delay(dureePause);
}
Avec ce programme, pour faire clignoter la LED avec une autre vitesse ou un autre port,
il suffit de changer à un seul endroit les valeurs affectées aux constantes dureePause et
brocheLED. Ici le type de brocheLED est const byte : le type byte peut représenter
tous les broches de la carte car leur nombre n’atteindra pas 256, et constante puisqu’elle ne
changera pas de valeur (et ne doit pas) au cours du programme. De même, le type de
brocheLED est unsigned: l’étendu de ce type est largement suffisant pour notre
application.
La variable dureePause de l’exemple suivant est indispensable car on veut modifier la
vitesse de clignotement au cours d’exécution du programme : le clignotement commence à
une vitesse élevée, puis ralentisse.
Programme 4:
/* clignoter une LED */
const byte brocheLED = 13;
unsigned dureePause = 100;
int i;
void setup()
{
pinMode(brocheLED, OUTPUT); // port 13 = builtin LED ( La LED L)
}
void loop()
{
for (i=0;i<=3;i++)
{
digitalWrite(brocheLED, HIGH);
delay(dureePause);
digitalWrite(brocheLED, LOW);
delay(dureePause);}
dureePause = dureePause + 100;
if (dureePause==2000) {dureePause=100;}
}

17
 L’utilisation des fonctions personalisées est une très bonne manière de programmation.
Le dernier exemple donné ci-dessous montre une restructuration du programme précédent
avec l’utilisation d’une fonction personalisée appellé Blinking :
Programme 4:
/* clignoter une LED */
const int brocheLED = 13;
unsigned dureePause = 100;
void setup()
{
pinMode(brocheLED, OUTPUT); // port 13 = builtin LED ( La LED L)
}
void loop()
{
Blinking(brocheLED, dureePause);
dureePause = dureePause + 100;
if (dureePause==2000)
{
dureePause=100;
}
}
void Blinking(const int LED, int delai )
{
int i;
for (int i=0;i<3;i++)
{
digitalWrite(LED, HIGH);
delay(delai);
digitalWrite(LED, LOW);
delay(delai);
}
}

2.3 Le Moniteur Série

Le moniteur série intégré à l'environnement Arduino assure une communication entre
l’ordinateur et la carte Arduino les ports arduino 0 (RX) et 1 (TX) via le connecteur USB.
Ainsi, si vous utilisez ces fonctions, vous ne pouvez pas utiliser les broches 0 et 1 pour E/S
numérique. Le lancement du Moniteur série se fait simplement à partir de la barre d'outils
en sélectionnant le même débit en bauds que celui configuré dans le programme.
L’interface du moniteur série est la suivante:

18
 Il faut alors régler le débit de communication sur la même valeur que celle utilisée par
le programme avec lequel nous allons programmer la carte Arduino :

Fig 2.6 : Réglage de la vitesse de transmission

Noter que la carte Arduino se réinitialisera quand vous vous lancez le moniteur Série. Il
existe plusieurs instructions pour utiliser le moniteur, nous introduisons aujourd’hui les 3
fonctions suivantes :
- [Link](uint8_t rate):fixe la vitesse de transmission entre PC et la carte
- [Link]("message") :affiche le "message" dans la fenêtre du moniteur série
- [Link]("message"):affiche le "message" sur une nouvelle ligne
Exemple :
Ce programme nous permet de voir l’état de la LED « en direct ». Quand on se trouve
dans la fenêtre du moniteur série et que le programme est lancé sur l’Arduino, on peut voir
s’afficher les mots « LED alumée », « LED éteinte »
Programme 3:
/* clignoter une LED */
const byte brocheLED = 13;
unsigned dureePause = 100;
void setup() {
pinMode(brocheLED, OUTPUT);
[Link](9600);
}
void loop()
{
digitalWrite(brocheLED, HIGH);
[Link](" LED allumée"); // Affiche le message " LED allumée"
delay(dureePause);
digitalWrite(brocheLED, LOW);
[Link](" LED éteinte"); // Affiche le message " LED éteinte"
delay(dureePause);
}
La ligne « [Link](9600) » qui se trouve dans le setup est obligatoire, et sert à
initialiser la liaison série de l’Arduino, en lui affectant une vitesse de transmission. Cette
vitesse peut évidemment être changée, mais il faudra aussi modifier cette valeur dans le
moniteur série pour que la lecture des informations se fasse à la même fréquence que leurs
envois.

19
2.4 Applications :
2.4.1 Rappels sur les composants requis :
▪ Plaque d’essai
▪ Résistances
▪ LEDs
▪ interrupteurs
▪ Fils de connexion

[Link] Plaque d’essai

Permet de tester un montage électronique sans réalisé de cirtuit imprimé. Grâce à cet
petit outil, il n'y a pas besoin de souder, il suffit juste de placer les composants dans les
trous organisés en rangés de points connectés entre eux:
▪ Les rangés horizontales, marqués en bleu, ne sont pas relié au milieu: Cela
permet de placer des circuits intégrés.
▪ La première rangés verticale, celle qui est rouge, est représenté par un "+". Il
convient de connecter la source de tension à cette endroit. De cette façon, le
montage est plus propre et vous pourrez connecter un fil à cette source
d'alimentation à chaque fois qu'il en sera nécessaire.
▪ La deuxième rangé, celle qui est bleu, est symbolisé par un "-". Sur la même idée
que la rangée jumelle, cette ligne sert à relier la masse. Ainsi, dès que vous devez
connecter un composant à la masse, vous avez juste à utiliser un fil pour la
liaison vers cette rangé (votre montage sera ainsi plus propre et plus
compréhensible).

Points
connectés

Fig 2.7 : Les connexions de la plaque d’essai

[Link] Les résistances

Une résistance est un composant électronique ou électrique dont la principale
caractéristique est d'opposer à la circulation du courant électrique. Ce composant est
caractérisée par sa valeur exprimée en Ohm et ces multiple( Ω, KΩ, MΩ) codée en couleur
de la manière suivante :

20
 Fig 2.8 : Code couleur des résistances

[Link] Les LEDs

Les LEDs sont des diodes qui produisent de la lumière lorsque le courant y passe en
polarisation directe de l’anode vers la cathode. Tout comme toute diode, la polarisation
inverse bloque le courant et la LED dans ce cas n’émet aucune lumière.

Anode + − Cathode
(A) (K)

Fig 2.9 : Symbole d’une LED

Avant l’utilisation de tous composant semiconducteur, il faut toujours consulter sa

fiche de spécifications techniques (Datasheet), qui présente les différentes informations et
les valeurs nominales de courant et de tension, afin d’utiliser correctement le composant.

21
 La LED est caractérisée par des propriétés électriques, optiques, thermiques et
géométriques. (constitue toujours un bon point de départ pour comprendre tout
dispositif)Les principaux termes que nous retrouvons dans les documentations techniques
sont décrits brièvement dans ce qui suit à travers un exemple de datasheet d’une LED
rouge 5mm classique .

Les principales caractéristiques de cette LED sont

▪ Forward Current IF (Courant direct) : c’est le courant direct maximal que la
LED est capable de supporter en régime continu ou permanent. Cette valeur
nominale est donnée pour une température ambiante de 25°C. Dans le cas de
l’exemple, le courant direct admissible est égal à 20mA, cela signifie que le
courant qui traverse cette LED doit être ≤ 20mA et que la luminosité maximale
est obtenue avec cette valeur.
▪ Forward voltage VF (Tension directe) : c’est la différence de potentiel présente
aux bornes de la LED en polarisation directe et en température ambiante de
25°C. Cette valeur de tension permet de dimensionner les composants du circuit
à LEDs comme le montre la section I.5.
Les tensions directes étant très basses (1,5 V à 3,3 V) il faut choisir une tension
d’alimentation adéquate et ajouter un ou plusieurs composants (résistances…) pour faire
fonctionner correctement la LED.
Pour le circuit à une seule LED (IF, VF) de la figure ci dessous, la résistance R permet de
limiter le courant à la valeur préconisée par le constructeur en correspondance à la tension
de la LED.

22
 I

VR R

VLED

Figure 2.10 : Circuit à une seule LED

Le calcul de la résistance de limitation R est une simple application de la loi d'Ohm et
se fait en deux étapes:
1. Nous calculons d'abord la chute de tension aux bornes de la résistance de limitation
nécessaire pour que la diode LED soit soumise à une tension directe :
VR=E-VLED=E-VF
2. Nous calculons maintenant la valeur de la résistance en tenant compte de la valeur
du courant qui traversera la LED (soit IF).
R= VR/I= VR/IF
Exemple de calcul pour une LED (20mA, 1.8V) :

I = IR = IF
= 20mA

VR E - VF
= 10.2V R=
IF
= 510 Ohms
E
= 12V

VF
= 1.8V

Les sorties microcontrôleurs peuvent à la fois générer et évacuer des quantités utiles de
courant, donc peuvent être utilisés pour contrôler directement une LED. La figure 2.11
donne les 2 montages de base pour contrôler l’allumage d’une LED avec ‘1’ ou ‘0’.

23
 Vcc La LED s’allume si la sortie
S est égale à 1

IF IF

Micro- Micro-
contrôleur S contrôleur S
R R

La LED s’allume si la sortie

S est égale à 0

Figure 2.11 : Commander une LED avec un port de microcontrôleur

[Link] Les interrupteurs

L’interrupteur est un composant qui permet d'interrompre ou d'autoriser le passage du
courant dans un circuit électrique (d’ouvrir et de fermer le circuit). Il existent une très
grande variété d’ntérrupteurs mais les principales sont les suivants :
1. Intérupteur maintenu : maintien son état (position) jusqu'à ce qu'il soit activé pour
le positionné dans l’autre état qui sera aussi maintenu jusqu’à une autre action de
modification de l’état. Cet intérrupteur peut avoir plusieur formes :
Fermé/Ouvert, Position 1/Position2 …
2. Intérrupteur momentané (bouton poussoir): les commutateurs restent actifs
uniquement s'ils sont actionnés (appuyés). Si le commutateur n’est pas actionné, il
reste à état "ouvert" (comme les touches de clavier)

Bouton Bouton
ouvert fermé

Interrupteur Interrupteur
ouvert fermé

Interrupteur Interrupteur
position 1 position 2

Figure 2.12 : Commander une LED avec un port de microcontrôleur

Les intérrupteurs sont souvent utilisés avec les ports du microcontrôleurs pour imposer un
‘1’ ou ‘0’. supposons une broche configurée comme une entrée. Si on connecte un
intérrupteur seulement relié à la masse (à Vcc) on se trouve à 2 cas :

24
 ▪ Intérrupteur fermé : l’entrée = ‘0’ (‘1’)
▪ Intérrupteur ouvert : l’entrée = indéfini (flottante)
Pour éviter cet état indéfni, une résistance de pull-up ou pull-down assurera que la
broche soit dans un état haut ou bas, tout en limitant le courant au courant admissible au
port d’entrée. les pull-up parce qu'elles sont plus courantes que les pull-downs. Ils
fonctionnent en utilisant les mêmes concepts, sauf que la résistance de pull-up est
connectée à l’alimentation (Vcc) et la résistance pull-down est connectée à la masse.
Vcc Vcc

Interrupteur ouvert:
→ E=0
R Interrupteur fermé:
Micro- Micro- → E=1
contrôleur E contrôleur E

Interrupteur ouvert:
→ E=1
R
Interrupteur fermé:
→ E=0

Figure 2.13 : Commander une LED avec un port de microcontrôleur

Avec une résistance de pull-up, la broche d'entrée lira un état haut lorsque le bouton
n'est pas enfoncé. En d'autres termes, une petite quantité de courant circule entre VCC et la
broche d'entrée (pas à la masse), ainsi la tension de la broche d'entrée est proche de VCC.
Lorsque le bouton est enfoncé, il connecte la broche d'entrée directement à la masse. Le
courant passe à travers la résistance à la terre, ainsi la broche d'entrée lit un état bas.
Gardez à l'esprit, si la résistance n’est pas utlisée, la femeture du bouton relie VCC à la masse, ce qui
provoque une court circuit.
La valeur de la résistance pull-up doit être choisie pour satisfaire deux conditions:
▪ Lorsque le bouton est enfoncé, la broche d'entrée est tirée à la masse. La valeur
de la résistance R1 contrôle la quantité de courant transmis à partir de VCC, via le
bouton, à la masse.
▪ Lorsque le bouton n'est pas enfoncé, la broche d'entrée est tirée vers le haut. La
valeur de la résistance de pull-up contrôle la tension sur la broche d'entrée.
Pour la condition 1, la valeur de la résistance ne doit pas être trop basse : plus la
résistance est faible, plus la puissance sera dissipée lorsque le bouton est appuyé. Cette
valeur de résistance ne doit pas être aussi trop grande pour satisfaire la condition 2: La
règle générale pour la condition 2 est d'utiliser une résistance de rappel (R1) qui est
inférieure d'un ordre de grandeur (1/10ème) à l'impédance d'entrée (R2) de la broche
d'entrée (figure 2.14). Une broche d'entrée d’un microcontrôleur a une impédance qui peut
varier de 100k-1MΩ. Ainsi, lorsque le bouton n'est pas enfoncé, une très petite quantité de
courant circule de VCC à R1 et dans la broche d'entrée. La résistance de rappel R1 et
l'impédance de broche d'entrée R2 divisent la tension, et cette tension doit être
suffisamment élevée pour que la broche d'entrée lise un état haut: une résistance de 10k à
100kΩ pour R1 devrait éviter la plupart des problèmes.

25
 Vcc

Micro- R1
Contrôleur
E

R2

Figure 2.14 : Commander une LED avec un port de microcontrôleur

Puisque les résistances pull-up sont si souvent utilisées, le microcontrôleur de la carte
Arduino, possède des pull-ups internes qui peuvent être activés et désactivés.

2.4.2 Circuits de LEDs clignotantes

Toute les applications de ce TP sont basées sur le premier skecth (Blink) que nous
modifierons pour obtenir des circuits avec plus de fonctionnalités en utilisant les variables,
les tableaux , les boucles et les fonctions pour écrire des programmes compacts qui
correspondent au fonctionnement décrit pour chaque application.
Le compte rendu de ce TP, à remettre à la fin de la séance, comprend :

- le schéma du circuit utilisé (fritzing)

- le programme écrit, modifié ou corrigé (commenté)

- la description du fonctionnement demandée.

Application 1 - Changer le port et la vitesse de clignotement

1/ Brancher une LED rouge à une broche de votre choix puis modifier le sketch Blink
précédent pour avoir une led clignotante avec une fréquence de 2Hz.

cycle

Sortie éteinte allumée éteinte allumée

0.5 1 t(s)

Figure 2.15: Fréquence de clignotement

2/ Ajouter 2 autres LEDs puis modifier le sketch Blink précédent pour faire clignoter les
LEDs notées Led1, Led2, Led3 à des vitesses différentes (0.5Hz, 1Hz et 2Hz
respectivement).

26
Application 2 - Commander une Led avec un bouton poussoir
Le programme suivant illustre un exemple d’utilisation d’un port d’entrée. Le circuit à
réaliser comprend une LED et un boutton poussoir. Réaliser le circuit correspondant et
tester le programme pour décrir le fonctionnement:
Programme 4:
/* utilisation d’un bouton */
const uint8_t buttonPin = 2; // the number of the pushbutton pin
const uint8_t ledPin = 12; // the number of the LED pin
const uint8_t buttonState = 0; // variable for reading the pin status
void setup() {
pinMode(ledPin, OUTPUT); // declare LED as output
pinMode(buttonPin, INPUT); // declare pushbutton as input
}
void loop() {
buttonState = digitalRead(buttonPin);
if (buttonState == HIGH)
digitalWrite(ledPin, HIGH); // turn LED on
else (buttonState == LOW)
digitalWrite(ledPin, LOW); // turn LED off
}

Application 3 - Ajouter une entrée de commande de vitesse de clignotement

1/ Utiliser le circuit précédent et élaborer un programme pour contrôler la vitesse de
clignotement de la LED de la manière suivante:
▪ Si l’intérrupteur ouvert (Entrée correspondante=1: Vitesse de clignotement = 0.5HZ)
▪ Si l’intérrupteur fermé (Entrée correspondante=0: Vitesse de clignotement = 2HZ)
2/ Modifier votre programme et le circuit pour avoir le même fonctionnement en
exploitant les résistances pull up intégrées aux ports d’entrées utilisées.

Application 4 - Utiliser 2 boutons

1/ Dérouler le programme suivant pour déterminer l’état de LED selon les conditions
données par la figure 2.16.
Programme 4:
/* utilisation d’un bouton */
const uint8_t ledPin = 13; // choose the pin for the LED
const uint8_t inputPin1 = 2; // choose the input pin (for a pushbutton)
const uint8_t inputPin2 = 3; // button 2
uint8_t val = 0; // variable for reading the pin status
void setup() {
pinMode(ledPin, OUTPUT); // declare LED as output
pinMode(inputPin1, INPUT); // declare pushbutton as input
pinMode(inputPin2, INPUT); } // declare pushbutton as input
void loop() {
if (digitalRead(inputPin1) == LOW)
digitalWrite(ledPin, LOW); // turn LED OFF
else if (digitalRead(inputPin2) == LOW)
digitalWrite(ledPin, HIGH); // turn LED ON
}
27
 bouton1

bouton2
allumée
LED
éteinte
t
Figure 2.16: chronogramme à compléter en fonction des états de bouton1 et bouton2
2/ Réaliser le circuit et vérifier la réponse.
Application 5 – débogage lors de l’exécution
Pratiquer le débogage pour corriger le programme suivant, de sorte que la LED clignote
comme il se doit.
Programme 5:
/* utilisation d’un bouton */
const uint8_t buttonPin = 2; // the number of the pushbutton pin
const uint8_t ledPin = 13; // the number of the LED pin
uint8_t buttonState = 0; // variable for reading the pin status
void setup() {
pinMode(ledPin, OUTPUT); // declare LED as output
pinMode(buttonPin, INPUT);} // declare pushbutton as input
void loop() {
buttonState = digitalRead(buttonPin);
if (buttonState = HIGH)
Blinking(brocheLED); // Blink LED
else (buttonState = LOW)
Offing(brocheLED); // turn LED off
}
void Blinking(const int LED){
digitalWrite(LED, HIGH);
delay(1000);
digitalWrite(LED, LOW);
delay(1000);
}
void Offing(const int LED ){
digitalWrite(LED, LOW);
}
Application 6 - Augmenter le nombre de LEDs et varier le motif de clignotement
Connecter 8 LEDs à des ports d’entrée puis écrire un programme pour faire clignoter les
LEDs de la façon suivante : après la mise sous tension de la carte, les LEDs clignotent 10
fois selon motif1 avec une période d’une seconde. Après, les LEDs clignotent infiniment
selon motif2 en basculant l’état des LEDs chaque 500ms.
Motif1 Motif2

28
Application 7 - Améliorer le programme avec l’utilisation de boucles et de tableaux
Si vous avez écris le programme de l’application 6 en utilisant les boucles et les tableaux
passez directement à l’application suivante.
Dans le cas de manipulations de plusieurs ports, les instructions de déclaration de
constantes de pin, de configuration et de traitement deviennent trop nombreuses :
const int Pin23 = 23; pinMode(Pin23, OUTPUT); digitalWrite(Pin23, HIGH);
const int Pin24 = 24; pinMode(Pin24, OUTPUT); digitalWrite(Pin24, HIGH);
const int Pin25 = 25; pinMode(Pin25, OUTPUT); ...
const int Pin26 = 26; pinMode(Pin26, OUTPUT);
const int Pin27 = 27; pinMode(Pin27, OUTPUT);
const int Pin28 = 28; pinMode(Pin28, OUTPUT);
...
Procéder ainsi est exact au regard de la programmation. Mais c’est long, fastidieux,
source d’erreurs et cela rend la modification et la correction problématiques. En général,
lorsqu’il faut rédiger des lignes de code répétitives, il est toujours possible de simplifier le
programme en utilisant des boucles et des tableaux. Dans le cas donné en exemple, on peut
utiliser un tableau pour les constantes de numéro de pin:
Exemple :
const byte pin[] = {22, 23, 24, 25, 26, 27, 28};
// Déclaration et initialisation d'un tableau : Ce tableau facilitera la
configuration et la manipulation des ports en utilisant les boucles:
for (int i = 0; i < 7; i++)
{
pinMode(pin[i], OUTPUT); // Les ports utilisées sont des entrées
digitalWrite(pin[i], HIGH); // Appliquer 1 pour chaque port
}
Ou simplement :
Exemple :
for (int i = 22; i <= 28; i++)
{
pinMode(i, OUTPUT); // Les ports utilisées sont des entrées
digitalWrite(i, HIGH); // Appliquer 1 pour chaque port
}
Ici toutes les broches se suivaient, mais cela reste applicable lorsque c’est pas le cas :
Exemple :
const byte OutPin[] = {23, 25, 27, 29, 31, 33, 35};
const byte InPin[] = {5, 7, 11};
void setup() {
for (int i = 0; i < 7; i++)
{
pinMode(OutPin[i], OUTPUT); // congigurés en sorties
digitalWrite(Outpin[i], LOW); // initialisés à 0
}
for (int i = 0; i < 3; i++)
{
pinMode(InPin[i], INPUT); // configurés en entrées
}
}
29
Application 8 - un chenillard simple
Le chenillard est un mouvement lumineux qui se produit en allumant et éteignant
successivement une série de lampes ou LEDs. L'effet se traduit par un déplacement de
la/les lumières dans un sens choisi. Réaliser un chenillard simple de 8 LEDs: une seule
LED est allumée à la fois, la lumière se déplace de gauche à droite ( ou de haut en bas ….).

Réaliser le circuit et écrire le programme correspondant.

Application 9 - un chenillard à plusieurs motifs

Le chenillard à réaliser est doté de 2 entrées de sélection pour choisir le motif selon la
description suivante :
▪ E1E2=00 : un chenillard simple (une seule LED allumée)
▪ E1E2=01 : un chenillard double (défilement double)
▪ E1E2=10 : un chenillard simple inverse (une seule LED éteinte)
▪ E1E2=11 : un chenillard bouble inverse (2 LEDs éteintes)

E1E2=00 E1E2=01 E1E2=10 E1E2=11

30
2.5 Exercices
Exercice 1 - un chennillard à entassement
Réaliser un chenillard à entassement de 8 LEDs avec une entrée de sélection pour
choisir entre 2 motifs : entassement à gauche ou à droite (L’effet d’entassement : les
lumières se déplacent et s'accumulent). Il faut prévoir une 2éme entrées de sélection pour
choisir la vitesse de défilement (lent et rapide).

Exercice 2 - Un chennillard simple 8 LEDS avec moins de ports

On désire réaliser un chenillard simple de 8 LEDs avec un délai de 500ms (durée
d’allumage d’une LED), mais supposons que nous sommes contraints par le nombre de
ports à utiliser. Réaliser ce chenillard en utilisant :
1- Trois ports seulement en utilisant:
a. un décodeur 3 entrées 74HC238
b. le registre à décalage 74HC595
2- Deux ports seulement et le registre à décalage 74HC164
3- Un port seulement et les composants nécessaires.

31
 TP N°3
Le langage Arduino (II):
Les Entrées/Sorties analogiques

1. Manipuler les ports d’entrée analogiques;

2. Manipuler les ports de sortie "analogiques" (PWM);
3. Applications avec des capteurs, LED RVB et un moteur courant continu (CC).

3.1 Rappels sur les composant à utiliser

Les composants requis pour ce TP sont :
▪ Potentiomètre
▪ Photoresistance
▪ Capteurs de température
▪ LED RVB
▪ Moteur courant continu 6V

3.1.1 Le potentiomètre
un potentiomètre est à la base un diviseur de tension reglable qui possède 2 bornes
d’extrémité et une borne centrale (Figure 3.1). Si on applique 0V et 5v aux bornes
d’extrémité, la tension collectée à la borne centrale est une tension analogique comprise 0V
et 5V et varie en fonction de la variation de la position de la tige de reglage (exemple : 2.5V
au milieu). Pour ce TP le potentiomètre sera utilisé pour générer des tensions analogiques
comprises 0V et 5V pour manipuler les entrées analogiques de la carte Arduino.

Équivalent à:

Figure 3.1 : Symbole et différents type de potentiomètres

32
3.1.2 La photorésistance
La photorésistance est un composant électronique dont la résistance varie en fonction
de la l’intensité lumineuse incidente (Figure 3.2). Plus cette luminosité est élevée, plus la
résistance diminue. À l’inverse, plus il fait sombre, plus la résistance augmente (Figure
3.3). Malheureusement, les photorésistances sont des transducteurs peu précis, non linéaire
et ayant un temps de réponse élevé et une grande tolérance. Nous les utiliserons donc pour
des applications qui ne demandent que peu de précision (pour des applications de détection
pas de mesure).

Figure 3.2 : Symbole et types de photorésistance

Figure 3.3 : Caractéristiques d’une photorésistance( extrait de datasheet)

33
 La photorésistance est principalement utilisée dans un montage en pont diviseur de
tension. Le schéma de montage généralement utilisé pour relier une photorésistance à une
entrée analogique d’une carte Arduino est le suivant :
Vcc

Port Arduino
analogique

10K VR

Figure 3.4 : Exemple de montage d’utilisation d’une photorésistance avec Aduino.

3.1.3 Capteurs de température analogiques

Les capteurs de la série LM3x sont des capteurs de température électroniques de
précision et faciles à calibrer. Les LM34, LM35 et LM335 par exemple, fonctionnent selon le
même principe. La différence entre eux est qu'ils fournissent une sortie analogique
proportionnelle calibrée à différentes unités de mesure:
• Le LM34 : sortie  degrés Fahrenheit, entre -50 ° F et 300 ° F(-45 ° C et 149 ° C ).
• Le LM35 : sortie  degrés Celsus, entre -55 ° C et 150 ° C.
• Le LM335 : sortie  degrés Kelvin, entre 218 ° K et 423 ° K (-55 ° C et 150 ° C).
Le capteur LM35 fonctionne avec des tensions d'alimentation comprise entre 4 volts et
30 volts (figure 3.5) et capable de mesurer des températures allant de -55°C à +150°C (selon
le modèle) avec une precision d’environ +/-0.5°C. Ces capteurs produisent une tension
lineairement proportionnel à la temperature : Donc, il suffit de mesurer la tension en
sortie du capteur pour en déduire la température : Chaque degré Celsius correspond à une
tension de +10mV (Figure 3.6). Donc, la relation entre la tension fournie par le capteur (en
Volts) et la température T (en °C) est : 𝑇 = 100 × 𝑉

Sortie
analogique
LM35

Figure 3.5: Symbole, brochage et types de LM35

34
 Figure 3.5: Caractéristiques de LM35 (Extrait data sheet)
Le capteur de temperature LM35 a une tension de decalage de zero, ce qui signifie que la
sortie est 0V Iorsque la temperature est à 0°C. Ainsi, pour la valeur de temperature
maximale (150 °C), la tension de sortie maximale du capteur serait 150 * 10 mV = 1,5V. Le
montage suivant permet de mesurer la température directement sur un port d’arduino ( le
condensateur dit de decouplage est optionnel et permet d’améliorer la mesure).
Vcc

100nF
Port Arduino
LM35
analogique

Fig 3.6 : Montage simple de mesure de la température avec Aduino.

Le LM335 similairement à LM35 possède 3 broches et il est facilement interfacé à un
microcontrôleur à travers ses entrées analogiques.

Sortie
analogique

broche
d’étalonnage

Figure 3.7: Symbole, brochage et types de LM335

35
 Ces principales caractéristiques sont (Figure 3.8) :
• La tension de sortie du capteur est linéairement proportionnelle à la mesure de la
température à +10mV/°K. Pour avoir la température en °C, il faut convertir la
valeur mesurée en utlisant la formule suivante : T(°C)≈T(°K)-273.
• À 0°K, la tension de sortie est de 0V et le capteur est étalonné à 2,982V à
298,15°K (25 °C).
• L’équation qui relie la tension fournie V (en Volts) à la température à mesurer
T (en °K) est : 𝑇 = 100 × 𝑉.

Figure 3.8: Principales caractéristiques de LM335 (extrait de datasheet)

La figure 3.9 donne un montage typique de mesure de la température avec un port
analogique d’arduino. La résistance R1 dépend de la tension d’alimentaion noté V+ et se
calcule de la manière suivante :
• Selon le datasheet, l’étalonnage de la sortie à 2.98V pour la température de 25C
est réalisé sous la condition Ir=1mA.
• Donc pour 5V et I=1mA et Vcapteur=2.98V la valeur de R1 sera :
𝑅1 = (5 − 𝑉𝑐𝑎𝑝𝑡𝑒𝑢𝑟 )/𝐼 = 5 − 2.98/1(𝑚𝐴) ≈ 2𝐾Ω

Figure 3.9: Montage basique de l’utlisation de LM335 (extrait de datasheet)

36
3.1.3 Les LED RVB
Cette LED est composée de trois LEDs de couleurs rouge, verte et le bleue. Elle possède
donc 4 broches et existe en deux modèles : à anode commune et à cathode commune
(Figure 3.10 et 3.11).

Common
cathode

Équivalent à:
Common
anode

Fig 3.10 : Types de LED RVB.

Fig 3.11 : Caractéritiques d’une LED RVB.

La couleur de la lumière émise résulte de la composition des trois couleurs primaires : il

est donc possible de créer n’importe quelle couleur du spectre lumineux visible en
mélangeant ces lumières de couleurs mais de différentes intensités (analogiques).
Généralement les intensités des trois LEDs sont contrôlées par des ports de
microcontrôleur malgé que le signal généré par un port d’un microcontrôleur est un signal
numérique pouvant pendre uniquement les valeurs 0 et 5V ( un port numérique ne peut
fournir une autre valeur de tension). Ce ci est possible grace à l’utilisation des signaux à
Modulation de Largeur d’Impulsion (MLI) communément appelée PWM (Pulse Width
Modulation) dont le principe est le suivant : Pour un signal carré périodique (porteuse) de
période T et de rapport cyclique 𝛼 = 𝜏/𝑇 (exprimé en %) appliqué à une charge ( LED,
lampe, moteur ….), la puissance est fonction de la valeur moyenne (Figure 3.12). Donc,
cette technique permet d’obtenir une allure analogique en variant la largeur d’impulsion.

37
 U(t)
t
E
Umoy(a) =aE

T
Fig 3.12 : Valeur moyenne d’un signal PWM.
En appliquant ce signal de rapport cyclique 𝛼 à une LED par exemple, le résultat est
semblable à celui que l’on obtiendrait en contrôlant la luminosité de la LED avec une
tension analogique continu égale à 𝑉𝑚𝑜𝑦(𝛼) .

Fig 3.13 : Principe de contôle de la luminosité d’une LED par PWM

La figure 3.13 donne un exemple de montage pour contrôler une LED RVB à cathode
commune avec la carte Arduino (Les valeurs des résistances de protection à calculer en
fonctions des caractéristique des LEDs).

Rr

Ports PWM
Arduino
Rv

Rb

Fig 3.13 : Exemple de montage pour contrôler une LED RVB avec Arduino
38
3.1.5 Les moteurs CC
Le moteur courant continu (CC) est un composant qui assure la conversion d’énergie
électrique en énergie mécanique de rotation et la transmission du mouvement à l’ensemble
mécanique qui lui est associé en aval ; souvent par l’intermédiaire d’un réducteur qui
diminue la vitesse de rotation tout en augmentant le couple (figure 3.12). Le moteur
courant continu (DC) est caractérisé par une constante de vitesse, et une pente
vitesse/couple. Le courant est proportionnel à la charge ; et la vitesse est proportionnelle à
la tension d’alimentation.

Figure 3.12 : Exemple de moteur CC 5V

1.3.2 Principe de commande d’un moteur CC

En réalité, les moteurs à courant continu sont des convertisseurs de puissance:
• Soit ils convertissent l’énergie électrique absorbée en énergie mécanique lorsqu’ils
sont capables de fournir une puissance mécanique suffisante pour démarrer puis
entraîner une charge en mouvement. On dit alors qu’ils ont un fonctionnement en
moteur.
• Soit ils convertissent l’énergie mécanique reçue en énergie électrique lorsqu’ils
subissent l’action d’une charge entraînante. On dit alors qu’ils ont un
fonctionnement en générateur.
En mode « moteur », l'énergie électrique est convertie en énergie mécanique. En mode
« générateur » ou « dynamo », l'énergie mécanique est convertie en une énergie électrique
capable de se comporter comme un frein.

1.3.3 Montages de commande d’un moteur CC

Nous présentons 3 montages de commande de base:
➢ Commander le moteur dans un seul sens à une vitesse constante :
M

UM

Ue

Figure 3.13: montage de base de commande d’un moteur CC.

39
 Principe de fonctionnement : si l’on applique une tension continu positive à la base
du transistor, ce dernier commute en conduction ce qui permet d’alimenter le
moteur avec la tension continu 𝐸 et commencera à tourner à une vitesse qui dépend
de la tension appliqué à ces borne (𝑈𝑀 ). La tension d’alimentation étant fixe, ce
circuit ne permet pas de changer la vitesse de rotation ni d’inverser son sens (il faut
inverser la polarité de la tension 𝑈𝑀 pour avoir ce dernier comportement).
La diode placée en parallèle du moteur, appelée diode de roue libre, sert d’une
part à protéger le transistor de la surtension induite par le moteur, et d’autre part à
permettre l’autofreinage du moteur :
• si on supprime l’alimentation d’un moteur en marche, ce dernier ne s’arretera
pas instantanément et continuera à tourner par la trainée de son inertie. Cela va
engendrer une tension au bornes du moteur (mode générateur). Cette tension
induite, qui peut atteindre plusieurs dizaines ou centaines de Volts est très
dangereuse pour le transistor. L’utilisation de diode en mode passant permet
d’empecher l’accumulation de la tension induite et la garde proche de la tension
d’alimentation du moteur en faisant circuler un courant « de décharge ».
• d’un autre côté, la tension induite par le moteur est opposée à celle que fournit
l’alimentation qui était appliqué à ce dernier. Or, étant donné que la la tension
induite est réappliquée à ses bornes, le couple et la tension s’opposent et cela a
pour effet de ralentir le moteur.

➢ Commander le moteur dans un seul sens à une vitesse variable :

Pour faire varier la vitesse du moteur avec le montage précédent on peut faire
varier la tension d'alimentation 𝐸 pour faire varier la tension à ses bornes.
Cependant, avec cette technique, une partie importante de l'énergie est consommée
par le dispositif d’alimentation. L’alternative consiste à utliser des signaux PWM.

UM(t)
Ue(t)
TON
TON E
M

UM(t)
UMmoy

t E T
T

Ue(t)

Figure 3.14: Commande de vitesse d’un moteur CC avec PWM

Dans ce cas, la vitesse de rotation du moteur dépendra de la valeur moyenne de
la tension appliquée à ses bornes 𝑈𝑀 𝑚𝑜𝑦, si 𝑈𝑒 est un signal à rapport cyclique
égale à 𝛼 = 𝑇𝑂𝑁 ⁄𝑇, la vitesse du moteur 𝑉𝑀 sera égale à 𝑉𝑀 = 𝛼 × 𝑉𝑚𝑎𝑥 avec 𝑉𝑚𝑎𝑥
est la vitesse maximale du moteur obtenu lorsque on applique une tension 𝑈𝑒 à
rapport cyclique égale à 1. De ce fait, la vitesse du moteur est variée par la variation
du rapport cyclique du signal de commande 𝑈𝑒 .

40
➢ Commander le moteur dans deux sens à une vitesse variable :
Pour contrôler la polarité aux bornes du moteur afin de changer le sens de
rotation, on utilise le montage appelé pont en H donné par la figure 3.15. Dans son
principe de base, le pont H est un assemblage de 4 transistors bipolaires (ou
MOSfet) monté de telle façon que le courant puisse passer soit dans un sens, soit
dans l'autre dans la charge (le moteur par exemple).

T1 T2

Tensions de
E M commandes
T3 T4

Figure 3.15 : Le pont H de commande de moteur CC

Les 4 transistors, symbolisés par des interrupteurs T1, T2, T3 et T4 dans la
figure 3.16, sont montés en pont et permettent de commander le sens de rotation du
moteur : Lorsque T1 et T4 sont fermés ( transistors saturés), le moteur tourne dans
un sens (sens 1). Lorsque T2 et T3 sont fermés, le moteur tourne dans l'autre sens
(sens 2)(Figure 3.16). Pour varier la vitesse, il faut appliquer le signal PWM de
commande au premier transistor de la branche activée et une tension continue au
deuxième transistor (figure 3.17).

T1 T2 T1 T2

M M

T3 T4 T3 T4

Figure 3.16: principe de la variation du sens de rotation.

41
 T1 T2

T3 T4

Figure 3.17 : Variation de la vitesse avec le montage H

Il existe des circuits intégrés qui servent de pont en H tel que L293 (Figures 3.18 et 3.19).
Ce circuit intègre 2 ponts en H , donc 4 demi-ponts , ce qui permet de contrôler 2 moteurs
en double sens ou 4 moteurs en sens unique. Ce circuit existe en 2 versions : le L293 et le
L293D. Le D fait référence aux diodes qui protège le circuit L298 des courants induits par
les bobinages du moteur CC. La différence entre la L293 et la L293D est donc simple : la
L293 ne contient pas ces diodes.

Pont A
Pont B

Figure 3.18 : Brochage du circuit L293

42
 (a)

(b)
Figure 3.19 : Structure interne (a) de L293 et structure simplifiée de L293D (b)
Les broches d’alimentation :
VSS Alimentation de la logique de commande (5V).
(A connecter par exemple, à la borne +5V d'Arduino).
VS Alimentation de puissance des moteurs. (à connecter par
exemple, la borne + d’une batterie 9V)
GND Doit être raccorder à la masse (GND) de la source
d'alimentation de puissance VS et à la masse de la source
d'alimentation de VSS (donc GND Arduino).

43
 La partie gauche commande le premier pont (Pont A: demi-pont 1 et 2) (Idem pour la
partie droite qui commande le deuxième pont (Pont B: demi-pont 3 et 4) :
OUTPUT1/OUTPUT2 Broches à raccorder à la charge (le moteur).
(1Y, 2Y)
INPUT1/INPUT2 Broche de commande du Pont H :
(1A, 2A) - INPUT1 commande demi-pont 1
- INPUT1. Commande demi-pont 2.
(à connecter aux ports de commande d’Arduino)
ENABLE1 Commande l'activation du premier Pont H (Pont A : demi-
(1,2EN ou ENA) pont 1 et 2). Permet d'envoyer (ou pas) la tension
d’alimentation sur les sorties de raccordement du moteur
(OUTPUT1/OUTPUT2) :
• Si ENABLE1 = 0, le pont H (A) est déconnecté et le
moteur ne fonctionne pas.
• Si ENABLE1 = 1, le pont H (A) est connecté aux
sorties et le moteur fonctionne dans un sens ou l'autre
ou pas en fonction des tensions appliquée sur INPUT1
et INPUT2.
(à connecter à un port de commande d’Arduino)
Les tableaux des figures 3.20 et 3.21 détaillent le comportement du circuit en fonction
des niveaux logiques sur les broches de commande du circuit (ENABLE1 , ENABLE2,
INPUT1 , INPUT2, INPUT3, INPUT4) pour 2 applications (Figure 3.22) :

Figure 3.20 : Commandes des demi-pont (1) et (2) avec ENABLE1(EN)

Figure 3.21 : Commandes des demi-pont (3) et (4) avec ENABLE2(EN)

1- Commande de moteur en double sens: pour faire fonctionner le moteur dans les
sens right ou left, il faut appliquer 1 aux entrées INPUT1 ou INPUT2 respectivement
en plus de l’application de 1 à l’entrée d’activation ENABLE1. Si INPUT1 et INPUT2
sont à 0 le moteur s’arrête mais de 2 manières très différente selon l’état de
ENABLE1 :
▪ Si ENABLE1=0 : arrêt sans freinage ( sortie en haute impedance (Z) →
moteur déconnecté ) le moteur tourne librement jusqu’à s’arrêter de
lui-même (Free running motor stop)
▪ Si ENABLE1=1 : arrêt avec freinage de la tension induite et les diodes
de roues libre. (Fast motor stop)

44
 2- Commande de moteur en sens unique: pour faire fonctionner le moteur dans un seul
sens (right ou left), il faut appliquer 1 à l’entrée adéquate (INPUT1 ou INPUT2) en
plus de l’application de 1 à l’entrée d’activation ENABLE1. Pour changer la vitesse on
applique un signal PWM à ENABLE. Si INPUTx et à 0 le moteur s’arrête selon de 2
manières déjà expliqué.

Figure 3.22 : Commandes en simple et double sens.

Enfin, la figure 3.23 donne un exemple de commande avec Arduino de 2 moteurs en
double sens et avec vitesse variable :
Alimenté
par la carte
Port PWM
Vitesse
Port digital Port digital
Sens 1 Sens 1

Port digital Port digital

Sens 2 Sens 2
Port PWM
Vitesse
Pile 9V

Figure 3.23 : Exemple de montage de commande avec Arduino

45
3.2 Ports d’entrée analogiques
Le Microcontrôleur de la carte Arduino Mega comporte un convertisseur
analogique/numérique multiplexé (partagé) par 16 cannaux (Les ports notés A0…A15 de la
carte Arduino mega). Ce convertisseur fournie une valeur numérique de 10 bits ce qui
correspond à 1024 niveaux distincts dans l’intervalle par défaut [0V 5V]. Il est possible
aussi de changer la tension de référence qui pemet de changer cet intervalle à [0V Vref] : la
tension Vref peut être une tension interne (1.1V ou 2.56V) ou externe appliquée au port
Aref.
Par défaut, le résultat de conversion est donc un entier Vc entre 0 et 1023 (autrement
dit une précision de 5/1024≈0.0049 Volts c-à-d 4.9mV) ). Pour retrouver la tension
analogique mesurée Vm on applique la règle de trois :
Vm=Vc*5/1023
En langage Arduino, la fonction analogRead est utlisée pour lire les entrées
analogiques :
- Uint16_t analogRead(uint8_t pin) : Lit la valeur numérique fournie par le
convertisseur après la conversion de la la tension analogique présente sur la broche
(pin) spécifiée. Les broches analogiques sont utilisées en entrée. Il n'est pas
nécessaire de les configurer avant d’utiliser la fonction analogRead.

Exemples:
A- mesurer une tension analogique :
Le programme suivant illustre la correspondance entre la valeur analogique mesurée
périodéquement, comprise entre 0V et 5V appliquée à l’entrée analogique A0 avec un
potentiomètre, et sa valeur numérique fournie par le convertisseur analogique numérique
(comprise entre 0 et 1023). (Réaliser le circuit et visualiser les valeurs de la tesion
mesurées et les valeurs numériques correspondantes):
Programme 1:
/* mesurer et afficher une tension */
uint16_t ValueConv; // variable for saving the converted digital value
float ValueMes; // variable for saving the calculated analog value
void setup()
{
[Link] (9600);
}
void loop()
{
ValueConv = analogRead (A0);
ValueMes = ValueConv * 5.0 / 1023 ;
[Link]("valeur fournie par le convertisseur = ");
[Link](ValueConv);
[Link]("tension mesurée= ");
[Link](ValueMes);
[Link](" V");
[Link]();
delay(1000); // an acquisition every 1s
}

46
Le délai introduit à la fin de Loop() reflète la fréquence d’échantillonnage de l’entrée. Ici
nous avons choisis de prendre une mesure toutes les secondes ce qui correspond à une
fréquence de 1Hz. Cette fréquence est approximative car la période d’acquisition est égale à
1s plus le temps d’exécution des instructions de la fonctions loop(). Ce temps peut être
mesuré approximativement avec la fonction millis (voir référence du langage). La
fréquenced’échantillonage doit être adaptée à la dynamique de l’entrée.
Le traceur série (Outils→Traceur série) permet aussi de visualiser l’évolution d’une entrée
analogique sous la forme graphique. Son utilisation est similaire au moniteur série :
insérer les instructions pour envoyer sur le port série la valeur à visualiser (nombre entier
ou à virgule) avec un retour chariot. Le programme suivant trace les valeurs fournies par le
convertisseur (on peut aussi visualiser les valeurs mesurées en remplaçant
[Link](ValueConv) par [Link](ValueMes).

Programme 2:
/* mesurer et afficher une tension */
uint16_t ValueConv; // variable for saving the converted digital value
float ValueMes; // variable for saving the calculated analog value
void setup()
{
[Link] (9600);
}
void loop()
{
ValueConv = analogRead (A0);
ValueMes = ValueConv * 5.0 / 1023 ;
[Link](ValueConv);
delay(1000); // an acquisition every 1s
}
On note que pour visualiser plusieurs courbes, il suffit d'envoyer la série de valeurs
séparées par des espaces, des tabulations ou des virgules terminé par un retour chariot :
Programme 3:
/* mesurer et afficher une tension */
uint16_t ValueConv; // variable for saving the converted digital value
float ValueMes; // variable for saving the calculated analog value
void setup()
{
[Link] (9600);
}
void loop()
{
ValueConv = analogRead (A0);
ValueMes = ValueConv * 5.0 / 1023 ;
[Link](ValueConv);
[Link](",");
[Link](ValueMes);
delay(1000); // an acquisition every 1s
}
47
B- Utiliser un capteur de lumière :
L’exemple suivant montre l’utilisation d’une photorésistance connectée au port analogique
A0. Ce programme contrôle l’allumage d’une LED en fonction de la luminosité ambiante :
Programme 4:
/* détecter la lumière avec une photorésistance*/
const uint8_t LedPin=13;// variable of LED controlling port
uint16_t ValueConv; // variable for saving the converted value
uint16_t threshold=0.1*1023; // thershold of detection = 10% of maximum
void setup()
{
pinMode(LedPin,OUTPUT);
[Link] (9600);
}
void loop()
{
if (analogRead(A0)>threshold) // if light level detected>10% of maximum
digitalWrite(LedPin, HIGH)
else
digitalWrite(LedPin, LOW)
delay(100); // an acquisition every 100ms
}
1- Réaliser le circuit puis observer l’état de la LED en fonction des différents niveaux de
lumière appliquée afin de décrire le fonctionnement de ce circuit.
2- Utiliser le traceur série pour observer le niveau de la tension d’entrée. Sur la (les)
figure(s) capturées reportée la condition de l’illuménation appliquée et l’état
correspondant de la LED.
2- Déterminer par raisonnement (sans la carte) le fonctionnement du circuit si on inverse
les polarités ( la photorésistante connectée à la masse et la résistance à Vcc) puis vérifier la
réponse avec la carte.
C- Utiliser un capteur de température :
Le programme suivant affiche sur le moniteur série la température mesurée avec LM35 :
Programme 5:
/* mesurer la température avec LM35 */
uint16_t ValueConv; // variable for saving the converted digital value
float Temp; // variable for saving the calculated analog value
void setup()
{
[Link] (9600); }
void loop()
{
ValueConv = analogRead (A0);
Temp = 100*(ValueConv * 5.0 / 1023);
[Link]("Température mesurée= ");
[Link](Temp);
[Link](" °C");
delay(1000); // an acquisition every 1s
}
48
3.3 Ports de sortie PWM ("Sorties Analogiques")
Le microcontrôleur de la carte Arduino possède des sorties qui permettent de générer des
signaux PWM. Ces sorties sont les ports 2 – 12 de la carte Arduino Mega (ils sont repérés
par le symbole ~). Ces ports sont physiquement liés à des compteurs/Timers. Ces timers
après configuration fonctionnent indépendamment du processeur. La génération d’un
signal s’effectue avec la fonction suivante :
- analogWrite(uint8_t pin, uint8_t largeur_impulsion) : Génère sur la pin spécifiée un
signal de 500Hz et de largeur d’impulsion spécifiée. La largeur d’impulsion est comprise
entre 0 et 255 tel que (Figure 3.24): 0 → rapport cyclique = 0% et 255 → rapport cyclique =
100%.

Fig 3.24 : Exemples de PWM généré avec analogWrite

Exemple: Générer et visualiser un signal PWM:
Ce programme génère un signal PWM sur le port 12. Téleverser ce programme et
visualiser le signal avec l’oscilloscope pour vérifier la période du signal PWM et le rapport
cyclique.
Programme 6:
/* générer PWM */
const uint8_t pwmPin = 12; // the number of the PWM pin
float rapport_cyclique=0.3; // variable for reading the converted
void setup()
{
pinMode(pwmPin, OUTPUT);
analogWrite (pwmPin,rapport_cyclique*255);
}
void loop() { }
49
3.4 Applications
Application 1 - Allumer graduellement et périodiquement une LED:
Ce programme allume une LED graduellement jusqu’à la brillance maximale:
Programme 1:
/* brillance graduelle */
const uint8_t pwmPin = 12; // the number of the PWM pin
uint8_t Pulse=0; // variable for reading the converted analog value
void setup()
{
pinMode(pwmPin, OUTPUT);
}
void loop()
{
Pulse ++;
analogWrite (pwmPin,Pulse);
delay(5);
}
- Tester le programme avec la carte,
- Déterminer puis vérifier l’effet de remplacement de Pulse ++ par Pulse += 50 et
delay(5)par delay(500)
- Ecrire un programme qui alume et éteint graduellement une LED par l’appui sur un
bouton poussoir (sans maintien).
Application 2 - Contrôler la luminosité d’une LED avec un potentiomètre
Ecrire un programme qui permet de varier la luminosité de la LED L en utilisant un
potentiomètre. Réaliser le circuit et vérifier le programme.
Modifier ce programme pour varier la vitesse de clignotement de la LED L en utilisant le
potentiomètre.
Application 3 - Contrôler une LED RVB en fonction
La couleur émise d’une LED RVB résultante de la combinaison de 3 valeurs comprises
entre 0 et 255 est très similaire au résultat obtenu par combinaison de couleurs dans les
logiciels de dessin :

Fig 3.25 : Exemple de composantes R, V et B d’une couleur

50
 Programme 2:
/* Contrôler une LED RVB */
const uint8_t led_verte = 9;
const uint8_t led_bleue = 10;
const uint8_t led_rouge = 11 ;
void setup()
{
pinMode(led_verte, OUTPUT);
pinMode(led_bleue, OUTPUT);
pinMode(led_rouge, OUTPUT);
}
void loop()
{
analogWrite(led_rouge, X);
analogWrite(led_verte, Y);
analogWrite(led_bleue, Z) ;
}
- Réaliser le circuit puis observer le résultat pour différente valeur de X , Y et Z.
- Si on note redlntensity , greenlntensity et bluelntensity les composantes R V et B
respectivement (comprise entre 0 et 255), des effets de changement graduel entre 2
couleur sont obtenu de la manière suivante :
1- De rouge au vert : augmenter greenIntensity de 0 à 255 avec
redIntensity=255-greenIntensity et blueIntensity=0
2- De vert au bleu : augmenter bluelntensity de 0 à 255 avec
greenIntensity=255-blueIntensity avec redIntensity=0
3- De bleu au rouge : augmenter redIntensity de 0 à 255 avec
blueIntensity=255-greenIntensity avec greenIntensity=0
Ecrire un programme pour produire ces effets séquentiellement et périodiquement.
Application 5 : différents cas de contrôle moteur CC
En utilisant le circuit L293D et un moteur CC 6V alimenté par une Pile de 9V, élaborer
puis vérifier les montages et les programmes de commande pour chacun des cas suivant :
• Commande de moteur dans le sens horaire uniquement à vitesse maximale
admissible.
• Commande de moteur dans les 2 sens à vitesse maximale en fonction d’une entrée
de sélection de sens de rotation.
• Commande de moteur dans le sens antihoraire à vitesse variable reglée par un
potentiomètre
• Commande de moteur dans les 2 sens à vitesse variable reglée par un
potentiomètre. Le basculement d’un sens à un autre sev fait par un appui sur un
bouton poussoir (sans maintien).
• Commande de moteur dans les 2 sens à vitesse variable reglée par un
potentiomètre. Le basculement d’un sens à un autre sev fait par un appui sur un
bouton poussoir (sans maintien).
• Commande de moteur selon la séquence suivante : tourne dans le sens horaire à
vitesse maximale pendant 5 scondes, puis continue dans le même sens à petite
vitesse (20% de la vitesse maximale) pendant 3 secondes et enfin tourne dans le
sens contraire à vitesse maximale pendant 8 secondes et ainsi de suite….

51
3.5 Exercices
Traiter un seul exercice au choix.
Exercice 1 :
On désire réaliser un circuit de commande de store automatique composé de 2 capteurs
(lumière et vent) et un moteur. Le principe de fonctionnement est le suivant :
- Lorsque la luminosité du soleil dépasse le seuil fixé pendant au moins 3 minutes le
store descend. Si la luminosité retombe en dessous du seuil réglé le store remonte au
bout d'un quart d'heure.
- Si la vitesse du vent dépasse le seuil fixé pendant 5 secondes consécutives, la
remontée du store s’effectue pour sa protection. Lorsque cette vitesse retombe en
dessous du seuil, le store reste relevé pendant une durée de 12 minutes avant
d'autoriser une redescente. A l'issue de cette temporisation, le store redescendra si la
luminosité du soleil dépasse le seuil fixé.

Exercice 2 :
On désire réaliser une application basée sur le capteur sonore KY-037. Ce capteur de
haute sensibilité fourni une tension analogique proportionnelle au bruit détecter par le
microphone.

- Donner les caractéristiques et le principe de fonctionnement de ce capteur.

- Réaliser une commande d’allumage de LED avec le claquement des mains.

52
 TP N°4
Le langage Arduino (III) :
Les Librairies Arduino (mini projet)

1. Découvrir les librairies Arduino;

2. Utiliser des exemples : LiquidCrystal, keyboard, Servo, Stepper, Wire, SPI;
3. Installer une bibliothèque : DC_Motor, Bounce.
4. Réaliser un menu avec LCD et boutons
5. Choisir une application en automatique (micro projet)

Les composants requis pour ce TP sont :

▪ L’afficheur LCD
▪ Mini clavier 16 touches
▪ Moteur pas à pas, ServoMoteur , moteur DC
▪ Modules SPI et I2C.

1.1 Librairies Arduino

Comme toute autre platforme, Arduino permet l’utilisation de bibliothèques dédiées à
des périphériques intégrés (Timer, interface série, …) et à l’utilisation de modules
externes tels que les afficheurs, les moteurs, les capteurs…. Certaines bibliothèques
usuelles sont déjà intégrées à Arduino IDE mais une infinité de bibliothèques développées
par la communauté Arduino peuvent être rajoutées (intallées). Ces bibliothèques facilite
la progrommation des applications lorsque ces dèrnières augmentent en complexité.
Parmis ces bibliothèques, on cite les bibliothèques standard intégrées à Arduino IDE:

53
 1.2 La librairie LiquidCrystal
1.2.1 Rappels sur les afficheurs LCD
Les afficheurs LCD sont monochromes et existent sous différentes formes et tailles : 8,
16, 20, 24, 32 et 40 caractères et plusieurs lignes. Ces afficheurs sont disponibles en 14 ou 16
pins selon le modèle.

Le tableau ci-dessous présente la définition des pins et leurs fonctions (modèle à 14pins):
Pin Description
Vss masse
Vdd alimentation
Vee réglage du contraste d'affichage (connecté à la troisième borne
du potentiomètre de réglage) (fonction facultative : reliée à Vcc si pas
de réglage ).
RS (Registre Select) :
0→ les bits transférés via D7..D0 sont interprétés comme une commande.
1→ les bits transférés via D7..D0 sont interprétés comme une donnée
(un caractère à afficher).
R/W (Read/Write) :
0→ envoi de commandes ou de données à l’afficheur LCD
1→ lecture des informations à partir du LCD
La lecture à partir du LCD n’est pas beaucoup utilisée. Donc, Cette pin
est généralement reliée à la masse (écriture seulement).
En (Enable) : utilisé pour initier le transfert de commandes ou de données
entre le module et le microcontrôleur :

54
 - Lors d’une écriture, les données sont transférées uniquement sur un
front descendant sur cette patte.
- Lors d’une lecture, les données sont valides après le front montant, et
ces données demeurent tant que cette patte de validation est au niveau
logique haut.
D7…D0 sont les huit lignes de données (D0 à D7) qui peuvent être utilisées selon
2 modes :
- Mode 8bits : les données sont transférées un octet à la fois.
- Mode 4 bits : les données sont transférées en deux fois 4-bits. Dans ce
cas, seules les quatre lignes de données supérieures (D4 à D7) sont
utilisées. Le mode 4-bits est fréquemment utilisé car il a l'avantage
de nécessiter moins de ports d'E/S du microcontrôleur pour communiquer
avec l'écran LCD.
Pour commander un afficheur LCD il faut respecter des procédures pour initialiser, en
voyer les commandes, les donner à afficher, … avec des délais d’attente très stricte. A titre
d’exemple, la figure suivante montre la procédure d’initilisation de l’afficheur après la
mise sous tension. La programmation de ces procédures est possible mais fastidieus, par
consequent il vaut mieux utiliser directement une bibliothèque spécialisée.

1.2.2 Utilisation de la bibliothèque LiquidCrystal

Cette librairie permet à une carte Arduino de contrôler un afficheur LCD
alphanumérique standard à cristaux liquides basé sur le circuit intégré Hitachi HD44780
(ou compatible), ce qui est le cas de la plupart des afficheurs alphanumériques LCD
55
disponibles. La librairie fonctionne aussi bien en mode 4 bits qu'en mode 8 bits (càd
utilisant 4 ou 8 broches de donnée en plus des broches de contrôle RS, Enable et RW
(optionnel)). Ainsi, en mode 4 bits, 6 broches numériques seulement suffisent pour
contrôler un afficheur LCD alphanumérique.
Les fonctions de base sont (Voir Références):
Fonctions d'initialisation
begin()
Fonctions d'écriture
print()
write()
Fonctions de gestion de l'écran
clear()
display()
noDisplay()
Fonctions de positionnement du curseur
home()
clear()
setCursor()
Fonctions modifiant l'aspect du curseur
cursor()
noCursor()
blink()
noBlink()
Fonctions de contrôle du comportement du curseur
autoscroll()
noAutoscroll()
leftToRight()
rightToLeft()
Fonctions d'effets visuels
scrollDisplayLeft()
scrollDisplayRight()
Fonction de création de caractère personnalisé
createChar()

56
LiquidCrystal (Constructeur de classe)
Prototype: LiquidCrystal lcd(rs, enable, d4, d5, d6, d7); // mode 4 bits - RW non utilisé
(le plus simple!)
LiquidCrystal lcd(rs, rw, enable, d4, d5, d6, d7); // mode 4 bits - RW utilisée
LiquidCrystal lcd(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7); // mode 8 bits -
RW non connectée
LiquidCrystal lcd(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7); //mode 8 bits
- RW utilisée

• lcd: le nom de la variable LiquidCrystal déclarée

• rs: le numéro de la broche de l'Arduino qui est connecté à la broche RS de
l'afficheur LCD.
• rw: le numéro de la broche de l'Arduino qui est connecté à la broche RW
de l'afficheur LCD (optionnel)
• enable: le numéro de la broche de l'Arduino qui est connecté à la broche
E(nable) de l'afficheur LCD
• d0, d1, d2, d3, d4, d5, d6, d7: le numéro de la broche de l'Arduino qui est
connecté aux broches correspondantes des broches de données de
l'afficheur LCD. Les broches de données d0, d1, d2, and d3 sont
optionnelles; si elles sont omises, le LCD pourra être contrôlé en utilisant
seulement les quatre broches de données d4, d5, d6, d7 (mode 4 bits).
Retourne: --
Description: Crée une variable de type LiquidCrystal en définissant les broches utilisées
avec le LCD et son mode de fonctionnement. L'afficheur LCD peut être
contrôlé avec 4 ou 8 lignes de données. Si vous souhaitez utiliser l'afficheur en
mode 4 bits, omettez les numéros broches pour d0 à d3 et laissez ces broches
non-connectées. La broche RW peut-être connectée à la masse (0V) au lieu
d'être connectée à une broche de la carte Arduino. De la même façon, si vous
ne souhaitez pas utiliser cette broche, omettez-là dans les paramètres de la
fonction LiquidCrystal() (voir ci-dessous)

Note : Un afficheur LCD peut être contrôlé uniquement avec 4 broches de

données (d4 à d7) et 2 broches de commandes (RS et E), soit 6 broches
seulement, contre 8 broches de données et 3 broches de commandes en
connexion complète. On économise donc ainsi 5 broches de la carte Arduino
qui resteront ainsi disponibles.
Requis: --
Exemple: #include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2); // déclare une variable

LiquidCrystal appelée lcd
// mode 4 bits et RW pas utilisé

Begin()
Prototype: [Link](colonnes, lignes)
Retourne: Nothing
Description: - lcd: une variable de type LiquidCrystal
- colonnes: le nombre de colonnes de l'afficheur LCD utilisé
- lignes: le nombre de lignes de l'afficheur LCD utilisé
Requis: --
Exemple: // --- Inclusion des librairies utilisées ---
#include <LiquidCrystal.h>
// --- constantes des broches ---
const byte RS=2; //declaration constante de broche
const byte E=3; //declaration constante de broche

57
 const byte D4=4; //declaration constante de broche
const byte D5=5; //declaration constante de broche
const byte D6=6; //declaration constante de broche
const byte D7=7; //declaration constante de broche

// --- Initialisation des fonctionnalités utilisées ---

LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// initialisation LCD en
mode 4 bits

void setup() {

[Link](20,2); // Initialise le LCD avec 20 colonnes x 2 lignes

…
}

print()
Prototype: [Link]("texte")
[Link](data)
[Link](data, BASE)
Retourne: Nothing
Description: - lcd : une variable de type LiquidCrystal
- "texte" : une chaîne de caractères
- data : la donnée à afficher (char, byte, int, long, float ou string)
- BASE (optionel): la base dans laquelle vous voulez afficher les nombres :
BIN pour binaire (base 2), DEC pour décimal (base 10 - base par défaut),
OCT pour octal (base 8) et HEX pour hexadécimal (base 16).
Requis: The Lcd module needs to be initialized avec Lcd_Init.
Exemple: #include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2);
void setup()
{
[Link]("hello, world!");
}
void loop() {}

clear()
Prototype: [Link]()
Retourne: Nothing
Description: lcd: une variable de type LiquidCrystal
Requis: --
Exemple: // --- Inclusion des librairies utilisées ---
#include <LiquidCrystal.h> // Inclusion de la librairie pour
afficheur LCD

// --- constantes des broches ---

const int RS=2; //declaration constante de broche
const int E=3; //declaration constante de broche

const int D4=4; //declaration constante de broche

const int D5=5; //declaration constante de broche
const int D6=6; //declaration constante de broche
const int D7=7; //declaration constante de broche

// --- Initialisation des fonctionnalités utilisées ---

LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// initialisation LCD en
mode 4 bits

void setup() { // debut de la fonction setup()

[Link](20,2); // Initialise le LCD avec 20 colonnes x 2 lignes

delay(10); // pause rapide pour laisser temps initialisation

58
 // Test du LCD

[Link]("LCD OK") ; // affiche la chaîne texte - message de test

delay(2000); // pause de 2 secondes

[Link](); // // efface écran et met le curseur en haut à gauche

delay(10); // pour laisser temps effacer écran

} // fin de la fonction setup()

void loop(){ // debut de la fonction loop()

// --- ici instructions à exécuter par le programme principal ---

} // fin de la fonction loop() - le programme recommence au début

de la fonction loop sans fin

setCursor()
Prototype: [Link](colonne, ligne)
Retourne: Nothing
Description: - lcd: une variable de type LiquidCrystal
- colonne: la colonne à laquelle positionner le curseur (ATTENTION : 0 est
le 1ère colonne, 1 la 2ème, etc..).
- ligne: la ligne à laquelle positionner le curseur (ATTENTION : 0 est le 1ère
ligne, 1 la 2ème, etc..).
Requis: The Lcd module needs to be initialized avec Lcd_Init.
Exemple: // --- Inclusion des librairies utilisées ---
#include <LiquidCrystal.h> // Inclusion de la librairie pour
afficheur LCD

// --- constantes des broches ---

const int RS=2; //declaration constante de broche

const int E=3; //declaration constante de broche

const int D4=4; //declaration constante de broche

const int D5=5; //declaration constante de broche
const int D6=6; //declaration constante de broche
const int D7=7; //declaration constante de broche

// --- Initialisation des fonctionnalités utilisées ---

LiquidCrystal lcd(RS, E, D4, D5, D6, D7);// initialisation LCD en
mode 4 bits

void setup() { // debut de la fonction setup()

[Link](20,4); // Initialise le LCD avec 20 colonnes x 4 lignes

delay(10); // pause rapide pour laisser temps initialisation

// Test du LCD
[Link]("LCD OK") ; // affiche la chaîne texte - message de test
delay(2000); // pause de 2 secondes

[Link](); // // efface écran et met le curseur en haut à gauche

delay(10); // pour laisser temps effacer écran

} // fin de la fonction setup()

void loop(){ // debut de la fonction loop()

[Link]("Arduino...") ; // affiche la chaîne texte - message de

59
 test
delay(2000); // pause de 2 secondes

[Link](9, 1) ; // 10ème col - 2ème ligne - positionne le

curseur à l'endroit voulu (colonne, ligne) (1ère=0 !)
[Link]("...pour te") ; // affiche la chaîne texte - message de
test
delay(2000); // pause de 2 secondes

[Link](4, 2) ; // 5ème col - 3ème ligne - positionne le

curseur à l'endroit voulu (colonne, ligne) (1ère=0 !)
[Link]("...servir") ; // affiche la chaîne texte - message de
test
delay(2000); // pause de 2 secondes

[Link](12, 3) ; // 13ème col - 4ème ligne - positionne le

curseur à l'endroit voulu (colonne, ligne) (1ère=0 !)
[Link]("...amigo") ; // affiche la chaîne texte - message de
test
delay(2000); // pause de 2 secondes

[Link](); // // efface écran et met le curseur en haut à gauche

delay(10); // pour laisser temps effacer écran

} // fin de la fonction loop() - le programme recommence au début

de la fonction loop sans fin

1.2.3 Application
1- Analyser le programme suivant pour déterminer sa fonction puis réaliser le montage
et vérifier . (consulter l’aide pour la fonction millis)
Programme :
/*
LiquidCrystal Library - Hello World
Demonstrates the use a 16x2 LCD display. */

// include the library code:

#include <LiquidCrystal.h>

// initialize the library by associating any needed LCD interface pin

// with the arduino pin number it is connected to
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
// set up the LCD's number of columns and rows:
[Link](16, 2);
// Print a message to the LCD.
[Link]("hello, world!");
}

void loop() {
// set the cursor to column 0, line 1
[Link](0, 1);
// print the number of seconds since reset:
[Link](millis() / 1000);
}

60
 1.3 Application en automatique (Micro projet)
On se propose de réaliser un mini système comme l’on pourrait retrouver dans un
milieu industriel (en plus simple ici, bien sûr !) ou dans d’autres applications. Le but sera
de :
1- Acquérir des informations à partir de cateurs, clavier, boutons …
2- De faire un traitement en fonction des données pour contôler, superviser … les
résultat de ce traitement est une action : démarrer/arrêter un actionneur, affichage
de message sur un afficheur, déclenchement alarme …
Ce système doit être autonome et non connecté au PC pendant le fonctionnement (il
faut prévoir une alimentation et un affichage indépendant). L’utlisation de menu avec
afficheur et l’élaboration d’une réalisation miniature soignée sont souhaitables (structure
avec imprimante 3d ou decoupe laser) ( +5 points à la moyenne du module). Aucun rapport
à réaliser mais un exposé détaillé est demandé. La note est comptabilisé à 70% de la note de
TP (exposé + réponses aux questions).
Le matériel disponible:

61
62
Partie 2

63
 TP N°5
Prise en main d’Atmel Studio 7
(Limitations du langage et de l’IDE Arduino)

1. Comparer Arduino IDE et Atmel Studio

2. Apprendre à créer un projet sous Atmel Studio;
3. Configurer l’IDE pour utiliser la carte Mega;
4. Vérifier les applications du cours et les exercices de TD.

1.1 Introduction
La platforme Arduino est une plateforme très facile à utiliser spécialement conçu pour
les débutant dans le domaine de la programmation des microcontrôleurs. Cependant, ces
caractéristiques ne l’adapte pas pour développer des applications complexe car :
- Le langage Arduino est une version simplifiée des langages C et C++, qui contourne
les difficultés avec des fonctions faciles très nombreuses mais souvent au prix d'un
allongement considérable du code : digitalWrite(), par exemple, requière un tableau
en mémoire programme de 440 octets, 6 appels de fonctions et un ensemble de
tests !. De plus, les fonctions disponibles, malgré qu’elle offre plusieur options
d’utlisation, délimitent les possibilité intrinsèque de l’utilisation des différents
modules du microcontroleurs.
- l'IDE Arduino n'offre aucune possibilité de debugging, à part l’utilisation de
multiples "[Link]()" pour contrôler le comportement du programme.
- Les cartes Arduino en nombre limités limitent également le développement à un
ensemble réduit de microcontrôleur.
Suite à ces considérations, il est necessaire d’élargir la programmation au langage C
standard et C++ et d’utiliser d’autre environnement de développement offrant plus d’outils
et de gamme de microcontrôleurs possibles. Il existe diverses solutions répondant à ces
exigences. L'une d'entre elles est la mise en oeuvre du langage C avec le compilateur
GNU-GCC et sa librairie AVR Libc. L'environnement de développement Studio de
Atmel permet d'utiliser aussi bien ce langage C que le C++ et l'assembleur pour
programmer une gamme énorme de microcontrôleurs, allant des minuscules ATtiny à 6
pins aux ARM Cortex en passant par les ATmega 8 bit et les AVR 32 bit. Le logiciel
Studio comporte un simulateur qui permet de simuler le fonctionnement du programme et
de vérifier l’exécution pas à pas en observant les valeurs des variables, des entrées/sorties
et des registres du microcontrôleur

1.2 Amel Studio

Atmel Studio est un IDE pour créer, compiler et déboguer un programme destiné aux
microcontrôleurs AVR. Nous utilisons Atmel Studio 7 pour le développement des
applications basé sur le MCU ATmega 2560 de la carte Arduino Mega2560.

64
 Atmel Studio 7 inclut le compilateur AVR GCC C et C ++ (comme Arduino IDE),
l'assembleur et un simulateur. Commençons par l’application Blink de la LED L pour
expliquer la procédure de création d’un projet, de compilation du programme et la
programmation de la carte.

1.3 Manipulation
Lancez Atmel Studio 7. Nous obtiendrons la fenêtre de la page de démarrage suivante :

Pour créer un nouveau projet, Clickez sur File -> New -> Project or utlisez le raccourci
clavier Ctrl+Shift+N Short keys

65
 la fenêtre de création de nouveau projet apparaîtra comme illustré ci-dessous. Il faut
sélectionner le type de projet comme indiqué, donner un nom du projet (soit Blink) et un
emplacement d’enregistrement.

En outre, il existe une option « Créer un répertoire pour la solution », ce qui créera un
répertoire pour chaque projet avec le même nom du projet à l'emplacement fourni.
Après avoir cliqué sur OK, la fenêtre de selection du MCU apparait: taper directement
le type du microcontrôleur pour obtenir le MCU requis dans la liste affichée.
Sélectionnez le MCU de la carte Arduino utlisée, puis sur OK. Atmel Studio crée alors le
projet et le fichier main.c à compléter avec les instructions de l’application.
Par défaut, le programme inclus la bibliothèque avr/io.h, necessaire pour la
manipulations des noms des registres, la fonction principale main et la boucle infinie de
traitement while(1). Compléter le programme avec les instructions qui permettent de
clignoter la LED (on rappelle aussi le Blink d’Arduino):
Programme : Blink Arduino
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage
level)
delay(500); // wait for a second
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage
LOW
delay(500); // wait for a second
}

66
 Programme : Blink Atmel
/* ATmega2560_LED_Blinking.c
* [Link]
* Created: Created Date & Created Time
* Author : Author Name
*/
#define F_CPU 16000000UL /* Define CPU frequency here 16MHz */
#include <avr/io.h>
#include <util/delay.h>
int main(void)
{
DDRB = 0xFF; /* Make all pins of PORTB as output pins */
while (1) /* Blink PORTB infinitely */
{
PORTB = 0x00;
_delay_ms(500);/* Delay of 500 milli second */
PORTB = 0xFF;
_delay_ms(500);
}
}

Après avoir la saisi, enregistrer (Ctrl + S) le programme et compiler à partir du menu

Build—Build Solution ( racourcci clavier F7).
Maintenant, nous pouvons voir le rapport de la compilation à la fenêtre de sortie (coin
inférieur gauche de la fenêtre) : on peut y voir la taille du programme etdes données

Après compilation, certain fichier de sortie sont générés comme le programme en

assembleur (.lss) correspondant et le fichier de programmation( .hex), ouvrez ces fichiers
pour les visualiser.

67
 Pour téléverser le programme ([Link]) dans la carte il faut d’abord configurer
l’Atmel Studio. Contrairement à Arduino IDE, Atmel Studio n’intègre pas l’outil
Avrdude (logiciel de programmation) necessaire pour programmer la carte arduino avec le
bootloader. Procédure de configuration : cliquez sur tools> External tools.

Puis suivez les étapes (2--6) décrites par la figure suivante :

▪ 2 : Ajouter dans Title un nom pour le nouveau outil (soit : Arduino Programmer)

68
 ▪ 3 : Ajouter dans Command l’emplacement de l'avrdude (il se trouve dans le dossier
d’arduino IDE) D:\Desktop\arduino-1.8.5\hardware\tools\avr\bin\[Link]
(ce qui est marqué en rouge varie selon l’emplacement d’Arduino IDE sur
votrePC).
▪ 4 :Ajouter dans Arguments la commande de programmation : -
C"D:\Desktop\arduino-1.8.5\hardware\tools\avr\etc\[Link]" -v -
patmega2560 -cwiring -PCOM7 -b115200 -D -
Uflash:w:"$(ProjectDir)Debug\$(TargetName).hex":i (Le COM à adapter aussi)
▪ 5 : cocher « Use Outrput Window »
▪ 6 : Après la validation (OK), l’outil Arduino programmer est rajouter au tools

Maintenant pour programmer la carte, Assurez-vous que la carte est connectée puis
cliquez sur tools> Arduino programmer.

1.1 Comparaison :
Comparer la taille occupée par Arduino Blink et celle de Atmel Blink.

69
1.2 Exercices :
1.2.1 Contôler la LED L :
A. Vérifier le programme suivant avec la carte Arduino Mega en connectant une led au
port utilisé.
Exemple
char *AdrPORTA=0x22; //pointeur de PORTA
char *AdrDDRA=0x21; //pointeur de DDRA

int main (void)

{ *AdrDDRA = 0x01;
while(1)
{
*AdrPORTA = 0x01; //make Bit0 of PORTA High to turn LED on
}
}

B. Consulter data sheet du MCU ATMEGA pour obtenir les adresses des registres
suivants :
Registre DDRB PINB PORTB PORTC DDRC PINC MCUCR
Adresse
C. Modifier le programme suivant afin de faire clignoter la led intégré L de la carte
Arduino Mega :
Exemple
char *AdrPORTA=0x22; //pointeur de PORTA
char *AdrDDRA=0x21; //pointeur de DDRA

int main (void)

{ *AdrDDRA = 0x01;
while(1)
{
*AdrPORTA = 0x01; //make Bit0 of PORTA High to turn LED on
}
}

1.2.2 Chennillards à plusieurs motifs

Ecrire un programme en langage C qui permet de réaliser un chennillard 8Leds à quatre
motifs (simple, double, simpl inversé, double inversé ) avec 2 entrées de sélection.

1.2.3 Chennillards à entassement

Ecrire un programme en langage C qui permet de réaliser un chennillard 8Leds à
entassement à gauche et à droite à 2 vitesses différentes avec 2 entrées de sélection.

1.2.4 Utilisation des interruptions

A. Vérifier toutes les applications du cours
B. Dérouler le programme ci-dessous afin de déterminer l’état de la LED selon le
chronnogramme suivant :

70
 Entrée
allumée
LED éteinte

t(s)
Exemples
#define F_CPU 16000000UL
#include <avr/io.h>
int main(void)
{
char previousSample ;
char currentSample;
DDRA = 0x01;
PORTA &=~(1<<PORTA0);
currentSample = (PINA & (1<<PINA1));
previousSample = currentSample;
while (1)
{
currentSample = (PINA & (1<<PINA1));
if (currentSample!= previousSample)
{
PORTA ^= (1<<PORTA0); // turn LED on/off
previousSample = currentSample;
}

}
}

- Que devient le chronogramme précédent si on remplace l’instruction soulignée par :

PORTA |=(1<<PORTA0)
C. Modifier le programme précédent afin d’allumer la LED L par front montant comme le
montre les chrogrammes suivants:
- Sans l’utilisation d’interruption
- En exploitant les interruption

Entrée
allumée
LED éteinte

t(s)
D. En exploitant les interruptions, adapter le circuit et le programme du chenillard 4
motifs pour utiliser une seule entrée pour sélectionner le motif : en appuyant sur
l’entrée on passe d’un motif à un autre (motif1→ motif2→ motif3→ motif4→
motif1→…).

71