Arduino Crash Course

AIAC AEROLEC CLUB
Support de Cours
Arduino Crash Course
Formateur
Ali Ben Taout
Année Académique
2023/2024
TABLE DE MATIÈRES TABLE DE MATIÈRES
Table de Matières
Résumé 3
Introduction 4
1 Arduino.. C’est d’abord une carte électronique ! 6

1.1 Micro-controleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Arduino UNO, C’est Quoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 ATMega328P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.4 Alimentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5 La connectique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.6 Pourquoi Choisir Arduino ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 Hardware - Matériel 14
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.1 Breadboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.2 Jumper Wires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.3 Résistances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2 Capteurs: Se renseigner sur le monde extérieur . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.1 Capteurs Analogiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2.2 Capteurs Numériques (Codeurs) . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3 Actionneurs: Agir sur le monde extérieur . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.1 LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.2 Moteurs à Courant Continu MCC . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.3.3 Servo-moteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.3.4 Moteurs Pas-à-pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.3.5 Moteur Brushless . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.4 Modules - Protocoles de Communication . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.4.1 UART . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.4.2 SPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.4.3 I2C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.4.4 Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.5 Do’s and Don’ts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.5.1 Do’s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.5.2 Don’ts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3 Mais aussi un IDE et un langage de programmation ! 34

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2 Arduino IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.3 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4 Lasse9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.5 Détails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.5.1 Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.5.2 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.5.3 Fonctions de Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.5.4 La bibliothèque Serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.5.5 Structures de controle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.5.6 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
AIAC AEROLEC CLUB 1 sur 61

TABLE DE MATIÈRES TABLE DE MATIÈRES
4 Pratique : Getting your hands dirty ! 48

4.1 Cas 1: Joystick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.1.1 Ingrédients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.1.2 Circuit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.1.3 Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.2 Cas 2: IR + LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.2.1 Ingrédients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.2.2 Circuit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.2.3 Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.3 Cas 3: Ultra-son . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.3.1 Ingrédients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.3.2 Circuit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.3.3 Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.4 Cas 4: MCC + Servo-moteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.4.1 Ingrédients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.4.2 Circuit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.4.3 Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.5 Cas 5: Gyroscope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.5.1 Ingrédients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.5.2 Circuit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.5.3 Sketch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5 Ressources 61
5.1 Théorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.2 Pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

RESUME RESUME
Résumé
Bienvenue au club AIAC AEROLEC CLUB ! Nous sommes ravis de vous
accueillir dans le monde passionnant de la robotique. Dans ce document,
nous explorerons les bases de la robotique en utilisant la plateforme Ar-
duino. Allez, c’est parti !
Abstract
Welcome to AIAC AEROLEC CLUB ! We are thrilled to welcome you

to the exciting world of robotics. In this document, we will explore the
basics of robotics using the Arduino platform. Let’s get started!
Mots Clés:
Arduino - Capteur - Moteur - Courant - Tension - Carte Electronique

INTRODUCTION INTRODUCTION
Introduction
L’électronique interactive est une discipline en constante évolution qui a
le pouvoir de transformer des idées en réalité, qu’il s’agisse de contrôler
l’éclairage d’une pièce, de créer des dispositifs automatisés ou d’inventer
des gadgets innovants. Arduino, un projet révolutionnaire, s’est imposé
comme le fer de lance de cette révolution, en rendant accessible à tous la
création d’applications électroniques et informatiques.
Arduino est né d’une collaboration entre Massimo Banzi, David Cuar-
tielles, Tom Igoe, Gianluca Martino, David Mellis et Nicholas
Zambetti, qui ont partagé une vision commune : simplifier l’accès à
l’électronique et à la programmation. Pour concrétiser cette vision, ils
ont créé une petite carte électronique programmable, associée à un logi-
ciel multiplateforme convivial. Arduino a rapidement gagné en popu-
larité grâce à son accessibilité et à sa polyvalence..
Dans ce monde en constante mutation, il est essentiel de commencer par

comprendre certains termes courants. Une ”carte électronique” est un
support, souvent en epoxy ou en fibre de verre, qui comporte des pistes
électriques disposées sur une ou plusieurs couches. Ces pistes permet-
tent de connecter les composants électroniques entre eux et de créer des
systèmes électroniques fonctionnels. En d’autres termes, c’est le cœur de
votre projet Arduino..
L’une des forces d’Arduino réside dans sa simplicité. Que vous soyez
un débutant complet en électronique ou un professionnel chevronné, vous
pouvez commencer à créer dès aujourd’hui. Arduino vous offre la liberté
d’explorer et d’innover sans être limité par des barrières techniques. C’est
une plateforme où l’imagination est la seule limite..
Arduino ne se limite pas à des projets amateurs. Ses applications sont

vastes et variées, de la domotique à la robotique, en passant par l’Internet
des objets (IoT) et la création d’installations artistiques interactives. Que

INTRODUCTION INTRODUCTION
vous souhaitiez automatiser votre maison, surveiller des paramètres en-

vironnementaux, ou réaliser des projets artistiques, Arduino est là pour
vous..
Cette formation vous guidera à travers tous les aspects d’Arduino, du

matériel au logiciel, en passant par la réalisation de projets concrets.
Vous acquerrez les compétences nécessaires pour créer vos propres dis-
positifs interactifs, programmer des microcontrôleurs et transformer vos
idées en réalité électronique.

1 ARDUINO.. C’EST D’ABORD UNE CARTE ÉLECTRONIQUE !
Chapitre 1
Arduino.. C’est d’abord
une carte électronique !
Résumé. Dans ce chapitre, nous découvrons la célèbre carte Arduino

et son anatomie.

1.1 Micro-controleurs 1 ARDUINO.. C’EST D’ABORD UNE CARTE ÉLECTRONIQUE !
1.1 Micro-controleurs
Un micro-controlleur (µC) est principalement composé:
- d’une unité de calcul
- de mémoire
- de modules d’entrée/sortie
Il existe plusieurs µC ATMega, dont l’ATMega328.

1.2 Arduino UNO, C’est Quoi1 ? ARDUINO.. C’EST D’ABORD UNE CARTE ÉLECTRONIQUE !
1.2 Arduino UNO, C’est Quoi ?

Une carte Arduino UNO est une petite (5,33 x 6,85 cm) carte électronique
équipée d’un micro-contrôleur. Le micro-contrôleur permet, à partir
d’événements détectés par des capteurs, de programmer et commander
des actionneurs ; la carte Arduino est donc une interface programmable.
Il existe deux modèles d’Arduino Uno: l’un avec un microcontrôleur de

grande taille, et un autre avec un microcontrôleur dit SMD (SMD: Sur-
face Mounted Device, soit composants montés en surface, en opposition
aux composants qui traversent la carte électronique et qui sont soudés
du côté opposé). D’un point de vue utilisation, il n’y a pas de différence
entre les deux types de microcontrôleurs.
Les couleurs de l’Arduino peuvent varier du bleu au bleu-vert, en fonction

des modèles et années de production.

1.3 ATMega328P 1 ARDUINO.. C’EST D’ABORD UNE CARTE ÉLECTRONIQUE !
1.3 ATMega328P
C’est le cerveau de notre carte. Il contient:
• Un processeur pour traiter les données et faire les calculs:
• Un espace de stockage des données:
• Des ports pour communiquer (les broches):
Il va recevoir le programme que nous allons créer et va le stocker dans sa

mémoire avant de l’exécuter. Grâce à ce programme, il va savoir faire des
choses, qui peuvent être : faire clignoter une LED, afficher des caractères
sur un écran, mettre en route ou arrêter un moteur. . .
1.4 Alimentation
Pour fonctionner, une carte Arduino a besoin d’une alimentation. Le mi-
crocontrôleur fonctionnant sous 5V, la carte peut être alimentée directe-
ment en 5V par le port USB ou bien par une alimentation externe

1.5 La connectique 1 ARDUINO.. C’EST D’ABORD UNE CARTE ÉLECTRONIQUE !
qui est comprise entre 7V et 12V. Un régulateur se charge ensuite de

réduire la tension à 5V pour le bon fonctionnement de la carte.
1.5 La connectique
A part une LED sur la broche 13, la carte Arduino ne possède pas de
composants (résistances, diodes, moteurs...) qui peuvent être utilisés
pour un programme. Il est nécessaire de les rajouter. Mais pour cela, il
faut les connecter à la carte. C’est là qu’interviennent les connecteurs,
aussi appelés broches (pins, en anglais).
- 0 à 13 Entrées/sorties numériques
- A0 à A5 Entrées/sorties analogiques
- GND Terre ou masse (0V)
- Alimentation 5V

1.6 Pourquoi Choisir Arduino1 ? ARDUINO.. C’EST D’ABORD UNE CARTE ÉLECTRONIQUE !
- Alimentation 3.3V
- Vin Alimentation non stabilisée (= le même voltage que celui à l’entrée

de la carte)
1.6 Pourquoi Choisir Arduino ?

- Facilité d’utilisation : Arduino est réputé pour sa simplicité d’utilisation,
même pour les débutants en électronique et en programmation. Les
cartes Arduino sont dotées d’une interface conviviale et sont accom-
pagnées d’un environnement de développement intégré (IDE) facile à
prendre en main.

1.6 Pourquoi Choisir Arduino1 ? ARDUINO.. C’EST D’ABORD UNE CARTE ÉLECTRONIQUE !
- Open Source : Arduino est un projet open source, ce qui signifie

que son matériel et son logiciel sont disponibles gratuitement. Cela en-
courage le partage d’informations, la collaboration et permet aux utilisa-
teurs de modifier et d’adapter le matériel et le logiciel selon leurs besoins.
- Large communauté : Arduino dispose d’une communauté mondi-

ale active composée de passionnés, de développeurs et de makers. Cette
communauté offre un support en ligne, des forums de discussion, des
tutoriels et des exemples de code, facilitant ainsi l’apprentissage et la
résolution de problèmes.
- Abordable : Les cartes Arduino et les composants associés sont

généralement abordables, ce qui en fait une option économique pour les
projets DIY (Do It Yourself) et les prototypes.
- Compatibilité matérielle et logicielle : Arduino est compatible

avec une variété de capteurs, de modules et de composants électroniques.
De plus, il est compatible avec plusieurs systèmes d’exploitation, ce qui
offre une flexibilité pour les utilisateurs travaillant sur différentes plates-
formes.
- Ressources pédagogiques abondantes : En raison de sa popu-

larité, il existe de nombreuses ressources éducatives, tutoriels et livres
consacrés à Arduino, facilitant ainsi l’apprentissage et le développement
de compétences.

2 HARDWARE - MATÉRIEL
Chapitre 2
Hardware - Matériel
Résumé. Dans ce chapitre nous explorerons les éléments de base

qui constituent le cœur de l’écosystème Arduino: Les capteurs et les
actionneurs

2.1 Introduction 2 HARDWARE - MATÉRIEL
2.1 Introduction
2.1.1 Breadboard
Une platine d’expérimentation (appelée breadboard) permet de réaliser

des prototypes de montages électroniques sans soudure et donc de pouvoir
réutiliser les composants.
Tous les connecteurs dans une rangée de 5 sont reliés entre eux. Donc si
on branche deux éléments dans un groupe de cinq connecteurs, ils seront
reliés entre eux. Il en est de même des alignements de connecteurs rouges
(pour l’alimentation) et bleus (pour la terre).
Ainsi, les liens peuvent être schématisés ainsi:

2.1 Introduction 2 HARDWARE - MATÉRIEL
2.1.2 Jumper Wires
Ces fils flexibles et conducteurs sont utilisés pour établir des connexions
entre les composants facilitant ainsi la création de circuits.
Il existe des fils Female-Female, Male-Female, Male-Male.
2.1.3 Résistances
Utilisées pour limiter le courant dans un circuit, les résistances sont

fréquemment employées dans des configurations telles que la commande
de LEDs.

2.2 Capteurs: Se renseigner sur le monde extérieur 2 HARDWARE - MATÉRIEL
2.2 Capteurs: Se renseigner sur le monde

extérieur
Un capteur est un dispositif capable de transformer une grandeur physique
en une autre grandeur physique manipulable (généralement électrique).
Les capteurs sont des composants matériels, qui une fois correctement
connectés à votre carte Arduino, peuvent fournir des informations sur le
monde extérieur.

Il est ainsi possible de capter la plupart des phénomènes physiques comme

le vent, la pression, la température, la lumière, la distance, etc.
On peut classifier l’ensemble des capteurs en deux familles suivant le

type d’informations qu’ils renvoient.
2.2.1 Capteurs Analogiques
Un capteur analogique fournit un signal électrique analogique qui est

proportionnel à la grandeur physique mesurée.
La sortie peut prendre une infinité de valeurs continues. Le signal

des capteurs analogiques peut être du type : sortie tension ou sortie

courant.
Pour qu’un microcontrôleur ou un microprocesseur puisse utiliser l’information

d’un capteur analogique, il faudra préalablement que le signal soit numérisé
par un composant qu’on appelle un CAN : Convertisseur Analogique
Numérique.
- Capteur de lumière à photorésistance LDR:
LDR utilise une photorésistance pour détecter les niveaux de lumière

dans une pièce ou dans l’environnement extérieur.
Le module a une sortie numérique qui change d’état en fonction de la

lumière détectée et une sortie analogique qui fournit une tension propor-
tionnelle à la lumière détectée.Le module est facile à installer et à utiliser
avec des microcontrôleurs comme Arduino, Raspberry Pi, et d’autres
cartes de développement.Il est largement utilisé dans les projets DIY pour
contrôler la luminosité d’une LED, la lumière ambiante dans une pièce,
ou pour mesurer la luminosité d’un écran ou d’un projecteur.La sensi-
bilité du module peut être ajustée pour s’adapter aux besoins spécifiques
de l’utilisateur.
- Capteur de Température:
Le capteur de température LM35 est un capteur analogique de température

fabriqué par Texas Instruments.

Le capteur de température LM35 est capable de mesurer des

températures allant de -55°C à +150°C dans sa version la plus
précise et avec le montage adéquat
La sortie analogique du capteur est proportionnelle à la température.

Il suffit de mesurer la tension en sortie du capteur pour en déduire la
température. Chaque degré Celsius correspond à une tension de +10mV.
- Capteur d’humidité du sol: sert à mesurer l’humidité du sol.
Lorsque le sol est sec, la tension de sortie est plus élevée. Cela
fonctionne selon deux modes : Le mode numérique qui détecte
simplement la présence d’eau et un signal numérique haut (1) et un
mode analogique qui est plus précis.
Les applications de ce capteur regroupent les systèmes d’arrosage au-

tomatique et plus encore. L’un des inconvénients de l’utilisation de ce
capteur est que sa surface se corrode facilement.

2.2.2 Capteurs Numériques (Codeurs)
Un capteur numérique fournit un signal numérique proportionnel à la

grandeur à mesurer.
Les capteurs numériques ont leur propre CAN (Convertisseur Analogique

Numérique) embarqué, c-à-d ils transforment une grandeur physique en
signal électrique analogique,et numérisent le signal analogique en signal
numérique.
- Capteur Infrarouge:
Un capteur infrarouge permet de détecter un mouvement dans son

champ de vision en se basant sur l’infrarouge.
On parle aussi de capteur pyroélectrique ou PIR. Les PIR sont capables

de détecter une variation des ondes infrarouges, ce qui génère un courant
électrique. Dans ce cas, ils captent les rayonnement infrarouge émis les
êtres vivants à sang chaud passant dans le champ de détection du cap-
teur. Pour élargir la zone de détection, ceux ci sont souvent recouverts
d’une lentille dite de Fresnel. Des composants électroniques divers trait-
ent la sortie brute du capteur en lui même et permettent d’obtenir une
sortie numérique en fonction du mouvement détecté.

- Capteur Ultra-Son: Un capteur à ultrasons émet à intervalles

réguliers de courtes impulsions sonores à haute fréquence. Ces impul-
sions se propagent dans l’air à la vitesse du son. Lorsqu’elles rencontrent
un objet, elles se réfléchissent et reviennent sous forme d’écho au capteur.
Celui-ci calcule alors la distance le séparant de la cible sur la base

du temps écoulé entre l’émission du signal et la réception de l’écho.
- Bouton Poussoir:
Un bouton poussoir est un interrupteur (ou contacteur) monostable:

il retourne seul dans la position repos (relâché).

- Recepteur IR:
Le récepteur IR est composé d’un capteur infrarouge qui détecte les sig-
naux infrarouges émis par la télécommande. Il convertit ensuite ces sig-
naux en signaux électriques que l’Arduino peut comprendre et traiter.
Le récepteur IR envoie les données du signal infrarouge à l’Arduino, qui
les analyse et exécute des actions en fonction des boutons pressés.

2.3 Actionneurs: Agir sur le monde extérieur 2 HARDWARE - MATÉRIEL
2.3 Actionneurs: Agir sur le monde extérieur

Les actionneurs sont des composants matériels qui, une fois correcte-
ment connectés à votre carte Arduino, permettent d’agir sur le monde
extérieur. Ceux-ci ont comme rôle de convertir une valeur électrique en
action physique.
2.3.1 LED
Une DEL / LED: Diode Electro-Luminescente, ou bien Light Emit-

ting Diode en anglais. Il s’agit d’un composant électronique qui crée
de la lumière quand il est parcouru par un courant électrique.

Choix Résistance:

2.3.2 Moteurs à Courant Continu MCC
Le moteur DC (aussi appelé moteur à courant continu) est l’un des mo-
teurs les plus utilisés pour convertir de l’énergie électrique en énergie
mécanique.
Les moteurs DC possèdent la particularité de fonctionner dans les 2 sens,

en fonction du sens du courant.
2.3.3 Servo-moteurs
Les servomoteurs sont contrôlés en envoyant un signal PWM (modu-

lation de largeur d’impulsion) à la ligne de signal du servo. La largeur
des impulsions détermine la position de l’arbre de sortie. Lorsque vous

envoyez au servo un signal avec une largeur d’impulsion de 1,5 millisec-

ondes (ms), le servo se déplace vers la position neutre (90 degrés). Les
positions min (0 degré) et max (180 degrés) correspondent généralement
à une largeur d’impulsion de 1 ms et 2 ms respectivement. Notez que cela
peut varier légèrement entre les différents types et marques de servomo-
teurs (par exemple 0,5 et 2,5 ms). De nombreux servos ne tournent que
d’environ 170 degrés (ou même seulement 90), mais la position médiane
est presque toujours à 1,5 ms.
PWM: La modulation de largeur d’impulsions (MLI ; en anglais : Pulse

Width Modulation, soit PWM), est une technique couramment utilisée
pour synthétiser des signaux continus à l’aide de circuits à fonction-
nement tout ou rien, ou plus généralement à états discrets.
Le principe général est qu’en appliquant une succession d’états discrets

pendant des durées bien choisies, on peut obtenir en moyenne sur une
certaine durée n’importe quelle valeur intermédiaire.
2.3.4 Moteurs Pas-à-pas
Le moteur pas à pas regroupe les avantages du moteur à courant continu

et du servomoteur. En effet, il permet de contrôler précisément sa vitesse
et/ou le positionnement.

Il existe deux types de moteur pas à pas, unipolaire et bipolaire. La

principale différence entre les deux réside dans l’organisation de leurs
bobinages, car cela a un impact sur leur mode de contrôle. Pour repérer
le type de moteur, il suffit de regarder le nombre de fils (phases) en
sortie du moteur, quand le moteur présente 5/6 fils d’alimentation c’est
un moteur unipolaire, s’il présente 4 fils d’alimentation c’est un moteur
bipolaire.
2.3.5 Moteur Brushless
Un moteur sans balais, ou moteur brushless , ou machine synchrone

auto-pilotée à aimants permanents, est une machine électrique de la
catégorie des machines synchrones, dont le rotor est constitué d’un ou de
plusieurs aimants permanents et pourvu d’origine d’un capteur de posi-
tion rotorique : capteur à effet Hall, synchro-résolver, codeur rotatif (par
exemple codeur incrémental), ou tout autre système permettant l’auto-
pilotage de la machine.

2.4 Modules - Protocoles de Communication 2 HARDWARE - MATÉRIEL
2.4 Modules - Protocoles de Communica-

tion
Un module ajouté à Arduino est généralement une carte d’extension
matérielle ou une composante électronique supplémentaire qui est con-
nectée à une carte Arduino pour étendre ses fonctionnalités ou ajouter
des capacités spécifiques à un projet.
2.4.1 UART
UART est un protocole de communication qui permet au microcontrôleur

d’échanger des données avec les périphériques connectés. Il utilise deux
lignes de données, une pour la transmission (TX) et une pour la réception
(RX), permettant la communication bidirectionnelle. Cette interface
est généralement implémentée via les broches numériques 0 (RX) et
1 (TX) du microcontrôleur.
Le protocole UART fonctionne de manière asynchrone, ce qui signifie

qu’il ne nécessite pas de signal d’horloge dédié pour synchroniser la trans-
mission des données. Au lieu de cela, il utilise des bits de départ (start
bits) et de fin (stop bits) pour indiquer le début et la fin de chaque pa-

quet de données.
Lorsqu’un microcontrôleur envoie des données via l’UART, il conver-

tit les données parallèles en une forme série et les transmet via la ligne
de transmission (TX). Le périphérique récepteur convertit ensuite les
données série en données parallèles pour les utiliser. Cette conversion
série-parallèle permet une transmission efficace des données entre les
périphériques.
- Exemple: HC05
Les modules Bluetooth tels que le HC-05 et le HC-06 permettent la com-

munication sans fil entre un Arduino et d’autres appareils compatibles
Bluetooth, tels que des smartphones ou des ordinateurs.
2.4.2 SPI
SPI est un protocole de communication série synchrone qui permet l’échange

de données entre un microcontrôleur maı̂tre et des périphériques esclaves.
Il utilise un certain nombre de lignes de communication, y compris les
lignes de données (MOSI et MISO), la ligne d’horloge (SCLK) et la ligne
de sélection du périphérique (SS). Contrairement à d’autres protocoles,
chaque périphérique esclave nécessite une ligne de sélection distincte.
- Exemple 1: ESP01

Des modules comme l’ESP01 offrent des fonctionnalités Wi-Fi pour per-
mettre à votre Arduino de se connecter à un réseau Wi-Fi, d’accéder à
Internet ou de communiquer avec d’autres dispositifs sur le réseau.
- Exemple 2: RFID
Les modules RFID tels que le MFRC522 permettent la lecture et l’écriture

d’informations sur des cartes RFID, permettant l’identification sans
contact.
2.4.3 I2C
Le protocole I2C, ou Inter-Integrated Circuit, est un protocole de com-

munication série bidirectionnel utilisé dans le développement de micro-
contrôleurs et d’autres systèmes électroniques. Il est largement utilisé

en raison de sa simplicité, de son faible nombre de fils requis et de sa

capacité à permettre la communication entre plusieurs périphériques.
L’I2C utilise deux fils pour la communication : la ligne de données série

(SDA) et la ligne d’horloge série (SCL). La ligne SDA est utilisée pour
transmettre les données, tandis que la ligne SCL synchronise la trans-
mission des données entre les périphériques connectés. Les périphériques
sur le bus I2C sont divisés en deux catégories : les maı̂tres et les esclaves.
Les maı̂tres initient la communication et les esclaves répondent aux de-
mandes des maı̂tres.
- Exemple: Gyroscope
2.4.4 Résumé

2.5 Do’s and Don’ts 2 HARDWARE - MATÉRIEL
2.5 Do’s and Don’ts
2.5.1 Do’s
- Lire la Documentation : Lisez la documentation officielle d’Arduino

et les fiches techniques des composants que vous utilisez.
- Inclure des Commentaires dans Votre Code : Incluez des com-

mentaires dans votre code pour expliquer la fonctionnalité et le rendre
plus facile à comprendre plus tard.
- Utiliser une source d’alimentation externe: Il vaut mieux ali-

menter les composantes par la carte ARDUINO.
2.5.2 Don’ts
- Ne manipulez pas les composants sous tension : Évitez de ma-

nipuler des composants ou de faire des connexions alors que l’Arduino
est sous tension.
- Ne négligez pas les résistances : Ne connectez pas de LEDs ou

d’autres composants directement sans résistance, cela peut endommager
votre Arduino.
- Evitez tout court-circuit: Attention au branchement de votre cir-

cuit (le VCC ne doit jamais etre branché directement au GND (sans
charge)).

3 MAIS AUSSI UN IDE ET UN LANGAGE DE PROGRAMMATION !
Chapitre 3
Mais aussi un IDE et un
langage de programma-
tion !
Résumé. Ce chapitre se focalise sur le langage de programmation

associé à la plateforme Arduino. Le langage Arduino, étroitement lié au
C et au C++, est crucial pour la création de code permettant aux cartes
Arduino d’exécuter diverses tâches

3.1 Introduction 3 MAIS AUSSI UN IDE ET UN LANGAGE DE PROGRAMMATION !
3.1 Introduction
Le langage Arduino est très proche du C et du C++.
Si vous êtes déjà familier avec le C ou le C++, il suffira de consulter

la section sur Arduino IDE, la structure et les fonctions de base ainsi que
la bibliothèque Serial.
3.2 Arduino IDE

L’Arduino IDE (Integrated Development Environment) est un environ-
nement de développement intégré open source spécifiquement conçu pour
programmer des cartes Arduino. Il fournit un ensemble d’outils et de
fonctionnalités pour simplifier le processus de développement de projets
électroniques basés sur les microcontrôleurs Arduino.

3.2 Arduino IDE 3 MAIS AUSSI UN IDE ET UN LANGAGE DE PROGRAMMATION !
Voici quelques caractéristiques de l’Arduino IDE :
Éditeur de Code : L’IDE Arduino propose un éditeur de code intégré

qui prend en charge la coloration syntaxique, ce qui facilite la lecture et
l’écriture du code.
Gestionnaire de Bibliothèques : Il offre un gestionnaire de bib-

liothèques qui permet de rechercher, installer et mettre à jour les bib-
liothèques Arduino utilisées dans les projets.
Outils de Compilation et de Téléversement : L’IDE prend en

charge la compilation du code source et le téléversement du programme
résultant vers la carte Arduino connectée.
Moniteur Série : Un moniteur série intégré permet de déboguer et

de visualiser les données envoyées ou reçues par la carte Arduino via la
communication série.

3.3 Structure 3 MAIS AUSSI UN IDE ET UN LANGAGE DE PROGRAMMATION !
Exemples et Tutoriels : L’IDE propose des exemples de code prêts à

l’emploi pour aider les débutants à comprendre les concepts de base et à
démarrer rapidement.
Intégration avec Arduino Boards : L’IDE Arduino est préconfiguré

pour prendre en charge diverses cartes Arduino. Vous pouvez sélectionner
le modèle de carte que vous utilisez dans le menu ”Outils” avant de
téléverser votre code.
3.3 Structure
La structure minimale est constituée de :
- en-tête : déclaration des variables, des constantes, indication de

l’utilisation de bibliothèques etc...
- void setup() : appelée une seule fois lorsque le programme com-

mence. C’est pourquoi c’est dans cette fonction que l’on va écrire le code
qui n’a besoin d’être exécuté qu’une seule fois. On appelle cette fonc-
tion : fonction d’initialisation. On y retrouvera la mise en place des
différentes sorties et quelques autres réglages.
Une fois que l’on a initialisé le programme, il faut ensuite créer son ’cœur’,
autrement dit le programme en lui même.
- void loop() : C’est donc dans cette fonction loop() que l’on va écrire
le contenu du programme. Il faut savoir que cette fonction est appelée

3.3 Structure 3 MAIS AUSSI UN IDE ET UN LANGAGE DE PROGRAMMATION !
en permanence, c’est-à-dire qu’elle est exécutée une fois, puis lorsque son
exécution est terminée, on la réexécute, encore et encore. On parle de
boucle infinie.
For your info
Que veut dire void ? Cela veut dire ”vide” et signifie qu’une fonc-
tion de ce type ne renvoie aucune valeur. Elle sont dites muettes.
Remarque
On n’est pas obligé d’écrire quelque chose dans ces deux fonctions.
En revanche, il est obligatoire de les écrire, même si elles ne con-
tiennent aucun code!
En dehors de ces deux blocs on ne doit trouver que ceux des différentes

3.4 Lasse9 3 MAIS AUSSI UN IDE ET UN LANGAGE DE PROGRAMMATION !
fonctions et sous-programmes éventuels ainsi que la définition des vari-

ables globales.
3.4 Lasse9
- Chaque instruction est terminée par le caractère ;
- Une fonction a un nom, des paramètres typés et un type de retour,

qu’ont définie pour organiser notre code. La déclaration d’une fonc-
tion se fait avant setup()
- Le comportement d’une fonction est défini dans un bloc identifié par

des accolades
- Les variables sont déclarées et initialisées avant d’être utilisées
- Les types de données de base incluent int (entier), float (nombre à

virgule flottante), char (caractère).. Boolean est utilisé pour les valeurs
vraies/fausses (true/false)
- Les structures if, else if, else permettent de prendre des décisions
conditionnelles.
- Les boucles for, while, do-while permettent de créer des itérations
- Arduino propose une variété de bibliothèques pour simplifier la pro-

grammation. Vous pouvez les inclure au début de votre programme .

3.5 Détails 3 MAIS AUSSI UN IDE ET UN LANGAGE DE PROGRAMMATION !
3.5 Détails
3.5.1 Instructions
Les instructions sont des lignes de code qui disent au programme : ”fais
ceci, fais cela...” Ce sont donc les ordres qui seront exécutés par l’Arduino.
Il est très important de respecter exactement la syntaxe; faute de quoi,
le code ne pourra pas être exécuté.
3.5.2 Fonctions
Une fonction peut donc retourner une valeur, possède un nom et des
arguments. La valeur retournée a un type. Si la fonction ne retourne
aucune valeur, comme setup() et loop(), le type de retour est void qui
signifie rien ou vide

La manipulation d’une fonction se fait en trois étapes:
- Déclaration de la fonction: se fait en spécifiant son type de re-

tour, son nom, et les types de ses paramètres (le cas échéant). Cette
étape permet d’informer le compilateur de l’existence de la fonction.
- Définition de la fonction: fournit l’implémentation réelle du code

de la fonction. Cela inclut le corps de la fonction, où vous écrivez les
instructions spécifiques que la fonction doit exécuter.
- Appel de la fonction: se fait en utilisant son nom suivi de par-

enthèses contenant les arguments nécessaires. Si la fonction a une valeur
de retour, vous pouvez également stocker cette valeur dans une variable.

3.5.3 Fonctions de Base
- pinMode(pin, mode) : Cette fonction est utilisée pour définir si une

broche est configurée en tant qu’entrée (INPUT) ou sortie (OUTPUT)
afin de lire ou de contrôler des signaux.
- digitalRead(pin) : Cette fonction permet de lire l’état d’une broche

configurée en entrée numérique et renvoie HIGH ou LOW, représentant
respectivement les états logiques 1 et 0.
- digitalWrite(pin,value) : Vous pouvez utiliser cette fonction pour

définir l’état d’une broche configurée en sortie numérique en lui at-
tribuant HIGH ou LOW pour activer ou désactiver un composant ex-
terne.
- analogRead(pin) : Cette fonction permet de lire la valeur analogique

(0-1023 pour Arduino UNO) d’une broche analogique. Cela est souvent
utilisé pour lire des capteurs analogiques tels que des potentiomètres ou
des capteurs de lumière.
- analogWrite(pin,value) : Utilisée pour générer une sortie analogique

(PWM - modulation de largeur d’impulsion) sur une broche. Cela per-
met de contrôler la vitesse des moteurs, la luminosité des LED, etc.
- delay(nbre of ms) : La fonction delay() met en pause l’exécution

du programme pendant un nombre spécifié de millisecondes. Cela est

utile pour introduire des temporisations dans votre code.
- millis() : Vous pouvez utiliser la fonction millis() pour obtenir le nom-

bre de millisecondes écoulées depuis le démarrage du programme.
Cela est utile pour créer des temporisations sans bloquer l’exécution du
code.
3.5.4 La bibliothèque Serial
La librairie Serial est une librairie essentielle du langage Arduino qui

permet de visualiser sur le PC des messages reçus depuis la carte
Arduino ou de commander la carte Arduino.

Vous pouvez utiliser le moniteur série intégré de l’environnement Ar-

duino pour communiquer avec une carte Arduino. Cliquez sur le bouton
du moniteur série dans la barre d’outils et sélectionnez le même débit en
bauds que celui utilisé dans l’appel à la fonction begin().
Pour utiliser la voie série et communiquer avec notre ordinateur (par

exemple), nous allons utiliser un objet (une sorte de variable mais plus
évoluée) qui est intégré nativement dans l’ensemble Arduino: l’objet Se-
rial.
- Serial.begin(débit) : Fixe le débit de communication en nombre

de caractères par seconde (l’unité est le baud) pour la communication
série.
- Serial.print(): cette fonction permet d’afficher les données sur le port

série sous forme lisible pour les humains. On peut par exemple en-
voyer un caractère, une chaine de caractère ou d’autres données.
- Serial.println(): c’est la même fonction que la précédente, elle permet

simplement un retour à la ligne à la fin du message envoyé.
Pour vérifier si on a reçu des données, on va régulièrement interroger la

carte pour lui demander si des données sont disponibles dans son buffer
de réception. Un buffer est une zone mémoire permettant de stocker des
données sur un court instant. Dans notre situation, cette mémoire est
dédiée à la réception sur la voie série. Il en existe un aussi pour l’envoi
de donnée, qui met à la queue les données à envoyer et les envoie dès que
possible.
- Serial.available(): Donne le nombre d’octets (caractères) disponible
pour lecture dans la file d’attente (buffer) du port série.
- Serial.read(): Lit les données entrantes sur le port Série.

- Serial.write(valeur ) :permet d’envoyer un seul octet (un seul byte)

ou un tableau d’octets.
For your info
On peut aussi utiliser Serial.write() pour envoyer une chaine de
caractères ou un tableau. Voici des exemples d’utilisation de cette
fonction:
Serial.write(”Promo20”);
Serial.write(20);
3.5.5 Structures de controle
- if, else if, else : Les structures de contrôle conditionnelles vous perme-
ttent de prendre des décisions dans votre code en fonction de conditions
spécifiques.
- for, while, do...while : Les boucles vous permettent de répéter des

blocs de code un certain nombre de fois ou jusqu’à ce qu’une condition
soit remplie.


3.5.6 Variables
Il existe un nombre limité de types:
- int, long, unsigned int, unsigned long
- float, double
- char
- void

4 PRATIQUE : GETTING YOUR HANDS DIRTY !
Chapitre 4
Pratique : Getting your
hands dirty !
Résumé. Ce chapitre présente plusieurs cas pratiques pour débuter

avec Arduino. Vous y trouverez le schéma des circuits et le code source
des démonstrations réalisées au cours de la séance.

4.1 Cas 1: Joystick 4 PRATIQUE : GETTING YOUR HANDS DIRTY !
4.1 Cas 1: Joystick
4.1.1 Ingrédients
- Joystick
- Arduino UNO
- Jumper Wires
4.1.2 Circuit

4.1 Cas 1: Joystick 4 PRATIQUE : GETTING YOUR HANDS DIRTY !
4.1.3 Sketch
const int X_out = A0 ;

const int Y_out = A1 ;
float x_value , y_value ;
void setup () {
Serial . begin (9600);
// pinMode ( X_out , INPUT );
// pinMode ( Y_out , INPUT );
}
void loop () {
x_value = analogRead ( X_out );
y_value = analogRead ( Y_out );
x_value = map ( x_value ,0 ,1023 , -70 ,70);

y_value = map ( y_value ,0 ,1023 , -70 ,70);
Serial . print ( x_value );

Serial . print ("/");
Serial . println ( y_value );
delay (20);
}

4.2 Cas 2: IR + LED 4 PRATIQUE : GETTING YOUR HANDS DIRTY !
4.2 Cas 2: IR + LED
4.2.1 Ingrédients
- Capteur Infra-rouge
- LED
- BreadBoard
- Résistance
- Jumper Wires
- Carte Arduino UNO
4.2.2 Circuit

4.3 Cas 3: Ultra-son 4 PRATIQUE : GETTING YOUR HANDS DIRTY !
4.2.3 Sketch
int IR_input = 2 ;
int LED = 3 ;
void setup () {
// put your setup code here , to run once :
pinMode ( IR_input , INPUT );
pinMode ( LED , INPUT );
void loop () {
// put your main code here , to run r e p e a t e d l y :
Serial . println ( digitalRead ( IR_input ));
digitalWrite ( LED , digitalRead ( IR_input ));
delay (50);
}
4.3 Cas 3: Ultra-son
4.3.1 Ingrédients
- Ultra-son
- Servo-Moteur
- Carte Arduino UNO
- Breadboard
- Jumper wires

4.3 Cas 3: Ultra-son 4 PRATIQUE : GETTING YOUR HANDS DIRTY !
4.3.2 Circuit
4.3.3 Sketch
// I n c l u d e s the Servo library

# include < Servo .h >.
// Defines Tirg and Echo pins of the U l t r a s o n i c Sensor

const int trigPin = 2;
const int echoPin = 3;
// V a r i a b l e s for the d u r a t i o n and the d i s t a n c e
long duration ;
int distance ;
Servo myServo ; // Creates a servo object for c o n t r o l l i n g the servo motor
void setup () {
pinMode ( trigPin , OUTPUT );
// Sets the trigPin as an Output
pinMode ( echoPin , INPUT );
// Sets the echoPin as an Input

4.4 Cas 4: MCC + Servo-moteur 4 PRATIQUE : GETTING YOUR HANDS DIRTY !

myServo . attach (9);
// Defines on which pin is the servo motor a t t a c h e d
}
void loop () {
// rotates the servo motor from 15 to 165 degrees
for ( int i =15; i <=165; i ++){
myServo . write ( i );
delay (30);
distance = c a l c u l a t e D i s t a n c e ();
// Calls a f u n c t i o n for c a l c u l a t i n g the d i s t a n c e m e a s u r e d by the U l t r a s o n i c sensor for each degree
Serial . print ( i ); // Sends the current degree into the Serial Port
Serial . print (" ,"); // Sends a d d i t i o n c h a r a c t e r right next to the p r e v i o u s value needed later in the P r
Serial . print ( distance ); // Sends the d i s t a n c e value into the Serial Port
Serial . print ("."); // Sends a d d i t i o n c h a r a c t e r right next to the p r e v i o u s value needed later in the P r
}
// Repeats the p r e v i o u s lines from 165 to 15 degrees
for ( int i =165; i >15; i - -){
myServo . write ( i );
delay (30);
distance = c a l c u l a t e D i s t a n c e ();
Serial . print ( i );
Serial . print (" ,");
Serial . print ( distance );
Serial . print (".");
}
}
// F u n c t i o n for c a l c u l a t i n g the d i s t a n c e m e a s u r e d by the U l t r a s o n i c sensor
int c a l c u l a t e D i s t a n c e (){
digitalWrite ( trigPin , LOW );

d e l a y M i c r o s e c o n d s (2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite ( trigPin , HIGH );
d e l a y M i c r o s e c o n d s (10);
digitalWrite ( trigPin , LOW );
duration = pulseIn ( echoPin , HIGH ); // Reads the echoPin , returns the sound wave travel time in m i c r o s e
distance = duration *0.034/2;
return distance ;
}
4.4 Cas 4: MCC + Servo-moteur
4.4.1 Ingrédients
- Potentiomètre
- Capacité
- Servo-moteur
- Moteur Driver
- Moteur DC
- Carte Arduino UNO

4.4 Cas 4: MCC + Servo-moteur 4 PRATIQUE : GETTING YOUR HANDS DIRTY !
- Breadboard
- Jumper wires
4.4.2 Circuit
4.4.3 Sketch
# include < Servo .h >
Servo servo ;
int p o t e n t i o m e t e r P i n = A0 ;
int servoMinAngle = 0;
int servoMaxAngle = 180;
void setup () {
servo . attach (6);
pinMode (10 , OUTPUT );

4.5 Cas 5: Gyroscope 4 PRATIQUE : GETTING YOUR HANDS DIRTY !
void loop () {
int potValue = analogRead ( p o t e n t i om e t e r P i n );
// Read the p o t e n t i o m e t e r value
int servoAngle = map ( potValue , 0 , 1023*(3.3/5) , servoMinAngle , servoMaxAngle );

// Map p o t e n t i o m e t e r value to servo angle
int motorSpeed = map ( potValue , 0 , 1023 , 255/3 , 255);
// Control the DC motor speed

analogWrite (5 , motorSpeed );
Serial . println ( potValue );

// Print p o t e n t i o m e t e r value to the Serial Monitor
servo . write ( servoAngle );

// Control the servo motor angle
delay (20);
}
4.5 Cas 5: Gyroscope
4.5.1 Ingrédients
- Gyroscope
- Carte Arduino UNO
- Jumper wires

4.5.2 Circuit
4.5.3 Sketch
# define OUTPUT_TEAPOT
# define INTERRUPT_PIN 2 // use pin 2 on Arduino Uno & most boards

# define LED_PIN 13 // ( Arduino is 13 , Teensy is 11 , Teensy ++ is 6)
bool blinkState = false ;
// MPU control / status vars

bool dmpReady = false ; // set true if DMP init was s u c c e s s f u l
uint8_t mpuIntStatus ; // holds actual i n t e r r u p t status byte from MPU
uint8_t devStatus ; // return status after each device o p e r a t i o n (0 = success , !0 = error )
uint16_t packetSize ; // e x p e c t e d DMP packet size ( default is 42 bytes )
uint16_t fifoCount ; // count of all bytes c u r r e n t l y in FIFO
uint8_t fifoBuffer [64]; // FIFO storage buffer
// o r i e n t a t i o n / motion vars
Quaternion q ; // [w , x , y , z ] quaternion container
VectorInt16 aa ; // [x , y , z ] accel sensor m e a s u r e m e n t s
VectorInt16 aaReal ; // [x , y , z ] gravity - free accel sensor m e a s u r e m e n t s
VectorInt16 aaWorld ; // [x , y , z ] world - frame accel sensor m e a s u r e m e n t s
VectorFloat gravity ; // [x , y , z ] gravity vector
float euler [3]; // [ psi , theta , phi ] Euler angle c o n t a i n e r
float ypr [3]; // [ yaw , pitch , roll ] yaw / pitch / roll c o n t a i n e r and gravity vector
// packet s t r u c t u r e for I n v e n S e n s e teapot demo

uint8_t teapotPacket [14] = { ’$ ’ , 0 x02 , 0 ,0 , 0 ,0 , 0 ,0 , 0 ,0 , 0 x00 , 0 x00 , ’\r ’ , ’\n ’ };
volatile bool mpuInterrupt = false ; // i n d i c a t e s whether MPU i n t e r r u p t pin has gone high

void dmpDataReady () {
mpuInterrupt = true ;
}
void setup () {
// join I2C bus ( I2Cdev library doesn ’ t do this a u t o m a t i c a l l y )
# if I 2 C D E V _ I M P L E M E N T A T I O N == I 2 C D E V _ A R D U I N O _ W I R E
Wire . begin ();
Wire . setClock (400000); // 400 kHz I2C clock . Comment this line if having c o m p i l a t i o n d i f f i c u l t i e s
# elif I 2 C D E V _ I M P L E M E N T A T I O N == I 2 C D E V _ B U I L T I N _ F A S T W I R E
Fastwire :: setup (400 , true );
# endif
// i n i t i a l i z e serial c o m m u n i c a t i o n
// (115200 chosen because it is r e q u i r e d for Teapot Demo output , but it ’ s
// really up to you d e p e n d i n g on your project )
while (! Serial ); // wait for L e o n a r d o enumeration , others c o n t i n u e i m m e d i a t e l y
// i n i t i a l i z e device
Serial . println ( F (" Initializing I2C devices ..."));
mpu . initialize ();
pinMode ( INTERRUPT_PIN , INPUT );
// verify c o n n e c t i o n
Serial . println ( F (" Testing device connections ..."));
if ( mpu . te stConne ction ()) {
Serial . println ( F (" MPU6050 connection successful "));
} else {
Serial . println ( F (" MPU6050 connection failed "));
}
// wait for ready

Serial . println ( F ("\ nSend any character to begin DMP programming and demo : "));
while ( Serial . available () && Serial . read ()); // empty buffer
while (! Serial . available ()); // wait for data
while ( Serial . available () && Serial . read ()); // empty buffer again
// load and c o n f i g u r e the DMP

Serial . println ( F (" Initializing DMP ..."));
devStatus = mpu . dmpInitialize ();
// supply your own gyro offsets here , scaled for min s e n s i t i v i t y

mpu . se tXGyroOf fset (220);
mpu . se tYGyroOf fset (76);
mpu . se tZGyroOf fset ( -85);
mpu . se tZ A cc el Of f se t (1788); // 1688 factory default for my test chip
// make sure it worked ( returns 0 if so )

if ( devStatus == 0) {
// C a l i b r a t i o n Time : g e n e r a t e offsets and c a l i b r a t e our MPU6050
mpu . Ca librateA ccel (6);
mpu . CalibrateGyro (6);
mpu . P r i n t A c t i v e O f f s e t s ();
// turn on the DMP , now that it ’ s ready
Serial . println ( F (" Enabling DMP ..."));
mpu . setDMPEnabled ( true );
// enable Arduino i n t e r r u p t d e t e c t i o n

Serial . print ( F (" Enabling interrupt detection ( Arduino external interrupt "));
Serial . print ( d i g i t a l P i n T o I n t e r r u p t ( INTERRUPT_PIN ));
Serial . println ( F (")..."));
a tt ac hI n te rr up t ( d i g i t a l P i n T o I n t e r r u p t ( INTERRUPT_PIN ) , dmpDataReady , RISING );
mpuIntStatus = mpu . getIntStatus ();
// set our DMP Ready flag so the main loop () f u n c t i o n knows it ’ s okay to use it
Serial . println ( F (" DMP ready ! Waiting for first interrupt ..."));
dmpReady = true ;
// get e x p e c t e d DMP packet size for later c o m p a r i s o n

packetSize = mpu . d m p G e t F I F O P a c k e t S i z e ();
} else {
// ERROR !
// 1 = initial memory load failed
// 2 = DMP c o n f i g u r a t i o n updates failed
// ( if it ’ s going to break , usually the code will be 1)
Serial . print ( F (" DMP Initial ization failed ( code "));
Serial . print ( devStatus );
Serial . println ( F (")"));
}
// c o n f i g u r e LED for output

pinMode ( LED_PIN , OUTPUT );
}
void loop () {
// if p r o g r a m m i n g failed , don ’ t try to do a n y t h i n g
if (! dmpReady ) return ;
// read a packet from FIFO
if ( mpu . d m p G e t C u r r e n t F I F O P a c k e t ( fifoBuffer )) { // Get the Latest packet
# ifdef O U T P U T _ R E A D A B L E _ Q U A T E R N I O N
// display q u a t e r n i o n values in easy matrix form : w x y z
mpu . d m p G e t Q u a t e r n i o n (& q , fifoBuffer );
Serial . print (" quat \ t ");
Serial . print ( q . w );
Serial . print ("\ t ");
Serial . print ( q . x );
Serial . print ( q . y );
Serial . println ( q . z );
# endif
# ifdef O U T P U T _ R E A D A B L E _ E U L E R
// display Euler angles in degrees
mpu . dmpGetEuler ( euler , & q );
Serial . print (" euler \ t ");
Serial . print ( euler [0] * 180/ M_PI );
Serial . print ( euler [1] * 180/ M_PI );
Serial . println ( euler [2] * 180/ M_PI );
# endif
# ifdef O U T P U T _ R E A D A B L E _ Y A W P I T C H R O L L
// display Euler angles in degrees
mpu . dmpGetGravity (& gravity , & q );
mpu . d m p G e t Y a w P i t c h R o l l ( ypr , &q , & gravity );
Serial . print (" ypr \ t ");
Serial . print ( ypr [0] * 180/ M_PI );


Serial . print ( ypr [1] * 180/ M_PI );
Serial . println ( ypr [2] * 180/ M_PI );
# endif
# ifdef O U T P U T _ R E A D A B L E _ R E A L A C C E L
// display real acceleration , a d j u s t e d to remove gravity
mpu . dmpGetAccel (& aa , fifoBuffer );
mpu . d m p G e t L i n e a r A c c e l (& aaReal , & aa , & gravity );
Serial . print (" areal \ t ");
Serial . print ( aaReal . x );
Serial . print ( aaReal . y );
Serial . println ( aaReal . z );
# endif
# ifdef O U T P U T _ R E A D A B L E _ W O R L D A C C E L
// display initial world - frame acceleration , a d j u s t e d to remove gravity
// and rotated based on known o r i e n t a t i o n from q u a t e r n i o n
mpu . dmpGetAccel (& aa , fifoBuffer );
mpu . d m p G e t L i n e a r A c c e l (& aaReal , & aa , & gravity );
mpu . d m p G e t L i n e a r A c c e l I n W o r l d (& aaWorld , & aaReal , & q );
Serial . print (" aworld \ t ");
Serial . print ( aaWorld . x );
Serial . print ( aaWorld . y );
Serial . println ( aaWorld . z );
# endif
# ifdef OUTPUT_TEAPOT
// display q u a t e r n i o n values in I n v e n S e n s e Teapot demo format :
teapotPacket [2] = fifoBuffer [0];
Serial . write ( teapotPacket , 14);
teapotPacket [11]++; // packetCount , loops at 0 xFF on purpose
# endif
// blink LED to i n d i c a t e a c t i v i t y
blinkState = ! blinkState ;
digitalWrite ( LED_PIN , blinkState );
}
}

5 RESSOURCES
Chapitre 5
Ressources
5.1 Théorie
https://www.arduino.cc/
https://zestedesavoir.com/tutoriels/pdf/686/arduino-premiers-pas-en-info
pdf
5.2 Pratique
https://juniorfall.files.wordpress.com/2011/11/arduino-cookbook.
pdf
https://www.uio.no/studier/emner/matnat/ifi/IN1060/v21/arduino/
arduino-projects-book.pdf

Arduino Crash Course

Transféré par

Informations du document

Titre original

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 Crash Course

Transféré par

Droits d'auteur :

Formats disponibles

AIAC AEROLEC CLUB

Arduino Crash Course

1 Arduino.. C’est d’abord une carte électronique ! 6

3 Mais aussi un IDE et un langage de programmation ! 34

AIAC AEROLEC CLUB 1 sur 61

4 Pratique : Getting your hands dirty ! 48

AIAC AEROLEC CLUB 2 sur 61

Welcome to AIAC AEROLEC CLUB ! We are thrilled to welcome you

Arduino - Capteur - Moteur - Courant - Tension - Carte Electronique

AIAC AEROLEC CLUB 3 sur 61

Dans ce monde en constante mutation, il est essentiel de commencer par

Arduino ne se limite pas à des projets amateurs. Ses applications sont

AIAC AEROLEC CLUB 4 sur 61

vous souhaitiez automatiser votre maison, surveiller des paramètres en-

Cette formation vous guidera à travers tous les aspects d’Arduino, du

AIAC AEROLEC CLUB 5 sur 61

Résumé. Dans ce chapitre, nous découvrons la célèbre carte Arduino

AIAC AEROLEC CLUB 6 sur 61

- d’une unité de calcul

Il existe plusieurs µC ATMega, dont l’ATMega328.

AIAC AEROLEC CLUB 7 sur 61

1.2 Arduino UNO, C’est Quoi ?

Il existe deux modèles d’Arduino Uno: l’un avec un microcontrôleur de

Les couleurs de l’Arduino peuvent varier du bleu au bleu-vert, en fonction

AIAC AEROLEC CLUB 8 sur 61

• Un processeur pour traiter les données et faire les calculs:

• Un espace de stockage des données:

• Des ports pour communiquer (les broches):

Il va recevoir le programme que nous allons créer et va le stocker dans sa

AIAC AEROLEC CLUB 9 sur 61

qui est comprise entre 7V et 12V. Un régulateur se charge ensuite de

- GND Terre ou masse (0V)

AIAC AEROLEC CLUB 10 sur 61

- Vin Alimentation non stabilisée (= le même voltage que celui à l’entrée

1.6 Pourquoi Choisir Arduino ?

AIAC AEROLEC CLUB 11 sur 61

- Open Source : Arduino est un projet open source, ce qui signifie

- Large communauté : Arduino dispose d’une communauté mondi-

- Abordable : Les cartes Arduino et les composants associés sont

- Compatibilité matérielle et logicielle : Arduino est compatible

- Ressources pédagogiques abondantes : En raison de sa popu-

AIAC AEROLEC CLUB 12 sur 61

Résumé. Dans ce chapitre nous explorerons les éléments de base

AIAC AEROLEC CLUB 13 sur 61

Une platine d’expérimentation (appelée breadboard) permet de réaliser

AIAC AEROLEC CLUB 14 sur 61

2.1.2 Jumper Wires

Utilisées pour limiter le courant dans un circuit, les résistances sont

AIAC AEROLEC CLUB 15 sur 61

2.2 Capteurs: Se renseigner sur le monde

AIAC AEROLEC CLUB 16 sur 61

Il est ainsi possible de capter la plupart des phénomènes physiques comme

On peut classifier l’ensemble des capteurs en deux familles suivant le

2.2.1 Capteurs Analogiques

Un capteur analogique fournit un signal électrique analogique qui est

La sortie peut prendre une infinité de valeurs continues. Le signal

AIAC AEROLEC CLUB 17 sur 61

des capteurs analogiques peut être du type : sortie tension ou sortie

Pour qu’un microcontrôleur ou un microprocesseur puisse utiliser l’information

- Capteur de lumière à photorésistance LDR:

LDR utilise une photorésistance pour détecter les niveaux de lumière

Le module a une sortie numérique qui change d’état en fonction de la

Le capteur de température LM35 est un capteur analogique de température