UE1.2 · 4 ECTS

Électronique & Capteurs

20h CM + 30h TP — 8 séances. Maîtrisez les fondamentaux de l'électronique pour l'IoT : composants, capteurs, alimentation et prototypage de cartes électroniques.

8 Séances 20h CM 30h TP 4 ECTS
1

Loi d'Ohm et composants passifs

Semaine 1CM+TP · 6h
Comprendre la relation tension-courant-résistance U = R × I
Savoir expliquer
Calculer la puissance dissipée dans un composant
Savoir faire
Utiliser un condensateur pour le filtrage et le lissage
Savoir analyser
Mesurer tension, courant et résistance avec un multimètre
Savoir produire

1. Loi d'Ohm — Fondamental de l'électronique

La loi d'Ohm est la relation mathématique la plus importante en électronique. Elle relie la tension U (en volts), le courant I (en ampères) et la résistance R (en ohms) : U = R × I.

Cette loi permet de dimensionner n'importe quel circuit : choisir la bonne résistance pour une LED, calculer le courant dans une charge, ou vérifier qu'un composant ne dépasse pas sa puissance maximale.

GrandeurSymboleUnitéSymbole unité
TensionUVoltV
CourantIAmpèreA
RésistanceROhmΩ
PuissancePWattW
CapacitéCFaradF
InductanceLHenryH

2. Puissance électrique

La puissance consommée par un composant se calcule par : P = U × I. En combinant avec la loi d'Ohm, on obtient : P = R × I² ou P = U² / R.

Exemple concret : une résistance de 220 Ω avec un courant de 20 mA dissipe P = 220 × (0,02)² = 0,088 W. Une résistance 1/4 W (0,25 W) est largement suffisante.

loi_ohm_calculs.inoArduino
// Calculatrice de loi d'Ohm pour IoT
// Exemple : dimensionner une résistance pour LED

float calculer_resistance(float vcc, float v_led, float i_led) {
  // Vcc = tension d'alimentation
  // V_led = tension aux bornes de la LED
  // I_led = courant souhaité (A)
  return (vcc - v_led) / i_led;
}

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

  // LED rouge standard : V_led = 2.0V, I_led = 20mA = 0.02A
  // Alimentation Arduino : Vcc = 5V
  float R = calculer_resistance(5.0, 2.0, 0.02);
  Serial.print("Résistance nécessaire : ");
  Serial.print(R, 0);
  Serial.println(" Ω");

  // Puissance dissipée
  float P = 0.02 * 0.02 * R;
  Serial.print("Puissance dissipée : ");
  Serial.print(P * 1000, 1);
  Serial.println(" mW");
}

void loop() {}

3. Condensateurs et inductances

Le condensateur stocke de l'énergie sous forme de champ électrique. Il s'oppose aux variations brusques de tension, ce qui le rend idéal pour le filtrage des alimentations (lissage) et la découplication.

L'inductance (ou bobine) stocke l'énergie sous forme de champ magnétique. Elle s'oppose aux variations brusques de courant, utilisée dans les filtres et les convertisseurs DC-DC.

ComposantSymboleUnitéRôle en IoT
Condensateur céramiqueCnF, µFFiltrage haute fréquence, découplage
Condensateur électrolytiqueCµF, mFLissage d'alimentation, réservoir d'énergie
InductanceLµH, mHFiltrage, convertisseurs DC-DC

4. Utilisation du multimètre

Le multimètre est l'outil indispensable de tout électronicien. Il permet de mesurer :

  • Tension (voltmètre) — en parallèle sur le composant
  • Courant (ampèremètre) — en série dans le circuit
  • Résistance (ohmmètre) — hors tension, composant isolé
  • Continuité — test de circuit avec bip sonore
💡 Conseil
L'électronique demande de la méthode : vérifiez toujours deux fois le câblage avant de mettre sous tension. Un mauvais branchement peut détruire un composant en quelques millisecondes.
Exercice 1 — Loi d'Ohm et mesures

a) Calculez la résistance à placer en série avec une LED bleue (V_led = 3.3V, I_led = 20mA) alimentée en 5V. Calculez aussi la puissance dissipée.

b) Même question avec 3 LEDs bleues en série et une alimentation 12V.

c) Sur une breadboard, mesurez la tension aux bornes d'une résistance de 1kΩ avec le multimètre. Vérifiez la loi d'Ohm expérimentalement.

d) BONUS — Circuit RC : branchez une résistance de 10kΩ et un condensateur de 100µF en série. Calculez la constante de temps τ = R × C. Mesurez le temps de charge avec le multimètre.

✓ Corrigé 1a — Résistance LED bleue
Calcul manuel
U_R = Vcc - V_led = 5.0 - 3.3 = 1.7 V
R = U_R / I_led = 1.7 / 0.02 = 85 Ω

→ Valeur normalisée la plus proche : 100 Ω
→ Puissance : P = R × I² = 100 × (0,02)² = 0,04 W → 1/4 W suffit
✓ Corrigé 1b — 3 LEDs bleues en série 12V
Calcul manuel
U_R = 12 - (3 × 3.3) = 12 - 9.9 = 2.1 V
R = 2.1 / 0.02 = 105 Ω

→ Valeur normalisée : 120 Ω
P = 120 × 0.0004 = 0.048 W → toujours OK avec 1/4 W
2

Diodes, LEDs et protection des circuits

Semaine 2CM+TP · 6h
Comprendre le fonctionnement d'une diode et son rôle redresseur
Savoir expliquer
Dimensionner une résistance de limitation pour une LED
Savoir faire
Analyser un circuit avec diode de protection (roue libre)
Savoir analyser
Réaliser un pont de Wheatstone pour mesure de résistance
Savoir produire

1. La diode — Redressement et protection

Une diode est un composant qui ne laisse passer le courant que dans un seul sens (anode → cathode). C'est un redresseur : en présence d'un signal alternatif, elle ne conserve que l'alternance positive.

La diode idéale a une tension de seuil de 0,7 V (silicium) : elle conduit quand la tension anode-cathode dépasse ce seuil. En dessous, elle bloque le courant.

diode_led_calcul.inoArduino
// Dimensionnement de résistance pour LED
// R = (Vcc - V_led) / I_led

void setup() {
  Serial.begin(9600);
  Serial.println("Tableau des résistances pour LEDs (Vcc=5V, I=20mA) :");

  // LED rouge : V_led = 2.0V
  // LED verte  : V_led = 2.2V
  // LED bleue  : V_led = 3.3V
  // LED blanche: V_led = 3.3V

  float couleurs[][2] = {{2.0, "Rouge"}, {2.2, "Verte"},
                         {3.3, "Bleue"}, {3.3, "Blanche"}};

  for (int i = 0; i < 4; i++) {
    float v_led = couleurs[i][0];
    float R = (5.0 - v_led) / 0.02;
    Serial.print(couleurs[i][1]);
    Serial.print(" : R = ");
    Serial.print(R, 0);
    Serial.println(" Ω");
  }
}

void loop() {}
Couleur LEDV_led (V)R pour 5V / 20mA
Rouge1.8 – 2.2150 – 160 Ω
Jaune/Orange2.0 – 2.4130 – 150 Ω
Verte2.0 – 3.0100 – 150 Ω
Bleue/Blanche3.0 – 3.670 – 100 Ω

3. Pont de Wheatstone

Le pont de Wheatstone est un circuit permettant de mesurer une résistance inconnue avec précision. Il est constitué de quatre résistances en pont dont une est la résistance inconnue Rx. Quand le pont est équilibré (tension nulle entre les deux branches), on a la relation : R1 / R2 = R3 / Rx.

Ce principe est utilisé dans de nombreux capteurs : jauges de contrainte, thermistances, capteurs de pression — où une variation de résistance est convertie en tension mesurable.

Exercice 2 — Diodes et LEDs

a) Calculez et câblez le circuit d'une LED blanche avec la bonne résistance de limitation. Vérifiez le courant avec le multimètre en série.

b) Réalisez un circuit avec 4 LEDs (rouge, jaune, verte, bleue) alimentées indépendamment sur des pins Arduino avec leurs résistances.

c) Montez un pont de Wheatstone avec R1=R2=R3=1kΩ et Rx=1kΩ (potentiomètre réglé à 1kΩ). Mesurez la tension entre les deux points centraux. Variez Rx et notez la tension.

d) BONUS — Créez un circuit avec une diode 1N4007 en parallèle sur un moteur DC (diode de roue libre) et observez la différence avec/sans la diode.

3

Transistors et relais — Contrôle de puissance

Semaine 3CM+TP · 6h
Comprendre le fonctionnement d'un transistor NPN BJT en commutation
Savoir expliquer
Dimensionner la résistance de base d'un transistor
Savoir faire
Comparer transistor BJT et MOSFET pour différentes applications
Savoir analyser
Commander un relais pour contrôler une charge haute tension
Savoir produire

1. Transistor NPN BJT comme commutateur

Le transistor bipolaire NPN est un commutateur commandé par courant. Quand un faible courant circule dans la base (I_b), un courant beaucoup plus grand peut circuler du collecteur vers l'émetteur (I_c). Le gain β = I_c / I_b est typiquement de 100 à 300.

Pour utiliser le transistor en commutation (ON/OFF), on le sature : I_b est choisi pour que I_c soit maximal (I_c = β × I_b). La résistance de base R_b dimensionne ce courant.

transistor_commutation.inoArduino
// Commande d'une charge avec transistor NPN (2N2222)
// Charge : moteur DC 6V - 200mA

const int BASE_PIN = 9;  // Pin PWM pour contrôler

void setup() {
  pinMode(BASE_PIN, OUTPUT);
  Serial.begin(9600);
  Serial.println("Contrôle de puissance avec transistor NPN");
  Serial.println("R_b = (V_arduino - V_be) / I_b");
  Serial.println("V_arduino = 5V, V_be ≈ 0.7V");
  Serial.println("I_b = I_c / β = 200mA / 100 = 2mA");
  Serial.print("R_b = (5 - 0.7) / 0.002 = ");
  Serial.print((5.0 - 0.7) / 0.002, 0);
  Serial.println(" Ω → 2.2 kΩ");
}

void loop() {
  // Moteur à pleine vitesse
  digitalWrite(BASE_PIN, HIGH);
  delay(3000);

  // Arrêt
  digitalWrite(BASE_PIN, LOW);
  delay(2000);

  // Variation PWM
  for (int pwm = 0; pwm <= 255; pwm += 5) {
    analogWrite(BASE_PIN, pwm);
    delay(30);
  }
  for (int pwm = 255; pwm >= 0; pwm -= 5) {
    analogWrite(BASE_PIN, pwm);
    delay(30);
  }
}

2. MOSFET — Commutation rapide et faible perte

Le MOSFET (Metal-Oxide-Semiconductor Field-Effect Transistor) est un transistor commandé par tension. Il ne consomme quasiment pas de courant de commande (résistance d'entrée gigantesque). L'IRF520 ou le FQP30N06L sont des MOSFETs de puissance courants pour l'IoT.

Avantages du MOSFET vs BJT : commutation plus rapide, pas de courant de base, dissipation plus faible, parfait pour le PWM haute fréquence.

CritèreBJT NPN (2N2222)MOSFET (IRF520)
Type de commandeCourant (I_b)Tension (V_gs)
Courant de commandeQuelques mA≈ 0 µA
Tension de saturationV_ce_sat ≈ 0.2VR_ds_on ≈ 0.1Ω
Fréquence maxQuelques MHzPlusieurs MHz
Usage typiquePetits signaux, LED, relaisMoteurs puissants, PWM rapide

3. Relais — Isolation galvanique

Un relais est un interrupteur électromagnétique : une bobine (tension 5V / 12V) crée un champ magnétique qui actionne un contact mécanique. L'avantage fondamental est l'isolation galvanique entre le circuit de commande et le circuit commandé.

Un relais permet de commuter du 220V AC avec un signal 5V. La diode de roue libre (1N4007) en parallèle sur la bobine est obligatoire pour protéger le transistor de commande.

⚠️ Obligatoire
La diode de roue libre (flyback diode) aux bornes de la bobine du relais est ABSOLUMENT obligatoire. Sans elle, la coupure du courant dans la bobine génère une surtension qui détruit le transistor ou le pin Arduino.
Exercice 3 — Transistors et relais

a) Câblez un transistor NPN (2N2222) pour commander une LED de puissance 1W. Calculez R_b pour β = 100.

b) Remplacez le BJT par un MOSFET IRF520. Comparez le comportement.

c) Câblez un module relais 5V (avec diode intégrée) pour commander une ampoule 220V. Écrivez le programme Arduino qui alterne ON/OFF toutes les 2s.

d) BONUS — Créez un variateur de vitesse pour moteur DC 12V avec MOSFET et PWM. Ajoutez un potentiomètre pour le réglage.

✓ Corrigé 3c — Module relais 5V
commande_relais.inoArduino
const int RELAIS_PIN = 8;

void setup() {
  pinMode(RELAIS_PIN, OUTPUT);
  Serial.begin(9600);
  Serial.println("Contrôle relais 220V");
  // Le module relais actif bas signifie :
  // LOW = fermé (ON), HIGH = ouvert (OFF)
  digitalWrite(RELAIS_PIN, HIGH);  // Départ OFF
}

void loop() {
  digitalWrite(RELAIS_PIN, LOW);   // Relais ON
  Serial.println("Charge 220V ALIMENTÉE");
  delay(2000);

  digitalWrite(RELAIS_PIN, HIGH);  // Relais OFF
  Serial.println("Charge 220V COUPÉE");
  delay(2000);
}
4

Alimentation et régulation de tension

Semaine 4CM+TP · 6h
Comprendre le rôle d'un régulateur linéaire 7805
Savoir expliquer
Calculer l'autonomie d'une batterie LiPo pour un projet IoT
Savoir faire
Comparer régulateur linéaire et buck converter (rendement)
Savoir analyser
Dimensionner l'alimentation d'un projet ESP32 avec capteurs
Savoir produire

1. Régulateur linéaire 7805

Le LM7805 est le régulateur de tension le plus connu. Il fournit une sortie stable de 5V à partir d'une entrée de 7V à 35V. Son principal inconvénient est le rendement : la différence de tension × courant est dissipée en chaleur.

Exemple : si l'entrée est 12V et le courant 500mA, P = (12-5) × 0.5 = 3.5W de perte. Un dissipateur thermique est alors indispensable.

calcul_autonomie.inoArduino
// Calcul d'autonomie batterie pour projet IoT
// Formule : Autonomie (heures) = Capacité (mAh) / Courant_moyen (mA)

void setup() {
  Serial.begin(9600);
  Serial.println("=== Calculateur d'autonomie batterie ===");

  // Exemple : ESP32 en veille profonde (DeepSleep)
  float capacite_mAh = 3000.0;     // Batterie LiPo 3.7V 3000mAh
  float courant_eveil_mA = 250.0;  // ESP32 actif WiFi allumé
  float courant_veille_mA = 0.01;  // ESP32 en DeepSleep (10 µA)
  float temps_eveil_s = 5.0;       // Mesure toutes les 5s
  float temps_cycle_s = 300.0;     // Cycle total = 5 min (300s)

  float courant_moyen = (courant_eveil_mA * temps_eveil_s +
                         courant_veille_mA * (temps_cycle_s - temps_eveil_s))
                         / temps_cycle_s;

  float autonomie_h = capacite_mAh / courant_moyen;
  float autonomie_j = autonomie_h / 24.0;

  Serial.print("Courant moyen : ");
  Serial.print(courant_moyen, 3);
  Serial.println(" mA");
  Serial.print("Autonomie estimée : ");
  Serial.print(autonomie_h, 0);
  Serial.print(" heures (");
  Serial.print(autonomie_j, 1);
  Serial.println(" jours)");
}

void loop() {}

2. Buck Converter — Alimentation efficace

Le buck converter (convertisseur abaisseur) utilise une découpage PWM + inductance pour convertir une tension avec un rendement > 90%. Contrairement au régulateur linéaire, il ne dissipe pas l'excès en chaleur.

Les modules LM2596 ou Mini-360 sont très utilisés en IoT pour alimenter des projets sur batterie. Ils acceptent une entrée jusqu'à 35V et délivrent 5V ou 3.3V avec un rendement de 90-96%.

Critère7805 (Linéaire)LM2596 (Buck)
Rendement≈ 40% (12V → 5V)≈ 90%
Chaleur dissipéeÉlevéeFaible
Bruit de sortieTrès faibleOndulation résiduelle
Coût≈ 0.50 €≈ 2.00 €
Idéal pourFaibles courants, audioBatteries, forts courants
💡 Consommation ESP32

DeepSleep 10 µA — idéal pour capteurs sur batterie longue durée.
Actif WiFi 250 mA — réservez pour les transmissions ponctuelles.
Bluetooth 100 mA — alternative moins énergivore que WiFi.

Astuce : utilisez le mode modem sleep (quelques mA) entre les mesures WiFi pour économiser la batterie.

Exercice 4 — Alimentation IoT

a) Calculez la puissance dissipée par un 7805 alimenté en 12V avec un courant de 200mA. Que se passe-t-il si le courant passe à 1A ?

b) Un projet IoT utilise un ESP32 (250mA actif, 10µA sommeil) qui se réveille 2s toutes les 10 minutes pour envoyer une mesure. Quelle batterie LiPo 3.7V faut-il pour 6 mois d'autonomie ?

c) Câblez un module buck LM2596 : réglez-le à 5V en sortie, mesurez le rendement avec entrée 9V et 12V.

d) BONUS — Créez un système d'alimentation solaire pour ESP32 : panneau 6V + TP4056 (chargeur LiPo) + batterie 18650 + buck 3.3V.

5

Capteurs de température et humidité

Semaine 5CM+TP · 6h
Choisir entre DHT11 et DHT22 selon le besoin de précision
Savoir expliquer
Lire et interpréter les mesures du DS18B20 waterproof
Savoir faire
Comprendre le principe des PT100/PT1000 (RTD)
Savoir analyser
Réaliser un système de régulation avec cellule Peltier
Savoir produire

1. DHT11 vs DHT22 — Le choix du capteur

Le DHT11 et le DHT22 sont des capteurs numériques combinant température et humidité. Ils utilisent un protocole 1-wire propriétaire et ne nécessitent qu'une seule broche de données.

CaractéristiqueDHT11DHT22 (AM2302)
Température0 à 50°C ±2°C-40 à 80°C ±0.5°C
Humidité20 à 90% ±5%0 à 100% ±2%
Résolution1°C / 1%0.1°C / 0.1%
Fréquence mesure1 Hz (1/s)0.5 Hz (1/2s)
Prix≈ 2 €≈ 6 €
UsageIntérieur, basiqueExtérieur, précis, météo

2. DS18B20 — Capteur 1-Wire waterproof

Le DS18B20 est un capteur de température numérique utilisant le bus 1-Wire de Dallas Semiconductor. Il est livré dans un boîtier étanche (sonde métallique) idéal pour les mesures en extérieur, dans l'eau ou le sol.

Avantage clé : chaque DS18B20 a un identifiant unique (ROM 64 bits), permettant de connecter plusieurs capteurs sur la même broche Arduino.

ds18b20_multi.inoArduino
#include <OneWire.h>
#include <DallasTemperature.h>

const int ONE_WIRE_BUS = 5;
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature capteurs(&oneWire);

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

  int nbCapteurs = capteurs.getDeviceCount();
  Serial.print("Nombre de capteurs DS18B20 : ");
  Serial.println(nbCapteurs);
}

void loop() {
  capteurs.requestTemperatures();

  for (int i = 0; i < capteurs.getDeviceCount(); i++) {
    float temp = capteurs.getTempCByIndex(i);
    Serial.print("Capteur ");
    Serial.print(i + 1);
    Serial.print(" : ");
    Serial.print(temp, 2);
    Serial.println(" °C");
  }

  Serial.println("---");
  delay(5000);
}

3. PT100/PT1000 — Capteurs RTD industriels

Les PT100 et PT1000 sont des détecteurs de température à résistance (RTD). Leur résistance varie linéairement avec la température : PT100 = 100 Ω à 0°C, PT1000 = 1000 Ω à 0°C. Ils sont très stables et précis (±0.1°C) sur une large plage (-200 à 850°C).

La mesure nécessite un circuit d'adaptation (pont de Wheatstone) ou un convertisseur dédié comme le MAX31865.

4. Cellule Peltier — Contrôle actif de température

Une cellule Peltier (module thermoélectrique TEC) pompe la chaleur d'un côté à l'autre quand on la traverse d'un courant. En inversant le courant, on inverse le sens du transfert : elle peut chauffer OU refroidir.

En IoT, on utilise la Peltier pour : refroidir un processeur, stabiliser la température d'un capteur de gaz, ou créer un mini-réfrigérateur.

Exercice 5 — Capteurs de température

a) Câblez un DHT22 et affichez température + humidité + indice de chaleur sur le moniteur série.

b) Câblez 3 DS18B20 en parallèle sur la même broche. Identifiez-les par leur adresse ROM et affichez leurs températures individuellement.

c) Testez le DS18B20 waterproof : mesurez la température ambiante, dans un verre d'eau froide, dans de l'eau chaude (max 70°C). Documentez les résultats.

d) BONUS — Système de régulation : utilisez un DHT22 + cellule Peltier + MOSFET pour maintenir une enceinte à 25°C (ventilateur si chaud, Peltier si froid).

6

Capteurs de luminosité et mouvement

Semaine 6CM+TP · 6h
Comprendre le fonctionnement du détecteur PIR HC-SR501
Savoir expliquer
Lire l'éclairage en lux avec le capteur BH1750 (I2C)
Savoir faire
Comparer BH1750, VEML7700 et photodiode simple
Savoir analyser
Créer un système d'éclairage automatique avec détection de présence
Savoir produire

1. Capteur de mouvement PIR HC-SR501

Le capteur PIR (Passive Infrared) détecte les mouvements en mesurant les variations de rayonnement infrarouge dans son champ de vision. Tout corps à une température > 0K émet des IR — le PIR détecte les changements de cette signature.

CaractéristiqueHC-SR501
Alimentation5V – 12V DC (typ. 5V)
Consommation≈ 65 µA (très faible)
Portée3 – 7 mètres (réglable)
Angle de détection< 120°
Temporisation5s – 5 min (réglable via potentiomètre)
SortieLOW = repos, HIGH = mouvement détecté
pir_lumiere_auto.inoArduino
// Éclairage automatique : PIR + BH1750 + LED

#include <Wire.h>
#include <BH1750.h>

BH1750 luxmetre;

const int PIR_PIN  = 3;
const int LED_PIN  = 9;

bool mouvement = false;
float lux = 0;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  luxmetre.begin();

  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);

  Serial.println("Système d'éclairage intelligent");
}

void loop() {
  lux = luxmetre.readLightLevel();
  mouvement = digitalRead(PIR_PIN);

  Serial.print("Luminosité : ");
  Serial.print(lux, 1);
  Serial.print(" lux | Mouvement : ");
  Serial.println(mouvement ? "OUI" : "NON");

  // Logique d'éclairage automatique
  if (lux < 50 && mouvement) {
    analogWrite(LED_PIN, 200);  // Allumer si sombre + présence
    Serial.println("→ Éclairage activé");
  } else {
    analogWrite(LED_PIN, 0);
  }

  delay(500);
}

2. Capteurs de luminosité — Luxmètres numériques

Le BH1750 est un capteur de lumière ambiante numérique utilisant le bus I2C. Il retourne directement la valeur en lux (0-65535) sans calcul. C'est le standard pour les stations météo IoT.

Le VEML7700 est plus récent : résolution plus fine (0.0036 lux/count), plage étendue (0-120k lux). Parfait pour les applications extérieures en plein soleil.

CapteurInterfacePlage (lux)Résolution
BH1750I2C (0x23 / 0x5C)1 – 65 5351 lux
VEML7700I2C (0x10)0 – 120 0000.0036 lux
Photodiode + ADCAnalogiqueVariableDépend du montage
LDR + ADCAnalogique≈ 10 – 10 000Approximatif
Exercice 6 — Luminosité et mouvement

a) Câblez le capteur PIR HC-SR501. Programmez une LED qui s'allume 10s quand un mouvement est détecté. Affichez le statut sur le moniteur série.

b) Câblez le BH1750 (I2C). Affichez les lux et détectez le passage jour/nuit (seuil 50 lux).

c) Comparez les lectures du BH1750 et d'une simple photodiode/LDR sur entrée analogique. Calibrez la LDR à partir du BH1750.

d) BONUS — Système complet : PIR + BH1750 + LED PWM. L'éclairage s'ajuste automatiquement : pleine lumière si très sombre, réduite si faible luminosité, éteint si assez clair.

7

Capteurs de gaz et qualité de l'air

Semaine 7CM+TP · 6h
Comprendre le principe des capteurs de gaz à semi-conducteur (MQ)
Savoir expliquer
Détecter les gaz combustibles avec le MQ-2
Savoir faire
Mesurer le CO2 et les COV avec le CCS811
Savoir analyser
Mesurer les particules fines PM2.5 avec le SDS011
Savoir produire

1. Capteurs de gaz MQ — Principe

Les capteurs de la série MQ (MQ-2, MQ-7, MQ-135) sont des capteurs de gaz à semi-conducteur. Leur résistance change en présence de gaz spécifiques. Un élément chauffant interne (≈ 300-400 mW) chauffe la céramique pour que la réaction chimique ait lieu.

Chaque modèle est sensible à une famille de gaz :

ModèleGaz détectésPréchauffage
MQ-2GPL, Butane, Propane, Méthane, Alcool, Fumée24h stabilisation
MQ-7Monoxyde de carbone (CO)48h stabilisation
MQ-135NH₃, NOₓ, Alcool, Benzène, Fumée, CO₂24h stabilisation
MQ-136Sulfure d'hydrogène (H₂S)24h stabilisation
qualite_air.inoArduino
#include <Wire.h>
#include "Adafruit_CCS811.h"

Adafruit_CCS811 ccs;

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

  if (!ccs.begin()) {
    Serial.println("ERREUR : CCS811 non trouvé !");
    while (1);
  }

  Serial.println("Capteur qualité d'air CCS811");
  Serial.println("Valeurs de référence :");
  Serial.println("  400 ppm CO2 = Air normal (extérieur)");
  Serial.println("  600-800 ppm = Air intérieur acceptable");
  Serial.println("  > 1000 ppm  = Air vicié — ventiler !");
  Serial.println("  > 2000 ppm  = Nocif — évacuer !");
  Serial.println("---");
}

void loop() {
  if (ccs.available()) {
    if (!ccs.readData()) {
      float co2 = ccs.geteCO2();
      float tvoc = ccs.getTVOC();

      Serial.print("CO2 : ");
      Serial.print(co2, 0);
      Serial.print(" ppm | TVOC : ");
      Serial.print(tvoc, 0);
      Serial.println(" ppb");

      if (co2 > 1000) {
        Serial.println("⚠️ AIR VICIÉ — Ouvrez les fenêtres !");
      } else if (co2 > 2000) {
        Serial.println("🚨 DANGER — Évacuez la zone !");
      }
    }
  }
  delay(1000);
}
📖 Références CO₂

400 ppm — Concentration normale en extérieur (air pur)
600 – 800 ppm — Air intérieur acceptable, bonne ventilation
800 – 1000 ppm — Légèrement vicié, certains peuvent ressentir de la fatigue
> 1000 ppm — Air vicié — ouvrez les fenêtres !
> 2000 ppm — Nocif : maux de tête, somnolence, perte d'attention

3. SDS011 — Particules fines PM2.5 / PM10

Le SDS011 est un capteur laser de particules fines. Il utilise un faisceau laser et un photodétecteur pour compter et dimensionner les particules en suspension. Il donne deux valeurs : PM2.5 (particules < 2.5 µm) et PM10 (particules < 10 µm).

Il communique en UART série à 9600 bauds. Idéal pour les stations de surveillance de la qualité de l'air urbaines ou industrielles.

Exercice 7 — Qualité de l'air

a) Câblez le MQ-2 et mesurez la concentration de gaz combustible. Testez avec un briquet (gaz butane, sans flamme) à distance de sécurité.

b) Câblez le CCS811 (I2C). Installez la bibliothèque Adafruit CCS811. Affichez CO₂ et TVOC. Documentez les valeurs dans différentes pièces.

c) Câblez le SDS011 (UART). Lisez PM2.5 et PM10. Comparez intérieur vs extérieur.

d) BONUS — Station qualité de l'air complète : CCS811 + SDS011 + DHT22 + affichage LCD I2C. Ajoutez un buzzer qui sonne si CO₂ > 1500 ppm.

8

Schématique et prototypage PCB

Semaine 8CM+TP · 6h
Comprendre le flux de conception d'un PCB : schématique → layout → fabrication
Savoir expliquer
Utiliser KiCad pour créer un schématique électronique
Savoir faire
Router un PCB simple et générer les fichiers Gerber
Savoir analyser
Prototyper un circuit sur breadboard et le transférer sur PCB
Savoir produire

1. Prototypage sur breadboard

La breadboard (platine d'expérimentation) permet d'assembler un circuit sans soudure. Les rangées sont connectées horizontalement, les colonnes verticalement. Elle est idéale pour tester un montage avant de le finaliser sur PCB.

Règles d'or du prototypage : utilisez des fils de couleurs différentes (rouge = VCC, noir = GND), gardez les chemins courts, et vérifiez la continuité au multimètre avant de mettre sous tension.

2. KiCad — Logiciel libre de CAO électronique

KiCad est la suite de conception de circuits imprimés open-source la plus utilisée. Elle comprend :

  • Eeschema — Éditeur de schématiques
  • Pcbnew — Éditeur de PCB (placement et routage)
  • Bibliothèques — Symboles et empreintes pour des milliers de composants
  • Visualiseur 3D — Aperçu réaliste du PCB avant fabrication
💡 Workflow PCB IoT
  1. Prototypage — Testez le circuit sur breadboard + Arduino
  2. Schématique — Dessinez le circuit dans KiCad Eeschema
  3. Assignation — Associez chaque symbole à son empreinte physique
  4. Placement — Positionnez les composants sur le PCB dans Pcbnew
  5. Routage — Tracez les pistes (largeur : signal 0.25mm, puissance 0.5-1mm)
  6. Plans de masse — Ajoutez un plan GND pour réduire le bruit
  7. Fichiers Gerber — Génération des fichiers pour fabrication
  8. Commande — Envoyez chez JLCPCB ou PCBWay
ServiceDélaiPrix (10x 100×100mm)Expédition
JLCPCB3-5 jours≈ 2 € + portDHL / Chine Post
PCBWay5-7 jours≈ 5 € + portFedEx / DHL
OSH Park7-12 jours≈ 10 € + portUSPS

3. Fichiers Gerber — Le format standard de fabrication

Les fichiers Gerber (format RS-274X) sont le langage universel entre le concepteur et le fabricant de PCB. Chaque fichier représente une couche du circuit : top cuivre, bottom cuivre, masque de soudure, sérigraphie, plans de perçage...

regles_routage_pcb.mdKiCad
Règles de conception pour PCB IoT :

1. GÉNÉRAL
   - Taille min. piste : 0.25mm (10 mils)
   - Espacement min. : 0.25mm
   - Diamètre min. via : 0.6mm

2. ALIMENTATION
   - Pistes VCC/GND : 0.5mm ou plus
   - Découplage : cap 100nF près de chaque CI
   - Plan GND séparé pour partie numérique et analogique

3. CAPTEURS
   - Pistes capteurs analogiques : courtes et blindées
   - Éviter les pistes à angle droit (préférer 45°)
   - Connecteurs JST pour capteurs externes

4. RF (ESP32 / WiFi)
   - Antenne dégagée sur le bord du PCB
   - Pas de plan GND sous l'antenne
   - Masse stitching autour des vias RF

5. FABRICATION
   - Min. 2 couches (top + bottom)
   - Épaisseur cuivre standard : 1 oz (35 µm)
   - Finition HASL (plomb) ou ENIG (sans plomb)
Exercice 8 — Prototypage PCB

a) Sur breadboard, réalisez le montage d'un capteur DHT22 + affichage LCD I2C 16×2. Testez le bon fonctionnement avec un programme Arduino.

b) Dans KiCad, créez le schématique du circuit ci-dessus : ESP32 (ou Arduino Nano) + DHT22 + LCD I2C + résistance pull-up I2C 4.7kΩ.

c) Dans Pcbnew, placez les composants et routez les pistes. Vérifiez les règles de conception (DRC). Générez les fichiers Gerber.

d) BONUS — Commandez le PCB chez JLCPCB (ou simulateur). Soudez les composants et vérifiez que le circuit fonctionne comme sur la breadboard.