TPs Arduino

TPs Arduino - 11 Projets Pratiques | BTS Electronique

💡

TP1 : Clignotement LED (Blink)

Premier programme Arduino - Controle d'une LED

⏱️ 1h 📊 Niveau: Debutant 🔧 GPIO Output

🎯 Objectifs pedagogiques

Decouvrir l'environnement Arduino IDE
Comprendre la structure d'un programme Arduino (setup/loop)
Configurer une broche en sortie (OUTPUT)
Utiliser les fonctions digitalWrite() et delay()

Materiel necessaire

🔧

Liste du materiel

1× Arduino UNO
1× LED rouge 5mm
1× Resistance 220Ω (ou 330Ω)
Breadboard + fils de connexion
Câble USB

Schema de câblage

    ARDUINO UNO                      LED
    ┌─────────────┐                  
    │             │                 ┌───┐
    │         D13 ├────────[220Ω]───┤ + │ (Anode - patte longue)
    │             │                 │LED│
    │         GND ├─────────────────┤ - │ (Cathode - patte courte)
    │             │                 └───┘
    └─────────────┘

    Note: La LED integree sur pin 13 peut aussi etre utilisee sans câblage externe

Code Arduino

/*
 * TP1 : Clignotement LED (Blink)
 * BTS Electronique - Arduino
 */

// Definition de la broche LED
const int LED_PIN = 13;

// Configuration initiale (executee une seule fois)
void setup() {
    // Configure la broche en sortie
    pinMode(LED_PIN, OUTPUT);
}

// Boucle principale (executee en continu)
void loop() {
    digitalWrite(LED_PIN, HIGH);  // Allumer LED
    delay(1000);                  // Attendre 1 seconde
    
    digitalWrite(LED_PIN, LOW);   // Éteindre LED
    delay(1000);                  // Attendre 1 seconde
}

💡

Astuce Modifiez les valeurs de delay() pour changer la frequence de clignotement. Essayez 100ms, 500ms, 2000ms.

Exercices complementaires

Faire clignoter 3 LEDs en sequence (feu tricolore)
Creer un clignotement SOS en morse (... --- ...)
Utiliser millis() au lieu de delay() (non bloquant)

📝 Questions d'analyse

Pourquoi utilise-t-on une resistance avec la LED ?
Quelle est la difference entre setup() et loop() ?
Que signifie HIGH et LOW en numerique ?
Calculez la valeur de resistance pour une LED rouge (Vf=2V, If=20mA) alimentee en 5V.

🔘

TP2 : Lecture Bouton Poussoir

Entree numerique et anti-rebond

⏱️ 1h30 📊 Niveau: Debutant 🔧 GPIO Input

🎯 Objectifs pedagogiques

Configurer une entree numerique avec resistance de pull-up
Lire l'etat d'un bouton poussoir
Comprendre et implementer l'anti-rebond (debounce)
Utiliser le moniteur serie pour le debogage

Materiel necessaire

🔧

Liste du materiel

1× Arduino UNO
1× Bouton poussoir
1× LED + resistance 220Ω
1× Resistance 10kΩ (pull-down optionnel)
Breadboard + fils

Schema de câblage

    ARDUINO UNO              BOUTON              LED
    ┌─────────────┐         ┌─────┐
    │             │         │     │
    │          D2 ├─────────┤     ├──── GND
    │             │         └─────┘
    │             │          (avec INPUT_PULLUP, pas besoin de resistance externe)
    │             │
    │         D13 ├────[220Ω]────LED────GND
    │             │
    │         GND ├─────────────────────────
    └─────────────┘

    INPUT_PULLUP : Bouton appuye = LOW, Bouton relâche = HIGH

Code Arduino avec anti-rebond

/*
 * TP2 : Lecture Bouton avec Anti-rebond
 * BTS Electronique - Arduino
 */

const int BUTTON_PIN = 2;
const int LED_PIN = 13;

// Variables pour l'anti-rebond
int buttonState = HIGH;
int lastButtonState = HIGH;
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50;  // 50ms

bool ledState = false;

void setup() {
    pinMode(BUTTON_PIN, INPUT_PULLUP);  // Resistance interne activee
    pinMode(LED_PIN, OUTPUT);
    Serial.begin(9600);
    Serial.println("TP2: Bouton + Anti-rebond");
}

void loop() {
    int reading = digitalRead(BUTTON_PIN);
    
    // Detection de changement d'etat
    if (reading != lastButtonState) {
        lastDebounceTime = millis();
    }
    
    // Apres le delai anti-rebond
    if ((millis() - lastDebounceTime) > debounceDelay) {
        if (reading != buttonState) {
            buttonState = reading;
            
            // Action sur front descendant (appui)
            if (buttonState == LOW) {
                ledState = !ledState;  // Inverser l'etat LED
                digitalWrite(LED_PIN, ledState);
                Serial.print("LED: ");
                Serial.println(ledState ? "ON" : "OFF");
            }
        }
    }
    
    lastButtonState = reading;
}

Questions d'analyse

📝 Questions

Qu'est-ce que le phenomene de rebond d'un bouton ?
À quoi sert INPUT_PULLUP ? Quelle est l'alternative ?
Pourquoi utiliser millis() plutot que delay() pour l'anti-rebond ?
Combien d'appuis sont detectes si on desactive l'anti-rebond ?

🌈

TP3 : PWM - Variation de Luminosite

Modulation de largeur d'impulsion et LED RGB

⏱️ 1h30 📊 Niveau: Intermediaire 🔧 PWM analogWrite

🎯 Objectifs pedagogiques

Comprendre le principe du PWM
Utiliser analogWrite() pour varier l'intensite
Controler une LED RGB
Creer des effets visuels (fade, rainbow)

Materiel necessaire

1× Arduino UNO
1× LED RGB (cathode commune)
3× Resistances 220Ω
1× Potentiometre 10kΩ (optionnel)

⚠️

Broches PWM Arduino UNO Seules les broches 3, 5, 6, 9, 10, 11 supportent le PWM (marquees ~)

Code : Effet Fade

/*
 * TP3 : PWM - Effet Fade sur LED
 * BTS Electronique - Arduino
 */

const int LED_PIN = 9;  // Broche PWM

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

void loop() {
    // Augmentation progressive (0 → 255)
    for (int brightness = 0; brightness <= 255; brightness++) {
        analogWrite(LED_PIN, brightness);
        delay(10);
    }
    
    // Diminution progressive (255 → 0)
    for (int brightness = 255; brightness >= 0; brightness--) {
        analogWrite(LED_PIN, brightness);
        delay(10);
    }
}

Code : LED RGB Rainbow

/*
 * TP3 : LED RGB - Effet Rainbow
 */

const int RED_PIN = 9;
const int GREEN_PIN = 10;
const int BLUE_PIN = 11;

void setup() {
    pinMode(RED_PIN, OUTPUT);
    pinMode(GREEN_PIN, OUTPUT);
    pinMode(BLUE_PIN, OUTPUT);
}

void setColor(int red, int green, int blue) {
    analogWrite(RED_PIN, red);
    analogWrite(GREEN_PIN, green);
    analogWrite(BLUE_PIN, blue);
}

void loop() {
    // Rouge → Jaune
    for (int i = 0; i < 256; i++) { setColor(255, i, 0); delay(5); }
    // Jaune → Vert
    for (int i = 255; i >= 0; i--) { setColor(i, 255, 0); delay(5); }
    // Vert → Cyan
    for (int i = 0; i < 256; i++) { setColor(0, 255, i); delay(5); }
    // Cyan → Bleu
    for (int i = 255; i >= 0; i--) { setColor(0, i, 255); delay(5); }
    // Bleu → Magenta
    for (int i = 0; i < 256; i++) { setColor(i, 0, 255); delay(5); }
    // Magenta → Rouge
    for (int i = 255; i >= 0; i--) { setColor(255, 0, i); delay(5); }
}

📡

TP4 : Capteur Ultrason HC-SR04

Mesure de distance par ultrasons

⏱️ 2h 📊 Niveau: Intermediaire 🔧 Ultrason

🎯 Objectifs pedagogiques

Comprendre le principe de mesure par ultrasons
Utiliser les fonctions pulseIn() et micros()
Calculer une distance a partir du temps de vol
Creer un radar de recul avec LEDs

Materiel necessaire

1× Arduino UNO
1× Capteur HC-SR04
3× LEDs (vert, jaune, rouge)
3× Resistances 220Ω
1× Buzzer (optionnel)

Principe de fonctionnement

    HC-SR04 : Mesure de distance par ultrasons
    
    ┌─────────────────────────────────────────────────────────┐
    │                                                         │
    │  Arduino         HC-SR04                   Obstacle     │
    │     │               │                          │        │
    │     │──TRIGGER──────│                          │        │
    │     │               │════════════════════════▶│        │
    │     │               │        ONDE ULTRASON    │        │
    │     │               │◀════════════════════════│        │
    │     │◀───ECHO───────│           ÉCHO          │        │
    │     │               │                          │        │
    └─────────────────────────────────────────────────────────┘
    
    Distance = (Temps × Vitesse du son) / 2
    Distance (cm) = Temps (µs) × 0.034 / 2
    
    Vitesse du son ≈ 340 m/s = 0.034 cm/µs

Schema de câblage

    ARDUINO UNO              HC-SR04
    ┌─────────────┐         ┌─────────────┐
    │          5V ├─────────┤ VCC         │
    │         GND ├─────────┤ GND         │
    │          D9 ├─────────┤ TRIG        │
    │         D10 ├─────────┤ ECHO        │
    └─────────────┘         └─────────────┘
    
    LEDs indicatrices :
    D3 ────[220Ω]────LED VERT────GND    (> 30cm)
    D4 ────[220Ω]────LED JAUNE──GND    (10-30cm)
    D5 ────[220Ω]────LED ROUGE──GND    (< 10cm)

Code : Radar de recul

/*
 * TP4 : Capteur Ultrason HC-SR04 - Radar de recul
 * BTS Electronique - Arduino
 */

const int TRIG_PIN = 9;
const int ECHO_PIN = 10;
const int LED_GREEN = 3;
const int LED_YELLOW = 4;
const int LED_RED = 5;
const int BUZZER = 6;

void setup() {
    pinMode(TRIG_PIN, OUTPUT);
    pinMode(ECHO_PIN, INPUT);
    pinMode(LED_GREEN, OUTPUT);
    pinMode(LED_YELLOW, OUTPUT);
    pinMode(LED_RED, OUTPUT);
    pinMode(BUZZER, OUTPUT);
    Serial.begin(9600);
}

float measureDistance() {
    // Envoyer impulsion TRIGGER de 10µs
    digitalWrite(TRIG_PIN, LOW);
    delayMicroseconds(2);
    digitalWrite(TRIG_PIN, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG_PIN, LOW);
    
    // Mesurer duree de l'echo
    long duration = pulseIn(ECHO_PIN, HIGH, 30000);
    
    // Calculer distance (cm)
    float distance = duration * 0.034 / 2;
    
    return distance;
}

void loop() {
    float distance = measureDistance();
    
    // Affichage serie
    Serial.print("Distance: ");
    Serial.print(distance);
    Serial.println(" cm");
    
    // Éteindre toutes les LEDs
    digitalWrite(LED_GREEN, LOW);
    digitalWrite(LED_YELLOW, LOW);
    digitalWrite(LED_RED, LOW);
    noTone(BUZZER);
    
    // Allumer LED selon distance
    if (distance > 0 && distance < 10) {
        digitalWrite(LED_RED, HIGH);
        tone(BUZZER, 1000);  // Alerte sonore
    } else if (distance >= 10 && distance < 30) {
        digitalWrite(LED_YELLOW, HIGH);
        tone(BUZZER, 500, 100);  // Bip court
    } else if (distance >= 30 && distance < 200) {
        digitalWrite(LED_GREEN, HIGH);
    }
    
    delay(200);
}

Questions d'analyse

📝 Questions

Pourquoi divise-t-on le temps par 2 dans le calcul ?
Quelle est la portee maximale du HC-SR04 ?
Quelles sont les sources d'erreur possibles ?
Comment ameliorer la precision des mesures ?

🌡️

TP5 : Capteur de Temperature DHT11/DHT22

Mesure temperature et humidite

⏱️ 2h 📊 Niveau: Intermediaire 🔧 Capteur numerique

🎯 Objectifs pedagogiques

Utiliser une bibliotheque externe (DHT)
Lire temperature et humidite
Creer une station meteo simple
Afficher les donnees sur le moniteur serie

Comparaison DHT11 vs DHT22

Caracteristique	DHT11	DHT22
Plage temperature	0 a 50°C	-40 a 80°C
Precision T°	±2°C	±0.5°C
Plage humidite	20-80%	0-100%
Precision H	±5%	±2-5%
Prix	~2€	~5€

Installation de la bibliotheque

Dans Arduino IDE : Croquis → Inclure une bibliotheque → Gerer les bibliotheques

Rechercher et installer : DHT sensor library par Adafruit

Code : Station Meteo

/*
 * TP5 : Capteur DHT11/DHT22 - Station Meteo
 * BTS Electronique - Arduino
 */

#include "DHT.h"

#define DHT_PIN 2
#define DHT_TYPE DHT11  // ou DHT22

DHT dht(DHT_PIN, DHT_TYPE);

void setup() {
    Serial.begin(9600);
    Serial.println("Station Meteo - DHT11");
    dht.begin();
}

void loop() {
    // Attendre 2 secondes entre les lectures
    delay(2000);
    
    // Lire humidite et temperature
    float humidity = dht.readHumidity();
    float tempC = dht.readTemperature();
    float tempF = dht.readTemperature(true);  // Fahrenheit
    
    // Verifier si la lecture a reussi
    if (isnan(humidity) || isnan(tempC)) {
        Serial.println("Erreur de lecture DHT!");
        return;
    }
    
    // Calculer l'indice de chaleur (ressenti)
    float heatIndex = dht.computeHeatIndex(tempC, humidity, false);
    
    // Affichage
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.print("🌡️ Temperature: ");
    Serial.print(tempC);
    Serial.println(" °C");
    
    Serial.print("💧 Humidite:    ");
    Serial.print(humidity);
    Serial.println(" %");
    
    Serial.print("🔥 Ressenti:    ");
    Serial.print(heatIndex);
    Serial.println(" °C");
}

📺

TP6 : Afficheur LCD 16x2 I2C

Affichage de texte et donnees capteurs

⏱️ 2h 📊 Niveau: Intermediaire 🔧 I2C LCD

Schema de câblage I2C

    ARDUINO UNO              LCD I2C (PCF8574)
    ┌─────────────┐         ┌─────────────────┐
    │          5V ├─────────┤ VCC             │
    │         GND ├─────────┤ GND             │
    │          A4 ├─────────┤ SDA             │
    │          A5 ├─────────┤ SCL             │
    └─────────────┘         └─────────────────┘
    
    Adresse I2C typique : 0x27 ou 0x3F
    (Scanner I2C disponible pour detecter l'adresse)

Code : Affichage temperature sur LCD

/*
 * TP6 : LCD I2C 16x2 + Capteur DHT11
 * BTS Electronique - Arduino
 */

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "DHT.h"

// Configuration LCD (adresse 0x27, 16 colonnes, 2 lignes)
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Configuration DHT
#define DHT_PIN 2
DHT dht(DHT_PIN, DHT11);

// Caracteres personnalises
byte degre[] = {0x06,0x09,0x09,0x06,0x00,0x00,0x00,0x00};
byte goutte[] = {0x04,0x04,0x0A,0x0A,0x11,0x11,0x0E,0x00};

void setup() {
    lcd.init();
    lcd.backlight();
    lcd.createChar(0, degre);
    lcd.createChar(1, goutte);
    
    dht.begin();
    
    lcd.setCursor(0, 0);
    lcd.print("Station Meteo");
    lcd.setCursor(0, 1);
    lcd.print("Initialisation..");
    delay(2000);
}

void loop() {
    float temp = dht.readTemperature();
    float hum = dht.readHumidity();
    
    lcd.clear();
    
    // Ligne 1 : Temperature
    lcd.setCursor(0, 0);
    lcd.print("Temp: ");
    lcd.print(temp, 1);
    lcd.write(0);  // Symbole degre
    lcd.print("C");
    
    // Ligne 2 : Humidite
    lcd.setCursor(0, 1);
    lcd.write(1);  // Symbole goutte
    lcd.print(" Hum: ");
    lcd.print(hum, 0);
    lcd.print("%");
    
    delay(2000);
}

⚙️

TP7 : Servomoteur

Controle de position angulaire

⏱️ 1h30 📊 Niveau: Intermediaire 🔧 PWM Servo

Code : Controle par potentiometre

/*
 * TP7 : Servomoteur controle par potentiometre
 * BTS Electronique - Arduino
 */

#include <Servo.h>

Servo monServo;

const int SERVO_PIN = 9;
const int POT_PIN = A0;

void setup() {
    monServo.attach(SERVO_PIN);
    Serial.begin(9600);
}

void loop() {
    // Lire potentiometre (0-1023)
    int potValue = analogRead(POT_PIN);
    
    // Convertir en angle (0-180°)
    int angle = map(potValue, 0, 1023, 0, 180);
    
    // Appliquer l'angle au servo
    monServo.write(angle);
    
    Serial.print("Pot: ");
    Serial.print(potValue);
    Serial.print(" → Angle: ");
    Serial.println(angle);
    
    delay(50);
}

Code : Balayage automatique

// Balayage de 0° a 180° et retour
void loop() {
    // Balayage aller
    for (int angle = 0; angle <= 180; angle++) {
        monServo.write(angle);
        delay(15);
    }
    
    // Balayage retour
    for (int angle = 180; angle >= 0; angle--) {
        monServo.write(angle);
        delay(15);
    }
}

☀️

TP8 : Capteur de Lumiere (LDR)

Photoresistance et eclairage automatique

⏱️ 1h30 📊 Niveau: Debutant 🔧 ADC

Code : Éclairage automatique

/*
 * TP8 : LDR - Éclairage automatique
 * BTS Electronique - Arduino
 */

const int LDR_PIN = A0;
const int LED_PIN = 9;
const int SEUIL_OBSCURITE = 300;  // À ajuster

void setup() {
    pinMode(LED_PIN, OUTPUT);
    Serial.begin(9600);
}

void loop() {
    int lumiere = analogRead(LDR_PIN);
    
    Serial.print("Lumiere: ");
    Serial.println(lumiere);
    
    // Éclairage automatique inverse a la lumiere
    int brightness = map(lumiere, 0, 1023, 255, 0);
    brightness = constrain(brightness, 0, 255);
    
    analogWrite(LED_PIN, brightness);
    
    // Ou version ON/OFF
    /*
    if (lumiere < SEUIL_OBSCURITE) {
        digitalWrite(LED_PIN, HIGH);  // Allumer si sombre
    } else {
        digitalWrite(LED_PIN, LOW);   // Éteindre si lumineux
    }
    */
    
    delay(100);
}

🔊

TP9 : Buzzer et Melodies

Generation de sons et alarmes

⏱️ 1h30 📊 Niveau: Debutant 🔧 tone()

Frequences des notes musicales

Note	Do	Re	Mi	Fa	Sol	La	Si
Freq (Hz)	262	294	330	349	392	440	494

Code : Melodie simple

/*
 * TP9 : Buzzer - Melodie
 * BTS Electronique - Arduino
 */

const int BUZZER = 8;

// Notes musicales (frequences en Hz)
#define NOTE_C4  262
#define NOTE_D4  294
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_G4  392
#define NOTE_A4  440
#define NOTE_B4  494
#define NOTE_C5  523

// Melodie : "Au clair de la lune"
int melody[] = {NOTE_C4, NOTE_C4, NOTE_C4, NOTE_D4, NOTE_E4, NOTE_D4,
                NOTE_C4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4};
int durations[] = {4, 4, 4, 4, 2, 2,
                   4, 4, 4, 4, 1};

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

void loop() {
    for (int i = 0; i < 11; i++) {
        int noteDuration = 1000 / durations[i];
        tone(BUZZER, melody[i], noteDuration);
        delay(noteDuration * 1.3);
        noTone(BUZZER);
    }
    delay(2000);
}

🔌

TP10 : Module Relais

Commande de charges secteur

⏱️ 2h 📊 Niveau: Intermediaire 🔧 Relais 5V

⚠️ Precautions de securite

⚠️

DANGER - Courant secteur 230V

Ne jamais toucher les parties sous tension
Couper l'alimentation secteur avant câblage
Utiliser des boitiers isoles
Verifier l'isolation du relais

Code : Minuterie avec relais

/*
 * TP10 : Module Relais - Minuterie
 * BTS Electronique - Arduino
 */

const int RELAY_PIN = 7;
const int BUTTON_PIN = 2;
const unsigned long DURATION = 10000;  // 10 secondes

bool relayState = false;
unsigned long startTime = 0;

void setup() {
    pinMode(RELAY_PIN, OUTPUT);
    pinMode(BUTTON_PIN, INPUT_PULLUP);
    digitalWrite(RELAY_PIN, LOW);  // Relais OFF
    Serial.begin(9600);
}

void loop() {
    // Appui bouton = demarrer minuterie
    if (digitalRead(BUTTON_PIN) == LOW && !relayState) {
        relayState = true;
        startTime = millis();
        digitalWrite(RELAY_PIN, HIGH);  // Relais ON
        Serial.println("Relais ON - Minuterie demarree");
        delay(300);  // Anti-rebond
    }
    
    // Verifier si temps ecoule
    if (relayState && (millis() - startTime >= DURATION)) {
        relayState = false;
        digitalWrite(RELAY_PIN, LOW);  // Relais OFF
        Serial.println("Relais OFF - Minuterie terminee");
    }
}

🏠

TP11 : Projet Final - Station Domotique

Integration de tous les capteurs et actionneurs

⏱️ 4h 📊 Niveau: Avance 🔧 Projet complet

🎯 Objectifs du projet

Integrer capteurs de temperature, lumiere et ultrason
Afficher les donnees sur LCD
Controler LED, buzzer et relais selon conditions
Creer une interface utilisateur avec boutons

Fonctionnalites

Mode Meteo : Affichage temperature/humidite
Mode Alarme : Detection de presence par ultrason
Mode Lumiere : Éclairage automatique selon LDR
Mode Manuel : Controle par boutons

Code : Projet Station Domotique

/*
 * TP11 : Station Domotique Complete
 * BTS Electronique - Arduino
 * 
 * Materiel : DHT11, HC-SR04, LDR, LCD I2C, LEDs, Buzzer, Relais, Boutons
 */

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "DHT.h"

// Configuration des broches
#define DHT_PIN      2
#define TRIG_PIN     9
#define ECHO_PIN     10
#define LDR_PIN      A0
#define BTN_MODE     3
#define LED_GREEN    4
#define LED_RED      5
#define BUZZER       6
#define RELAY        7
#define LED_PWM      11

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

// Variables globales
int mode = 0;  // 0=Meteo, 1=Alarme, 2=Lumiere
bool alarmeActive = false;
unsigned long lastUpdate = 0;

void setup() {
    Serial.begin(9600);
    
    // Initialisation LCD
    lcd.init();
    lcd.backlight();
    lcd.print("Station Domotique");
    
    // Initialisation capteurs
    dht.begin();
    
    // Configuration broches
    pinMode(TRIG_PIN, OUTPUT);
    pinMode(ECHO_PIN, INPUT);
    pinMode(BTN_MODE, INPUT_PULLUP);
    pinMode(LED_GREEN, OUTPUT);
    pinMode(LED_RED, OUTPUT);
    pinMode(BUZZER, OUTPUT);
    pinMode(RELAY, OUTPUT);
    pinMode(LED_PWM, OUTPUT);
    
    delay(2000);
}

float getDistance() {
    digitalWrite(TRIG_PIN, LOW);
    delayMicroseconds(2);
    digitalWrite(TRIG_PIN, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG_PIN, LOW);
    long dur = pulseIn(ECHO_PIN, HIGH, 30000);
    return dur * 0.034 / 2;
}

void modeMeteo() {
    float temp = dht.readTemperature();
    float hum = dht.readHumidity();
    
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("T:");
    lcd.print(temp, 1);
    lcd.print("C H:");
    lcd.print(hum, 0);
    lcd.print("%");
    lcd.setCursor(0, 1);
    lcd.print("[MODE: METEO]");
    
    // Alerte temperature
    if (temp > 30) {
        digitalWrite(LED_RED, HIGH);
    } else {
        digitalWrite(LED_GREEN, HIGH);
    }
}

void modeAlarme() {
    float dist = getDistance();
    
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Dist: ");
    lcd.print(dist);
    lcd.print(" cm");
    lcd.setCursor(0, 1);
    lcd.print("[MODE: ALARME]");
    
    if (dist > 0 && dist < 50) {
        digitalWrite(LED_RED, HIGH);
        tone(BUZZER, 1000);
        alarmeActive = true;
    } else {
        digitalWrite(LED_GREEN, HIGH);
        noTone(BUZZER);
        alarmeActive = false;
    }
}

void modeLumiere() {
    int lum = analogRead(LDR_PIN);
    int pwm = map(lum, 0, 1023, 255, 0);
    
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Lum: ");
    lcd.print(lum);
    lcd.print(" LED:");
    lcd.print(pwm*100/255);
    lcd.print("%");
    lcd.setCursor(0, 1);
    lcd.print("[MODE: LUMIERE]");
    
    analogWrite(LED_PWM, pwm);
}

void loop() {
    // Changement de mode
    if (digitalRead(BTN_MODE) == LOW) {
        mode = (mode + 1) % 3;
        digitalWrite(LED_GREEN, LOW);
        digitalWrite(LED_RED, LOW);
        noTone(BUZZER);
        analogWrite(LED_PWM, 0);
        delay(300);
    }
    
    // Mise a jour toutes les 500ms
    if (millis() - lastUpdate > 500) {
        lastUpdate = millis();
        
        switch (mode) {
            case 0: modeMeteo(); break;
            case 1: modeAlarme(); break;
            case 2: modeLumiere(); break;
        }
    }
}

Évaluation du projet

Critere	Points
Câblage correct et propre	/4
Code fonctionnel sans erreur	/4
Affichage LCD correct	/3
Tous les modes fonctionnent	/4
Rapport de TP (schema + explications)	/5
Total	/20

TPs Arduino

TP1 : Clignotement LED (Blink)

🎯 Objectifs pedagogiques

Materiel necessaire

Schema de câblage

Code Arduino

Exercices complementaires

📝 Questions d'analyse

TP2 : Lecture Bouton Poussoir

🎯 Objectifs pedagogiques

Materiel necessaire

Schema de câblage

Code Arduino avec anti-rebond

Questions d'analyse

📝 Questions

TP3 : PWM - Variation de Luminosite

🎯 Objectifs pedagogiques

Materiel necessaire

Code : Effet Fade

Code : LED RGB Rainbow

TP4 : Capteur Ultrason HC-SR04

🎯 Objectifs pedagogiques

Materiel necessaire

Principe de fonctionnement

Schema de câblage

Code : Radar de recul

Questions d'analyse

📝 Questions

TP5 : Capteur de Temperature DHT11/DHT22

🎯 Objectifs pedagogiques

Comparaison DHT11 vs DHT22

Installation de la bibliotheque

Code : Station Meteo

TP6 : Afficheur LCD 16x2 I2C

Schema de câblage I2C

Code : Affichage temperature sur LCD

TP7 : Servomoteur

Code : Controle par potentiometre

Code : Balayage automatique

TP8 : Capteur de Lumiere (LDR)

Code : Éclairage automatique

TP9 : Buzzer et Melodies

Frequences des notes musicales

Code : Melodie simple

TP10 : Module Relais

⚠️ Precautions de securite

Code : Minuterie avec relais

TP11 : Projet Final - Station Domotique

🎯 Objectifs du projet

Fonctionnalites

Code : Projet Station Domotique

Évaluation du projet

Formulaire de contact