Arduino Juste

Initiation à
l’Arduino
[Sous-titre du document]
Gonzalv Christophe HOUNSOKOU

initiAtion à l’Arduino
Introduction
Ce cours à pour but de présenter et d’initier à l’utilisation d’Arduino.
Les cartes Arduino sont conçues pour réaliser des prototypes et des
maquettes de cartes électroniques pour l’informatique embarquée. Ces cartes
permettent un accès simple et peu couteux à l’informatique embarquée. De
plus, elles sont entièrement libres de droit, autant sur l’aspect du code source
(Open Source) que sur l’aspect matériel (Open Hardware). Ainsi, il est possible
de refaire sa propre carte Arduino dans le but de l’améliorer ou d’enlever des
fonctionnalités inutiles au projet.
Le langage Arduino se distingue des langages utilisés dans l’industrie

de l’informatique embarquée de par sa simplicité. En effet, beaucoup de
librairies et de fonctionnalités de base occulte certains aspects de la
programmation de logiciel embarquée afin de gagner en simplicité. Cela en
fait un langage parfait pour réaliser des prototypes ou des petites applications
dans le cadre de hobby. Les possibilités des cartes Arduino sont énormes, un
grand nombre d’application ont déjà été réalisée et testées par bon nombre
d’internautes.
1. Présentation de l’arduino
1.1. Généralités
Arduino est un projet créé par une équipe de développeurs, composée de six
individus : Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino,
David Mellis et Nicholas Zambetti. Cette équipe a créé le "système Arduino".
C’est un outil qui va permettre aux débutants, amateurs ou professionnels de
créer des systèmes électroniques plus ou moins complexes.
1.1.1. Le but et l'utilité
Le système Arduino, nous donne la possibilité d'allier les performances

de la programmation à celles de l'électronique. Plus précisément, nous allons
programmer des systèmes électroniques. Le gros avantage de l'électronique
programmée c'est qu'elle simplifie grandement les schémas électroniques et
par conséquent, le coût de la réalisation, mais aussi la charge de travail à la
conception d'une carte électronique.
[Date] 1
1.1.2. Applications
Le système Arduino nous permet de réaliser un grand nombre de

choses, qui ont une application dans tous les domaines ! L’étendue de
l'utilisation de l'Arduino est gigantesque. En voici quelques exemples:
 contrôler les appareils domestiques

 fabriquer votre propre robot
 faire un jeu de lumières
 communiquer avec l'ordinateur
 télécommander un appareil mobile (modélisme)
 etc.
1.2. Les outils Arduino
À présent, rapprochons-nous de « l'utilisation » du système Arduino et

voyons comment il se présente. Il est composé de deux choses principales,
qui sont : le matériel et le logiciel. Ces deux outils réunis, il nous sera
possible de faire n'importe quelle réalisation !
1.2.1.Le matériel
Il s'agit d'une carte électronique basée autour d'un microcontrôleur

Atmega du fabricant Atmel, dont le prix est relativement bas pour l'étendue
possible des applications. Voici les versions les plus courantes sur le marché
:
 La carte Uno
[Date] 2
C’est celle-ci que nous utiliserons tout au long de ce cours.
 La carte Mega
La carte Arduino Mega est une autre carte qui offre toutes les fonctionnalités
des précédentes, mais avec des options en plus. On retrouve notamment un
nombre d’entrées et de sorties plus importantes ainsi que plusieurs liaisons
séries.
 La carte Arduino Nano
 La carte Arduino Pro-mini
1.2.2.Le logiciel
Le logiciel va nous permettre de programmer la carte Arduino. Il nous offre

une multitude de fonctionnalités.
[Date] 3
 Brève présentation de quelques boutons de l’interface
A – Utilisé pour vérifier s’il y a une erreur de compilation. Ce bouton permet

de précompiler le code.
B – Utilisé pour télécharger un programme sur la carte Arduino. C’est le
bouton de téléversement.
C – Raccourci utilisé pour créer un nouveau croquis (nouveau fichier).
D – Utilisé pour ouvrir directement l’un des exemples de croquis ou un croquis
enregistré.
[Date] 4
E – Utilisé pour enregistrer votre croquis.

F – Moniteur série utilisé pour recevoir des données série de la carte et envoyer
les données série à la carte.
 Comment programmer une carte arduino ?
a. Connexion à la carte Arduino et lancement de l’IDE Arduino
Connecter la carte Arduino à votre ordinateur à l’aide du câble USB.
La carte sera rapidement reconnue. Lancez dès à présent l’IDE Arduino !
b. Charger un programme
Ça y est ! L’IDE Arduino est lancé. Un projet vierge est ouvert par défaut,
vous présentant également la structure d’un programme Arduino
[Date] 5
Pour commencer et tester notre carte Arduino, on va ouvrir un projet

d’exemple : le projet “Blink”. Pour l’ouvrir, faire comme suit :
[Date] 6
Le projet est maintenant chargé ! Il est presque prêt à être transféré à la

carte Arduino.
[Date] 7
c. Sélection du type de carte, de la vitesse et du port COM
On va passer maintenant à la configuration de l’IDE Arduino pour votre

carte Arduino. Pour se faire, dans les options, il faudra choisir le type de
carte. Pour certaines cartes il faudra également choisir la fréquence, le type
de compilateur, la vitesse de transfert et le port COM correspondant au
canal de communication avec votre Arduino.
Pour l’Arduino UNO, optez pour les choix suivants :
 Carte Arduino/Genuino UNO

 Port COM correspondant à votre connexion
 Programmateur : Arduino Gemma
[Date] 8
Une fois que la bonne carte est sélectionnée, vous allez pouvoir commencer
le chargement. Votre configuration de carte est rappelée en bas à droite
de l’IDE Arduino :
Par défaut, votre port COM ne sera jamais le port COM1. Comment faire
pour connaître le numéro du port COM de votre Arduino ? Tout d’abord,
lancez votre gestionnaire de périphériques :
[Date] 9
Et repérez le port COM de votre Arduino sous “Ports (COM et LPT)” :
[Date] 10
d. Chargez le programme dans l’Arduino !
Une fois que tout est configuré, on va pouvoir compiler le programme et le

transférer ! Pour effectuer ces opérations, on va se servir du ruban présent
sous le bandeau des options.
Cliquez sur vérifier, puis sur téléverser ! Ça y est, “Blink” est transféré ! Vous
devriez voir la LED présente sur votre Arduino se mettre à clignoter. Il s’agit
de la LED notée “L” à côté. Elle est de couleur orange sur les cartes Arduino
officielles.
[Date] 11
2. Le langage Arduino
Pour pouvoir programmer notre carte, il nous faut trois choses :
 Un ordinateur
 Une carte Arduino
 Et connaitre le langage Arduino
C’est ce dernier point qu’il nous faut acquérir. Le but même de ce chapitre est
de vous apprendre à programmer avec le langage Arduino. Ce document ne
donne que les bases de la programmation Arduino.
2.1. La syntaxe du langage
La syntaxe d'un langage de programmation est l'ensemble des règles

d'écritures liées à ce langage. On va donc voir dans ce sous chapitre les règles
qui régissent l'écriture du langage Arduino.
2.1.1.Le code minimal
Avec Arduino, nous devons utiliser un code minimal lorsque l'on crée un
programme. Ce code permet de diviser le programme que nous allons créer
en deux grosses parties.
2.1.2.La fonction
Dans le code ci-dessus se trouvent deux fonctions. Les fonctions sont en fait
des portions de code.
[Date] 12
Cette fonction setup() est appelée une seule fois lorsque le programme
commence. C'est pourquoi c'est dans cette fonction que l'on va écrire le code
qui n'a besoin d'être exécuté qu’une seule fois. On appelle cette fonction:
"fonction d'initialisation". On y retrouvera la mise en place des différentes
sorties et quelques autres réglages. C'est un peu le check-up de démarrage.
Imaginez
un pilote d'avion dans sa cabine qui fait l'inventaire :
- patte 2 en sortie, état haut ?
- OK
- timer 3 à 15 millisecondes ? - OK
...
Une fois que l'on a initialisé le programme il faut ensuite créer son "cœur",
autrement dit le programme en lui-même.
C'est donc dans la fonction loop() où l'on va écrire le contenu du programme.

Il faut savoir que cette fonction est appelée en permanence, c'est-à-dire qu'elle
est exécutée une fois, puis lorsque son exécution est terminée, elle est ré-
exécuté et encore et encore. On parle de boucle infinie.
2.1.3.Les instructions
Les instructions sont des lignes de code qui disent au programme : "fait ceci,
fait cela, ...". Les instructions sont terminées par un point-virgule. Une
instruction non terminé par un point-virgule est source d’erreur et le
programme ne compile pas.
2.1.4.Les accolades
Les accolades sont les "conteneurs" du code du programme. Elles sont propres
aux fonctions, aux conditions et aux boucles. Les instructions du programme
sont écrites à l'intérieur de ces accolades.
2.1.5. Les commentaires
Ce sont des lignes de codes qui seront ignorées par le programme. Elles ne
servent en rien lors de l'exécution du programme. Elles permettent juste à
ceux qui liront le code de savoir ce que signifie la ligne de code que vous avez
écrite. C'est très important de mettre des commentaires et cela permet aussi
de reprendre un programme laissé dans l'oubli plus facilement !
Ligne unique de commentaire :
[Date] 13
Ligne ou paragraphe sur plusieurs lignes :
2.1.6.Les accents
Il est formellement interdit de mettre des accents en programmation. Sauf

dans les commentaires.
2.2. Les données (Variables et constantes)
2.2.1.Type de variables
Le compilateur de l’IDE Arduino compile par défaut du code écrit en C et en

C++ simplifié pour microcontrôleur. Le code est par ailleurs enrichit des
bibliothèques natives au monde Arduino pour communiquer directement avec
l’électronique. Au travers des programmes Arduino, on retrouve des types de
données différents selon les variables déclarées.
 Void
Le mot-clé “void” est uniquement utilisé pour déclarer des fonctions. La

spécificité du “void” c’est que la fonction ne retourne aucun résultat
lorsque celle-ci est appelée.
Exemple
 Boolean ou bool
Un “boolean” est un booléen. Il s’agit d’une donnée ne pouvant prendre que

2 valeurs : true (vrai) ou false (faux). Il est également possible de remplacer
true par 1 et false par 0 pour un booléen. Chaque variable booléenne occupe
un byte de mémoire.
Exemple
[Date] 14
 char
Les données char sont des données pouvant contenir un caractère. C’est un
type de donnée qui occupe un octet de mémoire. Un caractère s’écrit dans une
variable char entre guillemets simples comme ceci : ‘A’. Pour écrire plusieurs
caractères, ce qu’on appelle aussi une chaîne de caractères (string), on
utilisera les guillemets doubles comme ceci : “ABC”. Mais derrière chaque
caractère se cache un nombre. Vous pouvez voir l’encodage spécifique dans
le tableau ASCII. Cela signifie qu’il est possible d’effectuer des opérations
arithmétiques sur des caractères, dans lesquels la valeur ASCII du caractère
est utilisée. Par exemple, ‘A’ + 1 a la valeur 66, car la valeur ASCII du caractère
‘A’ est 65.
Exemple
 Unsigned Char
La donnée unsigned char se comporte exactement comme une variable char,

sauf que celle ci prends en compte la table ASCII étendue qui va de 0 à 255.
Voici la liste des codes restants (128-255) :
Exemple
 Byte
Une donnée byte peut stocker un nombre non signé sur 8 bits, de 0 à 255.
[Date] 15
 Int
Les données int représentent les données de stockage des nombres entiers.
Il s’agit du type de donnée principal pour le stockage des nombres. int stocke
une valeur sur 16 bits, soit 2 octets. Cela donne une fourchette de -32 768 à
32 767 (soit une valeur minimale de -215 et une valeur maximale de 215-1).
 Unsigned Int
Les Unsigned Int fonctionnent de la même manière que les Int. La différence
ici, c’est que les nombres négatifs ne sont plus pris en compte. Le nombre est
toujours encodé sur 2 bytes, soit 16 bits, soit 2 octets. La plage positive est
donc plus grande : de 0 à 65 535 (216-1).
 Long
Les variables Long peuvent stocker des nombres entiers sur 4 bytes, soit 32
bits : de -2 147 483 648 (-231) à 2 147 483 647 (231+1).
 Unsigned long
Les variables unsigned long peuvent stocker des nombres non signés
entiers sur 32 bits : de 0 à 4 294 967 295 (232-1).
 Short
Une donnée de type short peut stocker un nombre entier sur 16 bits quel
que soit la carte Arduino utilisée : de -32 768 à 32 767 (soit une valeur
minimale de -215 et une valeur maximale de 215-1).
 Float
Le type de données float permet de stocker un nombre à virgule flottante.

Les variables float sont souvent utilisées pour approcher les valeurs
analogiques et continues car la donnée float possède une plus grande
résolution que les nombres entiers. La plage d’un nombre float est la plus
grande : de -3,4028235 E+38 à 3,4028235 E+38. Ce nombre est stocké sur
32 bits, soit 4 octets.
[Date] 16
Exemple
NB : le séparateur entre la partie entière et la partie décimale est ‘’.’’ et non

‘’,’’.
 Double
Sur Arduino UNO et autres cartes munies de processeur ATMEGA, une

donnée double fonctionne exactement de la même manière qu’une donnée
float. Elle occupe également 32 bits, sans gain de précision supplémentaire.
2.2.2. Déclarer une variable
Pour déclarer une variable est déclarée selon son type de donnée. Une variable
peut être initialisée à la création ou non. On peut également déclarer
plusieurs variables du même type en même temps. Par exemple :
2.2.3. La portée d’une variable
Les variables utilisées dans un langage C que Arduino utilise possèdent tous
une portée dans le programme selon l’endroit où ces dernières sont déclarées.
Les variables ne peuvent être utilisées que par des instructions qui se
trouvent à l’intérieur de la fonction où ces variables ont été déclarées. On
distingue 3 emplacements dans le code où une variable peut être déclarée.
2.2.3.1. Les variables locales
Les variables déclarées à l’intérieur d’une fonction ou d’un bloc sont des
variables locales. Ils ne peuvent être utilisés que par les instructions qui se
[Date] 17
trouvent à l’intérieur de cette fonction ou d’un bloc de code. Voici un exemple

:
2.2.3.2. Les variables en tant que paramètre d’une fonction
Les variables peuvent être des paramètres d’une fonction. Prenons l’exemple
d’une fonction d’addition de deux nombres entiers que l’on va appeler dans
la boucle principale :
2.2.3.3. Les variables globales
Les variables globales sont définies en dehors de toutes les fonctions,

généralement en haut du programme. Les variables globales conserveront
leur valeur tout au long de la durée de vie de votre programme. Une variable
globale peut être accédée par n’importe quelle fonction. Elle est disponible
[Date] 18
pour toute l’utilisation de votre programme après sa déclaration, peu importe

la fonction où elle est appelée. Une variable globale peut également être une
variable partagée qui servira à plusieurs fonctions.
L’exemple suivant utilise des variables globales et locales ainsi que des
variables paramètres de fonction :
Les variables globales
2.2.4. Les constantes
Les constantes sont des valeurs qui ne changeront pas pendant

l’exécution du programme. Ce sont des valeurs fixes stockées dans la
mémoire de donnée de l’Arduino. Ces valeurs ne surchargent pas le
programme et leur stockage est optimisé par le compilateur de l’IDE Arduino.
Donc si vous avez une constante à déclarer, ne la déclarez pas en variable.
Il existe différents moyens de déclarer des valeurs constantes :
2.2.4.1. Déclaration avec le mot-clé const
Une déclaration de ce type se définit par le mot-clé const, par le type de

donnée, le nom de la constante et sa valeur. Il s’agit de la forme la plus
robuste. Le compilateur connaît le type de la constante et bloquera cette
donnée. Elle sera donc invariable, peu importe le comportement de votre
programme. C’est la forme à utiliser en priorité.
[Date] 19
2.2.4.2. Déclaration avec #define
Un #define ne fait pas partie du langage Arduino. #define est ce qu’on appelle
une fonction préprocesseur ou une macro. C’est une fonction qui va être
appelée par le compilateur avant que ce dernier effectue son travail de
compilation.
Comme vous pouvez le voir dans l’exemple, le type de donnée n’est même pas
à être spécifié. Du fait que ce n’est pas du code C, la syntaxe n’accepte pas le
point-virgule ni le signe “=”.
En fait, avant la compilation, la macro #define va remplacer toutes les pi par

la valeur 3.14. Le compilateur fait ensuite son travail. La donnée n’est pas
verrouillée, car elle n’existera pas dans le programme. Le programme ne verra
que des 3.14 partout. Dans certains cas, cela peut poser problème. À
proscrire si possible (préférez const !).
2.3. Les opérateurs
Un opérateur c’est un symbole permettant d’effectuer des fonctions de

mathématiques spécifiques ou logiques. Le langage C est riche pour
construire et pour fournir le suivi de différents types d’opérateurs.
2.3.1.Opérateurs arithmétiques
Supposons que la variable A est de 10 et que la variable B est de 20.
Nom de
Opérateur Description Exemple
l’opérateur
On assigne la valeur à gauche de

Assignement = l’égal dans la valeur à droite de l’égal. A = B
Ici la valeur B prend la valeur A.
A+B
Addition + Additionne les deux opérandes.
donne 30
Soustrais le second opérande du A–B

Soustraction –
premier. donne -10
[Date] 20
A*B
Multiplication * Multiplie les deux opérandes.
donne 200
Divise le numérateur par le B/A

Division /
dénominateur. donne 2
L’opérateur Modulo donne comme B%A

Modulo %
résultat le reste après la division. donne 0
2.3.2.Comparaison d’opérateurs
Nom de
l’opérateur
Vérifie si la valeur des deux (A == B) ce

Égal == opérandes est égale ou non, si oui n’est pas
alors la condition devient vraie. vrai
Vérifie si la valeur des deux

N’est pas opérandes est égale ou non, si les (A != B) c’est
!=
égal valeurs ne sont pas égales alors cela vrai
devient vrai.
Vérifie si la valeur de l’opérande

gauche est moins élevée que celle de (A < B) c’est
Inférieur à <
droite, si oui alors la condition vrai
devient vraie.
Vérifie si la valeur de l’opérande

(A > B) ce
gauche est plus élevée que celle de
Supérieur à > n’est pas
droite, si oui alors la condition
vrai
devient vraie.
Vérifie si la valeur de l’opérande de

Inférieur à gauche est moins élevée ou égale que (A <= B)
<=
ou égal l’opérande de droite, si oui alors la c’est vrai
condition devient vraie.
[Date] 21
Vérifie que la valeur de l’opérande de

(A >= B) ce
Supérieur à gauche est plus élevée ou égale à
>= n’est pas
ou égal celle de droite, si oui alors la
vrai
2.3.3.Opérateurs booléens
Nom de
l’opérateur
Appelé opérateur ET logique ou porte

logique ET. Si les deux opérandes ne
(A && B)
ET && valent pas zéro alors la condition
c’est vrai
devient vraie. Sinon, la condition est
fausse.
Appelé opérateur OU logique ou porte

logique OU. Si chacun des deux (A || B)
OU ||
opérandes n’est pas zéro alors la c’est vrai
Appelé opérateur NON logique ou porte

logique NON. Permets d’inverser l’état
logique d’un opérande. Si la condition !(A && B)
NON !
de l’opérande est vraie alors l’opérateur c’est faux
NON logique placé devant celui-ci
inversera le résultat : ce sera faux.
2.3.4.Opérateurs binaires
Nom de
l’opérateur
L’opérateur binaire ET effectue (A & B) donne

ET & une action logique ET bit à bit sur 12 qui est
la valeur des deux opérandes. 0000 1100
[Date] 22
L’opérateur binaire OU effectue (A | B) donne

OU | une action logique OU bit à bit sur 61 qui est
la valeur des deux opérandes. 0011 1101
L’opérateur binaire XOR effectue

une action logique XOR bit à bit
sur la valeur des deux opérandes.
(A ^ B)
XOR => OU exclusif
XOR ^ donne 49 qui
0 XOR 0 = 0
est 0011 0001
0 XOR 1 = 1
1 XOR 0 = 1
1 XOR 1 = 0
L’opérateur binaire NON effectue

une action logique NON bit à bit (~A ) donne -
NON ~ sur la valeur d’un opérande. Cela a 60 qui est
pour effet d’inverser bit à bit la 1100 0011
valeur.
Cela a pour effet de décaler les bits

Décalage à A << 2 donne
vers la gauche du nombre de
gauche << 240 qui est
positions indiqué. 11 << 2 devient
(shift left) 1111 0000
1100.
Cela a pour effet de décaler les bits

Décalage à A >> 2 donne
vers la gauche du nombre de
droite >> 15 qui est
positions indiqué. 1100 >> 2
(shift right) 0000 1111
devient 11.
2.3.5.Compositions d’opérateurs
Nom de
l’opérateur
A++ donne
Incrémenter ++ Augmentation d’une valeur par 1.
11
Décrémenter — Diminution d’une valeur par 1. A– donne 9
Permets d’incrémenter une valeur
B += A est
Addition d’une autre valeur souhaitée tout
+= égal à B =
composée en stockant le résultat dans le
B+ A
premier opérande.
[Date] 23
Permets de décrémenter une

B -= A est
Soustraction valeur d’une autre valeur
-= égal à B = B
composée souhaitée tout en stockant le
–A
résultat dans le premier opérande.
Permets de multiplier une valeur
B*= A est
Multiplication par une autre valeur souhaitée
*= égal à B =
composée tout en stockant le résultat dans
B* A
le premier opérande.
Permets de diviser une valeur par
B /= A est
Division une autre valeur souhaitée tout en
/= égal à B = B
composée stockant le résultat dans le
/A
premier opérande.
Permets de réaliser le modulo
B %= A est
Modulo d’une valeur par une autre valeur
%= égal à B = B
composé souhaitée tout en stockant le
%A
résultat dans le premier opérande.
Permets de réaliser une opération
bit à bit OU d’une valeur par une A |= 2 est
Composé bit à
|= autre valeur souhaitée tout en pareil que A
bit OU
stockant le résultat dans le =A|2
premier opérande.
Permets de réaliser une opération
bit à bit ET d’une valeur par une A &= 2 est
Composé bit à
&= autre valeur souhaitée tout en pareil que A
bit ET
stockant le résultat dans le =A&2
premier opérande.
Dans la prochaine partie, on va enfin pouvoir commencer à programmer des

boucles et réaliser nos premiers programmes Arduino !
2.4. Conditions
Les contrôles d’état vont permettre d’évaluer des conditions pour permettre
l’exécution d’une partie de programme. Les contrôles d’état vont déterminer
si une condition est vraie ou fausse. La réponse est forcément binaire. Elle
peut être retournée par la réponse à la condition ou par le retour d’une
fonction. Voici la forme générale d’un contrôle d’état (valable pour la plupart
des langages de programmation) :
[Date] 24
2.4.1. If (Conditions SI)
Il prend une expression entre parenthèses et une déclaration ou un bloc de

déclarations. Si l’expression est vraie, l’instruction ou le bloc d’instructions
est exécuté sinon ces instructions sont ignorées.
Appels de la condition if Séquence d’exécution if
Exemple
[Date] 25
2.4.2. If… else (Conditions SI… SINON)
Une instruction if peut être suivie d’une instruction else facultative, qui
s’exécute lorsque l’expression est fausse.
Séquence d’exécution
Appel de la condition if… else
if… else
Exemple
[Date] 26
2.4.3. Else if (Conditions SI… SINON SI… SINON (imbriqué))
L’instruction if peut être suivie d’une instruction else if… puis d’une
instruction else, ce qui est très utile pour tester diverses conditions. On
appelle ça une imbrication de conditions.
Il faut garder à l’esprit que :
 Une condition if peut être suivit d’autre if avant une instruction else.
 L’instruction else correspondra à sa propre imbrication de if. Veillez à
bien vérifier vos imbrications grâce aux “{}”.
 Si une boucle if retourne un résultat vrai, les conditions if suivantes (de
la même imbrication), ne seront pas testées.
Appel de la condition if… else if… else
[Date] 27
Séquence d’exécution if… else if… else
Exemple
[Date] 28
2.4.4.Conditions au cas par cas (switch case)
Cette instruction est similaire aux conditions imbriquées. Cela permet de

comparer une condition à plusieurs valeurs. Si une des valeurs correspond,
la condition est vraie et le code correspondant est exécuté. On peut également
définir le code à exécuter si aucune valeur ne correspond grâce à l’état
default. Le mot-clé break permet de sortir de la boucle. Il est généralement
placé à la fin de chaque code (par condition). Si le mot clé break n’est pas
placé à la fin de chaque condition, l’appel switch continuera de tester les cas
suivants.
Appel de la condition switch… case
[Date] 29
Séquence d’exécution switch… case
Exemple
2.5. Les boucles ?
Une boucle est une structure de programmation qui permet de réaliser

certaines tâches un certain nombre de fois et parfois selon certaines
conditions. Il s’agit d’une partie de code qui va être répétée tant qu’une
condition sera valide. Le programme ne sortira pas de cette boucle tant que
la condition sera respectée.
[Date] 30
2.5.1.La boucle while
La boucle while peut se traduire en français par la boucle “tant que”. En

effet, tant que la condition entre parenthèses est vraie, la boucle continuera
de s’exécuter indéfiniment. Pour sortir de la boucle, un élément du
programme devra changer cette condition, sinon le programme ne sortira
jamais de cette boucle.
Anecdote : En programmation Arduino, la fonction loop() peut s’apparenter à

une boucle while(), car une fois que l’exécution du programme se trouve dans
cette boucle (après la fonction setup()), le code y est répété à l’infinie.
Syntaxe
Exemple
Dans cet exemple, la boucle sera répétée 5 fois.
[Date] 31
2.5.2. La boucle do…while
La boucle do…while est similaire à la boucle while. La différence ici, c’est que
la condition de répétabilité de la boucle est testée à la fin de celle-ci. Donc la
boucle est au minimum exécutée une fois. Si la condition while est vraie, la
boucle est répétée. De même que pour la boucle while simple, pour sortir de
la boucle, un élément du programme devra changer la condition de
répétabilité, sinon le programme ne sortira jamais de la boucle.
Reprenons le même exemple qu'avant.
2.5.3.La boucle for
C’est l’un des concepts les plus utilisés dans le domaine de la programmation
! Une boucle for a pour but d’exécuter une partie du code un certain nombre
de fois. Une boucle for est déterminée par 3 expressions : la valeur initiale, la
valeur à contrôler et la valeur d’incrémentation ou de décrémentation.
Exemple
[Date] 32
2.5.4.Les boucles imbriquées
Le langage C permet l’utilisation de boucles imbriquées, tout comme les

contrôles d’état qui peuvent également s’imbriquer les uns dans les autres.
L’exemple suivant illustre le concept :
2.5.5.La boucle infinie
La boucle infinie est une boucle qui se répète… à l’infinie ! La condition de

terminaison de la boucle n’est jamais atteinte, car toujours vraie. Une boucle
infinie est soit l’effet recherché dans un programme, soit une erreur de la part
du programmeur. Ce genre de boucle peut également servir à déboguer
certaines parties du code, pour tester les limites d’une boucle. On peut créer
une boucle infinie avec les boucles for, while et do..while.
Syntaxe
[Date] 33
2.6. Les fonctions
Dans un programme, les lignes sont souvent très nombreuses. Il devient alors
impératif de séparer le programme en petits bouts afin d'améliorer la lisibilité
de celui-ci, en plus d'améliorer le fonctionnement et de faciliter le débogage.
Nous allons voir ensemble ce qu'est une fonction, puis nous apprendrons à
les créer et les appeler.
Une fonction est un "conteneur" mais différent des variables. En effet,

contrairement aux variables une fonction peut contenir un programme entier!
Pour être plus concret, une fonction est un bout de programme qui permet de
réaliser une tâche bien précise. L'utilité d'une fonction réside dans sa capacité
à simplifier le code et à le séparer en "petits bouts" que l'on assemblera
ensemble pour créer le programme final.
[Date] 34
2.6.1.Fabriquer une fonction
Pour fabriquer une fonction, nous avons besoin de savoir trois choses :
Quel est le type de la fonction que je souhaite créer ?
Quel sera son nom ?
Quel(s) paramètre(s) prendra-t-elle ?
2.6.1.1. Nom de la fonction

Pour commencer, nous allons, en premier lieu, choisir le nom de la
fonction. Par exemple, si votre fonction doit récupérer la température d'une
pièce fournie par un capteur de température : vous appellerez la fonction
lireTemperaturePiece, ou bien lire_temperature_piece, ou encore
lecture_temp_piece. Bon, des noms on peut lui en donner plein, mais soyez
logique quant au choix de ce dernier. Ce sera plus facile pour comprendre le
code que si vous l'appelez tmp (pour température). Un nom de fonction
explicite garantit une lecture rapide et une compréhension aisée du code. Un
lecteur doit savoir ce que fait la fonction juste grâce à son nom, sans lire le
contenu !
2.6.1.2. Les paramètres
Les paramètres servent à nourrir votre fonction. Ils servent à donner des
informations au traitement qu'elle doit effectuer. Prenons un exemple concret.
Pour changer l'état d'une sortie du microcontrôleur, Arduino nous propose la
fonction suivante: digitalWrite(pin, value). Ainsi, la référence nous explique
que la fonction a les caractéristiques suivantes:
- paramètre pin: le numéro de la broche à changer
- paramètre value: l'état dans lequel mettre la broche (HIGH, (haut, +5V) ou
LOW (bas, masse))
- retour: pas de retour de résultat
Comme vous pouvez le constater, l'exemple est explicite sans lire le code de
la fonction. Son nom, digitalWrite ("écriture digitale" pour les anglophobes),
signifie qu'on va changer l'état d'une broche numérique (donc pas analogique).
Ses paramètres ont eux aussi des noms explicites, pin pour la broche à
changer et value pour l'état à lui donner.
Lorsque vous aller créer des fonctions, c'est à vous de voir si elles ont besoin
de paramètres ou non. Par exemple, vous voulez faire une fonction qui met en
pause votre programme, vous pouvez faire une fonction Pause() qui prendra
en paramètre une variable de type char ou int, etc. (cela dépendra de la taille
de la variable). Cette variable sera donc le paramètre de notre fonction Pause()
et déterminera la durée pendant laquelle le programme sera en pause. On
obtiendra donc, par exemple, la syntaxe suivante : void Pause(char duree).
[Date] 35
2.6.2.Type
On a le choix de créer des fonctions vides, donc sans paramètres, ou bien

des fonctions "typées" qui acceptent un ou plusieurs paramètres.
 Les fonctions vides
Une fonction qui n'accepte pas de paramètres est une fonction vide. La
syntaxe utilisée pour définir une fonction vide est la suivante :
 Les fonctions "typées"
En effet, si on veut créer une fonction qui calcule le résultat d'une addition de
deux nombres (ou un calcul plus complexe), il serait bien de pouvoir renvoyer
directement le résultat plutôt que de le stocker dans une
variable qui a une portée globale et d’accéder à cette variable dans une autre
fonction.
En clair, l'appel de la fonction nous donne directement le résultat. On peut
alors faire "ce que l'on veut" avec ce résultat (le stocker dans une variable,
l'utiliser dans une fonction, lui faire subir une opération, ...)
Pour créer une fonction typée il faut simplement remplacer void par le type
choisi (int, long, ...)
Lorsqu'elle sera appelée, la fonction maFonction() va tout simplement

retourner la variable resultat. Dans la fonction loop(), on fait un calcul avec
[Date] 36
la valeur que nous retourne la fonction maFonction(). Autrement dis, le

calcul est : calcul = 10 * 44; Ce qui nous donne : calcul = 440.
 Les fonctions avec paramètres
la synthaxe est de la forme
La fonction récupère dans des variables les paramètres que l'on lui a envoyés
et faire les traitements puis retourner un résultat. Cela va nous servir à
simplifier notre code. Mais pas seulement ! Par exemple, vous voulez faire
plusieurs opérations différentes (addition, soustraction, etc.) et bien au lieu
de créer plusieurs fonctions, on ne va en créer qu'une qui les fait toutes !
Mais, afin de lui dire quelle opération faire, vous lui donnerez un paramètre
lui disant : "Multiplie ces deux nombres" ou bien "additionne ces deux
nombres".
[Date] 37
Donc si la variable operation vaut 0, on addition les variables x et y, sinon si

operation vaut 1, on soustrait y à x. Notez qu'une fonction ne peut renvoyer
qu'un seul résultat à la fois.
3. Gestion des Ports
Tout d'abord, une entrée / sortie est une connexion physique, une
"broche", sur laquelle vous pouvez venir câbler quelque chose, comme un
voyant, un bouton, un capteur, etc. Une entrée / sortie numérique est une
entrée / sortie qui peut prendre un des trois états physiques suivant : "haut"
(HIGH), "bas" (LOW) ou "haute impédance" (INPUT). L'état "haut" (HIGH)
signifie que la broche génère un signal. Cet état se traduit généralement par
une tension de 5 volts en sortie de la broche avec une carte Arduino classique.
L'état "bas" (LOW) signifie que la broche ne génère pas de signal. Cet état se
traduit généralement par une tension de 0 volt en sortie de la broche. L'état
"haute impédance" (INPUT) est un état un peu particulier. Dans cet état, la
broche ne génère aucun signal. L'état "haute impédance" signifie que la
broche est "en lecture" (en entrée). C'est cet état qui permet de "lire" un bouton
par exemple.
3.1. Sorties numériques
Les sorties numériques sont utilisées pour allumer des leds, piloter des
afficheurs 7 segments ou à cristaux liquides, commander des transistors, des
relais, etc...
Pour configurer une broche numérique en sortie, il faut, dans la partie Setup
du programme, écrire la ligne pinMode(broche, OUTPUT), où broche
représente le numéro de la broche numérique (0 à 20 pour l’arduino UNO).
Pour mettre un niveau logique sur une broche, il faut écrire la ligne
digitalWrite(broche, valeur), où broche représente le numéro de la broche
numérique et valeur le niveau logique LOW ou HIGH.
Pour raison de faciliter il faut déclarer ou définir le port au début du

programme. On peut écrire
« const int nomDuPort = NuméroDuPort » ou
« #define nomDuPort NuméroDuPort »
[Date] 38
Exemple : allumer la led incluse sur la carte arduino (cette led est connectée
au port 13)
3.2. Les entrées numériques
Les entrées numériques sont utilisées pour lire l'état d'un interrupteur ou
bouton poussoir, recevoir une information en provenance d'un capteur tout
ou rien.
Pour configurer une broche numérique en entrée, il faut dans la partie Setup
du programme écrire la ligne pinMode(broche, INPUT), où broche représente
le numéro de la broche numérique (0 à 20 pour l’arduino UNO).
Très souvent, les niveaux logiques sont fournis par des interrupteurs ou des
boutons poussoirs selon les schémas ci-dessous :
[Date] 39
Sur le schéma de gauche, l’entrée est maintenue au niveau haut et passe au

niveau bas lorsque le bouton poussoir est actif. La résistance R impose un
niveau haut et protège le montage des courts-circuits lorsque le bouton
poussoir devient actif. C’est une résistance de tirage (pull-up).
Sur le schéma de droite, l’entrée est maintenue au niveau bas et passe au

niveau haut lorsque le bouton poussoir est actif. La résistance R impose un
niveau bas et protège le montage des courts-circuits lorsque le bouton
poussoir devient actif. C’est une résistance de rappel (pull-down).
Les microcontrôleurs ATMega ont la particularité de posséder sur chaque

broche une résistance de tirage qu’il faut activer à l’aide de
l’instruction pinMode(broche, INPUT_PULLUP).
Pour lire l'état d'une broche, il faut écrire la ligne digitalRead(broche).
Exemple :
Nous allumons la led branchée sur la broche numérique N°13 si le bouton

poussoir branché sur la broche numérique N°4 est actif.
[Date] 40
4. Les bibliothèques
4.1. Description.
Dans l'univers Arduino, vous rencontrerez les LIBRARIES, que l'on

appelle bibliothèques . Certaines sont intégrées d'origine au sein du
compilateur mais il est aussi possible d'en ajouter en les téléchargeant sur
Internet. Mais en réalité, c'est un sous-programme qui forme un
groupement de fonctions utiles à l'exploitation d'équipements comme les
servomoteurs, les afficheurs LCD ou gérer des communications SPI et autres
composants électroniques.
4.2. Installer une bibliothèque.
Il vous sera parfois nécessaire d'installer une librairie qui ne fait pas partie de
la liste. Tout d'abord, il vous faudra la télécharger sous format ZIP sur
Internet.
Prenons l'exemple de <RTClib.h> utile à la gestion des temps horaires

coordonnés pour avoir l'heure exacte. Après avoir recherché et trouvé un
site ou télécharger la bibliothèque.
1. D’abord, téléchargez la en format ZIP dans un ficher de destination

de votre choix. Nous prendrons "Téléchargement" par défaut.
2. Vous lancez ensuite votre compilateur et ouvrez le menu "croquis",
sélectionner "inclure une bibliothèque". Puis la fenêtre déroulante
s'ouvre. Cliquez sur " Ajoutez une bibliothèque ZIP".
3. L'explorateur de fichiers s'ouvre. Sélectionnez et ouvrez votre dossier
de destination en l’occurrence pour nous "Téléchargement".
Recherché le fichier ZIP appelé RTClib et cliquez dessus.
4. Vous retournerez systématiquement au compilateur et constaterez
la confirmation du chargement.
[Date] 41
Finalement, vous avez installé RTClib.h dans la librairie du compilateur.
Il ne vous reste plus qu'a l'installer dans vos programmes. A l'opposé des
originales, celle-ci se trouve dans une seconde liste appelé "Contributed
bibliothèque". Il y a aussi une autre liste "Recommended bibliothèque".
[Date] 42
Note: Vous retrouverez aussi les fichiers source (.h) des bibliothèques dans le
fichier d'installation "Arduino" dans programme files dans le fichier
"libraries". Prenez garde à ne pas les modifier si vous ne maîtrisez pas la
programmation car il serait endommagé et plus du tout utilisable.
4.3. Faire appel à une bibliothèque.
[Date] 43
Pour faire appel à une bibliothèque, il faut aller la chercher dans le menu du
compilateur "croquis" =>>"inclure une bibliothèque" comme illustré ci-
dessous.
Vous y retrouverez toutes les bibliothèques incluses dans le compilateur

Arduino. Il suffit de cliquer sur l'une d'elle pour installer la directive
d'inclusion dans notre programme.
Exemple:
[Date] 44
#include de l'anglais veut dire inclure en français c'est la directive

d'inclusion. Ce terme ordonne au compilateur de traiter le contenu d'un
fichier de la bibliothèque spécifié à son nom, comme s'il faisait partie du
programme principal. La directive d'inclusion se présente sous cette
forme #include<nomDeLaBibliothèque.h>.
Il ne faut pas oublier que pour que le compilateur trouve la bibliothèque à

inclure, il faut lui spécifier un chemin d'accès nommé entre < > guillemets.
Le compilateur recherchera les termes du fichier entre guillemets.
Le .h spécifie le type de fichier. H vient du terme anglais Header qui veut dire
entête. C'est donc pour spécifier un fichier dit d'entête.
5. Gestion du temps et Interruptions

5.1. Introduction du temps
C'est bien beau d'allumer une LED, mais si elle ne fait rien d'autre, ce n'est
pas très utile. Autant la brancher directement sur une pile. Alors voyons
comment rendre intéressante cette LED en la faisant clignoter !
Pour cela il va nous falloir introduire la notion de temps.
5.1.1.La fonction delay() ;
Cette fonction va sert à mettre en pause le programme pendant un temps

prédéterminé. Elle admet un paramètre qui est le temps pendant lequel on
veut mettre en pause le programme. Ce temps doit être donné en
millisecondes. C'est-à-dire que si vous voulez arrêter le programme pendant
1 seconde, il va falloir donner à la fonction ce même temps, écrit en
millisecondes, soit 1000ms. Le code est simple à utiliser, il est le suivant :
Mise en pratique : faire clignoter une LED

Du coup, si on veut faire clignoter notre LED, il va falloir utiliser cette
fonction. Voyons un peu le schéma de principe du clignotement d'une LED :
[Date] 45
Vous le voyez, la LED s'allume. Puis, on fait intervenir la fonction delay(), qui
va mettre le programme en pause pendant un certain temps. Ensuite, on
éteint la LED. On met en pause le programme. Puis on revient au début du
programme. On recommence et ainsi de suite. C'est cette somme de
commande, qui forme le processus qui fait clignoter la LED.
Travaux Pratiques : Réaliser un chenillard
Le but du programme
Le but du programme que nous allons créer va consister à réaliser un
chenillard. Pour ceux qui ne savent pas ce qu'est un chenillard, c’est un
mouvement lumineux qui se produit en allumant et en éteignant
[Date] 46
successivement une série de lapes ou de led ; l’effet se traduit par un

déplacement de cette lumière dans un sens choisi.
Organigramme...
Bon, aller, le voilà cet organigramme ! Attention, il n'est pas complet, mais si
vous avez compris le principe, le compléter ne vous posera pas de problèmes
:
5.1.2.Fonction millis()
Si on veut faire clignoter une LED sans arrêter l’exécution du programme,

on ne peut pas utiliser la fonction delay() qui met en pause le programme
durant le temps défini.
[Date] 47
5.1.2.1. Les limites de la fonction delay()
Vous avez probablement remarqué, lorsque vous utilisez la fonction "delay()"

tout notre programme s’arrête le temps d'attendre. Dans certains cas ce n'est
pas un problème mais dans certains cas ça peut être plus gênant. Imaginons,
vous êtes en train de faire avancer un robot. Vous mettez vos moteurs à une
vitesse moyenne, tranquille, jusqu'à ce qu'un petit bouton sur l'avant soit
appuyé (il clic lorsqu'on touche un mur par exemple). Pendant ce temps-là,
vous décidez de faire des signaux en faisant clignoter vos LED. Pour faire un
joli clignotement, vous allumez une LED rouge pendant une seconde puis
l’éteignez pendant une autre seconde. Voilà par exemple ce qu'on pourrait
faire comme code
Attention ce code n'est pas du tout rigoureux voire faux dans son écriture, il
sert juste à comprendre le principe !
Maintenant imaginez. Vous roulez, tester que le bouton n'est pas appuyé,
donc faites clignoter les LED (cas du else). Le temps que vous fassiez
l'affichage en entier s'écoule 2 longues secondes ! Le robot a pu pendant cette
éternité se prendre le mur en pleine poire et les moteurs continuent à avancer
tête baissée jusqu'à fumer ! Ce n'est pas bon du tout ! Solution : la fonction
millis().
[Date] 48
5.1.2.2. Découvrons et utilisons millis()
A l'intérieur du cœur de la carte Arduino se trouve un chronomètre. Ce chrono

mesure l'écoulement du temps depuis le lancement de l'application. Sa
granularité (la précision de son temps) est la milliseconde. La fonction millis()
nous sert à savoir quelle est la valeur courante de ce compteur. Attention,
comme ce compteur est capable de mesurer une durée allant jusqu'à 50 jours,
la valeur retournée doit être stockée dans une variable de
type "long".
Utilisation
Maintenant, au lieu de dire "allume-toi pendant une seconde et ne fais
surtout rien pendant ce temps", on va faire un truc du genre "Allume-toi, fais
tes petites affaires, vérifie l'heure de temps en temps et si une seconde est
écoulée, alors réagis !".
Voici le code précédent transformé selon la nouvelle philosophie :
[Date] 49
Et voilà, grâce à cette astuce plus de fonction bloquante. L'état du bouton

est vérifié très fréquemment ce qui permet de s'assurer que si jamais on
rentre dans un mur, on coupe les moteurs très vite. Dans ce code, tout
s'effectue de manière fréquente. En effet, on ne reste jamais bloqué à
attendre que le temps passe. A la place, on avance dans le programme et
test souvent la valeur du chronomètre. Si cette valeur est de 1000 itérations
supérieures à la dernière valeur mesurée, alors cela signifie qu'une seconde
est passée.
Attention, au "if" de la ligne 25 ne faites surtout pas "millis() - temp ==
1000". Cela signifierait que vous voulez vérifier que 1000 millisecondes
EXACTEMENT se sont écoulées, ce qui est très peu probable (vous pourrez
plus probablement mesurer plus ou moins mais rarement exactement).
5.2. Les interruptions
Une interruption est un déclenchement qui arrête l’exécution d’un programme

ou d’un bout de code pour exécuter une autre fonction. C’est typiquement le
cas lorsque l’on programme un chronomètre. Le temps s’écoule jusqu’au
moment où on décide de stopper le chronomètre afin de lire la valeur inscrite
sur l’écran. Une interruption permet ainsi de stopper ou d’effectuer un
programme puis d’en reprendre l’exécution à partir de l’instant où il a été
stoppé. On peut effectuer une interruption par changement d’état d’un port
(interruption matériel) ou périodiquement à l’aide d’un Timer.
5.2.1.Interruption matériel
Le tableau suivant montre les ports susceptibles de produire une interruption

selon le type de carte arduino :
Pour déclencher une interruption, il existe plusieurs solutions :
[Date] 50
 LOW : Passage à état bas du pin

 FALLING : Détection d’un front descendant (passage de l’état haut à
l’état bas)
 RISING : Détection d’un front montant (passage de l’état bas à l’état
haut)
 CHANGE : Changement d’état du pin
Pour créer une interruption on utilise La fonction suivante :
o interrupt : numéro du pin (0 pour le pin 2 et 1 pour le pin 3)

o function : fonction à appeler
o mode : type de déclenchement (LOW // FALLING // RISING //
CHANGE)
Contexte : Nous voulons que notre chronomètre se stoppe lorsque l’on appui
sur un bouton.
Nous allons appeler une fonction « Pause() » lorsque l’utilisateur appuie sur
un bouton branché sur le pin 2.
Ainsi, nous aurons la syntaxe suivante :
Notez l’absence des parenthèses après l’appel de la fonction « Pause ». Vous

pouvez coder par exemple la fonction « Pause() » un peu plus loin dans le
programme.
Lorsque vous utilisez une interruption, tout le programme se met en « pause »

et la fonction appelée dans l’interruption prend le relais. Ainsi, les fonctions
de temps « delay() », « millis() » seront également stoppée. Veillez à bien faire
attention dans vos programmes pour ne pas avoir de mauvaise surprise !
Exemple
[Date] 51
5.2.2.Timer
5.2.2.1. Description
Un Timer est un composant matériel construit sur Arduino Controller

qui fournit une variable temporelle à notre projet de microcontrôleur. Cela
pourrait ressembler à une horloge générale. La minuterie peut être
programmée en utilisant un registre spécial, mais pour que les choses restent
simples. Nous allons d’abord utiliser la bibliothèque de programmateurs
Arduino existante et, plus tard, nous allons nous plonger dans la
programmation de bas niveau proprement dite, dans laquelle nous
programmerons des registres matériels sur le contrôleur Arduino pour
configurer Timer Interrupt dans Arduino Uno.
Arduino Uno comporte trois minuteries: Timer0, Timer1, Timer2 . Ces

minuteries se différencient en termes de résolution. Timer0 et Timer2 ont une
résolution de 8 bits, alors que Timer1 a une résolution de 10 bits. Maintenant,
quelle est une résolution? et tout ce que nous garderons pour l'avenir. Notez
que nous utiliserons le minuteur 1 pour démontrer le potentiel de
minuteur et d’interruption dans Arduino.
5.2.2.2. Exemple: interruption du minuteur dans Arduino Uno (avec

la bibliothèque TimerOne)
Dans cet exemple, nous utiliserons Timer Interrupt pour faire clignoter une
LED et noter combien de fois elle a clignoté. La première étape consiste à
installer des bibliothèques. Ouvrons l' IDE Arduino -> Sketch -> Inclure la
[Date] 52
bibliothèque -> Gérer la bibliothèque -> Recherchez “ TimerOne ” ->

Cliquez sur TimerOne et cliquez sur le bouton Installer . Nous sommes
maintenant prêts à créer un projet.
5.2.2.3. Exemple: interruption du minuteur dans Arduino Uno (sans

bibliothèque)
Dans Arduino, le processeur central est ATmega328 Microcontroller. Ainsi,
Arduino prend en charge trois minuteries (comme indiqué précédemment).
Dans cet exemple, nous utiliserons le temporisateur 1 pour notre
interruption. Il s’agit d’un exercice de base avec clignotement des voyants,
mais au lieu d’utiliser des retards, il déclenche l’interruption du clignotement
du voyant toutes les demi-secondes pour allumer le voyant, puis l’éteindre;
[Date] 53
6. Communication série
6.1. Communication série UART
L'un des protocoles de communication les plus élémentaires de

l'électronique est le protocole série UART (Universal Asynchronous Receive
Transmit). Le protocole UART permet à deux appareils de communiquer l'un
avec l'autre. Le protocole nécessite deux câbles entre les périphériques en
communication; un pour chaque sens de communication. Chaque appareil
possède un module de transmission et de réception indépendant. Ces
modules ne doivent pas nécessairement être synchronisés les uns avec les
autres (c.-à-d. Asynchrones). Lorsqu'un appareil transmet, il envoie des
données sous forme d'une série (c.-à-d. En série) d'impulsions. Chaque
impulsion représente un bit de données. Par conséquent, un octet (8 bits) de
données est envoyé sous forme de huit impulsions sur le fil. Ces impulsions
sont envoyées avec une synchronisation prédéfinie, appelée débit en bauds,
qui doit être comprise par les deux appareils.
6.1.1.Protocole
Bien que l'IDE Arduino ait créé une configuration par défaut, qui sera la même
sur tous les périphériques Arduino, plusieurs paramètres de protocole
peuvent être modifiés en série UART. Il est important que tous les paramètres
[Date] 54
de trame (format d'une communication) correspondent dans les deux

périphériques communicants.
Débit en bauds
Le débit auquel chaque bit de données est envoyé est appelé débit en bauds
. L'un des débits en bauds les plus courants pour UART (l'élément le plus
proche de la valeur par défaut) est de 9 600 bits par seconde (bits / s). Les
autres débits en bauds courants sont 300, 600, 1200, 2400, 4800, 19200,
38400, 57600, 74880 et 115200 bps. Bien que ceux-ci soient courants, vous
pouvez choisir n'importe quel débit que vous puissiez utiliser tant que le
matériel peut le gérer et que les deux appareils sont programmés pour utiliser
le même débit en bauds .
Trame de données
Dans le protocole UART, un octet de données est envoyé dans une trame de
données ou un paquet. Une trame comprend les données ainsi que d'autres
informations permettant de s'assurer que les données sont communiquées
avec précision.
Cadre de données UART
Bit de départ
Chaque trame de données commence par un bit de départ. Cela permet à

l'appareil destinataire de savoir que des données sont sur le point d'être
envoyées. Il y a toujours un bit de début et il est indiqué lorsque la ligne de
données inactive (haute) devient basse.
Bloc de données
Le bloc de données est envoyé immédiatement après le bit de départ. Le plus

souvent, un octet complet de 8 bits est envoyé dans chaque image.
Cependant, vous devez en fait pouvoir envoyer de 5 à 8 bits de données dans
le bloc. Si toutes les données que vous transmettez utilisent seulement 7 bits
[Date] 55
de chaque octet, pourquoi perdre du temps en envoyant un zéro dans chaque

trame de données?
Bit de parité
Le bit de parité est utilisé pour la vérification d'erreur du paquet lors de sa

réception. Il existe deux types de contrôle de parité; pair et impair.
Bits d'arrêt)
Le bit d'arrêt est la fin du paquet. La plupart du temps, un seul bit d’arrêt est
envoyé et il s’agit de la ligne renvoyant l’état haut inactif.
6.1.2.Matériel
Pour que deux appareils puissent communiquer avec le port série UART,
trois fils doivent les connecter. Les deux premiers sont des fils de
communication. La transmission (TX) du premier doit se connecter à la
réception (RX) du second et le TX des secondes au RX du premier. Le troisième
fil est la terre. Les appareils doivent avoir une référence de masse commune,
sinon les impulsions peuvent ne pas aller de 0V à 5V. Cela pourrait
ressembler à -5V à 0V, ce qui ne serait pas enregistré comme impulsions à
l'autre appareil.
Les broches TX et RX d’une carte Arduino sont les broches 0 et 1. Ils sont
étiquetés TX et RX, et ils sont connectés au pont UART-USB de la carte
Arduino. Cela signifie que, lorsque la carte est connectée à l'ordinateur via
USB, l'UART de la carte Arduino est déjà câblée à un port série virtuel de
l'ordinateur (COM3). Cela permet à la carte d’envoyer et de recevoir des
données série avec un terminal série sur l’ordinateur.
[Date] 56
6.1.3.Programmation
6.1.3.1. Initialisation
Pour utiliser le port série UART dans l'IDE Arduino, vous devez initialiser le
module série. La configuration par défaut nécessite uniquement l’appel de la
fonction Serial.begin (). Serial.begin () nécessite que le débit en bauds souhaité
soit placé dans la fonction en tant qu'argument.
6.1.3.2. Transmission
Serial.write ()
C'est la commande de sortie la plus simple. Il envoie un seul octet de

données à la fois. Une valeur unique de 0-255. L'entrée dans la fonction
peut être définie avec une valeur numérique ou avec un caractère entre
guillemets.
Serial.print ()
Cette commande est construite sur la commande Serial.write (). Il est capable
d'envoyer plusieurs octets, l'un après l'autre, pour former des chaînes. Ceci
est très utile pour transmettre des messages (chaînes de caractères). Cette
entrée de cette fonction peut être un tableau d'octets, un tableau de caractères
ou une chaîne.
Serial.println ()
C'est exactement la même chose que la commande Serial.print (), sauf qu'elle
ajoute un nouveau caractère de retour ligne / chariot à la fin de la chaîne
d'octets.
[Date] 57
6.1.3.3. Recevoir
Lorsque nous recevons des données série dans l'IDE Arduino, nous ne lisons
que des données à partir d'un tampon. L’environnement Arduino s’occupe de
saisir chaque octet à la réception et de le placer dans ce tampon logiciel, ce
qui le rend encore plus facile à utiliser. Voici les fonctions que vous pourriez
utiliser lors de la réception de données.
Serial.read ()
Renvoie le premier octet du tampon série. Si aucune donnée n'est

disponible, il retournera -1.
Serial.available ()
Renvoie le nombre d'octets actuellement disponibles dans le tampon série.
Serial.peak ()
Retourne le premier octet dans le tampon série, mais ne le supprime pas. Si

aucune donnée n'est disponible, il retournera -1.
Serial.flush ()
Efface tous les octets du tampon série.
Serial.parseInt ()
Trouve le prochain ensemble d'entiers dans le tampon série et les analyse

ensemble, générant une valeur entière.
Serial.readString()
Lit une chaîne de caractères dans le tampon série.
[Date] 58
Serial.readStringUntil()
Lit une chaîne de caractères dans le tampon série jusqu’à rencontrer un

caractère passé en paramètre de la fonction
Une autre Classe nous sera nécessaire pour l'exploitation du moniteur série
et pour l'envoi de phrases appelées des chaînes de caractères alphabétiques.
C'est la classe String qui veut dire "chaîne" en français. De même que Serial
la classe String englobe des fonctions particulières, utiles aux traitements
des chaînes de caractères.
Par contre pour exploiter la classe string, il nous faut lui affecter un dit
"objet". Plusieurs "objets" peuvent être affectés à une classe. On appelle ça
une instanciation.
Cela se présente de cette manière
Par contre les guillemets sont laissés vides pour accueillir une chaîne de
caractères (phrases) transmise par le moniteur série.
"maPhrase" est notre objet. Vous remarquerez aussi qu'il n'est pas utile de
placer un point entre l'objet et la classe; contrairement à Serial.
Un objet, c'est un peu comme une variable mais pas vraiment. Cet objet
contiendra la donnée à exploiter mais ne sera exploitable que par le biais de
la Classe et de ses fonctions incluses.
Les fonctions de la classe String.
Voici ci-dessous les différentes fonctions de String.
 trim() Supprime les espaces dit des « blancs » au début et à la fin d'une
chaîne de caractères.
 concat() Rassemble (concatène) deux objets String en un seul dans un
nouvel objet String.
 compareTo() Compare deux Objets String.
[Date] 59
 toLowerCase() Retourne en minuscules la chaîne de caractères d'un

objet String.
 toUpperCase() Retourne en majuscules la chaîne de caractères d'un
objet String.
 setCharAt() Modifie un caractère d'un objet String.
 charAt() Retourne à un caractère précis de l'objet String.
 endsWith() Contrôle qu'un objet String se termine ou pas avec des
caractères d'un autre objet String.
 equals() Contrôle la similarité de deux objets String. En prenant en
compte le format.
 equalsIgnoreCase() Compare la similarité de deux objets String sans
prendre en compte le format.
 getBytes() Pointe dans un tableau interne les caractères utilisés pour
stocker les caractères d'un objet String.
 indexOf() Localise un caractère ou un String dans un autre objet String
 lastIndexOf() Localise un caractère ou un String dans un autre objet
String
 length() Renvoie la longueur de la chaîne d'un objet String, en nombre
de caractères
 replace() La fonction replace() de la classe String pour permet de
remplacer toutes les instances d'un caractère donné par un autre
caractère.
 startsWith() Teste si un objet String commence avec les caractères d'un
autre objet String.
 substring() Extrait une sous-chaîne d'un objet String.
 toCharArray() Copie les caractères d'un objet String dans un tableau
de caractères (char).
Les données peuvent être reçu ou transmis du moniteur série
6.2. Qu'est-ce que le moniteur série
6.2.1.Introduction.
Pour commencer il se nomme "moniteur série" car il utilise la

communication dit "série" entre votre "PC" et votre carte Arduino qui sont
connectés via leurs ports "USB". Tout d’abord, il faut dire que le moniteur
série est un outil indispensable pour les tests de programmes. Il est utile
pour avoir un retour de données et ainsi nous permet de déboguer les
[Date] 60
dysfonctionnements de nos programmes par des affichages séquencés des

données utiles au traitement du bogue.
6.2.2.Présentation
Il est représenté par une loupe et se trouve dans la barre d'outils en haut à
droite du compilateur.
Nous voyons apparaître une fenêtre.
Commençons par examiner plus en détail cette fenêtre dans laquelle

apparaissent plusieurs commandes et deux zones blanches d'exploitation.
 Premièrement La grande zone au centre est la zone d'affichage des

données reçues par le moniteur.
 Deuxièmement La petite zone rectangulaire, en haut est une zone
de saisie et bien-sûr le bouton Envoyer qui se trouve à sa droite
permet la commande d'envoi des données saisies. On peut à l'aide du
moniteur série envoyer des données vers l'Arduino qui s'occupera de
les traiter grâce à la commande spécifique.
Troisièmement La case cochée "Défilement automatique" permet d’arrêter

le défilement des données retournées par l'Arduino si on la décoche.
[Date] 61
Quatrièmement Le bouton de gauche en bas permet le réglage du mode de

défilement des informations via une liste déroulante de choix.
Finalement Le bouton de droite en bas affiche une liste déroulante de

choix qui va nous permettre de choisir la vitesse de transmission de notre
moniteur série. Voyez comme les choix sont multiples et en unité bauds.
Ensuite Une fois lancé, le moniteur doit être configuré. On doit lui attribuer
un débit de traitement, en bauds, pour qu'il soit synchronisé à la même
vitesse que l'Arduino.
6.2.3.Synchronisation
Avant toute chose le moniteur série et la carte Arduino ont besoin d’être
renseigné et de connaître la vitesse à laquelle ils vont travailler si les deux
périphériques n'ont pas le même débit (vitesse) ils ne se comprendront
pas. Il faut donc choisir la même vitesse que celle configuré dans le
programme arduino. Tout ceci est dû à une horloge qui synchronise et fixe
une cadence de traitement et d'envoi des données. C'est la raison pour
laquelle Les valeurs doivent être identiques.
Imaginons par exemples une chaîne de production de deux machines "A et

B" qui emballent dans des cartons un produit X. La machine "A" met le
produit X dans les cartons et la machine B ferme le carton. La machine "A"
met 1 produit par minute dans un carton et la machine "B" ferme 1 carton
par minute. Jusque là, pas de problème, mais si j'augmente la cadence de
la machine "A" à 2 produits par minute, Comme on pouvait s'y attendre il
va se produire une saturation devant la machine "B" et par conséquent les
cartons se retrouveront coincés, tomberont (être ignorés) et ne serons jamais
fermés (lus). Pour notre synchronisation, c'est à peu près la même chose. Les
deux périphériques doivent travailler à la même vitesse.
6.2.4.Configuration du moniteur série (IDE).
D'abord commençons par le moniteur série qui est plus directement

accessible. C'est à nous de choisir et de définir le débit en bauds que l'on
souhaite utiliser, donc il suffit donc de le sélectionner dans la liste
déroulante qui se trouve en bas à droite du moniteur. A partir de là, nous
[Date] 62
avons configuré le débit de traitement du moniteur qui est en soit celle du

"PC".
Finalement notre moniteur est prêt à être utilisé ! Il ne reste donc plus
qu'à créer le programme qui lui envoie des données à afficher.
6.2.5.Recevoir des données au moniteur série.
6.2.6.Envoyer des données depuis le moniteur.
Le moniteur série ne sert pas seulement à recevoir des données, il peut

également en envoyer. C'est pour cela que nous avons un bouton de
commande "envoyer" avec une zone de saisie de données.
Exemple : Ecrivons un programme qui renvoie au moniteur série ce qu’il

reçoit de ce dernier
[Date] 63
7. Grandeurs analogiques
Faisons un petit rappel sur ce que sont les signaux analogiques. D’abord,
jusqu’à présent nous n’avons fait qu’utiliser des grandeurs numériques
binaires. Autrement dit, nous n’avons utilisé que des états logiques HAUT et
BAS. Ces deux niveaux correspondent respectivement aux tensions de 5V et
0V. Cependant, une valeur analogique ne se contentera pas d’être exprimée
par 0 ou 1. Elle peut prendre une infinité de valeurs dans un intervalle donné.
Dans notre cas, par exemple, la grandeur analogique pourra varier aisément
de 0 à 5V en passant par 1.45V, 2V, 4.99V, etc. Voici un exemple de signal
analogique, le très connu signal sinusoïdal :
Si on essaye de mettre ce signal (ce que je vous déconseille de faire) sur une
entrée numérique de l’Arduino et qu’on lit les valeurs avec digitalRead(), on
ne lira que 0 ou 1. Les broches numériques de l’Arduino étant incapables de
lire les valeurs d’un signal analogique.
7.1. Entrées analogiques
7.1.1. Les convertisseurs analogiques –> numérique ou CAN
C’est un dispositif qui va convertir des grandeurs analogiques en

grandeurs numériques. La valeur numérique obtenue sera proportionnelle à
la valeur analogique fournie en entrée, bien évidemment. Arduino dispose d’un
tel dispositif intégré dans son cœur : le micro-contrôleur. Ce convertisseur est un
convertisseur "à approximations successives".
[Date] 64
7.1.2.Lire la tension sur une broche analogique
Un truc très sympa avec Arduino, c’est que c’est facile à prendre en main. Et
ça se voit une fois de plus avec l’utilisation des convertisseurs numérique ->
analogique ! En effet, vous n’avez qu’une seule nouvelle fonction à retenir :
analogRead() !
analogRead(pin)
Cette fonction va nous permettre de lire la valeur lue sur une entrée
analogique de l’Arduino. Elle prend un argument et retourne la valeur lue :
 L’argument est le numéro de l’entrée analogique à lire (explication ci-

dessous)
 La valeur retournée (un int) sera le résultat de la conversion analogique-
numérique
Sur une carte Arduino Uno, on retrouve 6 CAN. Ils se trouvent tous du même
côté de la carte, là où est écrit "Analog IN" :
Ces 6 entrées analogiques sont numérotées, tout comme les entrées/sorties

logiques. Par exemple, pour aller lire la valeur en sortie d’un capteur branché
sur le convertisseur de la broche analogique numéro 3, on fera :
valeur = analogRead(3);.
[Date] 65
7.1.3.Convertir la valeur lue
Suite à la lecture, on a une valeur retournée par la fonction comprise entre 0

et 1023, mais ça ne nous donne pas vraiment une tension ça ! Il va être temps
de faire un peu de code (et de math) pour convertir cette valeur…
Nous avons une valeur entre 0 et 1023. Cette valeur est l’image de la tension
mesurée, elle-même comprise entre 0V et +5V. nous pouvons donc déterminer
la tension correspondante avec un simple produit en croix
Exemple : La mesure nous retourne une valeur de 458.
1023<------>5V
458<------> ?
 Avec un produit en croix on obtient : (458×5)/1023=2.235V ;
Exemple : Le potentiomètre
Le potentiomètre est un composant très fréquemment employé en

électronique. On le retrouve aussi sous le nom de résistance variable. Comme
ce dernier nom l’indique si bien, un potentiomètre nous permet entre autres
de réaliser une résistance variable. Il est souvent utilisé comme pont diviseur
de tension.
Symbole du potentiomètre
Le potentiomètre a trois broches. Deux servent à borner les tensions

maximum (A) et minimum (B) que l’on peut obtenir à ses bornes, et la
troisième est reliée à un curseur mobile qui donne la tension variable obtenue
entre les bornes précédemment fixées. Ainsi, il peut servir de "diviseur de
tension réglable". En effet, lorsque vous déplacez le curseur, en interne cela
équivaut à modifier le point milieu. En termes électroniques, vous pouvez
imaginer avoir deux résistances en série (R1 et R2 pour être original). Lorsque
vous déplacez votre curseur vers la borne basse, R1 augmente alors que R2
diminue et lorsque vous déplacez votre curseur vers la borne haute, R2
augmente alors que R1 diminue. Voici un tableau montrant quelques cas de
figure de manière schématique :
[Date] 66
Attention, il existe des potentiomètres linéaires (la valeur de la tension évolue

de manière proportionnelle au déplacement du curseur), mais aussi des
potentiomètres logarithmique/anti-logarithmique (la valeur de la tension
évolue de manière logarithmique ou anti-logarithmique par rapport à la
position du curseur). Choisissez-en donc un qui est linéaire si vous souhaitez
avoir une proportionnalité.
Une fois le raccordement fait, nous allons faire un petit programme pour
tester cela. Ce programme va simplement effectuer une mesure de la tension
obtenue sur le potentiomètre, puis envoyer la valeur lue sur la liaison série ().
Dans l’ordre, voici les choses à faire :
 Déclarer la broche analogique utilisée (pour faire du code propre)

 Mesurer la valeur
 L’afficher !
[Date] 67
Vous venez de créer votre premier voltmètre !
7.2. Sorties analogiques
7.2.1.Convertisseur Numérique->Analogique : PWM ou MLI
La carte arduino fournit une fonctionnalité spéciale appelée PWM. La PWM

veut dire : Pulse Width Modulation et en français cela donne Modulation à
Largeur d’Impulsion (MLI). La PWM est en fait un signal numérique qui, à une
fréquence donnée, a un rapport cyclique qui change.
La fréquence et le rapport cyclique
La fréquence d’un signal périodique correspond au nombre de fois que la

période se répète en UNE seconde. On la mesure en Hertz, noté Hz. Prenons
l’exemple d’un signal logique qui émet un 1, puis un 0, puis un 1, puis un 0,
etc. autrement dit un signal créneaux, on va mesurer sa période (en temps)
entre le début du niveau 1 et la fin du niveau 0 :
[Date] 68
Représentation d'une période
Ensuite, lorsque l’on aura mesuré cette période, on va pouvoir calculer sa

fréquence (le nombre de périodes en une seconde) grâce à la formule suivante :
F=1TF = \frac 1 TF=T1
Avec :
 FFF : fréquence du signal en Hertz (Hz)

 TTT : temps de la période en seconde (s)
Le rapport cyclique, un mot bien particulier pour désigner le fait que le niveau
logique 1 peut ne pas durer le même temps que le niveau logique 0. C’est avec
ça que tout repose le principe de la PWM. C’est-à-dire que la PWM est un
signal de fréquence fixe qui a un rapport cyclique qui varie avec le temps
suivant "les ordres qu’elle reçoit" (on reviendra dans un petit moment sur ces
mots).
Le rapport cyclique est mesuré en pourcentage (%). Plus le pourcentage est

élevé, plus le niveau logique 1 est présent dans la période et moins le niveau
logique 0 l’est. Et inversement. Le rapport cyclique du signal est donc le
pourcentage de temps de la période durant lequel le signal est au niveau
logique 1. En somme, cette image extraite de la documentation officielle
d’Arduino nous montre quelques exemples d’un signal avec des rapports
cycliques différents :
[Date] 69
Des signaux aux rapports cycliques différents
Après avoir généré ce signal, il va nous falloir le transformer en signal

analogique. Et oui ! Pour l’instant ce signal est encore constitué d’états
logiques, on va donc devoir le transformer en extrayant sa valeur moyenne…
7.2.2.La PWM de l’Arduino
Sur votre carte Arduino UNO, vous devriez disposer de 6 broches qui sont
compatibles avec la génération d’une PWM. Elles sont repérées par le symbole
tilde ~ . Voici les broches générant une PWM : 3, 5, 6, 9, 10 et 11. Sa fréquence,
est fixe, elle ne varie pas au cours du temps. Pour votre carte Arduino UNO
elle est d’environ 490Hz.
L’Arduino intègre une fonction toute prête pour utiliser la PWM
analogWrite(). Elle prend deux arguments :
 Le premier est le numéro de la broche où l’on veut générer la PWM

 Le second argument représente la valeur du rapport cyclique à
appliquer. Malheureusement on n’exprime pas cette valeur en
pourcentage, mais avec un nombre entier compris entre 0 et 255
[Date] 70
Le rapport cyclique s’exprime de 0 à 100 % en temps normal. Cependant, dans

cette fonction il s’exprimera de 0 à 255 (sur 8 bits). Ainsi, pour un rapport
cyclique de 0% nous enverrons la valeur 0, pour un rapport de 50% on enverra
127 et pour 100% ce sera 255. Les autres valeurs sont bien entendu
considérées de manière proportionnelle entre les deux. Il vous faut faire un
petit calcul pour savoir quel est le pourcentage du rapport cyclique plutôt que
l’argument passé dans la fonction.
Voilà un petit exemple de code illustrant tout ça :
Travaux Pratiques : Variation de luminosité d’une led

En combinant les notions sur les entrées et les sortie analogiques,
réaliser et programmer un montage constitué d’une led, connectée au port 10
de l’arduino, dont vous ferez varier l’intensité à l’aide d’un potentiomètre
connecté sur l’entrée analogique A2 de l’arduino
[Date] 71
Table des matières

Introduction ............................................................................................................................................ 1
1. Présentation de l’arduino ............................................................................................................... 1
1.1. Généralités .............................................................................................................................. 1
1.1.1. Le but et l'utilité .............................................................................................................. 1
1.1.2. Applications..................................................................................................................... 2
1.2. Les outils Arduino.................................................................................................................... 2
1.2.1. Le matériel ...................................................................................................................... 2
1.2.2. Le logiciel......................................................................................................................... 3
2. Le langage Arduino ....................................................................................................................... 12
2.1. La syntaxe du langage ........................................................................................................... 12
2.1.1. Le code minimal ............................................................................................................ 12
2.1.2. La fonction .................................................................................................................... 12
2.1.3. Les instructions ............................................................................................................. 13
2.1.4. Les accolades................................................................................................................. 13
2.1.5. Les commentaires ......................................................................................................... 13
2.1.6.Les accents ........................................................................................................................... 14
2.2. Les données (Variables et constantes)................................................................................. 14
2.2.1. Type de variables .......................................................................................................... 14
2.2.2. Déclarer une variable .................................................................................................... 17
2.2.3. La portée d’une variable ............................................................................................... 17
2.2.4. Les constantes ............................................................................................................... 19
2.3. Les opérateurs....................................................................................................................... 20
2.3.1. Opérateurs arithmétiques ............................................................................................ 20
2.3.2. Comparaison d’opérateurs ........................................................................................... 21
2.3.3. Opérateurs booléens .................................................................................................... 22
2.3.4. Opérateurs binaires ...................................................................................................... 22
2.3.5. Compositions d’opérateurs........................................................................................... 23
2.4. Conditions ............................................................................................................................. 24
2.4.1. If (Conditions SI) ............................................................................................................ 25
2.4.2. If… else (Conditions SI… SINON).................................................................................... 26
2.4.3. Else if (Conditions SI… SINON SI… SINON (imbriqué)) .................................................. 27
2.4.4. Conditions au cas par cas (switch case) ........................................................................ 29
2.5. Les boucles ? ................................................................................................................... 30
[Date] 72
2.5.1. La boucle while.............................................................................................................. 31

2.5.2. La boucle do…while....................................................................................................... 32
2.5.3. La boucle for.................................................................................................................. 32
2.5.4. Les boucles imbriquées ................................................................................................. 33
2.5.5. La boucle infinie ............................................................................................................ 33
2.6. Les fonctions ......................................................................................................................... 34
2.6.1. Fabriquer une fonction ................................................................................................. 35
2.6.2. Type ............................................................................................................................... 36
3. Gestion des Ports .......................................................................................................................... 38
3.1. Sorties numériques ............................................................................................................... 38
3.2. Les entrées numériques ........................................................................................................ 39
4. Les bibliothèques ......................................................................................................................... 41
4.1. Description. ........................................................................................................................... 41
4.2. Installer une bibliothèque. .................................................................................................... 41
4.3. Faire appel à une bibliothèque. ............................................................................................ 43
5. Gestion du temps et Interruptions ............................................................................................... 45
5.1. Introduction du temps .......................................................................................................... 45
5.1.1. La fonction delay() ;....................................................................................................... 45
Travaux Pratiques : Réaliser un chenillard ............................................................................................ 46
5.1.2. Fonction millis()............................................................................................................. 47
5.2. Les interruptions ................................................................................................................... 50
5.2.1. Interruption matériel .................................................................................................... 50
5.2.2. Timer ............................................................................................................................. 52
6. Communication série .................................................................................................................... 54
6.1. Communication série UART .................................................................................................. 54
6.1.1. Protocole ....................................................................................................................... 54
Débit en bauds ........................................................................................................................ 55
Trame de données................................................................................................................. 55
6.1.2. Matériel ......................................................................................................................... 56
6.1.3. Programmation ............................................................................................................. 57
Les fonctions de la classe String. ................................................................................................... 59
6.2. Qu'est-ce que le moniteur série ........................................................................................... 60
6.2.1. Introduction. ................................................................................................................. 60
6.2.2. Présentation .................................................................................................................. 61
6.2.3. Synchronisation............................................................................................................. 62
6.2.4. Configuration du moniteur série (IDE). ......................................................................... 62
[Date] 73
6.2.5. Recevoir des données au moniteur série...................................................................... 63

6.2.6. Envoyer des données depuis le moniteur..................................................................... 63
7. Grandeurs analogiques ................................................................................................................. 64
7.1. Entrées analogiques .............................................................................................................. 64
7.1.1. Les convertisseurs analogiques –> numérique ou CAN ................................................ 64
7.1.2. Lire la tension sur une broche analogique .................................................................... 65
7.1.3. Convertir la valeur lue ................................................................................................... 66
Exemple : Le potentiomètre ......................................................................................................... 66
7.2. Sorties analogiques ............................................................................................................... 68
7.2.1. Convertisseur Numérique->Analogique : PWM ou MLI................................................ 68
7.2.2. La PWM de l’Arduino .................................................................................................... 70
Travaux Pratiques : Variation de luminosité d’une led ......................................................................... 71
[Date] 74

Langue

Arduino Juste

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Arduino Juste

Transféré par

Droits d'auteur :

Formats disponibles

Initiation à

Gonzalv Christophe HOUNSOKOU

Le langage Arduino se distingue des langages utilisés dans l’industrie

1.1.1. Le but et l'utilité

Le système Arduino, nous donne la possibilité d'allier les performances

Le système Arduino nous permet de réaliser un grand nombre de

 contrôler les appareils domestiques

1.2. Les outils Arduino

À présent, rapprochons-nous de « l'utilisation » du système Arduino et

Il s'agit d'une carte électronique basée autour d'un microcontrôleur

C’est celle-ci que nous utiliserons tout au long de ce cours.

 La carte Arduino Nano

 La carte Arduino Pro-mini

Le logiciel va nous permettre de programmer la carte Arduino. Il nous offre

 Brève présentation de quelques boutons de l’interface

A – Utilisé pour vérifier s’il y a une erreur de compilation. Ce bouton permet

E – Utilisé pour enregistrer votre croquis.

 Comment programmer une carte arduino ?

a. Connexion à la carte Arduino et lancement de l’IDE Arduino

Connecter la carte Arduino à votre ordinateur à l’aide du câble USB.

La carte sera rapidement reconnue. Lancez dès à présent l’IDE Arduino !

Pour commencer et tester notre carte Arduino, on va ouvrir un projet

Le projet est maintenant chargé ! Il est presque prêt à être transféré à la

c. Sélection du type de carte, de la vitesse et du port COM

On va passer maintenant à la configuration de l’IDE Arduino pour votre

Pour l’Arduino UNO, optez pour les choix suivants :

 Carte Arduino/Genuino UNO

Et repérez le port COM de votre Arduino sous “Ports (COM et LPT)” :

d. Chargez le programme dans l’Arduino !

Une fois que tout est configuré, on va pouvoir compiler le programme et le

Pour pouvoir programmer notre carte, il nous faut trois choses :

2.1. La syntaxe du langage

La syntaxe d'un langage de programmation est l'ensemble des règles

2.1.1.Le code minimal

C'est donc dans la fonction loop() où l'on va écrire le contenu du programme.

2.1.5. Les commentaires

Ligne ou paragraphe sur plusieurs lignes :

Il est formellement interdit de mettre des accents en programmation. Sauf

2.2. Les données (Variables et constantes)

Le compilateur de l’IDE Arduino compile par défaut du code écrit en C et en

Le mot-clé “void” est uniquement utilisé pour déclarer des fonctions. La

Un “boolean” est un booléen. Il s’agit d’une donnée ne pouvant prendre que

La donnée unsigned char se comporte exactement comme une variable char,

Le type de données float permet de stocker un nombre à virgule flottante.

NB : le séparateur entre la partie entière et la partie décimale est ‘’.’’ et non

Sur Arduino UNO et autres cartes munies de processeur ATMEGA, une

2.2.2. Déclarer une variable

2.2.3. La portée d’une variable

2.2.3.1. Les variables locales

trouvent à l’intérieur de cette fonction ou d’un bloc de code. Voici un exemple

2.2.3.2. Les variables en tant que paramètre d’une fonction

2.2.3.3. Les variables globales

Les variables globales sont définies en dehors de toutes les fonctions,

pour toute l’utilisation de votre programme après sa déclaration, peu importe

Les variables globales

2.2.4. Les constantes

Les constantes sont des valeurs qui ne changeront pas pendant

Il existe différents moyens de déclarer des valeurs constantes :

2.2.4.1. Déclaration avec le mot-clé const

Une déclaration de ce type se définit par le mot-clé const, par le type de

2.2.4.2. Déclaration avec #define

En fait, avant la compilation, la macro #define va remplacer toutes les pi par

2.3. Les opérateurs