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 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_PULLUPdanssetup().
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.)
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.
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_LEVELdit quelle lecture signifie « alarme » : tu peux donc réutiliser le programme pour un autre type d’interrupteur en changeant une seule ligne.lastReadingse 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-1ne 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.
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.
Simulation : un ILS simplifié, pas une mesure.
distance : 24 mm
Ton interrupteur a sa propre distance : trouve-la avec le croquis.
Fais glisser l’aimant, ou sélectionne-le et utilise les flèches.
Simulation : durées raccourcies, pas un vrai capteur.
mise en route : encore 60 s, sortie ignorée
Mise en route : le PIR se stabilise, sa sortie n’est pas encore fiable.
H : reste haut tant que tu bouges. L, simplifié ici : marche-arrêt environ chaque seconde.
Voici l’état de départ : les commandes ont besoin de JavaScript.
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
5Vde 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
5Vde 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.
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. Ledelay(1000)convient danssetup(), 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 :HIGHl’allume,LOWl’éteint.
Fais tes propres modifications
Change une seule chose, téléverse, observe.
- 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 ?
- Alarme inversée. Mets
ALARM_LEVELàLOW. Quelle situation fait sonner l’alarme maintenant ? Où cela pourrait-il servir ? - 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_LEVELdeHIGHà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 vers5V) 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.
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
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].)
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_LEVELselon 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
5Vs’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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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