1.

INTRODUCTION

2. PRÉSENTATION
SENTATION DE LA CARTE ARDUINO UNO
La carte Arduino Uno est un circuit imprimé spécifiquement conçu pour héberger un
microcontrôleur et donner accès à toutes ses entrées et sorties. Elle comprend aussi quelques
autres composants électroniques qui permettent de faire fonctionner le microcontrôleur ou
d’en étendre les fonctionnalités.
fonctionnalités Le logiciel et le matériel de la carte Arduino Uno sont Open
source. Cela signifie que ce logiciel et ce matériel peuvent être librement adaptés aux besoins.
La version la plus récente reste pour l’heure la carte Arduino Uno Rev3. R Considérez-la
comme la carte Arduino de base. C’est un bon matériel, fiable, qui conviendra à de nombreux
projets.
Le microcontrôleur ATmega mega328P représente le cerveau de la carte Arduino Uno. Uno Ce
microcontrôleur de 8 bits de la famille AVR d’Atmeld’ est basé sur l’architecture RISC et
Harvard. Ce microcontrôleur possède trois types de mémoires :
- EEPROM dont la taille est de 1ko et e qui permet de stocker des données qui ne
changent pas trop souvent.
- Mémoire Flash dont la taille est de 32ko 32 et qui sert à enregistrer les programmes
sources (Croquis ou bien sketchs). Un programme appelé Bootloaderootloader (0,5ko) réside
généralement dans cette mémoire.
- Mémoire volatile SRAM dont la taille est de seulement 2ko 2k et qui est utilisée pour
stocker les variables et les données utilisées par le microcontrôleur ATmega328P
pendant l'exécution du programme.
Les caractéristiques
aractéristiques générales dud microcontrôleur de la carte
rte Arduino Uno sont les suivantes :
- Nombre de broches : 28 (sur le modèle DIP, DIP amovible). Ill existe aussi au format TQFP
(32 broches,, Composant Monté en Surface)
Surface ;
- 32 registres d'usage général;
général
- Gestion d'interruptions (24 sources possibles) ;
- Entrées/Sorties
ées/Sorties numériques : 14 ;
- Fréquence
quence d'horloge : 16 Mhz (maximum 20Mhz);
- Un convertisseur Analogique/Numérique à 06 canaux (résolution résolution de 10 bits), 01
comparateur analogique,
analogique 01 timer 16 bits (T1), 02 timers 8 bits (T0,T2) ;
- 06 canaux MLI (PWM PWM) (le symbole ~ apparaît à côté des broches 3, 5, 6, 9, 10 et 11) ;
- 011 chien de garde (watchdog), Interface série SPI maître/esclave,
maître/esclave USART série
2
programmable, TWI (Two Two Wire Interface, compatible I C) ;
- En mode exécution, l’ATmega328
l’ consomme environ 10 mA, soit 0,05 W pour une
tension de fonctionnement de 5V.
5V En mode veille, saa consommation descend à 0,1 µA.
-

Fig.1 : Vue générale de la carte Arduino Uno R3

1
 Fig.2 : Connexion de l’Arduino Uno

3. LES DIFFÉRENTES BROCHES DE LA CARTE ARDUINO UNO

Une broche numérique ne peut fournir que 40mA et que l'ensemble des broches de la carte
Arduino Uno ne peut fournir que 200mA. Par conséquent, il faut limiter l'intensité utilisée
pour chaque broche à une dizaine de mA (recommandé 20 mA).

- La broche Vin : Cette broche peut être utilisée pour alimenter la carte Arduino Uno depuis
une autre source (une pile ou un adaptateur secteur). Elle correspond à l’entrée du régulateur
de tension présent sur la carte. Pour alimenter l’Arduino via cette broche, il faut une
alimentation dont la tension est comprise entre 7 et 12V (tension d’alimentation limite : 6-20
V);
- Les broches GND : Il y a deux broches de masse en bas, près des broches analogiques, et
une troisième en haut à côté de la broche 13. Toutes ces broches sont reliées pour partager la
même masse.
- La broche 3,3V : Elle sert à alimenter des composants fonctionnant avec cette tension
réduite au lieu de 5V (maximum 50mA).
- La broche 5V : Cette broche de 5V est utilisée pour alimenter les composants ou les circuits
en 5 volts.
- La broche IOREF : Elle sert à distribuer à des cartes d’extension la même tension que celle
utilisée par la carte Arduino. Elle fournit soit du 5V, soit du 3,3V.
- La broche AREF : AREF est l’acronyme anglais de “référence analogique”. Cette broche
est parfois utilisée pour définir une tension de référence externe (entre 0 et 5V) comme limite
supérieure pour les broches d’entrée analogiques.

4. LES CONNECTEURS DE LA CARTE ARDUINO UNO

- Le connecteur USB : Ce connecteur métallique est un port USB que vous pouvez relier à un
câble USB A-B (câble USB d’une imprimante ou d’un scanner). Il assure la communication
avec l’ordinateur afin de programmer la carte Arduino Uno, en convertissant le signal série en
USB. Il permet aussi, dans les limites de la prise USB (500mA maximum) d’alimenter la carte
Arduino Uno. Cette dernière n'utilise pas le circuit intégré FTDI usb-vers-série. A la place,
elle utilise un ATmega16U2 programmé en convertisseur USB-vers-série.

2
- Le connecteur ICSP (In-Circuit
Circuit Serial Programming) : C’est est une connectique AVR
comprenant les broches MOSI, MISO, SCK, RESET, VCC et GND. Il s’agit d’un connecteur
de programmation. Ce connecteur permet entre autre de programmer directement le
microcontrôleur surr les couches les plus basses (Bootloader,
(B code ASM…).
M…). C’est aussi un
port appelé port SPI qui permet de dialoguer avec d’autres
d’autres composants SPI (écrans, capteurs,
etc…).

- Le connecteur Jack: Ce type de connecteur de 2,1mm possède 2 fils dont le fil positif est à
l’intérieur et le fil négatif à l’extérieur (Fig.3).Vous
Vous y reliez un adaptateur AC-DC,
AC une
batterie ou même un panneau solaire. La tension recommandéee pour la carte Uno Un R3 est
comprise entre 7 et 12V continu.
continu Sur cette entrée, une diode de protection évite les mauvais
branchements.

Fig.3 : Connecteur Jack

- Le bouton Reset : La carte Arduino Uno dispose d’un bouton à côté du connecteur USB.
C’est le bouton de réinitialisation (RESET). Il réinitialise l’Arduino ou l’arrête complètement
lorsqu’il est maintenu appuyé un certain temps. Vous parvenez au même résultat en reliant par
un strap la broche
che du bas marquée Reset à la masse, une des deux broches GND plus à droite
dans la même rangée.

- Les LED : La carte Arduino Uno dispose de quatre diodes émettant

mettant de la lumière
lumi nommées
L, RX, TX et ON.
• ON est verte et signifie que votre carte est alimentée.
• RX et TX ne s’allument que lorsque des données sont reçues ou émises par la carte.
• L est une LED particulière. Elle est directement connectée à la broche 13 et permet de
procéder à des tests et des montages simples sans vous obliger à ajouter au circuit une
LED externe sur la broche numérique 13.

5. LA FAMILLE ARDUINO
Il en existe d’autres cartes Arduino qui sont conçues pourr répondre à différents besoins telles
que : Arduino Micro, Arduino Mini, Arduino Leonardo, Arduino Mega 2560, Arduino Nano,
Arduino Yun,…etc. Chaque carte possède ses avantages et ses inconvénients. Il existe même
des cartes clones 100% compatibles avec les cartes Arduino et qui sont tout à fait légales tant
qu’elles
elles ne comportent pas la mention Arduino.

6. L’ENVIRONNEMENT DE PROGRAMMATION ARDUINO IDE

L'Arduino IDE est l'environnement de développement intégré des différentes cartes Arduino.
Il permet de regrouper dans le même outil les programmes nécessaires au pilotage de la carte
Arduino. Il comprend un éditeur de texte, un débogueur/compilateur, une interface permettant
de gérer les ports COM et le type de carte.
carte. De plus, il fournit de nombreux exemples, installe
automatiquement les drivers les plus courants et assure ensuite la communication avec la carte
Arduino (téléversement et moniteur série). Le langage de programmation officiel est très
proche des langages
ages C et C++ auxquels s'ajoutent les fonctions des nombreuses bibliothèques
(libraries) Arduino.

3
Pour l’installation de l’Arduino
Arduino IDE, il suffit d’ouvrir la page de téléchargement d’Arduino
sur https://arduino.cc/en/Main/Software
://arduino.cc/en/Main/Software, et de cliquer sur le lien Windows pour télécharger le
fichier .zip qui contient une copie de l’application Arduino pour Windows (Fig.4). L’étape
suivante consiste à Brancher l’embout carré d’un câble USB dans laa carte Arduino Uno et
l’embout
mbout plat dans le port d’un PC afin de connecter l’Arduino à un ordinateur. Aussitôt que
la carte est connectée, la LED verte libellée ON indique que la carte Arduino Uno est
alimentée.

Fig.4 : Page de téléchargement de l’Arduino IDE

6.1 Description de l’interface graphique de l’Arduino IDE

La barre d’outils
Le rôle essentiel du logiciel Arduino IDE est de compiler puis de transférer un programme
vers la mémoire du microcontrôleur sur la carte Arduino Uno.. Le texte source de ce
programme est appelé un croquis (sketch).
La barre d’outils contient plusieurs boutons qui sont communément utilisés lorsque vous
écrivez des croquis pour Arduino (Fig.5).. Ces boutons, qui sont aussi accessibles dans la barre
de menus, permettent d’accomplir les actions suivantes :
• Vérifier : Un compilateur vérifie le code de votre croquis. Laa console affichera la taille
qu'occupera le croquis sur les mémoires du microcontrôleur. Dans le cas contraire, des
messages d'erreurs apparaîtront dans cette même zone.
• Téléverser : Envoie votre croquis à la carte Arduino Uno connectée
connect à l’ordinateur.
Votre croquis est compilé
compil avant d’être envoyé.
• Nouveau : Crée un nouveau croquis.
• Ouvrir : Ouvre un croquis existant.
• Enregistrer : Sauvegarde le croquis courant.
• Moniteur série : Vous permet de visualiser les les données qui sont envoyées ou reçues
par votre carte Arduino Uno.
Éditeur de texte
Cette zone affiche votre croquis sous la forme de texte.
Zone des messages (console)
Dans cette zone, Arduino IDE communique certaines informations utiles quant à la
compilation et au téléversement de votre croquis.

4
 Fig.5 : Les zones de l’interface graphique.

6.2 Premier exemple : LED clignotant

Le croquis que vous allez utiliser ici s’appelle Blink (clignoter une LED). Cliquez dans la
fenêtre Arduino. Dans la barre de menus, ouvrez le menu Fichier puis le sous-menu
Exemples, puis la catégorie 01.Basics pour sélectionner enfin Blink (Fig.6). Une nouvelle
fenêtre apparaît devant votre croquis vierge.

Fig.6 : Utilisation d’un exemple prédéfini.

Avant de pouvoir téléverser votre croquis, vous devez vérifier quelques petites choses. Tout
d’abord, vous devez confirmer le type de carte dont vous disposez. Vous pouvez faire votre
choix parmi toute une variété de cartes Arduino. La dernière génération de carte Arduino Uno
est la R3. Sélectionnez Outils- >Type de carte. Vous accéderez alors à une liste des différents

5
types de cartes gérés par l’Arduino IDE. Sélectionnez votre carte dans la liste, comme sur la
Figure 7.

Fig.7 : Choix du modèle de carte.

Afin de permettre à votre ordinateur et à la carte Arduino Uno de communiquer, vous devez
sélectionner le port série. Pour déterminer le port série, sélectionnez Outils->Port série. Une
liste des matériels connectés à votre ordinateur apparaît (Fig.8). Sous Windows, les ports
séries sont nommés COM1, COM2, COM3, et ainsi de suite. Le nombre le plus élevé
correspond généralement au dernier périphérique connecté. Une fois que vous avez trouvé le
port série, sélectionnez-le. Il devrait apparaître en bas de l’interface de l’Arduino, avec la
carte que vous avez sélectionnée.

Fig.8 : Liste des connexions séries disponibles dans l’environnement Arduino IDE.

Cliquez ensuite sur le bouton Vérifier. Cela permet de vérifier le code afin de s’assurer qu’il
fait sens. Cela ne signifie pas forcément que votre code fera ce que vous attendez, mais cela
garantit que sa syntaxe est telle qu’Arduino Uno saura la comprendre. Vous devriez visualiser

6
une barre de progression (Fig.9) et le texte compilation du croquis (Fig.10) durant quelques
secondes, puis le texte compilation terminée une fois le processus achevé.

Fig.9 : Vérification du croquis prédéfini Blink.

Fig.10 : Messages d’une compilation réussie du croquis Blink

Si le croquis est bien compilé, vous pouvez cliquer sur le bouton Téléverser à côté du bouton
Vérifier. Une barre de progression apparaît. Vous allez aussi pouvoir observer des activités
sur votre carte (clignotement des LED libellées RX et TX). Cela montre que la carte Arduino
Uno est en train de recevoir et d’émettre des données. Après quelques secondes, les LED RX
et TX cessent de clignoter, et le message Téléversement terminé apparaît en bas de la fenêtre
Arduino. Vous devriez maintenant voir la LED libellée L clignoter comme le demande le
croquis Blink (une seconde allumée et une seconde éteinte).

Si vous avez suivi les étapes précédentes, le croquis Blink devrait toujours être affiché. Si ce
n’est pas le cas, vous pouvez le recharger en sélectionnant Fichier->Exemples->01.Basics-
>Blink. Vous pouvez même éditer le croquis de clignotement d’une LED en cliquant sur
Fichier->Nouveau et en utilisant le code source ci-dessous.

//----------------------------------------------- Croquis N°1------------------------------------------------

7
/* Blink Active la LED durant une seconde,
puis l’éteint durant une seconde, et ainsi de suite.*/
// La routine setup est exécutée quand vous pressez le bouton reset
void setup() {
// La LED est connectée à la broche 13 sur la plupart des cartes Arduino.
// Faire de la broche numérique une sortie.
pinMode(LED_BUILTIN, OUTPUT); //LED_BUILTIN est une constante Arduino
//prédéfinie comme étant la broche 13 de carte Uno
}
// La routine loop se répète à l’infini
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // Allumer la LED (HIGH, tension haute)
delay(1000); // Attendre une seconde
digitalWrite(LED_BUILTIN, LOW); // Éteindre la LED (LOW, tension nulle)
delay(1000); // Attendre une seconde
}
//---------------------------------------------------------------------------------------------------------------
Le croquis Blink est composé de lignes de code. Nous pouvons identifier deux structures
principales :
- Une fonction setup() dont les instructions seront exécutées qu’une seule fois au
démarrage.
- Une fonction loop() dont les instructions seront exécutées indéfiniment, en boucle
jusqu'à l’extinction.

Les fonctions setup et loop n’ont pas d’arguments. Il existe par exemple une fonction qui
demande à l’Arduino Uno d’attendre un certain temps avant d’exécuter l’instruction suivante
(fonction delay). Dans ce cas, l’argument est indispensable, car il précise combien de temps la
pause doit durer.

7. SIMULER UNE CARTE ARDUINO UNO AVEC PROTEUS ISIS

Pour ajouter la librairie Arduino au logiciel de simulation Proteus ISIS, il suffit de suivre les
étapes suivantes :
1. Vous devez télécharger la librairie Arduino à partir du lien suivant :
https://www.instructables.com/id/How-to-add-Arduino-Library-in-to-Proteus-7-8/
2. Extraire les deux fichier qui existent dans le fichier .zip que vous avez télécharger. Ces
deux fichiers sont normalement arduino.idx et arduino.lib. Ces deux fichiers doivent
être placés sous le dossier Library qui a normalement le chemin suivant :
C:\Program Files (x86)\Labcenter Electronics\Proteus 7 Professional\LIBRARY
3. Fermez Proteus ISIS et relancez-le.
4. Dans l'interface, vous allez trouver à gauche sous le cadre deux boutons portant les
lettres P et L. Cliquez sur celui qui porte la lettre P (Pick from Libraries). Une
nouvelle fenêtre va s'ouvrir (Fig.11). Maintenant, vous devez taper le mot arduino
dans la zone de texte (keyword) et sélectionner la carte Arduino Uno. La carte sera
ajouter dans la partie "device" dans la partie gauche de l'interface de Proteus ISIS.

8
 Fig.11 : Choix du type de carte.
Après la phase compilation du croquis, sélectionnez dans le menu Croquis->Exporter les
binaires compilées afin de générer les deux fichiers hexadécimaux (hex avec et sans
Bootloader) (Fig.12). Ces fichiers seront accessibles en sélectionnant dans le menu Croquis-
>Afficher le dossier des croquis (Fig.13). Il suffit maintenant de cliquer sur le circuit de la
carte Arduino Uno pour obtenir une boite de dialogue et de lui fournir le chemin du fichier
.hex sans Bootloader (Fig.14 et Fig.15). La figure 16 représente le résultat de simulation du
croquis N°1 avec le logiciel Proteus ISIS (LED est reliée à la broche 13 de la carte Arduino
Uno à travers une résistance de 330Ω).

Fig.12: Exporter les fichiers hexadécimaux.

Fig.13: Chemin des fichiers hexadécimaux (avec et sans Bootloader).

9
Fig.14 : Fenêtre de sélection du fichier hex correspondant au croquis Blink

Fig.15 : Sélection du fichier hexadécimal sans Bootloader.

10
 Fig.16 : Exécution du croquis Blink sous Proteus ISIS.

8. LANGAGE DE PROGRAMMATION ARDUINO

Arduino IDE utilise le langage de programmation C, l’un des langages les plus utilisés de tous
les temps. C’est un langage extrêmement puissant et versatile. Un programme Arduino ou
bien un croquis peut être divisé en de trois parties principales: les structures, les variables et
constantes et les fonctions.
Cette section présente une référence minimale du langage Arduino avec des instructions
vraiment utiles pour débuter la programmation d’une carte Arduino Uno. La référence
étendue pour davantage de fonctions avancées du langage Arduino peut être consultée sur le
site web (https://www.arduino.cc/reference/en) ou bien en sélectionnant la rubrique Aide->
référence partir du menu (Fig.17).

Fig.17 : La référence des instructions du langage Arduino.

8.1. Les variables et les constantes

a- Les variables
Les variables sont des informations que l'Arduino stocke dans la mémoire vive SRAM. A la
création d'une variable, il faut indiquer son type, son nom et éventuellement sa valeur
(initialisation de la variable). Les différents types de variables sont reportés dans le tableau ci-
dessous.
b- Les constantes
La valeur d'une constante est définie une fois pour toutes et elle ne changera jamais au cours
de l'exécution du programme. De plus, la constante n'est pas stockée dans la SRAM.
L'Arduino IDE ne transmet pas la constante, mais seulement sa valeur à la carte Uno.
Certaines constantes sont prédéfinies telles que: true, false, LOW, HIGH, INPUT, OUTPUT,
et LED_BUILTIN dont la valeur est égale a 13 (LED interne de la carte Uno).

11
 Table 1 : Les différents types de variables

8.2. Entrées/Sorties numériques

- pinMode( ) : Configure la broche spécifiée pour qu'elle se comporte soit en entrée, soit en
sortie. Cette instruction permet aussi d’activer les résistances internes de rappel (internal
pullup resistors, 20KΩ) avec le mode INPUT_PULLUP. De plus, le mode INPUT désactive
l’utilisation des ces résistances de rappel.
Syntaxe
pinMode(pin, mode).
Paramètres
pin: Le numéro de la broche de la carte Arduino dont le mode de fonctionnement
(entrée ou sortie) doit être défini.
mode: INPUT, OUTPUT, ou INPUT_PULLUP.
Valeur retournée
Aucune.
- digitalWrite( ): Met un niveau logique HAUT (HIGH) ou BAS (LOW) sur une broche
numérique.
Syntaxe
digitalWrite(pin, value).
Paramètres
pin: Le numéro de la broche de la carte Arduino.
value: HIGH ou LOW
Valeur retournée
Aucune.
Remarque
Si la broche est configurée en entrée avec l'instruction pinMode(), écrire un niveau HAUT sur
cette broche a pour effet d'activer la résistance de rappel interne sur cette broche. A l'inverse,
mettre un niveau BAS sur cette broche en entrée désactivera le pullup interne.
Exemple
pinMode(pin, INPUT); //configure la broche en entrée
digitalWrite(pin, HIGH); //écrit la valeur HIGH sur la broche en entrée
// ce qui active la résistance de rappel "pullup" au plus
//de la broche
- digitalRead( ) : Lit l’état d'une broche précise en entrée numérique, et renvoie la valeur
HAUT ou BAS.
Syntaxe

12
 digitalRead(pin)
Parametres
pin: Le numéro de la broche numérique que vous voulez lire (Entier int).
Valeur retournée
HIGH or LOW
Exemple
Dans le programme suivant, la broche 9 reflète fidèlement l'état de la broche 2 qui est une
entrée numérique reliée à un bouton poussoir et une résistance pullup externe (Fig.18 et
Fig.19).
//------------------------------------------Croquis N°2------------------------------------------------------
const int BOUTON = 2; // un bouton poussoir connecté à la broche 2 avec une résistance de
//pullup externe de 10kΩ
const int LEDROUGE = 9; // LED connectée à la broche n°9
void setup()
{ pinMode(LEDROUGE, OUTPUT); // La LED rouge est une SORTIE
pinMode(BOUTON, INPUT); // Le bouton est une ENTREE
}
void loop()
{
digitalWrite(LEDROUGE, digitalRead(BOUTON)); // Etat du bouton
}
//------------------------------------------------------------------------------------------------------------------------------------

Fig.18 : Compilation réussie du croquis N°2

Fig. 19 : Simulation de l’exemple du bouton poussoir sous Proteus ISIS

8.3. Entrées/Sorties analogiques
a- Entrées analogiques

13
analogRead ( ) : Lit la valeur de la tension présente sur la broche spécifiée. La carte Arduino
comporte 6 voies connectées à un convertisseur analogique-numérique 10 bits. Cela signifie
qu'il est possible de transformer la tension d'entrée entre 0 et 5V en une valeur numérique
entière comprise entre 0 et 1023. Il en résulte une résolution de (5 volts / 1024) intervalles,
autrement dit une précision de 0.0049 volts (4.9 mV) par pas.
Une conversion analogique-numérique dure environ 100 µs pour convertir l'entrée
analogique, et donc la fréquence maximale de conversion est environ de 10 000 fois par
seconde.
Syntaxe
analogRead(broche_analogique) ;
Paramètres
broche_analogique : le numéro de la broche analogique sur laquelle il faut convertir la
tension analogique appliquée (0 à 5 sur la plupart des cartes Arduino).
Valeur renvoyée
Valeur entière (0 to 1023) correspondante au résultat de la mesure effectuée.

Exemple
Fixer la luminosité d'une LED proportionnellement à la valeur de la tension lue depuis un
potentiomètre (Fig.20 et Fig.21).
//----------------------------------------- Croquis N°3------------------------------------------------------
const int POTENTIOMETRE = A0; // Le potentiomètre
const int LEDROUGE = 9; // La LED rouge est reliée à la pin 9
void setup() {
pinMode(POTENTIOMETRE, INPUT);
pinMode(LEDROUGE, OUTPUT); // La LED rouge est une sortie
}
void loop() {
// Conversion de la valeur de l'entrée (de 0 à 1023) en une valeur de sortie (de 0 à 255)
int lum = analogRead(A0)/4; // Ou lum = analogRead(A2)*256/1024;
// division par 4 pour adaptation
analogWrite(LEDROUGE, lum);
delay(50);
}//--------------------------------------------------------------------------------------------------------------

Fig.20 : Compilation réussie du croquis N°3.

14
 Fig. 21 : Simulation du croquis N°3 sous Proteus ISIS

Remarques
La tension de référence par défaut est de 5V. Il est possible d'utiliser une autre valeur si
besoin.
Les broches analogiques sont utilisées en entrée. Il n'est pas nécessaire de les configurer au
préalable à l'appel de la fonction analogRead( ).

b- Sorties analogiques
analogWrite( ) : Génère une impulsion de largeur / période voulue sur une broche de la carte
Arduino (MLI- Modulation de Largeur d'Impulsion). Ceci peut-être utilisé pour faire briller
une LED avec une luminosité variable ou contrôler un moteur à des vitesses variables.
Après avoir appelé l'instruction analogWrite( ), la broche générera une onde carrée stable
avec un rapport cyclique "duty cycle" de longueur spécifiée (en %), jusqu'à l'appel suivant
de l'instruction analogWrite() (ou bien encore l'appel d'une instruction digitalRead() ou
digitalWrite() sur la même broche). La fréquence de l'onde PWM est approximativement de
490 Hz. Cette fonction fonctionne sur les broches 3,5, 6, 9, 10 et 11 (le symbole ~ apparaît à
côté ces broches PWM).
Syntaxe
analogWrite(broche, valeur);
Paramètres
Broche : La broche utilisée pour générer le signal PWM. Cette broche devra être
une broche ayant la fonction PWM.
Valeur: La largeur du rapport cyclique entre 0 (0% niveau BAS) et 255 (100%
niveau HAUT).
Valeur renvoyée
Aucune.

Remarque
Il n'est pas nécessaire de faire appel à l'instruction pinMode() pour mettre la broche
en sortie avant d'appeler la fonction analogWrite().

c- Référence analogique
analogReference( ) : Configure la tension de référence utilisée avec les entrées analogiques.
La fonction analogRead( ) renverra la valeur 1023 pour une entrée analogique égale à la
tension de référence. Les options sont :
DEFAULT: La valeur par défaut de la tension de référence analogique est de 5V (3.3V sur
certaines cartes Arduino).

15
INTERNAL: Une tension de référence interne, égale à 1.1V sur ATmega328P
EXTERNAL: La tension de référence appliquée sur la broche AREF utilisée en tant que
référence en tension.
Syntaxe
analogReference(type)
Paramètres
Type: le type de référence utilisée soit DEFAULT, INTERNAL, ou EXTERNAL.
Valeur retournée
Aucune.

8.4. Temps
Delay(ms) : Réalise une pause dans l'exécution du programme pour la durée (en
millisecondes) indiquée en paramètre.
Syntaxe
delay (ms);
Parametres
ms (unsigned long) : le nombre de millisecondes que dure la pause.
Valeur renvoyée
Aucune.

8.5. Le moniteur série

Le moniteur série est le moyen que possède l’Arduino IDE pour transmettre des informations
a l’ordinateur lorsqu’ils sont reliés. Pour pouvoir l’utiliser, il faut l’indiquer dans la fonction
setup de votre croquis.

Exemple
Le capteur de température LM35 est facile à utiliser et ne coute pas très cher. De plus, il est
calibré en degré et offre une bonne précision. Le capteur est soumis à une tension de 5V, mais
la tension à la borne centrale varie suivant la température (Fig.22). Apres l’exécution du
croquis N°4, lancez l’interface de communication série pour visualiser la température et la
valeur de la tension à la borne centrale du capteur (Fig.23).
//--------------------------------------------- Croquis N°4--------------------------------------------------
const int CAPTEURTEMPERATURE = A0;
void setup() {
pinMode(CAPTEURTEMPERATURE, INPUT);
Serial.begin(9600);
}
void loop() {
float tension = analogRead(CAPTEURTEMPERATURE) * 5;
tension = tension/1024;
Serial.print(tension);
Serial.println(" Volts");
float temperature = (tension) * 100 ;
Serial.print(temperature);
Serial.println(" Degres");
delay(500);
}
//---------------------------------------------------------------------------------------------------------------

16
Remarque
Il possible de choisir une autre vitesse que 9600 bauds, mais il faudra aussi la modifier dans
l’Arduino IDE. Utilisez ensuite l’instruction Serial.print pour l’affichage du contenu de la
variable locale temperature. Téléversez le programme et ouvrez le moniteur série, pour cela
allez dans Outils – Moniteur série.

Fig. 22: Branchement du capteur de température LM35.

Fig.23: Affichage de la température dans le moniteur série.

8.6. Les fonctions sans arguments

Une fonction est un sous-programme capable d'exécuter à la demande une suite d'instruction
définie à l'avance. Les fonctions peuvent être déclarées n’importe où dans le programme, à
condition que ce ne soit pas à l'intérieur d'une autre fonction. Afin de faciliter la lecture d'un
croquis, il est d’usage de les regrouper à la fin ou au début du programme.

17
Exemple

//-------------------------------------------- Croquis N°5-------------------------------------------------

const int LEDROUGE = 9 ; // La LED rouge est reliée à la pin 9
void setup() {
pinMode(LEDROUGE, OUTPUT); // La LED rouge est une sortie
}
void loop() {
allumer( ) ; // Appel de la fonction qui allume la LED
delay(1000) ; // Attends 1000 millisecondes (1 seconde)
eteindre() ; // Appel de la fonction qui éteint la LED
delay(1000) ; // Attends 1000 millisecondes (1 seconde)
}
// Mes fonctions
void allumer() {
digitalWrite(LEDROUGE, HIGH); // Alimente la LED rouge
}
void eteindre() {
digitalWrite(LEDROUGE, LOW); // Coupe le courant de la LED rouge
}
//-------------------------------------------------------------------------------------------------------------

Fig.24 : Compilation réussie du croquis N°5.

9. LES BIBLIOTHEQUES (LIBRARIES)

Ce sont des fichiers qui rajoutent des fonctions au langage de programmation de l'Arduino
IDE. Certaines sont préinstallées dans l'Arduino IDE, mais il est aussi possible d'en installer
de nouvelles. Pour cella, allez dans Croquis->Inclure une bibliothèque->Gérer les
bibliothèques (Fig.25). Une deuxième méthode consiste à télécharger le fichier zip de la
bibliothèque que vous voulez utiliser et de l’inclure en sélectionnant dans le menu Croquis-
>Inclure une bibliothèque->Ajouter les bibliothèques .ZIP…

18
 Fig.25 : Ajouter une bibliothèque.

Pour utiliser les nouvelles fonctions, il faut indiquer au début d’un programme que l’on a
besoin de la bibliothèque.
Exemple
#include <MaBibliotheque.h >

10. IMPLEMENTATION DU PROGRAMME BLINK SOUS mBlock

mBlock est une version personnalisée de Scratch développée par Makeblock. Ceux qui sont
familiers avec Scratch peuvent facilement interagir avec des modules électroniques
dans l'environnement Arduino. mBlock possède une interface qui permet de reproduire
facilement du code Arduino en manipulant des blocs (Fig.26).

Fig.26 : Interface graphique du logiciel mBlock.

19
Pour débuter la programmation graphique, il faut sélectionner dans le menu Edit-> Arduino
mode afin d’ouvrir le panneau supplémentaire (Fig.27).

Fig.27 : Mode Arduino avec le panneau supplémentaire de programmation.

Après avoir branché votre carte Arduino Uno sur le port USB de votre ordinateur, il vous
suffit dans mBlock de sélectionner :
-Le type de votre carte (Fig. 28).
-Le port de communication COM de votre carte.

Fig.28 : Choix du type de carte et du port de communication.

20
Pour la programmation, il suffit d’utiliser les blocks suivants :
- Data & Blocs : pour définir des variables, paramètre et procédures.
- Control : les structures usuelles de contrôle du code.
- Operators : arithmétiques et autres.
- Robots : gère les interactions avec l’Arduino.

Fig.29 : les blocks de programmation "Robots" et "Control".

En mode Arduino, la programmation visuelle consiste à sélectionner les instructions dans le
cadre de gauche et de les combiner par glisser-déposer sur la page centrale (Fig.30). Le code
généré pour l’Arduino Uno s’affiche dans le cadre de droite. Il n’est plus nécessaire de définir
ni d’initialiser les broches. Il ne faut pas oublier de positionner le bloc "Arduino Program" en
tête de votre programme. Le programme de la figure 30 permet d’allumer une LED
alternativement toutes les 1 seconde. La LED interne est connectée sur la broche 13 de la
carte Arduino Uno.

Fig.30 : Programmation par blocs de l’exemple Blink

21
Le code Arduino est généré automatiquement. Vous pouvez maintenant téléverser le code
dans la carte Arduino Uno en cliquant sur le bouton "Upload to Arduino".
Pour modifier le programme avant de le téléverser, il vous suffit de cliquer sur le bouton "Edit
with Arduino IDE". A la fin un message vous indique que votre téléversement est
terminé rendant ainsi votre montage autonome (Fig.31).

Fig.31 : Chargement réussie du programme Blink

11. IMPLEMENTATION DU PROGRAMME BLINK SOUS VISUAL DESIGNER

Proteus Visual Designer combine un simple éditeur d'organigramme avec un outil de

simulation de circuits électroniques pour fournir un environnement de développement intuitif
pour Arduino et Raspberry Pi. L’outil Visual Designer est basé sur la programmation
graphique par blocs permettant de développer des organigrammes qui piloteront le matériel

22
(Arduino ou Raspberry Pi). Pour l’implémentation du programme ‘blink’ sous Visual
Designer, il suffit de suivre les étapes suivantes :
-Lancez Proteus Professional 8.7 et Cliquez sur la rubrique ‘New Flowchart’ (Fig.32).

Fig.32 : Création d’un nouvel organigramme

-Associez au nouveau projet un nom et un chemin d’enregistrement.

Fig.33 : Enregistrement d’un nouveau projet.

- Sélectionnez
onnez le type de carte Arduino utilisée.

Fig.3 : Sélection du type de carte utilisée.

Fig.34
-L’avant dernière étape consiste
siste à cliquer sur le bouton ‘finish’
‘finish’ pour activer l’environnement
l
de développement de l’organigramme ‘blink’ permettant le pilotage de la carte Arduino Uno
(Fig.35). L’organigramme
’organigramme suivant est associé au programme ‘blink’ qui fait clignoter la
LED (Built-in
in LED) connectée a la broche 13 de la carte Arduino Uno.

Fig.35 : Organigramme associé au programme ‘blink’

23
La programmation de l’organigramme précédent se fait par le biais des blocs en les glissant
et déplaçant sur l’environnement de travail tel qu’il est indiqué sur la figure suivante.
Chaque bloc peut être configuré en fonction des paramètres exigés par l’application. La
figure 36 représente un exemple de configuration du bloc Entrée/Sortie avec les paramètres
de gestion de la broche 13 de la carte Arduino Uno.

Fig.36 : Implémentation de l’instruction ‘digitalWrite’ sous Visual Designer

Dans la dernière étape, la carte Arduino Uno doit être connectée à votre PC pour pouvoir
configurer les options de votre projet (configuration : microcontrôleur, Horloge, le
programme chargeur ‘loader’, le port de communication et la vitesse de transfert, etc..).
Ensuite, il suffit de cliquer sur la rubrique ‘Build -> Upload’ afin de televerser le
programme ‘blink’ (fichier de forme hexadécimale) dans la carte Arduino Uno.

Fig.37 : Configuration matérielle et chargement du fichier binaire.

24
12. IMPLEMENTATION DU PROGRAMME BLINK SOUS MATLAB

Il existe trois possibilités d’interfacer la carte Arduino avec Matlab/Simulink, à savoir :

-Programmation de la carte Arduino Uno comme une carte d’interface.
-Utilisation du package ArduinoIO ‘MATLAB Support Package for Arduino Hardware’.
-Utilisation du package Arduino Target ‘Simulink Support Package for Arduino Hardware’.
En cliquant sur ‘Add-Ons -> Get Hardware Support Packages’, une fenêtre s’activera et
vous guidera tout au long de l’installation des packages Matlab/Simulink.

Fig.38 : Installation des supports de la carte Arduino Uno

Le package ArduinoIO consiste à utiliser la carte arduino comme une interface

d’entrée/sorties. Ce package permet a Matlab de communiquer avec la carte Arduino Uno via
le port USB. Par conséquent, un programme sera chargé dans la carte Arduino afin que celle-
ci fonctionne en serveur. Ce programme consiste à "écouter" les requêtes envoyées via la
liaison série (USB) et de répondre à ces requêtes en renvoyant l’état d’une entrée ou en
modifiant l’état d’une sortie. La figure ci-dessous représente un exemple d’établissement de
communication entre la carte Arduino Uno et Matlab (instruction arduino(‘com3’,’uno’)). De
plus le jeu d’instructions suivant permet de faire clignoter la LED de la même carte pendant
10 secondes. Donc, le package ArduinoIO offre une panoplie de commandes permettant
d’écrire un programme sous Matlab.

Fig.39 : Exemple d’exécution du programme ‘blink’ sous Matlab

25
‘Simulink Support Package for Arduino Hardware’ permet de créer des applications Simulink
qui vont fonctionner de façon autonome sur la carte Arduino Uno. Cette dernière peut
fonctionner d’une façon autonome (sans avoir recours à Matlab/Simulink) et devient ainsi une
cible (Target). Maintenant pour exécuter le programme ‘blink’, nous devons : relier la carte
Arduino Uno a un PC, lancer Simulink et configurer les paramètres matériels.

Fig.40 : Configuration des paramètres matériels.

Dans la suite, Nous utiliserons les blocs Simulink offert par le package et la librairie Sources
pour faire clignoter la LED (Built-in LED) de la carte Arduino Uno.

Fig.41 : Programmation par blocs de l’exemple ‘blink’ sous simulink.

Pour lancer l’execution du programme ‘blink’, il suffit de cliquer sur le bouton ‘Deploy to
Hardware’.

26
 Fig.42 : Exécution du programme ‘Blink’.

13. CONCLUSION
Arduino est plus qu’un kit d’initiation ; c’est un outil. Sa simplicité d’utilisation, l’étendue de
ses applications et son prix modique ont conquis un large public d’amateurs et de
professionnels. Avec son petit microcontrôleur hautement performant, une carte Arduino se
couple aisément avec d’autres composants (capteurs, LCD, moteurs….).

L'environnement de programmation officiel des cartes Arduino offre une interface simple et
pratique. Cet environnement de programmation a cependant le gros inconvénient de nécessiter
une programmation en langage C. La programmation avec des blocs fonctionnels peut être
comparée à l’utilisation de Scratch alors que le pseudo-code offre la possibilité d’écrire un
programme en langage presque naturel et de s’affranchir de la complexité de C.

14. BIBLIOGRAPHIE

-Erik Bartmann, "Le Grand Livre d'arduino", 2ème Edition, Eyrolles, 2015.
-Jean-Christophe Quetin, "Arduino: Apprivoisez l'Electronique et le Codage", Editions ENI,
2018.
-Olivier Engler, "Programmer avec Arduino en s’Amusant pour les Nuls", Wiley Publishing,
2017.
-John Nussey, "Arduino pour les Nuls", Wiley Publishing, 2017.
-Agus Kurniawan, "Arduino Programming using MATLAB", PE Press, 2015.
- Labcenter Electronics, "PROTEUS DESIGN SUITE - Visual Designer Help",
https://labcenter.s3.amazonaws.com/downloads/visualDesigner.pdf
-Arduino Programming, https://www.mblock.cc

27