Table des matières
I. Cours ARDUINO ............................................................................................................... 2
1) Le rôle d’Arduino dans un système................................................................................ 2
2) Définition simple ............................................................................................................ 2
3) Deux types de capteurs : numérique et analogique ........................................................ 2
4) Exemples de capteurs très utilisés .................................................................................. 3
5) Les actionneurs courants ................................................................................................ 4
6) Comment choisir la bonne fonction Arduino ? .............................................................. 4
7) Notion clé à expliquer aux étudiants .............................................................................. 4
8) Chaîne complète d’exemple pédagogique ...................................................................... 4
9) Cas particuliers : capteurs “numériques” intelligents (I2C, OneWire…) ...................... 5
II. Cours complet d’initiation Arduino (C++ embarqué) ........................................................ 6
1) Langage haut niveau vs bas niveau ................................................................................ 6
2) Le C++ : cœur du langage Arduino ................................................................................ 6
3) Structure OBLIGATOIRE d’un programme Arduino ............................................................................... 6
4) Les variables (types essentiels) ...................................................................................... 7
5) Entrées / Sorties (GPIO) ................................................................................................. 7
6) Comprendre ce que lit vraiment Arduino : Numérique vs Analogique ......................... 7
7) Conditions ...................................................................................................................... 9
8) Boucles ........................................................................................................................... 9
9) Fonctions ........................................................................................................................ 9
10) Le temps : delay() vs millis() ........................................................................ 9
11) Communication série (debug) .................................................................................. 10
12) Bibliothèques ............................................................................................................ 10
13) Mémoire Arduino ..................................................................................................... 10
14) Variables globales vs locales.................................................................................... 10
15) Machine à états (méthode pro) ................................................................................. 10
16) Tableaux (arrays) ...................................................................................................... 11
17) Protocoles de communication .................................................................................. 11
18) Interruptions ............................................................................................................. 11
19) EEPROM .................................................................................................................. 11
20) Structure type d’un vrai projet ................................................................................. 11
21) Bonnes pratiques ...................................................................................................... 12
22) À la fin de ce cours, l’étudiant sait ........................................................................... 12
1
I. Cours ARDUINO
1) Le rôle d’Arduino dans un système
Arduino est une interface entre le monde physique et le monde numérique :
MONDE RÉEL → Capteurs → Arduino → Actionneurs → MONDE RÉEL
• Les capteurs donnent une information à Arduino
• Les actionneurs exécutent une action commandée par Arduino
2) Définition simple
- Capteur
Un dispositif qui mesure une grandeur physique et la transforme en signal électrique.
Exemples :
• Température
• Lumière
• Distance
• Pression
• Humidité
• Mouvement
- Actionneur
Un dispositif qui reçoit un signal électrique et produit une action physique.
Exemples :
• LED (lumière)
• Moteur (mouvement)
• Buzzer (son)
• Relais (commutation)
3) Deux types de capteurs : numérique et analogique
C’est LA notion clé à comprendre.
Type Signal Lecture Arduino Exemple
Numérique 0 ou 1 (LOW/HIGH) digitalRead() Bouton, détecteur de mouvement
Analogique Valeur variable analogRead() LDR, potentiomètre, capteur gaz
2
- Capteur numérique
Le capteur dit seulement :
OUI / NON — 0 / 1 — HIGH / LOW
Exemples :
• Bouton poussoir
• Détecteur PIR
• Fin de course
int etat = digitalRead(2);
- Capteur analogique
Le capteur donne une valeur proportionnelle à la grandeur mesurée.
int valeur = analogRead(A0); // 0 à 1023
Exemples :
• Potentiomètre
• Capteur lumière (LDR)
• Capteur gaz MQ
• Capteur pression
4) Exemples de capteurs très utilisés
Capteur Grandeur Type
Potentiomètre Position Analogique
LDR Lumière Analogique
MQ-2 Gaz Analogique
Bouton Appui Numérique
PIR Mouvement Numérique
DHT11 Température/Humidité Numérique (protocole)
HC-SR04 Distance Numérique (temps)
3
5) Les actionneurs courants
Actionneur Action Commande
LED Lumière digitalWrite / analogWrite
Buzzer Son digitalWrite
Servo moteur Position PWM / bibliothèque
Moteur DC Rotation PWM + transistor
Relais Commutation digitalWrite
6) Comment choisir la bonne fonction Arduino ?
Situation Fonction
Lire bouton digitalRead
Lire capteur lumière analogRead
Allumer LED digitalWrite
Varier intensité LED analogWrite
7) Notion clé à expliquer aux étudiants
Un capteur n’envoie pas une température ou une lumière.
Il envoie une tension.
Arduino convertit cette tension en nombre.
Monde réel → Tension (V) → Nombre (0–1023)
C’est ça qu’ils doivent comprendre.
8) Chaîne complète d’exemple pédagogique
Potentiomètre → LED
• Potentiomètre : tension variable → analogRead
• Arduino : transforme en nombre
• Arduino : envoie PWM vers LED → analogWrite
• LED : intensité variable
Ils voient toute la chaîne physique ↔ numérique ↔ physique.
4
9) Cas particuliers : capteurs “numériques” intelligents (I2C, OneWire…)
Certains capteurs sont numériques mais communiquent par protocole :
• DHT11
• BMP280
• Écrans LCD I2C
Ils utilisent :
#include <Wire.h>
A retenir :
• Arduino ne lit pas des grandeurs physiques.
→ Arduino lit des tensions électriques.
• Arduino ne commande pas un moteur.
→ Arduino envoie une tension électrique.
Capteur = information → Arduino
Actionneur = Arduino → action
Numérique = 0 ou 1
Analogique = valeur variable
Tout est une histoire de tension électrique.
5
II. Cours complet d’initiation Arduino (C++ embarqué)
1) Langage haut niveau vs bas niveau
- Bas niveau
• Très proche du matériel (registres, mémoire)
• Rapide, précis, difficile à lire
• Ex : assembleur
- Haut niveau
• Proche du langage humain
• Plus simple à écrire
• Le compilateur traduit pour le matériel
• Ex : Python, Java, C++, Arduino
Arduino utilise du C++ (haut niveau) pour piloter le matériel (bas niveau).
2) Le C++ : cœur du langage Arduino
Arduino est une version simplifiée du C++ :
• Pas de main()
• Fonctions déjà prêtes
• Bibliothèques pour le matériel
Apprendre Arduino = apprendre le C++ embarqué.
3) Structure OBLIGATOIRE d’un programme Arduino
void setup() {
// exécuté une seule fois
}
void loop() {
// exécuté en boucle infinie
}
6
4) Les variables (types essentiels)
int a = 10;
float b = 3.14;
bool etat = true;
char c = 'A';
String txt = "Bonjour";
Constantes pour les pins :
const int LED = 13;
5) Entrées / Sorties (GPIO)
Dans setup() :
pinMode(LED, OUTPUT);
pinMode(2, INPUT_PULLUP);
Dans loop() :
digitalWrite(LED, HIGH);
int bouton = digitalRead(2);
6) Comprendre ce que lit vraiment Arduino : Numérique vs Analogique
Arduino ne lit pas une température, une lumière ou une pression.
Arduino lit une tension électrique (Volt).
Cette tension est ensuite transformée en nombre.
- Entrée NUMÉRIQUE — digitalRead()
Une entrée numérique ne reconnaît que deux niveaux de tension.
Tension mesurée Valeur Arduino Interprétation
0V LOW (0) niveau bas
5V HIGH (1) niveau haut
int etat = digitalRead(2);
Arduino ne mesure pas une valeur précise. Il vérifie seulement : la tension est-elle proche de 0
V ou de 5 V ?
7
Entrée ANALOGIQUE — analogRead()
Arduino mesure précisément la tension entre 0 V et 5 V.
L’ADC (convertisseur analogique/numérique) est sur 10 bits, soit 1024 valeurs possibles (0–
1023).
int valeur = analogRead(A0);
- Le calcul réel
Exemples :
Tension en entrée Calcul Valeur retournée
0V (0 / 5) × 1023 0
2.5 V (2.5 / 5) × 1023 ≈ 512
5V (5 / 5) × 1023 1023
Retrouver la tension à partir de la valeur
float tension = (valeur / 1023.0) * 5.0;
Sortie PWM — analogWrite() (fausse analogique)
PWM = tension 0/5 V rapide → tension moyenne variable (8 bits → 256 niveaux) :
analogWrite(5, 128);
Valeur PWM Tension moyenne
0 0V
128 ≈ 2.5 V
255 5V
8
Ce qu’il faut retenir
Fonction Ce que fait réellement Arduino
digitalRead() 0 V ou 5 V
analogRead() mesure 0 → 5 V
analogWrite() tension moyenne via PWM
Exemple
int valeur = analogRead(A0);
float tension = (valeur / 1023.0) * 5.0;
[Link](9600);
[Link]("Valeur lue = ");
[Link](valeur);
[Link]("Tension mesuree = ");
[Link](tension);
7) Conditions
if (valeur > 500) {
digitalWrite(LED, HIGH);
} else {
digitalWrite(LED, LOW);
}
8) Boucles
for (int i = 0; i < 10; i++) {}
while (condition) {}
9) Fonctions
void allumerLED() {
digitalWrite(LED, HIGH);
}
10) Le temps : delay() vs millis()
Éviter :
delay(1000);
Préférer :
unsigned long t0 = millis();
9
if (millis() - t0 > 1000) {
// action
}
11) Communication série (debug)
[Link](9600);
[Link](valeur);
12) Bibliothèques
#include <Wire.h> // I2C
#include <SPI.h> // SPI
#include <Servo.h>
#include <EEPROM.h>
13) Mémoire Arduino
Mémoire Usage
RAM Variables (faible)
Flash Programme
EEPROM Données persistantes
Optimisation :
[Link](F("Texte en FLASH"));
14) Variables globales vs locales
int globalVar = 0; // partout
void loop() {
int localVar = 0; // détruite à chaque tour
}
15) Machine à états (méthode pro)
enum Etat {ATTENTE, MESURE, ENVOI};
Etat etat = ATTENTE;
10
16) Tableaux (arrays)
int mesures[5];
mesures[0] = analogRead(A0);
17) Protocoles de communication
Protocole Usage Bibliothèque
I2C Capteurs, écrans Wire
SPI SD, LoRa SPI
UART Debug, modules Serial
18) Interruptions
attachInterrupt(digitalPinToInterrupt(2), fonction, RISING);
19) EEPROM
[Link](0, 25);
int x = [Link](0);
20) Structure type d’un vrai projet
#include <Wire.h>
const int LED = 13;
const int BP = 2;
void setup() {
[Link](9600);
pinMode(LED, OUTPUT);
pinMode(BP, INPUT_PULLUP);
}
void loop() {
if (digitalRead(BP) == LOW) {
digitalWrite(LED, HIGH);
} else {
digitalWrite(LED, LOW);
}
}
11
21) Bonnes pratiques
• Ne jamais bloquer le loop
• Utiliser millis() pour temporisation non bloquante
• Penser en états
• Utiliser des fonctions
• Debug avec Serial
• Toujours déclarer les pins avec const int
22) À la fin de ce cours, l’étudiant sait
• Lire les entrées numériques et analogiques
• Générer des sorties numériques et PWM
• Utiliser les bibliothèques et protocoles (I2C/SPI/Serial)
• Gérer le temps avec millis()
• Optimiser la mémoire
• Structurer un vrai programme Arduino
• Comprendre le lien tension électrique ↔ valeur numérique
12