Thursday, September 24, 2026

Cours Arduino Complet

bts eii · arduino uno

Arduino — Systèmes Embarqués

Un cours complet depuis zéro : GPIO, ADC, PWM, DHT11, I2C, LCD, capteurs et projet final. Chaque ligne de code expliquée, aucune hypothèse.

10 chapitres GPIO · ADC · PWM · I2C · SPI DHT11 · LCD · OLED · Moteurs 40 questions de quiz

1. Introduction à Arduino

Arduino est une plateforme de prototypage électronique open source créée en 2005. Elle combine une carte matérielle (microcontrôleur + connecteurs) et un environnement de développement (Arduino IDE). L'objectif : rendre la programmation de microcontrôleurs accessible à tous.

Analogie : Un Arduino est comme un interrupteur électronique universel programmable. Tu lui dis : « allume cette LED quand ce bouton est pressé », « mesure cette température toutes les 2 secondes ». Il exécute ton programme en boucle infinie, du démarrage à l'extinction.
CarteCPUFlashRAMSpécialité
Arduino Uno R3ATmega328P 16 MHz32 KB2 KBDébutant — référence absolue
Arduino NanoATmega328P 16 MHz32 KB2 KBCompact — même puce que l'Uno
Arduino Mega 2560ATmega2560 16 MHz256 KB8 KBGrands projets, beaucoup d'I/O
Arduino DueAT91SAM3X8E 84 MHz512 KB96 KBHaute performance, 3.3 V
Pour débuter : L'Arduino Uno R3 est la carte de référence. Tous les tutoriels, shields et bibliothèques sont conçus pour elle. Une fois maîtrisée, passer au Nano (compact) ou au Mega (plus d'I/O) est trivial.
Comment ça fonctionne — du code au mouvement
  • 1

    Tu écris le code en C++

    Dans l'Arduino IDE ou VS Code avec l'extension PlatformIO.

  • 2

    L'IDE compile

    Le compilateur avr-g++ transforme ton code en binaire machine pour l'ATmega.

  • 3

    Upload via USB

    avrdude envoie le binaire par le câble USB. Le chip convertisseur USB/UART (CH340 ou ATmega16U2) sert de pont.

  • 4

    Stocké en Flash

    Le programme est gravé dans les 32 KB de mémoire Flash — il persiste après extinction.

  • 5

    L'ATmega328P exécute en boucle

    setup() une seule fois au démarrage, puis loop() indéfiniment jusqu'à l'extinction.

structure_base.ino — Les 2 fonctions obligatoires
// Tout programme Arduino a exactement ces 2 fonctions :
// setup()  → exécutée UNE SEULE FOIS au démarrage
// loop()   → exécutée EN BOUCLE INFINIE ensuite

const int LED = 13;   // LED intégrée sur broche 13

void setup() {
  Serial.begin(9600);        // démarrer la com série à 9600 bauds
  pinMode(LED, OUTPUT);       // broche 13 en SORTIE
  Serial.println("Arduino démarré !");
}

void loop() {
  digitalWrite(LED, HIGH);   // allumer LED
  delay(500);                  // attendre 500 ms
  digitalWrite(LED, LOW);    // éteindre LED
  delay(500);
}
📌 C'est le sketch "Blink" — le Hello World d'Arduino. La LED orange sur la carte clignote toutes les 500 ms.

2. Architecture & Broches

L'ATmega328P est un microcontrôleur 8 bits de la famille AVR d'Atmel. Il exécute une instruction par cycle d'horloge à 16 MHz, soit 16 millions d'instructions par seconde.

ComposantTailleRôle
Flash32 KBStockage du programme (non-volatile — persiste après extinction)
SRAM2 KBVariables, stack, heap (volatile — s'efface à l'extinction)
EEPROM1 KBDonnées permanentes modifiables (compteur, config — 100 000 cycles)
ADC10 bits × 6Convertit 0–5 V en 0–1023 sur les broches A0–A5
Timers3 (0, 1, 2)Génèrent millis(), micros() et le PWM — ne pas modifier Timer0 !
Carte des broches — Arduino Uno
5V 3.3V VIN (7–12V) RESET GND ×3 D2 — INT0 D3 ~ INT1 D4 D5 ~PWM D6 ~PWM D7 D8 D9 ~PWM D10 ~PWM SS D11 ~PWM MOSI D12 MISO D13 SCK LED A0 A1 A2 A3 A4 (SDA) A5 (SCL)
Rouge = Alim Gris = GND Orange = GPIO Bleu = PWM~ Jaune = ADC Violet = I2C Vert = SPI
Limites importantes : Maximum 40 mA par broche GPIO (une LED directement : ok. Un moteur directement : NON). Maximum 200 mA total sur toutes les broches. Pour piloter moteurs, relais ou LEDs puissantes → toujours utiliser un transistor ou un driver (L298N, MOSFET).
BrocheAliasFonction spécialeRemarque
D0RXUART réceptionNe pas utiliser si câble USB branché
D1TXUART émissionNe pas utiliser si câble USB branché
D3,5,6,9,10,11~PWM 8 bits (analogWrite)490 Hz (D5,D6,D9,D10) ou 980 Hz (D3,D11)
D13LED_BUILTINLED intégréeLED orange sur la carte — HIGH = allumée
A0–A5–ADC 10 bits 0–5 VPeuvent aussi fonctionner comme GPIO digital
A4 / A5SDA / SCLBus I2CPull-up 4,7 kΩ externe vers 5 V recommandé

3. GPIO — Sorties & Entrées Digitales

Un GPIO digital ne connaît que deux états : HIGH (5 V = logique 1) et LOW (0 V = logique 0). En sortie, tu commandes une LED, un relais. En entrée, tu lis un bouton, un capteur digital.

Les 3 modes de broche : OUTPUT — tu contrôles la tension. INPUT — tu lis la tension (broche flottante si rien de branché !). INPUT_PULLUP — tu lis avec une résistance interne (~47 kΩ) maintenant la broche à HIGH au repos — le mode à utiliser pour les boutons.
bouton_led.ino — Lire un bouton, piloter une LED
const int LED = 13;
const int BTN = 7;

void setup() {
  pinMode(LED, OUTPUT);
  pinMode(BTN, INPUT_PULLUP); // résistance interne activée
}

void loop() {
  int etat = digitalRead(BTN);

  // INPUT_PULLUP → logique inversée !
  // Bouton relâché : broche à HIGH (via résistance interne)
  // Bouton appuyé  : broche à LOW (connectée à GND)
  if (etat == LOW) {
    digitalWrite(LED, HIGH);  // allumer si appuyé
  } else {
    digitalWrite(LED, LOW);   // éteindre sinon
  }
}
📌 Câblage bouton : une borne → broche 7, autre borne → GND. Pas de résistance externe nécessaire grâce à INPUT_PULLUP.
Clignotement non-bloquant avec millis()
Règle d'or : N'utilise delay() que dans des exemples simples. Dès que tu as plusieurs tâches simultanées (lire un capteur ET faire clignoter une LED ET lire un bouton), utilise millis() — la montre interne de l'Arduino. delay() bloque tout le programme pendant qu'il attend.
millis_nonbloquant.ino — Chronomètre interne
const int LED = 13;
unsigned long tDernier = 0;  // horodatage du dernier bascule
bool etatLED = false;
const int INTERVALLE = 500;    // clignoter toutes les 500 ms

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  unsigned long maintenant = millis();  // ms depuis le démarrage

  if (maintenant - tDernier >= INTERVALLE) {
    tDernier = maintenant;     // mémoriser l'heure
    etatLED = !etatLED;        // inverser l'état
    digitalWrite(LED, etatLED);
  }

  // ← Ici : tout autre code continue à tourner sans être bloqué !
}
📌 La soustraction millis() - tDernier fonctionne correctement même après l'overflow (49 jours) si les deux variables sont unsigned long.
Anti-rebond pour boutons

Les boutons mécaniques rebondissent 5–50 ms à chaque appui : 1 appui réel peut déclencher 10–50 lectures parasites. Solution logicielle :

antirebond.ino — Debounce logiciel
const int BTN_PIN    = 2;
const int DEBOUNCE_MS = 50;
unsigned long tDernier = 0;
int etatBrut   = HIGH;
int etatStable = HIGH;
int compteur   = 0;

void setup() {
  Serial.begin(9600);
  pinMode(BTN_PIN, INPUT_PULLUP);
}

void loop() {
  int lecture = digitalRead(BTN_PIN);

  if (lecture != etatBrut)         // signal changé → reset timer
    tDernier = millis();

  if ((millis() - tDernier) > DEBOUNCE_MS) {  // stable 50 ms
    if (lecture != etatStable) {
      etatStable = lecture;
      if (etatStable == LOW) {   // front descendant = appui
        compteur++;
        Serial.print("Appui #");
        Serial.println(compteur);
      }
    }
  }
  etatBrut = lecture;
}

4. ADC & PWM — Signaux Analogiques

Le monde physique est analogique. L'ADC (Analog-to-Digital Converter) convertit une tension (0–5 V) en nombre (0–1023). Le PWM (Pulse Width Modulation) simule une sortie analogique en faisant varier la largeur des impulsions numériques.

Calcul ADC : L'ADC 10 bits lit 0–5 V et retourne 0–1023.
Formule : tension = valeur × 5.0 / 1023
Exemple : valeur = 512 → tension = 512 × 5.0 / 1023 ≈ 2.50 V
adc_potentiometre.ino — Lire un potentiomètre
// Câblage potentiomètre : pin 1 → 5V, pin 3 → GND, pin 2 (curseur) → A0

const int POT_PIN = A0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int   brut     = analogRead(POT_PIN);          // 0 à 1023
  float tension  = brut * 5.0 / 1023.0;           // convertir en Volts
  int   pourcent = map(brut, 0, 1023, 0, 100);  // map() rééchelonne

  Serial.print("Brut: ");     Serial.print(brut);
  Serial.print("  Tension: "); Serial.print(tension, 2); Serial.print("V");
  Serial.print("  Pot: ");     Serial.print(pourcent); Serial.println("%");
  delay(200);
}
📌 map(val, inMin, inMax, outMin, outMax) — rééchelonnage linéaire. Ex : map(512, 0, 1023, 0, 180) → 90 (utile pour les servos).
PWM — Comment ça marche : analogWrite(pin, 0–255) alterne rapidement HIGH/LOW. 255 = 100% HIGH = pleine puissance. 128 = 50% = mi-puissance. 0 = éteint. La fréquence est 490 Hz (ou 980 Hz pour D3 et D11). Disponible uniquement sur les broches marquées ~ : D3, D5, D6, D9, D10, D11.
pwm_fondu.ino — Fondu d'une LED & veilleuse automatique
// Fondu progressif sur broche PWM D9
const int LED = 9;
const int LDR = A1;   // photorésistance (5V → R10kΩ → A1 → LDR → GND)

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  // ── Fondu 0→255→0 ───────────────────────────────
  for (int i = 0; i <= 255; i++) {
    analogWrite(LED, i);
    delay(8);
  }
  for (int i = 255; i >= 0; i--) {
    analogWrite(LED, i);
    delay(8);
  }

  // ── Veilleuse : plus il fait sombre, plus la LED brille ──
  int lumiere     = analogRead(LDR);            // 0=sombre, 1023=clair
  int luminosite  = map(lumiere, 0, 1023, 255, 0);  // inverser
  analogWrite(LED, luminosite);
  delay(100);
}

5. Capteur DHT11 — Température & Humidité

Le DHT11 est un capteur numérique de température (0–50°C, ±2°C) et d'humidité relative (20–90%, ±5%). Il communique via un protocole série 1 fil propriétaire. Simple, bon marché, parfait pour débuter.

DHT11 (bleu)DHT22 (blanc)
Température0–50°C, ±2°C-40–80°C, ±0.5°C
Humidité20–90%, ±5%0–100%, ±2%
Vitesse1 mesure / seconde1 mesure / 2 secondes
Prix~1–3€~3–7€
UsageProjets débutants, station météo simpleMesures précises, industrie légère
Câblage DHT11 — 4 broches
Résistance pull-up obligatoire : Le protocole DHT11 utilise la ligne DATA en open-drain. Sans résistance de 10 kΩ entre DATA et 5 V, les mesures seront invalides (NaN). Certains modules DHT11 sur breakout board l'incluent déjà.
Broche DHT11Connecter à
Pin 1 — VCC5V Arduino
Pin 2 — DATAD2 Arduino + résistance 10 kΩ vers 5V
Pin 3 — NCNon connecté
Pin 4 — GNDGND Arduino
Installer la bibliothèque
  • 1

    Ouvrir le gestionnaire

    Arduino IDE → Outils → Gérer les bibliothèques (ou Ctrl+Shift+I).

  • 2

    Rechercher "DHT sensor library"

    Choisir la bibliothèque par Adafruit → Installer.

  • 3

    Installer la dépendance

    Une boîte de dialogue propose d'installer Adafruit Unified Sensor — accepter.

dht11_basique.ino — Lire température et humidité
#include "DHT.h"

const int DHT_PIN  = 2;
const int DHT_TYPE = DHT11;   // DHT11 ou DHT22

DHT dht(DHT_PIN, DHT_TYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
  delay(2000);   // laisser le capteur se stabiliser
}

void loop() {
  delay(2000);   // ⚠️ minimum 1 s entre les lectures DHT11

  float humidite    = dht.readHumidity();
  float temperature = dht.readTemperature(); // °C par défaut
  //  .readTemperature(true) → Fahrenheit

  // Toujours vérifier si la lecture est valide (NaN = erreur)
  if (isnan(humidite) || isnan(temperature)) {
    Serial.println("Erreur ! Vérifier câblage et résistance 10kΩ.");
    return;
  }

  float ressenti = dht.computeHeatIndex(temperature, humidite, false);

  Serial.print("Humidité    : "); Serial.print(humidite, 1);    Serial.println(" %");
  Serial.print("Température : "); Serial.print(temperature, 1); Serial.println(" °C");
  Serial.print("Ressenti    : "); Serial.print(ressenti, 1);   Serial.println(" °C");
  Serial.println("---");
}
📌 isnan() détecte la valeur NaN (Not a Number) que la bibliothèque retourne en cas d'erreur. Toujours vérifier avant d'utiliser la valeur !
dht11_alarme.ino — LED et buzzer d'alerte
#include "DHT.h"

const int DHT_PIN   = 2;
const int BUZZER    = 8;
const int LED_ROUGE = 7;
const int LED_VERTE = 6;
const float SEUIL_TEMP = 28.0;
const float SEUIL_HUMI = 75.0;

DHT dht(DHT_PIN, DHT11);

void setup() {
  Serial.begin(9600);
  pinMode(BUZZER, OUTPUT);
  pinMode(LED_ROUGE, OUTPUT);
  pinMode(LED_VERTE, OUTPUT);
  dht.begin();
}

void loop() {
  delay(2000);
  float t = dht.readTemperature();
  float h = dht.readHumidity();

  if (isnan(t) || isnan(h)) { Serial.println("Erreur capteur"); return; }

  bool alarme = (t > SEUIL_TEMP) || (h > SEUIL_HUMI);

  digitalWrite(LED_VERTE, !alarme);
  digitalWrite(LED_ROUGE,  alarme);

  if (alarme) {
    Serial.print("T="); Serial.print(t,1);
    Serial.print(" H="); Serial.print(h,1);
    Serial.println("  ⚠️ ALARME !");
    tone(BUZZER, 2000, 500);   // 2000 Hz pendant 500 ms
  } else {
    Serial.println("OK");
    noTone(BUZZER);
  }
}

6. Protocoles — I2C, SPI, UART

L'Arduino peut communiquer avec des centaines de capteurs et modules via trois protocoles série principaux. Choisir le bon dépend du nombre de fils disponibles et de la vitesse requise.

ProtocoleFilsVitesseAppareils maxUsage typique
UART2 (TX + RX)1200–115200 bps1 à 1 seulementGPS, Bluetooth HC-05, GSM
I2C2 (SDA + SCL)100–400 kHz127Capteurs, OLED, RTC, ADC
SPI4 (MOSI+MISO+SCK+SS)jusqu'à 8 MHzplusieurs (1 SS/esclave)Carte SD, écran TFT, Flash
Adresses I2C courantes : LCD 16×2 + module I2C : 0x27 ou 0x3F | BME280 : 0x76 ou 0x77 | MPU6050 (gyroscope) : 0x68 | DS3231 RTC : 0x57 | SSD1306 OLED : 0x3C ou 0x3D
scanner_i2c.ino — Trouver l'adresse de tes modules
#include "Wire.h"

void setup() {
  Wire.begin();       // SDA = A4, SCL = A5 sur Uno
  Serial.begin(9600);
  Serial.println("=== Scan I2C ===");
  int nb = 0;

  for (byte addr = 1; addr < 127; addr++) {
    Wire.beginTransmission(addr);
    if (Wire.endTransmission() == 0) {
      Serial.print("Trouvé à 0x");
      Serial.println(addr, HEX);
      nb++;
    }
  }
  Serial.print(nb);
  Serial.println(" appareil(s) trouvé(s)");
}

void loop() {}   // le scan se fait une seule fois dans setup()
📌 Lance ce sketch pour découvrir l'adresse I2C de n'importe quel module. Branche les modules un par un si plusieurs sont connectés.
uart_bluetooth.ino — Module HC-05 via SoftwareSerial
// HC-05 Bluetooth via UART logiciel
// Câblage : HC-05 TX → D10, HC-05 RX → D11
// (éviter D0/D1 = UART matériel = interfère avec USB)
#include "SoftwareSerial.h"

SoftwareSerial btSerial(10, 11);  // RX=D10, TX=D11

void setup() {
  Serial.begin(9600);     // moniteur PC
  btSerial.begin(9600);   // HC-05 (9600 par défaut)
  Serial.println("Bluetooth prêt.");
}

void loop() {
  if (Serial.available())   btSerial.write(Serial.read());
  if (btSerial.available()) {
    char c = btSerial.read();
    Serial.write(c);
    if (c == 'A') digitalWrite(13, HIGH);  // allumer LED
    if (c == 'E') digitalWrite(13, LOW);   // éteindre LED
  }
}

7. Afficheurs LCD & OLED

Afficher des données en temps réel sans passer par le moniteur série. Le LCD 16×2 est économique et lisible de loin. L'OLED SSD1306 128×64 permet des graphiques mais est plus délicat à programmer.

Module I2C pour LCD : Le module PCF8574 (breakout I2C) soude sur le LCD et réduit les connexions de 12 fils à 4 fils (VCC, GND, SDA=A4, SCL=A5). Bibliothèque : LiquidCrystal I2C par Frank de Brabander.
lcd_i2c.ino — Afficher température sur LCD 16×2
// Installer : "LiquidCrystal I2C" par Frank de Brabander
// Câblage : VCC→5V, GND→GND, SDA→A4, SCL→A5
#include "LiquidCrystal_I2C.h"

LiquidCrystal_I2C lcd(0x27, 16, 2);  // adresse 0x27, 16 col, 2 lignes

// Caractère personnalisé : signe degré °
byte degre[8] = {
  0b00110, 0b01001, 0b01001, 0b00110,
  0b00000, 0b00000, 0b00000, 0b00000
};

void setup() {
  lcd.begin();
  lcd.backlight();                // allumer le rétroéclairage
  lcd.createChar(0, degre);
  lcd.setCursor(0, 0);
  lcd.print("Station Meteo");
  delay(2000);
}

void afficher(float temp, float humi) {
  lcd.setCursor(0, 0);           // colonne 0, ligne 0
  lcd.print("T:"); lcd.print(temp, 1);
  lcd.write(byte(0));              // afficher le ° personnalisé
  lcd.print("C  ");

  lcd.setCursor(0, 1);           // colonne 0, ligne 1
  lcd.print("H:"); lcd.print(humi, 0); lcd.print("%  ");
}

void loop() {
  afficher(23.5, 65.0);
  delay(2000);
}
📌 Si l'adresse 0x27 ne fonctionne pas, essayer 0x3F. Utiliser le scanner I2C de la section 6 pour trouver l'adresse correcte.
oled_ssd1306.ino — Graphique sur OLED 128×64
// Installer : "Adafruit SSD1306" + "Adafruit GFX Library"
#include "Wire.h"
#include "Adafruit_GFX.h"
#include "Adafruit_SSD1306.h"

Adafruit_SSD1306 oled(128, 64, &Wire, -1);

void setup() {
  Serial.begin(9600);
  if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("OLED introuvable !");
    while (true);
  }
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
}

void afficherDonnees(float temp, float humi) {
  oled.clearDisplay();

  oled.setTextSize(2);              // grands caractères 12×16 px
  oled.setCursor(0, 0);
  oled.print(temp, 1); oled.print(" C");

  oled.setTextSize(1);              // petits caractères 6×8 px
  oled.setCursor(0, 25);
  oled.print("Humidite: "); oled.print(humi, 0); oled.print("%");

  // Barre de progression pour l'humidité
  int barre = map(humi, 0, 100, 0, 128);
  oled.fillRect(0, 55, barre, 8, SSD1306_WHITE);
  oled.drawRect(0, 55, 128, 8, SSD1306_WHITE);

  oled.display();   // ← INDISPENSABLE : envoyer le buffer à l'écran
}

void loop() {
  afficherDonnees(23.5, 65.0);
  delay(2000);
}
📌 Sans oled.display() à la fin, rien n'apparaît. Tout se dessine dans un buffer en RAM, puis display() l'envoie à l'écran en une seule fois.

8. Moteurs & Actionneurs

L'Arduino ne peut pas alimenter directement un moteur — ses broches fournissent au maximum 40 mA. Il faut toujours passer par un circuit de puissance : transistor, driver L298N ou MOSFET.

Règle de sécurité : Un moteur DC consomme plusieurs centaines de mA et génère des pics de courant au démarrage. Brancher un moteur directement sur une broche GPIO = broche ou ATmega grillé. Toujours utiliser un driver.
servo.ino — Servo-moteur SG90
// Câblage SG90 : marron→GND, rouge→5V, orange→D9
// La lib Servo gère le signal PWM 50 Hz (1–2 ms) automatiquement
#include "Servo.h"

Servo monServo;

void setup() {
  monServo.attach(9);   // attacher à la broche D9
}

void loop() {
  // Balayage 0° → 180° → 0°
  for (int angle = 0; angle <= 180; angle += 5) {
    monServo.write(angle);
    delay(50);
  }
  for (int angle = 180; angle >= 0; angle -= 5) {
    monServo.write(angle);
    delay(50);
  }

  // Contrôle par potentiomètre :
  // int angle = map(analogRead(A0), 0, 1023, 0, 180);
  // monServo.write(angle);
}
moteur_dc_l298n.ino — Moteur DC avec driver L298N
// L298N : double pont en H — pilote 2 moteurs DC
// Câblage moteur A : IN1→D2, IN2→D3, ENA→D9(PWM)
const int IN1 = 2;
const int IN2 = 3;
const int ENA = 9;   // Enable A → vitesse par PWM

void avancer(int vitesse) {
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  analogWrite(ENA, vitesse);  // 0–255
}
void reculer(int vitesse) {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  analogWrite(ENA, vitesse);
}
void stopper() {
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  analogWrite(ENA, 0);
}

void setup() {
  pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(ENA, OUTPUT);
}
void loop() {
  avancer(200);  delay(2000);
  stopper();    delay(500);
  reculer(150); delay(2000);
  stopper();    delay(500);
}

9. Projet Final — Station Météo Complète

Projet de A à Z : Arduino Uno + DHT11 mesure la température et l'humidité toutes les 2 secondes, affiche sur LCD I2C, alerte LED + buzzer si un seuil est dépassé, et sauvegarde les données sur carte SD au format CSV.

Matériel & Connexions
  • 1

    Matériel nécessaire

    Arduino Uno, DHT11, LCD 16×2 + module I2C, buzzer passif, 1 LED rouge, 1 LED verte, module carte SD, breadboard, fils dupont.

  • 2

    Connexions

    DHT11 DATA→D2, LCD SDA→A4 SCL→A5, Buzzer→D8, LED rouge→D6, LED verte→D7, SD CS→D4 MOSI→D11 MISO→D12 SCK→D13.

  • 3

    Bibliothèques à installer

    DHT sensor library (Adafruit), LiquidCrystal I2C (Frank de Brabander), SD et SPI (incluses dans l'IDE).

  • 4

    Préparer la carte SD

    Formater en FAT32. Le fichier meteo.csv sera créé automatiquement au premier démarrage.

  • 5

    Calibrer les seuils

    Modifier SEUIL_TEMP et SEUIL_HUMI selon ton environnement de test.

  • 6

    Tester

    Ouvrir le moniteur série à 9600 baud. Souffler sur le DHT11 pour faire monter l'humidité et déclencher l'alarme.

station_meteo_complete.ino — Code complet
#include "DHT.h"
#include "LiquidCrystal_I2C.h"
#include "Wire.h"
#include "SD.h"
#include "SPI.h"

// ── Broches ─────────────────────────────────────────────
#define DHT_PIN    2
#define BUZZER     8
#define LED_ROUGE  6
#define LED_VERTE  7
#define SD_CS      4

// ── Seuils ──────────────────────────────────────────────
const float SEUIL_TEMP = 28.0;   // °C
const float SEUIL_HUMI = 75.0;   // %
const long  INTERVALLE = 2000;   // ms entre mesures

// ── Objets ──────────────────────────────────────────────
DHT dht(DHT_PIN, DHT11);
LiquidCrystal_I2C lcd(0x27, 16, 2);

// ── Variables globales ───────────────────────────────────
unsigned long tDerniereLecture = 0;
bool sdOk = false;
byte degre[8] = {0b00110,0b01001,0b01001,0b00110,0b00000,0b00000,0b00000,0b00000};

void setup() {
  Serial.begin(9600);
  Serial.println("=== Station Météo ===");

  pinMode(BUZZER, OUTPUT);
  pinMode(LED_ROUGE, OUTPUT);
  pinMode(LED_VERTE, OUTPUT);
  digitalWrite(LED_VERTE, HIGH);  // vert au démarrage = OK

  dht.begin();

  lcd.begin(); lcd.backlight();
  lcd.createChar(0, degre);
  lcd.setCursor(0, 0); lcd.print("Station Meteo");
  lcd.setCursor(0, 1); lcd.print("Init...");

  sdOk = SD.begin(SD_CS);
  Serial.println(sdOk ? "SD: OK" : "SD: non trouvée");
  if (sdOk) {
    File f = SD.open("meteo.csv", FILE_WRITE);
    if (f) { f.println("temps_s,temperature,humidite,alarme"); f.close(); }
  }
  delay(2000);
}

void mettreAJourLCD(float t, float h) {
  lcd.setCursor(0, 0);
  lcd.print("T:"); lcd.print(t, 1); lcd.write(byte(0)); lcd.print("C  ");
  lcd.setCursor(0, 1);
  lcd.print("H:"); lcd.print(h, 0); lcd.print("%   ");
}

void sauvegarderSD(float t, float h, bool alarme) {
  if (!sdOk) return;
  File f = SD.open("meteo.csv", FILE_WRITE);
  if (f) {
    f.print(millis()/1000); f.print(",");
    f.print(t, 2);           f.print(",");
    f.print(h, 2);           f.print(",");
    f.println(alarme ? 1 : 0);
    f.close();
  }
}

void loop() {
  if (millis() - tDerniereLecture < INTERVALLE) return;
  tDerniereLecture = millis();

  float t = dht.readTemperature();
  float h = dht.readHumidity();

  if (isnan(t) || isnan(h)) {
    Serial.println("Erreur DHT11 !"); return;
  }

  bool alarme = (t > SEUIL_TEMP) || (h > SEUIL_HUMI);
  digitalWrite(LED_ROUGE, alarme);
  digitalWrite(LED_VERTE, !alarme);
  if (alarme) tone(BUZZER, 1500, 200); else noTone(BUZZER);

  mettreAJourLCD(t, h);
  sauvegarderSD(t, h, alarme);

  Serial.print("T="); Serial.print(t, 1);
  Serial.print(" H="); Serial.print(h, 1);
  Serial.println(alarme ? "  ⚠️ ALARME" : "  OK");
}
📌 Le pattern if (millis() - tDerniereLecture < INTERVALLE) return; est la clé du code non-bloquant. Rien ne bloque le loop(), donc d'autres capteurs ou boutons peuvent être lus entre les mesures.

Quiz — 40 Questions

Du niveau débutant à expert — Arduino Uno, GPIO, ADC, DHT11, I2C, mémoire et optimisation. Chaque erreur est expliquée en détail.

Progression
0 / 40 répondues  ·  Score : 0
Niveau 1 — Débutant Bases Arduino, GPIO, DHT11, I2C, Serial (Q01–Q10)
Q01Débutant
Quelle fonction Arduino s'exécute une seule fois au démarrage ?
Q02Débutant
Que retourne analogRead(A0) sur Arduino Uno ?
Q03Débutant
Sur quelle broche se trouve la LED intégrée de l'Arduino Uno ?
Q04Débutant
Que fait pinMode(7, OUTPUT) ?
Q05Débutant
Pourquoi utiliser INPUT_PULLUP pour un bouton plutôt que INPUT ?
Q06Débutant
Quelle bibliothèque faut-il installer pour utiliser le DHT11 ?
Q07Débutant
Quelles broches de l'Arduino Uno sont les entrées analogiques (ADC) ?
Q08Débutant
Quelle est la différence principale entre delay(1000) et millis() ?
Q09Débutant
Que fait Serial.begin(9600) ?
Q10Débutant
Sur quelle broche est la SDA (I2C) par défaut sur Arduino Uno ?
Niveau 2 — Intermédiaire ADC, millis, mémoire, capteurs avancés (Q11–Q25)
Q11Intermédiaire
Que se passe-t-il si tu lis le DHT11 plus d'une fois par seconde ?
Q12Intermédiaire
Quelle fonction vérifie si une valeur float est NaN ?
Q13Intermédiaire
Pourquoi les broches D0 et D1 ne doivent pas être utilisées pendant la programmation USB ?
Q14Intermédiaire
Que fait map(val, 0, 1023, 0, 180) ?
Q15Intermédiaire
Quel est le courant maximum par broche GPIO de l'Arduino Uno ?
Q16Intermédiaire
Quelle résistance pull-up recommander pour le DHT11 sur Arduino 5V ?
Q17Intermédiaire
Que contient le 5ème octet (checksum) envoyé par le DHT11 ?
Q18Intermédiaire
Comment déclarer une variable qui survit entre les appels de loop() sans être globale ?
Q19Intermédiaire
Quel est le rôle de Wire.begin() sur Arduino Uno ?
Q20Intermédiaire
Que mesure pulseIn(pin, HIGH) ?
Q21Intermédiaire
Pourquoi écrire volatile devant une variable partagée avec une interruption ?
Q22Intermédiaire
Quelle fréquence PWM produit analogWrite() sur D3 et D11 de l'Arduino Uno ?
Q23Intermédiaire
Comment éviter le problème d'overflow de millis() après ~49 jours ?
Q24Intermédiaire
Quelle est la taille de la SRAM de l'Arduino Uno et pourquoi est-ce critique ?
Q25Intermédiaire
À quoi sert la macro F() dans Serial.print(F("message")) ?
Niveau 3 — Expert Timers, PROGMEM, FSM, optimisation, mémoire (Q26–Q40)
Q26Expert
Pourquoi ne faut-il pas modifier Timer0 sur Arduino Uno ?
Q27Expert
Que se passe-t-il quand la SRAM de l'Arduino est pleine (stack overflow) ?
Q28Expert
Qu'est-ce qu'une machine à états (FSM) et pourquoi l'utiliser sur Arduino ?
Q29Expert
Comment brancher 2 appareils I2C (LCD 0x27 et OLED 0x3C) sur le même Arduino ?
Q30Expert
Quelle est la différence entre EEPROM.write() et EEPROM.update() ?
Q31Expert
À quoi sert PROGMEM et dans quel cas est-il indispensable ?
Q32Expert
Comment implémenter un anti-rebond dans une ISR (routine d'interruption) ?
Q33Expert
Pourquoi le DHT11 a-t-il une précision de seulement ±2°C ?
Q34Expert
Combien de cases faut-il pour stocker 24h de mesures DHT11 toutes les minutes ?
Q35Expert
Comment lire plusieurs capteurs DS18B20 sur le même bus 1-Wire ?
Q36Expert
Quelle est la signification de NaN et comment le produire pour tester isnan() ?
Q37Expert
Quelle est la différence entre Serial.print() et Serial.println() ?
Q38Expert
Comment afficher un float avec exactement 2 décimales avec Serial.print() ?
Q39Expert
Quel est le problème de brancher une LED directement sans résistance sur un GPIO Arduino ?
Q40Expert
Quelle instruction permet d'afficher oled.display() et pourquoi est-elle indispensable sur SSD1306 ?
Score final
—

Mémo Rapide — Cheat Sheet Arduino

GPIO Digital

pinMode(pin, OUTPUT);
pinMode(pin, INPUT_PULLUP);
digitalWrite(pin, HIGH/LOW);
int v = digitalRead(pin);
// pull-up : repos=HIGH, appui=LOW
// Max 40mA/broche, 200mA total

ADC & PWM

int v = analogRead(A0);   // 0–1023
float V = v * 5.0 / 1023.0;
int p = map(v,0,1023,0,100);
// PWM sur ~ : 3,5,6,9,10,11
analogWrite(9, 0-255);
// 490Hz (ou 980Hz D3/D11)

DHT11

#include "DHT.h"
DHT dht(2, DHT11);
dht.begin();
// Dans loop() :
delay(2000); // min 1s !
float t = dht.readTemperature();
float h = dht.readHumidity();
if (isnan(t)) // vérifier !

I2C (Wire.h)

#include "Wire.h"
Wire.begin(); // SDA=A4, SCL=A5
// Scanner I2C :
Wire.beginTransmission(addr);
byte e = Wire.endTransmission();
// e==0 → appareil trouvé
// pull-up 4.7kΩ sur SDA et SCL

Millis non-bloquant

unsigned long t = 0;
// Dans loop() :
if (millis() - t >= 2000) {
  t = millis();
  // action toutes les 2s
}
// Ne JAMAIS bloquer avec delay()
// dans les projets avancés

EEPROM

#include "EEPROM.h"
// 100 000 cycles max par adresse
EEPROM.update(addr, val);
// update = write si changé !
byte v = EEPROM.read(addr);
float f; EEPROM.get(10, f);
EEPROM.put(10, f);
// Uno : 1024 octets (0–1023)

Serial debug

Serial.begin(9600);
Serial.print(F("msg")); // Flash !
Serial.print(val, 2); // 2 déc.
Serial.println(val);  // + newline
// F() garde la chaîne en Flash
// → économise la SRAM de 2KB

Broches spéciales Uno

// D0/D1 : RX/TX (USB) — éviter
// D2/D3 : INT0/INT1 interruptions
// D3,5,6,9,10,11 : PWM ~
// D10-D13 : SPI SS/MOSI/MISO/SCK
// D13 : LED_BUILTIN intégrée
// A4/A5 : I2C SDA/SCL
// A0–A5 : ADC (aussi GPIO digital)
Cours Arduino — BTS EII — Lycée Moulay Youssef, Tanger