English

Leçons · Leçon S2 · Les capteurs · 30 min

Aimants, inclinaison et mouvement

Construis une alarme de porte avec un capteur à lames souples et un aimant, essaie un interrupteur à bille, puis lis un capteur de mouvement PIR et branche-le sans risque à l’ESP32. Environ 30 minutes, avec un aimant que tu peux faire glisser.

L’aimant secret de toutes les alarmes de porte

Beaucoup d’alarmes de porte et de fenêtre cachent la même astuce : un petit boîtier sur le cadre, un petit boîtier sur la porte, et rien de visible entre les deux. L’un des boîtiers contient un aimant. L’autre contient un interrupteur qui l’écoute. Quand la porte s’ouvre, l’aimant s’éloigne, et l’alarme le sait sans rien toucher.

Jusqu’ici, tes capteurs répondaient « faisceau ou pas de faisceau ». Cette leçon ajoute trois autres façons de remarquer que quelque chose a changé :

  • un capteur à lames souples (ILS, reed switch en anglais) : un interrupteur qu’un aimant ferme,
  • un interrupteur d’inclinaison : un interrupteur qu’une bille roulante ferme,
  • un capteur PIR : un petit module qui remarque un corps chaud qui bouge.

Les deux premiers sont de simples interrupteurs. Tu sais déjà les lire : leçon K2, INPUT_PULLUP. Le troisième est un petit module électronique qui a son caractère, et il demande un peu plus de soin.

Le secret de l’alarme de porte : un aimant et un interrupteur Une porte vue de dessus avec son cadre, deux fois. Un petit boîtier sur le cadre contient l’interrupteur ; un petit boîtier sur la porte contient l’aimant. À gauche, porte fermée : l’aimant est juste à côté de l’interrupteur, l’interrupteur est fermé, la broche lit LOW, l’alarme se tait. À droite, porte ouverte : la porte a pivoté, l’aimant est loin de l’interrupteur, l’interrupteur est ouvert, la broche lit HIGH, l’alarme sonne. Rien ne se touche : l’interrupteur sent seulement l’aimant. FIG. 1 — PORTE VUE DE DESSUSaPorte ferméeNSinterrupteursur le cadreaimantsur la portepièceinterrupteur fermédigitalRead(27) → LOWalarme calmebPorte ouverteNSinterrupteursur le cadreaimant, loininterrupteur ouvertdigitalRead(27) → HIGHalarme en marche
Touche le schéma pour l’ouvrir en plein écran.

Le capteur à lames souples

Un ILS a deux contacts qui, normalement, ne se touchent pas : il est « normalement ouvert », sans aucune liaison entre ses deux fils [1]. Approche un aimant et les deux contacts métalliques à l’intérieur s’attirent : l’interrupteur se ferme [12]. Un ILS nu est un petit tube de verre, et il est fragile : quand tu plies ses pattes, tiens-les près du corps, sans forcer sur le verre [12]. La pièce pour alarme de porte vendue par Adafruit en est un : un ILS dans un boîtier en plastique, avec un aimant comme moitié partenaire. Son interrupteur se ferme quand l’aimant arrive à moins de 13 mm (0,5 pouce) [1]. D’autres pièces ont d’autres distances : vérifie la tienne sur sa propre fiche, ou découvre-la avec le programme ci-dessous.

Un ILS a deux fils et pas de polarité : c’est un simple interrupteur, comme le bouton de K2. Même recette :

  • un fil à la GPIO 27,
  • l’autre fil à GND,
  • INPUT_PULLUP dans setup().

Ce qui donne :

Porte Aimant Interrupteur La broche se lit
fermée contre l’interrupteur fermé LOW
ouverte loin ouvert HIGH

L’alarme sonne donc quand la broche se lit HIGH, l’inverse du bouton de K2. Petit bonus appréciable : si un fil se détache ou est coupé, le circuit est ouvert, la broche se lit HIGH, et l’alarme sonne. Un fil cassé est traité comme une porte ouverte. (Cela découle de la résistance de rappel : sans rien de relié à GND, la broche est tirée vers HIGH.)

Là où l’image s’arrête. Un aimant et un interrupteur te disent que la porte s’est éloignée, pas qui l’a fait ni de combien. Ils ne répondent que « fermé » ou « ouvert ».

Fais glisser l’aimant dans le widget de l’écran 5 pour voir un ILS simplifié se fermer et s’ouvrir. (Les lames du dessin sont une représentation simplifiée, pas une mesure.)

Dans un ILS (dessin simplifié) Vue de côté simplifiée d’un ILS, deux fois. Une petite capsule de verre contient deux fines lames de métal, une à chaque bout, qui se chevauchent au milieu avec un petit espace. À gauche, l’aimant est loin à droite : les lames restent écartées, l’interrupteur est ouvert, aucune liaison entre ses deux fils. À droite, l’aimant s’est approché : les lames sont attirées et se touchent, l’interrupteur est fermé. Sous chaque dessin, le symbole de schéma d’un interrupteur normalement ouvert, ouvert puis fermé. Dessin simplifié, pas à l’échelle. FIG. 2 — ILS, VUE DE CÔTÉdessin simplifiéaAimant loinNSloinlames écartéesverresymbole de schémaouvert : pas de liaisonbAimant procheNSchamp magnétiquelames qui se touchentsymbole de schémafermé : reliéNormalement ouvert : fermé seulement quand l’aimant est proche. Ton interrupteur a sa propre distance.
Touche le schéma pour l’ouvrir en plein écran.

Construis l’alarme de porte

Pièces : l’ILS (et son aimant), la DEL sur la GPIO 26 à travers 220 Ω, et le buzzer actif sur la GPIO 25, comme en K2. Fixe l’interrupteur sur un cadre, et l’aimant sur la porte, à quelques millimètres l’un de l’autre quand la porte est fermée.

Câblage S2 : ILS sur 27, DEL sur 26, buzzer sur 25 Plaque d’essai vue de dessus, disposée comme dans la leçon K2. DevKitC à cheval sur la rainure, USB à gauche, broches 25, 26, 27 et GND sur la rangée du haut, colonne j libre. Sept fils numérotés. 1 noir : broche GND vers le rail moins du haut. 2 orange : GPIO 25 vers la rangée 22, patte plus du buzzer actif ; son autre patte est en rangée 25 ; 3 noir : rangée 25 vers le rail moins. 4 vert : GPIO 26 vers la rangée 28 ; la résistance de 220 ohms relie les rangées 28 et 32 ; la patte longue de la DEL est en rangée 32, la courte en rangée 33 ; 5 noir : rangée 33 vers le rail moins. 6 bleu : GPIO 27 vers la rangée 37, un fil de l’ILS, couché sur les rangées 37 à 41 ; 7 noir : son autre fil, rangée 41, vers le rail moins. Un ILS n’a pas de polarité ; un capteur de porte à deux fils se branche de la même façon. FIG. 3 — CÂBLAGE, VUE PLAQUE D’ESSAI+−−+jihgfedcba15101522252832374144ENBOOT5VCMDD3D213GND121427262533323534VNVPEN3V3++12435buzzer actif220 ΩDEL67ILS(pas de polarité)1noir : broche GND → rail − du haut2orange : GPIO 25 → + du buzzer (rangée 22)3noir : − du buzzer (rangée 25) → rail −4vert : GPIO 26 → 220 Ω (rangée 28)5noir : − de la DEL (rangée 33) → rail −6bleu : GPIO 27 → ILS (rangée 37)7noir : ILS (rangée 41) → rail −Un capteur de porte à deux fils se branche de la même façon en rangées 37 et 41. INPUT_PULLUP, sans résistance.L’aimant va sur la porte, à côté de l’interrupteur, à quelques millimètres quand la porte est fermée.
Touche le schéma pour l’ouvrir en plein écran.

Téléverse le programme et ouvre le moniteur série à 115200 baud :

// Tinker Mission, leçon S2 : une alarme de porte avec un capteur à lames souples (ou un interrupteur d’inclinaison)
// Câblage :
//   ILS (deux fils, sans polarité) : un fil à la GPIO 27, l’autre fil à GND (pas de résistance nécessaire)
//   DEL : GPIO 26 -> résistance de 220 ohms -> patte longue de la DEL ; patte courte de la DEL -> GND
//   Buzzer actif : patte + à la GPIO 25, autre patte à GND (module à 3 broches : VCC à 3V3, GND à GND, I/O à la GPIO 25)
// Fixe l’interrupteur sur le cadre de la porte et l’aimant sur la porte, à quelques millimètres l’un de l’autre porte fermée.
// Porte fermée : l’aimant ferme l’interrupteur, la broche se lit LOW. Porte ouverte : l’interrupteur s’ouvre, la broche se lit HIGH.
// Un interrupteur d’inclinaison se câble pareil. Si le tien se ferme quand il penche, mets ALARM_LEVEL à LOW.

const int SWITCH_PIN = 27;
const int LED_PIN = 26;
const int BUZZER_PIN = 25;

const int ALARM_LEVEL = HIGH;   // HIGH : alarme quand l’interrupteur est ouvert. LOW : alarme quand il est fermé.

int lastReading = -1;           // -1 veut dire « rien lu pour l’instant »

void setup() {
  Serial.begin(115200);
  pinMode(SWITCH_PIN, INPUT_PULLUP);   // la résistance de rappel de la carte : interrupteur ouvert = HIGH, fermé = LOW
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
}

void loop() {
  int reading = digitalRead(SWITCH_PIN);

  if (reading == ALARM_LEVEL) {
    digitalWrite(LED_PIN, HIGH);
    digitalWrite(BUZZER_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, LOW);
    digitalWrite(BUZZER_PIN, LOW);
  }

  // N’affiche que lorsque la lecture change, pour que le moniteur série montre de vrais événements.
  if (reading != lastReading) {
    lastReading = reading;
    if (reading == LOW) {
      Serial.println("switch CLOSED (LOW)");
    } else {
      Serial.println("switch OPEN (HIGH)");
    }
  }

  delay(20);   // une courte pause entre deux lectures
}

Télécharger le dossier du croquis (.zip)

Avec l’aimant contre l’interrupteur, la DEL et le buzzer sont éteints. Éloigne l’aimant : ils s’allument. Rapproche-le : ils s’arrêtent. Fais-le entrer et sortir doucement pour trouver la distance de ton propre interrupteur.

Ce que font les nouvelles lignes :

  • ALARM_LEVEL dit quelle lecture signifie « alarme » : tu peux donc réutiliser le programme pour un autre type d’interrupteur en changeant une seule ligne.
  • lastReading se souvient de la lecture précédente. Le moniteur série n’affiche une ligne que quand elle change. La première lecture est toujours affichée, parce que -1 ne correspond à rien.
  • delay(20) convient ici : ce programme n’a qu’une seule tâche. Si tu ajoutes d’autres tâches, la leçon K4 montre comment s’en passer.

L’interrupteur d’inclinaison

Un interrupteur à bille (ou d’inclinaison) est un petit tube métallique qui contient une bille métallique libre. Penche le tube d’un côté et la bille roule sur les contacts et les relie. Redresse-le et la bille s’éloigne [6]. Il détecte un mouvement ou une orientation de base, ce qui explique qu’Adafruit l’appelle l’accéléromètre du pauvre [6]. Il ne dit pas de combien ni à quelle vitesse il a bougé, seulement s’il est penché ou non.

Le câblage est le même que pour l’ILS, et le programme aussi. Il y a une chose à décider : l’inclinaison qui ferme ton interrupteur dépend de la façon dont tu le montes. Si ton alarme doit sonner quand l’interrupteur se ferme, mets ALARM_LEVEL à LOW et téléverse de nouveau.

Des choses utiles à essayer :

  • Monte-le sur le couvercle d’une boîte, et fais sonner l’alarme quand le couvercle est penché.
  • Regarde le moniteur série pendant que tu l’inclines doucement. La bille rebondit un peu dans le tube, donc le contact peut clignoter au lieu de rester stable [13]. Vois-tu plusieurs changements à la suite ? Pense-y quand tu conçois un projet autour de lui.

Un ILS et un interrupteur d’inclinaison sont de la même famille : ils restent tranquillement dans un état jusqu’à ce que quelque chose bouge.

Un interrupteur à bille Trois vues de côté d’un interrupteur à bille : un petit tube de métal avec deux contacts qui entrent par un bout et une bille de métal libre à l’intérieur. a, le tube penché, bout des contacts en haut : la bille roule à l’autre bout, loin des contacts, l’interrupteur est ouvert. b, le tube penché dans l’autre sens : la bille roule sur les deux contacts et les relie, l’interrupteur est fermé. c, le même tube fixé sous un couvercle de boîte : quand on soulève le couvercle, le tube penche, la bille roule et la lecture change. Une bille qui roule ne reste pas immobile : attends-toi à quelques changements rapides d’affilée. FIG. 4 — INTERRUPTEUR À BILLE, VUE DE CÔTÉaContacts en hautniveaubille loin des contactsouvertbContacts en basniveaubille sur les contactsfermécSous un couverclecouvercle soulevé : le tube penchele couvercle le fait pencherquelques changements rapides
Touche le schéma pour l’ouvrir en plein écran.

Le capteur de mouvement PIR

Un capteur PIR (infrarouge passif, passive infrared) remarque les personnes et les animaux qui bougent. Tout objet émet un peu de rayonnement infrarouge, et plus il est chaud, plus il en émet [2]. Le capteur à l’intérieur d’un PIR est divisé en deux moitiés câblées de façon à s’annuler. Si une moitié voit un peu plus ou un peu moins d’infrarouge que l’autre, la sortie bascule [2]. Il détecte donc un changement, pas la chaleur en elle-même. Une personne qui traverse le champ passe d’abord devant une moitié, puis devant l’autre [3].

Une petite lentille en plastique, faite de nombreuses facettes, répartit le champ en plusieurs zones, pour qu’un mouvement qui les traverse déclenche le capteur [3]. Le module autour du capteur transforme cette bascule en simple impulsion numérique : HIGH quand il voit un mouvement, LOW quand il est au repos [2].

Trois limites à connaître :

  • Un PIR ne dit pas combien il y a de personnes ni à quelle distance. Les animaux domestiques peuvent aussi le déclencher [2].
  • La portée de détection est généralement d’environ 6 à 7 mètres, dans un cône large d’environ 110 à 120 degrés [2][4].
  • Il lui faut du temps pour se stabiliser après la mise sous tension : environ 30 à 60 secondes [7]. C’est pourquoi le programme ci-dessous commence par un compte à rebours.

Les réglages du module. Le PIR d’Adafruit (produit 189) a ces réglages [7]. D’autres modules peuvent en avoir de semblables, avec d’autres étiquettes :

  • Sensibilité : une petite résistance ajustable, appelée potentiomètre ajustable (trimpot). Dans le sens horaire, il est plus sensible.
  • Durée : un autre potentiomètre ajustable règle combien de temps la sortie reste haute après une détection. La plage va de quelques secondes à quelques minutes, selon le module (vérifie le tien). Le guide d’Adafruit donne environ 2,5 s à environ 250 s pour sa carte [7].
  • Cavalier de redéclenchement (H ou L). En H, la sortie reste haute tant que le mouvement continue. En L, la sortie s’allume et s’éteint environ une fois par seconde tant que tu continues à bouger [7]. Pour une alarme simple, H est le mode le plus facile [7].

D’autres modules vendus aux amateurs (le HC-SR501 est un modèle courant) sont conçus dans le même esprit, mais n’ont pas les mêmes pièces aux mêmes endroits. Lis ce qui est imprimé sur le tien, ou la fiche de l’endroit où tu l’as acheté.

Essaie le widget ci-dessous. Fais glisser l’aimant et regarde les lames. Puis passe à l’onglet mouvement, déplace la « personne » à travers l’éventail, et essaie les réglages de sensibilité et de durée ainsi que le cavalier de redéclenchement.

Fais glisser l’aimant (interactif) · Marche devant un PIR (interactif)
Fais glisser l’aimant (interactif) Simulation interactive, dessin simplifié. Un ILS est couché à gauche, ses deux lames écartées. Fais glisser l’aimant à gauche et à droite, ou sélectionne-le et utilise les flèches. Quand l’aimant arrive à moins de la distance de fermeture, réglée par le curseur (13 mm par défaut), les lames se touchent : l’interrupteur est fermé et la GPIO 27 lit LOW, la DEL d’alarme de porte est éteinte. Éloigne-le : les lames s’ouvrent, la broche lit HIGH et la DEL s’allume. Ton interrupteur a sa propre distance. ILS010203040mmNSsimulation, dessin simplifié

Simulation : un ILS simplifié, pas une mesure.

distance : 24 mm

interrupteur ouvertla GPIO 27 lit HIGHDEL d’alarme de porte allumée

se ferme à moins de 13 mm

Ton interrupteur a sa propre distance : trouve-la avec le croquis.

Voici l’état de départ : les commandes ont besoin de JavaScript.

Un module PIR, dehors et dedans (simplifié) Trois vues d’un module de détection de mouvement PIR typique, simplifiées. a, vue de côté : une lentille blanche en dôme, faite de nombreuses facettes, est posée sur une petite carte ; sous le dôme, l’élément sensible, divisé en deux moitiés câblées pour s’annuler. Une personne chaude qui traverse le champ est vue d’abord par une moitié, puis par l’autre. b, le dessous : trois broches, VCC, OUT et GND, deux petits potentiomètres ajustables étiquetés sensibilité et durée, et le cavalier H/L de redéclenchement. c, la lentille vue de face : ses facettes découpent le champ en zones. Note : l’ordre des broches varie, lis ton module. FIG. 5 — MODULE PIR (SIMPLIFIÉ)aVue de côtéABlentille à facettes (dôme)élément sensible :deux moitiés A et BIl voit un changement entre A et B,pas la chaleur elle-même.dessin simplifiébDessousVCCOUTGNDsensibilitéduréeHLcavalierpotentiomètres : petit tournevisH : reste haut tant que ça bougeL : marche-arrêt environ chaque secondecLentille, faceles facettes découpentle champ en zonesL’ordre des broches varie : lis ton module avant de le brancher.
Touche le schéma pour l’ouvrir en plein écran.

Branche le PIR sans risque

Un module PIR a trois broches : l’alimentation, la masse et le signal. L’ordre change d’un module à l’autre : lis donc les étiquettes imprimées à côté des broches avant de brancher quoi que ce soit. Branché à l’envers, le module d’Adafruit n’est pas abîmé, mais il ne fonctionne pas [8].

Deux tensions se rencontrent ici, et il ne faut pas les confondre :

  • L’alimentation en entrée. Adafruit indique que la plupart des modules PIR acceptent de 5 V à 12 V, avec un petit régulateur à l’intérieur, et que 5 V est le choix idéal [2][4]. Son guide de branchement donne 3 V à 5 V comme plage habituelle, parfois jusqu’à 12 V [8]. Les deux indications se recoupent à 5 V : c’est donc le point de départ le plus sûr. Regarde la fiche de ton module pour en être sûr. Quand la carte est alimentée par l’USB, utilise la broche 5V de la DevKitC pour alimenter le module. C’est la broche qu’Espressif décrit comme l’alimentation 5 V sur le connecteur [9]. Par l’USB, elle donne un peu moins de 5 V, parce que la carte a une diode de protection entre la prise USB et cette broche [11]. Un multimètre (leçon E2) y mesure en général entre 4,6 et 4,8 V (mesure la tienne), ce que la plupart des modules acceptent. N’alimente pas la carte par une autre source en même temps : Espressif demande d’utiliser une seule des options d’alimentation, et une seule, sinon la carte ou l’alimentation peuvent être endommagées [9].
  • Le signal en sortie. Le signal du PIR d’Adafruit est de 3,3 V à l’état haut [4]. Les broches d’entrée de l’ESP32 acceptent des niveaux hauts d’au plus 0,3 V au-dessus de leur propre alimentation : 3,3 V convient donc [5]. Un module qui sortirait 5 V ne conviendrait pas : ne branche jamais une sortie que tu n’as pas mesurée. Si tu as un doute, mesure-la avec un multimètre avant de la brancher : pointe noire sur GND, pointe rouge sur la broche de signal, et agite la main pour que la sortie passe à l’état haut.

Un dernier détail : certains modules ont une sortie « à collecteur ouvert », qui demande une résistance de rappel de 10 kΩ pour donner un niveau propre [8]. Sur l’ESP32, branche cette résistance entre le signal et la broche 3V3, jamais la broche 5V, pour que le signal ne dépasse jamais 3,3 V [5]. Le module d’Adafruit n’en a pas besoin. Si ton signal ne passe jamais à l’état haut, regarde la fiche de ton module à ce sujet.

Branchements :

  • la broche d’alimentation du PIR à la broche 5V de la DevKitC,
  • la masse du PIR à GND,
  • le signal du PIR à la GPIO 32,
  • la DEL sur la GPIO 26 (à travers 220 Ω) et le buzzer sur la GPIO 25, comme avant.
Câblage S2 : PIR sur 32, DEL sur 26, buzzer sur 25 Plaque d’essai vue de dessus. DevKitC à cheval sur la rainure, USB à gauche, colonne j libre. Huit fils numérotés. 1 noir : broche GND vers le rail moins du haut. 2 orange : GPIO 25 vers la rangée 22, patte plus du buzzer actif ; son autre patte est en rangée 25 ; 3 noir : rangée 25 vers le rail moins. 4 vert : GPIO 26 vers la rangée 28 ; la résistance de 220 ohms relie les rangées 28 et 32 ; la patte longue de la DEL est en rangée 32, la courte en rangée 33 ; 5 noir : rangée 33 vers le rail moins. Le module PIR est au-dessus de la plaque, broches marquées VCC, OUT et GND dans cet ordre sur ce dessin : 6 rouge, marqué 5V, un fil direct de la broche 5V de la DevKitC, rangée 1, à la broche VCC du PIR, alimentation environ 5 V ; 7 jaune, OUT vers j13 à côté de la GPIO 32, un signal de 3,3 V ; 8 noir, GND vers le rail moins. Le 5 V ne va jamais sur un rail de la plaque : les rails restent 3V3 et GND, comme dans les autres leçons, et le rail plus n’est pas utilisé ici. L’ordre des broches change d’un module à l’autre : lis les étiquettes du tien. FIG. 6 — CÂBLAGE, VUE PLAQUE D’ESSAI+−−+jihgfedcba15101318222528323744ENBOOT5VCMDD3D213GND121427262533323534VNVPEN3V3++12435buzzer actif220 ΩDEL5V6VCCOUTGNDmodule PIR, broches vues du dessus78rouge : alimentation environ 5 Vjaune : sortie 3,3 V1noir : broche GND → rail − du haut2orange : GPIO 25 → + du buzzer (rangée 22)3noir : − du buzzer (rangée 25) → rail −4vert : GPIO 26 → 220 Ω (rangée 28)5noir : − de la DEL (rangée 33) → rail −6rouge : broche 5V → VCC du PIR, fil direct, 5 V7jaune : OUT du PIR → j13 (GPIO 32), 3,3 V8noir : GND du PIR → rail − (rangée 18)L’ordre des broches change d’un module à l’autre : lis les étiquettes du tien avant de brancher.Le 5 V ne va jamais sur un rail : un seul fil de la broche 5V au VCC. Les rails restent 3V3 et GND.L’USB alimente la carte, la broche 5V alimente le PIR. Mesure la sortie d’un module inconnu avant de le brancher.
Touche le schéma pour l’ouvrir en plein écran.

Le programme :

// Tinker Mission, leçon S2 : lire un capteur de mouvement PIR (module à sortie 3,3 V)
// Câblage (le module PIR a trois broches : vérifie les étiquettes imprimées dessus) :
//   PIR VCC -> la broche 5V de la DevKitC (beaucoup de modules demandent environ 5 V, voir la leçon)
//   PIR GND -> GND
//   PIR OUT -> GPIO 32 (la sortie doit être en 3,3 V, jamais en 5 V)
//   DEL : GPIO 26 -> résistance de 220 ohms -> patte longue de la DEL ; patte courte de la DEL -> GND
//   Buzzer actif : patte + à la GPIO 25, autre patte à GND (module à 3 broches : VCC à 3V3, GND à GND, I/O à la GPIO 25)
// Un PIR a besoin de temps pour se stabiliser après la mise sous tension : reste immobile et hors de son champ pendant le compte à rebours.

const int PIR_PIN = 32;
const int LED_PIN = 26;
const int BUZZER_PIN = 25;

const int WARMUP_SECONDS = 60;   // un PIR a besoin d’environ 30 à 60 secondes pour se stabiliser

int lastReading = LOW;

void setup() {
  Serial.begin(115200);
  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);

  Serial.println("Warming up. Keep still and stay out of the sensor's view.");
  for (int s = WARMUP_SECONDS; s > 0; s--) {
    Serial.print(s);
    Serial.println(" s left");
    delay(1000);
  }
  Serial.println("Ready.");
}

void loop() {
  int reading = digitalRead(PIR_PIN);   // HIGH = mouvement détecté

  digitalWrite(LED_PIN, reading);
  digitalWrite(BUZZER_PIN, reading);

  if (reading != lastReading) {
    lastReading = reading;
    if (reading == HIGH) {
      Serial.println("Motion detected!");
    } else {
      Serial.println("Motion ended.");
    }
  }

  delay(50);
}

Télécharger le dossier du croquis (.zip)

Attends « Ready. », puis agite la main devant le capteur. La DEL et le buzzer s’allument tant que la sortie est haute, et le moniteur série t’indique quand le mouvement commence et finit. C’est la même idée que le programme de test d’Adafruit, qui affiche lui aussi quand la sortie change [10].

Ce que font les nouvelles lignes :

  • for (int s = WARMUP_SECONDS; s > 0; s--) compte à rebours de 60 à 1, une étape par seconde. Le delay(1000) convient dans setup(), où la carte n’a rien d’autre à faire.
  • pinMode(PIR_PIN, INPUT) : le module pilote lui-même sa sortie, donc aucune résistance de rappel n’est nécessaire.
  • digitalWrite(LED_PIN, reading) recopie le capteur sur la DEL : HIGH l’allume, LOW l’éteint.

Fais tes propres modifications

Change une seule chose, téléverse, observe.

  1. Test de distance. Avec l’alarme de porte, éloigne l’aimant d’un millimètre à la fois. À quelle distance l’alarme se déclenche-t-elle ? Note-la. Est-ce pareil des deux côtés de l’interrupteur ?
  2. Alarme inversée. Mets ALARM_LEVEL à LOW. Quelle situation fait sonner l’alarme maintenant ? Où cela pourrait-il servir ?
  3. Réglages. Tourne le potentiomètre ajustable de sensibilité du PIR petit à petit, et remarque à quelle distance ta main est détectée. Puis déplace le cavalier de redéclenchement de H à L (si ton module en a un) et regarde le moniteur série pendant que tu continues d’agiter la main.

Quand ça ne marche pas

  • ILS : l’alarme est toujours allumée, ou toujours éteinte. Vérifie les deux fils : l’un doit aller à GND. Puis teste la distance : l’aimant est peut-être trop loin, ou du mauvais côté. Regarde la fiche de l’interrupteur pour sa distance (13 mm pour celui d’Adafruit [1]).
  • ILS : l’alarme marche à l’envers. Passe ALARM_LEVEL de HIGH à LOW (ou l’inverse), ou vérifie que l’aimant est bien contre l’interrupteur quand la porte est fermée.
  • Inclinaison : plusieurs messages pour une seule inclinaison. La bille rebondit sur les contacts [13]. Essaie un mouvement plus lent, ou un autre angle de montage.
  • PIR : il se déclenche quand je l’allume. C’est normal, laisse finir le compte à rebours [7].
  • PIR : il ne se déclenche jamais. Vérifie l’alimentation et les broches. Les étiquettes imprimées sur le module passent en premier, car le brochage varie [8]. Si ton module demande 5 V, mesure sa broche d’alimentation : par l’USB, un peu moins de 5 V est normal [11]. Si le module a une sortie à collecteur ouvert, une résistance de rappel de 10 kΩ vers 3V3 (jamais vers 5V) aide [8].
  • PIR : la sortie reste haute très longtemps. Le potentiomètre de durée est tourné à fond, ou le cavalier est sur H et quelque chose continue de bouger [7].
  • PIR : fausses alarmes. Les animaux domestiques peuvent le déclencher [2]. Essaie une autre position, ou baisse la sensibilité.
  • Rien dans le moniteur série. Règle-le sur 115200 baud.

Vérifie-toi

Trois petites questions. Rien n’est enregistré, prends ton temps.

  1. Un capteur à lames souples (ILS) est branché entre la GPIO 27 et GND, avec INPUT_PULLUP. La porte est fermée et l’aimant est contre le capteur. Que renvoie digitalRead() ?

    • HIGH, car l’interrupteur est ouvert
    • LOW, car l’aimant a fermé l’interrupteur
    • Rien : un ILS a besoin de 5 V pour fonctionner
    Voir la réponse

    LOW, car l’aimant a fermé l’interrupteur. Un ILS est normalement ouvert, et un aimant assez proche le ferme [1]. Un interrupteur fermé relie la broche à GND : la broche se lit donc LOW. (La résistance de rappel de la carte fait qu’un interrupteur ouvert se lit HIGH [5].)

  2. Ton module PIR est alimenté en 5 V, et sa sortie mesure 3,3 V à l’état haut. Le fil de sortie peut-il aller directement sur une GPIO de l’ESP32 ?

    • Oui, 3,3 V est un niveau haut normal pour les entrées de l’ESP32
    • Non, l’ESP32 ne comprend que des signaux de 5 V
    • Non, il faut toujours une résistance de 10 kΩ en série
    Voir la réponse

    Oui, 3,3 V est un niveau haut normal pour les entrées de l’ESP32. Une entrée de l’ESP32 accepte un niveau haut de 0,75 fois son alimentation jusqu’à 0,3 V au-dessus d’elle : 3,3 V est donc bien dans la plage [5], et la sortie du PIR d’Adafruit est de 3,3 V [4]. Le vrai danger, ce serait un module dont la sortie fait 5 V : mesure d’abord un module que tu ne connais pas. (Une résistance de rappel de 10 kΩ ne sert que pour les sorties à collecteur ouvert [8].)

  3. Juste après avoir alimenté un capteur PIR, sa sortie vacille pendant un moment. Que faire ?

    • Le remplacer, il est cassé
    • Attendre : il lui faut environ 30 à 60 secondes pour se stabiliser
    • Mettre la sensibilité à fond
    Voir la réponse

    Attendre : il lui faut environ 30 à 60 secondes pour se stabiliser. Un PIR a besoin de temps pour se stabiliser après la mise sous tension, et sa sortie peut vaciller pendant ce temps [7]. Le programme compte 60 secondes à rebours pour cette raison.


En bref

  • Un ILS est normalement ouvert et un aimant proche le ferme [1]. Avec INPUT_PULLUP, porte fermée = LOW, porte ouverte = HIGH. Un fil coupé se lit comme une porte ouverte.
  • Un interrupteur d’inclinaison relie ses contacts quand une bille roulante les atteint [6]. Même câblage, même programme : règle ALARM_LEVEL selon la façon dont tu le montes.
  • Un PIR détecte la variation d’infrarouge entre ses deux moitiés : il remarque un mouvement, pas un corps chaud immobile [2]. Il lui faut 30 à 60 secondes pour se stabiliser [7].
  • Alimente le module sur 5V s’il le demande, et vérifie que son signal est en 3,3 V avant de le brancher à une GPIO [2][4][5].
  • Les modules diffèrent : lis les étiquettes, puis teste.

Prochaines étapes : utilise un de ces capteurs comme déclencheur de l’alarme de la leçon K4. Attention : ils se lisent HIGH pour « alarme », alors que le bouton de K4 se lisait LOW : inverse ce test.


Sources

Voir les 13 sources
  1. Adafruit, « Magnetic contact switch (door sensor) », page produit 375 (essentiellement un ILS dans un boîtier en plastique, avec un aimant comme autre moitié ; normalement ouvert, aucune liaison entre les deux fils ; l’interrupteur se ferme quand l’aimant est à moins de 13 mm (0,5 pouce) ; sert à détecter l’ouverture d’une porte ou d’un tiroir) — https://www.adafruit.com/product/375
  2. Adafruit, « PIR Motion Sensor », guide d’apprentissage, « Overview » (les capteurs PIR détectent le mouvement, en général de personnes ; tout objet émet de l’infrarouge, et plus il est chaud, plus il en émet ; le capteur est divisé en deux moitiés qui s’annulent et la sortie bascule quand l’une voit plus ou moins d’infrarouge ; sortie numérique, haute (3 V) en cas de mouvement et basse au repos, durée de l’impulsion fixée par des composants de la carte et variable d’un capteur à l’autre ; ne dit ni combien de personnes ni à quelle distance ; parfois déclenché par des animaux domestiques ; portée jusqu’à environ 6 m (20 pieds), 110° x 70° ; tension d’entrée de 5 V à 12 V pour la plupart des modules avec un régulateur 3,3 V, 5 V idéal) — https://learn.adafruit.com/pir-passive-infrared-proximity-motion-sensor/overview
  3. Adafruit, « PIR Motion Sensor », guide d’apprentissage, « How PIRs Work » (deux fentes sensibles à l’infrarouge ; un corps chaud qui passe intercepte d’abord une moitié, puis l’autre, ce qui produit une variation différentielle ; une lentille de Fresnel à facettes répartit le champ en plusieurs zones de détection) — https://learn.adafruit.com/pir-passive-infrared-proximity-motion-sensor/how-pirs-work
  4. Adafruit, « PIR (motion) sensor », page produit 189 (délai et sensibilité réglables ; fonctionne avec une alimentation de 5 V à 12 V ; sortie du signal numérique en 3,3 V, état haut ou bas ; portée de détection d’environ 7 m, cône de 120 degrés) — https://www.adafruit.com/product/189
  5. Espressif, ESP32 Series Datasheet v5.3, section 5.3 « DC Characteristics (3.3 V, 25 °C) » (tension d’entrée de niveau haut entre 0,75 x VDD et VDD + 0,3 V) et description des GPIO (la plupart des GPIO numériques peuvent être configurées avec une résistance de rappel ou d’abaissement interne) — https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf
  6. Adafruit, « Tilt ball switch », page produit 173 (les capteurs d’inclinaison détectent un mouvement et une orientation de base, « l’accéléromètre du pauvre » ; une bille métallique roule dans un tube métallique et, quand il est penché, roule sur les contacts au bout et les met en court-circuit) — https://www.adafruit.com/product/173
  7. Adafruit, « PIR Motion Sensor », guide d’apprentissage, « Testing a PIR » (attendre 30 à 60 secondes que le PIR se stabilise après la mise sous tension ; le cavalier de redéclenchement en H garde la sortie haute pendant un mouvement continu, en L la sortie s’allume et s’éteint environ chaque seconde ; potentiomètre ajustable de sensibilité, sens horaire = plus sensible ; potentiomètre TIME qui règle la durée de l’impulsion de sortie, d’environ 2,5 s à 250 s sur la carte d’Adafruit) — https://learn.adafruit.com/pir-passive-infrared-proximity-motion-sensor/testing-a-pir
  8. Adafruit, « PIR Motion Sensor », guide d’apprentissage, « Connecting to a PIR » (la plupart des modules ont trois broches et le brochage varie d’un module à l’autre, donc à vérifier ; l’alimentation est en général de 3 V à 5 V continu mais peut aller jusqu’à 12 V ; certaines sorties sont à collecteur ouvert et demandent une résistance de rappel de 10 kΩ entre le signal et l’alimentation ; brancher le câble à l’envers n’abîme pas le PIR d’Adafruit, mais il ne fonctionne pas) — https://learn.adafruit.com/pir-passive-infrared-proximity-motion-sensor/connecting-to-a-pir
  9. Espressif, ESP32-DevKitC V4 User Guide (trois modes d’alimentation qui s’excluent mutuellement : port Micro USB, broches 5V et GND, broches 3V3 et GND ; l’alimentation doit venir d’un seul d’entre eux, sinon la carte et/ou la source peuvent être endommagées ; la broche « 5V » du connecteur est décrite comme l’alimentation 5 V) — https://docs.espressif.com/projects/esp-dev-kits/en/latest/esp32/esp32-devkitc/user_guide.html
  10. Adafruit, « PIR Motion Sensor », guide d’apprentissage, « Using a PIR w/Arduino » (le PIR se comporte comme une sortie numérique ; relier la sortie à une broche numérique et surveiller son passage à l’état haut ou bas ; le programme d’exemple affiche un message quand le mouvement commence et quand il se termine ; cavalier de redéclenchement en position H ; alimenter le PIR en 5 V) — https://learn.adafruit.com/pir-passive-infrared-proximity-motion-sensor/using-a-pir-w-arduino
  11. Espressif, ESP32-DevKitC V4 schematic (le VBUS de l’USB rejoint le réseau EXT_5V, qui est la broche « 5V » du connecteur, à travers la diode Schottky D3, BAT760-7) — https://dl.espressif.com/dl/schematics/esp32_devkitc_v4_sch.pdf
  12. SparkFun, « Reed Switch Hookup Guide » (dans un champ magnétique, deux pièces ferromagnétiques à l’intérieur s’attirent et le contact se ferme ; normalement ouvert ; les ILS en verre de base sont assez fragiles, plier les pattes sans forcer sur le corps) — https://learn.sparkfun.com/tutorials/reed-switch-hookup-guide
  13. Adafruit, « Tilt Sensor », guide d’apprentissage, « Using a Tilt Sensor » (la bille rebondit un peu dans le boîtier, donc le contact peut être un peu intermittent au lieu de constant ; programme d’exemple avec un délai anti-rebond) — https://learn.adafruit.com/tilt-sensor/using-a-tilt-sensor

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.