Université Mohammed V – Rabat EST – Salé

Université Mohammed V - Rabat Ecole Supérieure de Technologie - Salé Professeur : E. Chater

Filières : IMB - MES Informatique Industrielle Année Universitaire : 2023 - 2024

Complément # 2 : Utilisation et programmation des cartes Arduino

1) Présentation des cartes ARDUINO

2) Principaux avantages du système ARDUINO
3) Carte ARDUINO UNO
4) Programmation de la carte ARDUINO

1. Présentation des cartes ARDUINO

o ARDUINO est une plateforme matérielle et logicielle de développement d'applications embarquées.
o Côté matériel, elle se compose d'une carte électronique basée autour d’un microcontrôleur (ATMEL AVR)
comportant un certain nombre d’entrées et de sorties (les ports) permettant la connexion de capteurs, ou
d’actionneurs.
o Le logiciel de programmation des cartes ARDUINO est une application Java, libre et multi- plateformes, servant
d’éditeur de code et de compilateur, et qui peut transférer le programme au travers de la liaison USB.
o Le langage de programmation utilisé est une combinaison de C et de C++, adaptée aux possibilités de la carte.

Cable USB (A Mini-B) pour Arduino Cable USB (A – B) pour Arduino

NANO UNO/MEGA

2. Principaux avantages du système ARDUINO

o Matériel peu onéreux : Comparées aux autres plateformes de développement, les cartes ARDUINO sont peu
coûteuses.
o Matériel : Les schémas des modules sont publiés sous une licence Creative Commons, et il est possible de réaliser
ses propres versions de cartes ARDUINO, en les complétant ou en les améliorant.
o Logiciel gratuit : Le logiciel ARDUINO et le langage ARDUINO sont disponibles pour être complétés par des
programmeurs expérimentés. Le langage peut être aussi étendu à l'aide de librairies C++.
o Logiciel multi-plateforme : Le logiciel ARDUINO, écrit en Java, tourne sous les systèmes d'exploitation
Windows, Mac OS et Linux.
o Modules « Shield » : Cartes supplémentaires se connectant sur la carte ARDUINO pour augmenter ses possibilités
: afficheur graphique couleur, interface Ethernet, GPS, …
3. Carte ARDUINO UNO
Le modèle UNO des cartes ARDUINO est une carte électronique dont le cœur est un microcontrôleur ATMEL de
référence ATMega328 qui est un microcontrôleur 8bits de la famille AVR dont la programmation peut être effectuée
en langage C.

Professeur : E. Chater 1/8

 Université Mohammed V – Rabat EST – Salé

3.1. Description d’une carte ARDUINO UNO

3.2. Caractéristiques principales

3.3. Alimentation
La carte ARDUINO UNO peut être alimentée :
o par le câble USB,
o par un bloc secteur externe connecté grâce à une prise « jack » de 2,1mm ou bien
o par un bloc de piles dont le raccordement est réalisé par des « GND » et « Vin » du connecteur d’alimentation.
Dans le cas d’une alimentation extérieure, la tension doit être comprise entre 7 à 12V.
La carte génère, par l’intermédiaire de régulateurs intégrés, deux tensions stabilisées (5 V et 3,3 V) qui peuvent
alimenter d’autres composants électroniques. Ces deux tensions permettent également d’alimenter des modules
Shields.
3.4. Entrées-sorties d’une carte Arduino
La carte « ARDUINO UNO » dispose de 14 E/S numériques et de 6 entrées analogiques.

Professeur : E. Chater 2/8

 Université Mohammed V – Rabat EST – Salé

3.4.1. Entrées-sorties numériques

Chacune des 14 E/S numériques (repérées 0 à 13) peut être utilisée en entrée (INPUT) ou en sortie (OUTPUT) sous
le contrôle du programme utilisateur.
Leur sens de fonctionnement peut même être changé au cours de l’exécution du programme.
Ces E/S numériques fonctionnent en logique TTL (0V-5V). Chacune peut fournir ou recevoir un courant maximal de 40
mA et dispose si besoin est d’une résistance interne de ‘pull-up’.
Certaines broches peuvent avoir plusieurs fonctions différentes choisies par programmation :

3.4.2. Entrées analogiques

Les six entrées analogiques, repérées A0 à A5 (PC0 à PC5), peuvent admettre une tension analogique comprise
entre 0 et 5V (par défaut mais cela peut être modifié). Ces entrées analogiques sont gérées par un CAN à 10 bits,
dont la sortie peut varier de 0 à 1023.
Les entrées A4 et A5 peuvent également être utilisées respectivement comme la ligne de donnée SDA et la ligne
d’horloge SCL de l’interface série I2C.
3.5. Mémoires
Le microcontrôleur ATmega 328 dispose de 32ko de mémoire Flash permettant de stocker le programme à exécuter.
Il contient aussi 2ko de mémoire vive (SRAM). Cette mémoire est généralement utilisée pour stocker les résultats
temporaires lors des calculs. Elle peut être lue et écrite par le microcontrôleur mais son contenu est volatile.
L’ATmega 328 dispose également de 1ko mémoire EEPROM pour permettre au programme de stocker des données
persistantes. Le contenu de cette mémoire est accessible grâce aux fonctions de la librairie « EEPROM ».
3.6. L’horloge
L’horloge est pilotée par un quartz qui fonctionne à la fréquence de 16 MHz.
3.7. Communication
ARDUINO UNO a de nombreuses possibilités de communication avec l’extérieur. En effet, le microcontrôleur
Atmega328 possède une interface de communication série accessible, grâce aux E/S numériques 0 (Rx) et 1 (Tx).
D’autre part, Arduino prend en charge le bus I2C accessible, grâce aux broches analogiques 4 (SDA) et 5 (SCL) et
la liaison série synchrone SPI grâce aux broches numériques 10 (SS), 11 (MOSI), 12(MISO) et 13 (SCX).
3.8. Reset
A la mise sous tension, un reset automatique permet au programme contenu en mémoire du microcontrôleur de
démarrer automatiquement dès que la carte ARDUINO est alimentée. En plus, la carte Arduino UNO est également
équipée d'un bouton poussoir de reset manuel. Un appui sur celui-ci permet de relancer l'exécution d'un programme
si nécessaire (suite à un plantage, ou bien parce que l’utilisateur souhaite le faire réinitialiser).

Professeur : E. Chater 3/8

 Université Mohammed V – Rabat EST – Salé

3.9. Protection d’une surintensité sur le port USB

Par mesure de sécurité pour l'ordinateur auquel la carte ARDUINO est reliée, un fusible est présent sur la connexion
d'alimentation 5V de la prise USB. Ainsi, toute consommation supérieure à 500mA, provoque le déclenchement de
ce fusible, ce qui permet de protéger le port USB de l'ordinateur utilisé pour l’alimentation de la carte.
4. Programmation de la carte ARDUINO
Le logiciel ARDUINO permet de :
a) écrire et compiler des programmes pour la carte ARDUINO,
b) se connecter avec la carte ARDUINO pour y transférer les programmes,
c) communiquer avec la carte ARDUINO.
4.1. Interface de programmation
L’interface de programmation du logiciel ARDUINO est la suivante :
Barre de Menu
Barre des boutons
Onglet des fichiers ouverts

Fenêtre d’édition du programme

Messages des actions en cours

Messages de compilation

La Barre de Boutons donne un accès direct aux fonctions courantes du logiciel :

Fonction des boutons
Vérifier puis compiler Sauvegarder un fichier édité
Transférer le Programme vers la carte Arduino Ouvrir un fichier
Créer nouveau fichier Ouvrir le moniteur série

4.2. Structure d’un programme

Un programme destiné à une carte ARDUINO est constitué de 3 parties principales
Barre de titre
Zone de commentaire (optionnel)
Cette zone permet de définir les constantes et les variables en
déclarant leur type. Elle permet aussi d’inclure des
bibliothèques en utilisant #include.
Fonction setup() : contient les instructions d’initialisation ou
de configuration des ressources de la carte. Cette fonction
n’est exécutée qu’une seule fois juste après le lancement du
programme.
Fonction loop() : contient les instructions du programme à
exécuter. Cette fonction est répétée indéfiniment tant que la
carte ARDUINO restera sous tension.
4.3. Programme de test : Faire clignoter la led du pin 13
a) Charger le programme de test en utilisant le menu : File > Examples > 01. Basics > Blink
b) Sauvegarder le programme sous un nouveau nom : File > Save as
c) Editer le programme de test en ajoutant la variable LED : int LED = 13 ;
d) Ajouter des commentaires appropriés. Par exemple : // LED désigne la sortie numérique N°13.
e) Le vérifier/compiler, puis le charger dans la carte (si disponible)

Professeur : E. Chater 4/8

 Université Mohammed V – Rabat EST – Salé

4.4. Syntaxe du langage ARDUINO

Le manuel de référence sur la syntaxe de programmation d’ARDUINO est accessible en utilisant le menu :
Help > Reference. Ce manuel est aussi accessible à l’adresse : http://www.arduino.cc/en/Reference/HomePage

// teste de commentaire
/* teste de commentaire
*/
Commentaires
Pour placer des commentaires sur une ligne unique ou en fin de ligne
Pour placer des commentaires sur plusieurs lignes
Types de données et variables

Types de données
Pour les constantes et les
variables

Définition de constantes
#define N = 2 // Toute variable N rencontrée dans le programme sera remplacée par la valeur 2
const byte N=2 // N est une constante de type « byte » et de valeur 2

Noms de constantes
prédéfinis dans le
langage ARDUINO

Opérateurs

Opérateurs
arithmétiques

Opérateurs logiques

Affectations

Opérateurs de
comparaisons

Professeur : E. Chater 5/8

 Université Mohammed V – Rabat EST – Salé

4.4.1. Bibliothèques de fonctions

Une bibliothèque est un ensemble de fonctions utilitaires mises à disposition des utilisateurs de l'environnement
Arduino. Les fonctions sont regroupées en fonction de leur appartenance à un même domaine conceptuel
(mathématique, graphique, tris, etc).

Pour importer une bibliothèque à l’IDE Arduino, utiliser le menu : Sketch > Include Library > Ass .ZIP Library
Instruction d’ajout d’une bibliothèque au début d’un programme : #include <bibliothèque.h>
#include <SPI.h> // Importer la bibliothèque SPI dans le programme actuel
Certaines fonctions sont présentes (par défaut) dans l’IDE ARDUINO

Fonctions de gestion du temps

delay(tempo) ; // tempo doit être de type unsigned long pour autoriser de très longues temporisations.
delay(1000) ; // Cette fonction génère une pause de 1000 ms = 1s
delayMicroseconds(tempo) ; // tempo doit être de type unsigned int et supérieures à 3
delayMicroseconds(100) ; // Cette fonction génère une pause égale à 100 × 1 μs
Valeur = millis() ; // Valeur prend le nombre de millisecondes depuis le démarrage du programme
La valeur retournée est de type unsigned long.
Valeur = micros() ; // Cette fonction retourne le nombre de microsecondes depuis le démarrage du programme
La valeur retournée est de type unsigned long. Cette fonction a une résolution de de 4μs (horloge de 16MHz).

Fonctions de gestion des E/S numériques

pinMode (Npin, Sens) ; // Configurer le sens de fonctionnement, entrée ou sortie, de la broche Npin.
pinMode (12,OUTPUT) ; // La broche 12 est configurée en sortie
digitalWrite(NpinOut, Niveau logique) ; // Forcer le niveau (HIGH ou LOW) sur la sortie numérique NpinOut.
digitalWrite(12,HIGH) ; // La sortie 12 est placée au niveau logique haut (1)
Valeur = digitalRead(Npin) ; // Valeur prend la valeur du niveau logique sur l’entrée numérique Npin.
// Cette fonction ne retourne que deux valeur HIGH ou LOW.
etat = digitalRead(11) ; // La variable etat prend la valeur du niveau logique de l’entrée 11

Fonctions de gestion des sorties PWM

Certaines E/S numériques (configurées en sorties) sont capables de générer des signaux à Modulation à Largeur
d’Impulsions (MLI) ou Pulse Width Modulation (PWM).
Il s’agit de signaux logiques rectangulaires de fréquence égale à 490 Hz et à rapport cyclique alfa programmable.
analogWrite(NpinOut, alfa) ; // Générer, sur la sortie NpinOut, un signal PWM avec le rapport cyclique alfa.
// La variable (alfa = rapport cyclique) doit être de type int, entre 0 et 255 pour un rapport cyclique entre 0 et 100 %.
analogWrite(2,64) ; // Signal PWM de rapport cyclique de 25 % sur la sortie analogique 2
Le signal PWM est généré à partir de l’instant de l’exécution de la fonction analogWrite et jusqu’à ce qu’une nouvelle
instruction analogWrite ou une instruction « digitalRead » ou « digitalWrite » soit exécutée sur la même broche.
La valeur de la variable (alfa = rapport cyclique) n’est garantie que pour des valeurs supérieures à 10 %.

Fonctions de gestion des entrées analogiques

Les entrées analogiques sont connectées à un CAN à 10 bits. La sortie (numérique) du CAN génère une donnée
égale à 0 lorsque la tension d’entrée est nulle et une donnée égale à 1023 lorsque la tension d’entrée est égale à la
tension de référence du CAN.
analogReference(Type) ; // Cette fonction permet de définir la tension de référence du CAN.
La variable type peut prendre les valeurs suivantes :
o DEFAUT : La tension de référence est égale à la tension d’alimentation de la carte Arduino (5V pour Arduino Uno) ;
o INTERNAL : La tension de référence est égale à 1,1 V pour Arduino Uno ;
o EXTERNAL : La tension de référence est égale à la tension appliquée sur l’entrée externe AREF de la carte Arduino.
La tension appliquée sur une entrée analogique ne doit jamais être supérieure à la tension d’alimentation de la carte.
Valeur = analogRead(NpinIn) ;
// la variable Valeur (de type int) contient le résultat de la CAN de la tension présente sur l’entrée analogique NpinIn.
// tension = analogRead(1) ; // tension est égale au résultat de la CAN de l’entrée analogique 1
// tension est comprise entre 0 et 1023, et la durée de la conversion est d’environ 100 μs.

Professeur : E. Chater 6/8

 Université Mohammed V – Rabat EST – Salé

Fonctions particulières de gestion des entrées-sorties

tone(NpinOut, fréquence, durée) ;
// Générer, sur la sortie NpinOut, un signal carré de fréquence programmable et pendant un temps = durée.
// fréquence doit être exprimée en Hz et la donnée Durée doit être fixée en ms.
// Si durée n’est pas précisée, le signal est généré jusqu’à ce que la fonction notone soit exécutée.
notone(NpinOut) ; // Stopper la génération du signal carré sur la sortie NpinOut
durée = pulseIn(NpinIn, Type, DelaiMax) ;
// Mesurer la durée d’une impulsion sur l’entrée NpinIn. Le résultat retourné est du type unsigned long.
La valeur de la donnée Type peut être HIGH pour une impulsion (NL1) ou LOW pour une impulsion (NL0).
La variable DelaiMax permet de définir le délai d’attente de l’impulsion. Lorsque ce délai est dépassé et qu’aucune
impulsion ne s’est produite, la fonction retourne une valeur nulle. Cette donnée est du type unsigned long et est
exprimé en μs. Si ce paramètre n’est pas précisé, la valeur par défaut sera de 1 s.
Le résultat fourni n’est considéré comme correct que pour des impulsions de durée comprise entre 10 μs et 3 min.

Fonctions de manipulation d’octets et de bits

octetBas = lowByte(Data1) ; // Extraire les 8 bits de poids faible (LSB) de la variable Data1
// La valeur retournée (octetBas) est de type byte alors que la variable Data1 peut être de n’importe quel type
octetHaut = highByte(Data2) ; // Extraire le deuxième octet en partant de la droite de la variable Data2
La valeur retournée (octetHaut) est de type byte alors que la variable Data2 peut être de n’importe quel type
bitX = bitRead(Data3, n) ; // Lire le nième bit de la variable Data3
bitWrite(Data4, n, Niveau) ; // Imposer le niveau logique (HIGH ou LOW) sur le nième bit de la variable Data4
bitSet(Data5, n) ; // Imposer le niveau logique HIGH sur le nième bit de la variable Data5
bitClear(Data6, n) ; // Imposer le niveau logique LOW sur le nième bit de la variable Data6

Les fonctions de gestion du port série asynchrone

ARDUINO UNO dispose d’un port série asynchrone accessible via les E/S numériques 0 (Rx) et 1 (Tx)
Le port série asynchrone des microcontrôleurs qui équipent les cartes ARDUINO disposent d’une mémoire tampon
capable de mémoriser jusqu’à 128 caractères reçus.
Serial.begin(Vitesse) ; // définir la vitesse à utiliser pour la liaison série RS232 en utilisant une valeur normalisée
// Cette fonction est appelée dans la fonction setup()
Serial.end() ; // Désactiver la liaison série asynchrone, et libérer les broches numériques 0(Rx) et 1(Tx)
Serial.available(nombre) ; // détermine le nombre de caractères reçus dans la mémoire tampon de réception
// La variable nombre est de type int, correspond alors au nombre de caractère en attente de lecture par le programme
Serial.read(caractère) ; // lire le premier caractère disponible dans la mémoire tampon de réception
// La variable caractère est de type int. La valeur retournée est -1 si la mémoire tampon est vide.
Serial.flush() ; // Vider la mémoire tampon de réception
Serial.write(DataSer) ; // Emettre les bits de (DataSer) sur la liaison série sous la forme binaire brute
// Si (DataSer) est une chaîne de caractères, les caractères sont transmis (l’un après l’autre) sous le format ASCII
Serial.print(DataSer, format) ; // Emettre les données (DataSer) sur la liaison série en précisant le codage utilisé.
Serial.print(100101, BIN) ; // Transmission de la donnée (100101)2
Serial.print(4B, HEX) ; // Transmission de la donnée (4B)16
Serial.print(K, BYTE) ; // Transmission de la donnée (K)ASCII
Serial.print(1.23456, 0) ; // Transmission de la donnée 1
Serial.print(1.23456, 5) ; // Transmission de la donnée 1.23456
/*Sinon le paramètre Format permet de préciser le codage ou la base de numération pour les données numériques.
Elle peut prendre une des valeurs suivantes : BIN (binaire), OCT (Octal), HEX (hexadécimal), DEC (Décimal) ou
BYTE (codage ASCII). Pour les données à virgule flottante, le paramètre Format peut prendre une valeur
numérique (entre 0 et 7) qui correspond au nombre de décimales à transmettre. Si le paramètre Format n’est pas
défini, une donnée numérique sera considérée comme décimale, une chaîne de caractères sera transmise tel quelle
et une donnée à virgule flottante sera transmise avec deux décimales
*/

Professeur : E. Chater 7/8

 Université Mohammed V – Rabat EST – Salé

4.5. Etapes de développement d’un programme

Éditer le programme à partir du logiciel ARDUINO (utiliser la syntaxe appropriée avec commentaire)
Créer fichier Déclarer les constantes et variables avec leur type fonction void setup() Fonction void loop()

Vérifier et compiler le code à l’aide du bouton (vérifier)

Si pas d’erreurs, on verra le message : “Compilation terminée”, suivi de la taille du programme.
2

Connecter la carte ARDUINO à

l’ordinateur en utilisant le câble
3 USB (appropriée).
La LED verte d'alimentation
(PWR) devrait s'allumer.

4 Sélectionner la carte ARDUINO utilisée à partir du menu : Tools > Board: (Outils → Type de carte)
5 Sélectionner le bon port série à partir du menu : Tools > Port (Outils → Port série)
Charger le programme dans la carte ARDUINO en cliquant sur le bouton Upload (Téléverser).
6
A la fin du téléversement, le logiciel ARDUINO doit afficher " Téléversement terminé"
Vérifier le fonctionnement du programme sur la carte ARDUINO
7
Si nécessaire, appuyer sur le bouton poussoir (Reset) de la carte afin de redémarrer le programme

Professeur : E. Chater 8/8