Leçons · Leçon K3 · Les bases du code · 25 min
Valeurs analogiques et seuils
Lis une tension qui varie avec analogRead(), transforme-la en décision avec un seuil, puis supprime le bégaiement avec deux seuils. Environ 25 minutes, avec un graphique en direct que tu peux faire glisser.
Du oui / non au « combien »
Dans la leçon S1, le capteur donnait deux réponses : le faisceau est libre, ou il est coupé. Beaucoup de capteurs font mieux. Un capteur de lumière, par exemple, produit une tension qui glisse en douceur entre « sombre » et « lumineux ». Une broche numérique ne sait pas décrire ça : elle ne connaît que haut et bas.
Ce qui sait le faire, c’est le CAN, le convertisseur analogique-numérique (ADC en anglais). Il mesure une tension et donne à ton code un nombre [1]. L’ESP32 en a deux, de 12 bits chacun, reliés à 18 broches d’entrée [3].
La règle graduée. Imagine une règle à 4096 graduations. Tu poses une tension contre elle et tu lis la graduation la plus proche. Ce nombre, c’est ce que analogRead() te donne. Douze bits font 2 puissance 12 = 4096 niveaux, numérotés de 0 à 4095 [2]. (Une carte Arduino classique a un convertisseur de 10 bits : elle compte donc de 0 à 1023 [6].)
Là où l’image s’arrête. Une règle mesure une longueur de façon droite et régulière. La règle de l’ESP32 a ses propres défauts, surtout près de ses deux extrémités, et nous les verrons à l’écran 4.
Dans cette leçon, le nombre vient d’un capteur de lumière, et il commande la DEL et le buzzer de K2. Ensuite, nous rendons la décision robuste.
Le capteur : un pont diviseur sensible à la lumière
Une LDR (light-dependent resistor, une photorésistance) change de résistance selon la lumière qu’elle reçoit. Place-la en série avec une résistance fixe et lis la tension au point où elles se rejoignent. Quand la lumière augmente, la résistance de la LDR diminue, et la tension aux bornes de la résistance fixe monte [4]. La leçon E5 explique ce pont diviseur de tension en détail. Ici, nous l’utilisons comme une recette, et la tension U sur la broche monte avec la lumière :
3V3à une patte de la LDR.- L’autre patte de la LDR à la GPIO 34, et depuis ce même point une résistance de 10 kΩ vers
GND.
Adafruit montre ce montage avec une alimentation de 5 V et note que 3,3 V fonctionne tout aussi bien [4]. Plus de lumière, plus de tension, un nombre plus grand.
Choisir la broche. Les entrées analogiques de l’ESP32 sont réparties entre deux convertisseurs, ADC1 et ADC2. La GPIO 34 appartient à ADC1 (canal 6) et ne sert qu’en entrée [3][5]. Les GPIO 32 à 39 sont sur ADC1, alors que les GPIO 25, 26 et 27 (notre buzzer, notre DEL et notre bouton) sont sur ADC2 [3]. Nous ne les utilisons ici que comme de simples broches numériques. Mais les broches d’ADC2 ne peuvent pas servir quand le Wi-Fi est utilisé [5] : nous gardons donc les capteurs analogiques sur des broches d’ADC1, et le Wi-Fi ne gênera pas plus tard.
Ajoute la DEL sur la GPIO 26 et le buzzer actif sur la GPIO 25 comme en K2. Ces pièces ne changent pas.
Lis le nombre
Téléverse ce premier programme et ouvre le moniteur série à 115200 baud :
// Tinker Mission, leçon K3 : lire une valeur analogique (pont diviseur à LDR sur la GPIO 34) et en faire la moyenne
// Câblage (un pont diviseur de tension, voir la leçon E5) :
// 3V3 -> LDR -> GPIO 34 -> résistance de 10 kohms -> GND
// (la LDR et la résistance se rejoignent au fil qui va à la GPIO 34)
// Ouvre le moniteur série à 115200 baud. Couvre la LDR avec la main, puis éclaire-la.
const int LDR_PIN = 34; // une broche d'ADC1, entrée seulement
// Fait la moyenne de plusieurs lectures pour lisser les petits écarts.
int readAveraged(int howMany) {
long total = 0;
for (int i = 0; i < howMany; i++) {
total = total + analogRead(LDR_PIN);
delay(2);
}
return total / howMany;
}
void setup() {
Serial.begin(115200);
analogReadResolution(12); // 12 bits : valeurs de 0 à 4095 (c'est déjà la valeur par défaut)
analogSetPinAttenuation(LDR_PIN, ADC_11db); // plage de tension la plus large (garde les lectures loin des deux bouts de l'échelle)
}
void loop() {
int single = analogRead(LDR_PIN); // une lecture brute, de 0 à 4095
int smooth = readAveraged(16); // moyenne de 16 lectures
Serial.print("single: ");
Serial.print(single);
Serial.print(" averaged: ");
Serial.println(smooth);
delay(200);
}
Télécharger le dossier du croquis (.zip)
Couvre la LDR avec ta main, puis éclaire-la avec une lampe ou la lampe de ton téléphone, et regarde les deux colonnes.
Ce que font les nouvelles lignes :
analogRead(34)renvoie la lecture brute de la broche, un nombre entier [1].analogReadResolution(12)règle la taille de la règle. 12 bits, c’est déjà la valeur par défaut, et la ligne est là pour rendre l’idée visible [1].analogSetPinAttenuation(...)règle l’atténuation : un réducteur intégré qui permet au convertisseur de mesurer des tensions plus élevées. Plus l’atténuation est forte, plus la tension mesurable est élevée [1]. Nous la réglons nous-mêmes, pour que la leçon ne dépende pas d’une valeur par défaut.readAveraged(16)est notre propre fonction. Sa boucleforrépète 16 fois les lignes qu’elle contient : elle additionne 16 lectures, puis divise le total par 16. Les décimales sont perdues, car le résultat est rangé dans unint, un nombre entier.
Si tu préfères voir des millivolts plutôt que des graduations brutes, analogReadMilliVolts() renvoie une valeur calibrée en millivolts [1]. Nous restons sur les nombres bruts ici, parce que les seuils s’en accommodent très bien.
Vérification du câblage. Main sur la LDR : un petit nombre ; lampe dessus : un grand nombre. Si c’est l’inverse, la LDR et la résistance sont échangées. Avec une résistance de 10 kΩ, une LDR très éclairée (environ 1 kΩ, typique, selon la pièce) met environ 3,0 V sur la broche, juste sous les 3100 mV du haut de la plage 11 dB : la lecture arrive près du haut de l’échelle, et une lumière plus forte peut la pousser jusqu’à 4095 [1][4]. Dans le noir profond, la tension est proche de 0, et la lecture aussi. Voir 4095 sous une lampe, ou 0 dans le noir, est normal : la tension dépasse une extrémité de la règle. Tes seuils n’ont besoin que de se situer au milieu. Dans une pièce lumineuse, utilise une résistance fixe plus petite (par exemple 1 kΩ) pour que la lecture reste hors de la zone haute peu fiable [4]. Adafruit note qu’une résistance de 10 kΩ sature en pleine lumière et conseille une plus petite, au prix de moins de détails dans le noir [4].
Les extrémités de la règle
La règle n’est pas parfaite. Les documents d’Espressif le disent, et les détails comptent :
Plage utilisable. L’atténuation fixe la plage de tensions que le convertisseur peut mesurer, et les extrémités de cette plage ne sont pas fiables. Pour le réglage le plus large, la documentation Arduino indique de 150 mV à 3100 mV [1], alors que la fiche technique donne une plage effective de 150 mV à 2450 mV et précise que la précision se dégrade au-dessus d’une lecture d’environ 3000, soit à peu près 2450 mV [3]. Les pages d’Espressif nomment les paliers différemment (11 dB, 12 dB, « atten = 3 ») [1][2][3], et leurs chiffres diffèrent. Quand les sources ne s’accordent pas, retiens la plus prudente : garde les lectures sur lesquelles tu comptes loin des deux bouts de l’échelle.
Des graduations inégales. La fiche technique donne une non-linéarité différentielle allant jusqu’à ±7 LSB et une non-linéarité intégrale allant jusqu’à ±12 LSB [3]. Un LSB, c’est une graduation sur les 4096. En clair : les graduations de la règle n’ont pas toutes la même taille, et la règle entière penche un peu. Douze graduations sur 4096, c’est environ 0,3 %, peu pour un seuil. Ces chiffres ont été mesurés dans de bonnes conditions : un condensateur de 100 nF sur l’entrée, une tension stable, et le Wi-Fi et le Bluetooth coupés [3].
D’une puce à l’autre. Par défaut, les résultats mesurés diffèrent de ±6 % d’une puce à l’autre, et ESP-IDF propose des méthodes de calibrage pour faire mieux [3]. Ton 1500 n’est donc pas le 1500 de ton voisin. Ne copie jamais un seuil trouvé dans un tutoriel : mesure le tien.
Le bruit. La fiche technique suggère elle-même de prendre plusieurs échantillons avec un filtre, ou d’en faire la moyenne, pour des paliers plus lisses et plus réguliers (meilleur DNL) [3]. Nous le faisons à l’écran 7.
Choisir un seuil
Un seuil est un nombre auquel ton code compare la lecture, pour retransformer le « combien » en oui ou non :
if (value < 1500) {
// sombre : allume l’alarme
}
Pour le choisir, il y a trois étapes :
- Mesure la situation normale. Laisse la pièce comme d’habitude et note les valeurs que le moniteur série affiche, de la plus basse à la plus haute.
- Mesure l’événement. Couvre la LDR, ou fais ce que tu veux détecter, et note aussi ces valeurs.
- Choisis un nombre entre les deux groupes, avec de la marge de chaque côté. Le milieu est une bonne première idée, puis teste-le aux deux extrêmes et entre les deux.
Exemple (nombres inventés, pas une mesure) : la lumière de la pièce donne de 2300 à 2500, une main sur la LDR donne de 500 à 700. Les deux groupes sont bien séparés : un seuil vers 1500 laisse beaucoup de marge.
Le cas facile, c’est quand les groupes sont éloignés. Les situations réelles sont plus brouillonnes, comme le montre l’écran suivant.
Le bégaiement
Imagine maintenant le crépuscule. La lumière baisse lentement, et la lecture dérive vers ton seuil, disons 1500. Près de la ligne, de minuscules oscillations suffisent à la franchir : 1502, 1498, 1503, 1497. Le code voit sombre, clair, sombre, clair. La DEL bégaie et le buzzer crépite, alors que rien de réel n’a changé.
La cause n’est pas un bogue. Toute lecture porte un peu de bruit, et un seuil unique est une ligne que le bruit peut franchir dans les deux sens. Essaie dans le graphique ci-dessous : fais glisser la ligne, augmente le bruit et compte combien de fois l’alarme bascule. Puis active la deuxième ligne.
Fais glisser le dessin sur le côté pour tout voir.
Remède 1 : la moyenne
Le premier remède consiste à calmer la lecture. Au lieu de te fier à une seule lecture, tu en prends plusieurs à la suite et tu utilises leur moyenne [3]. Une oscillation au hasard qui monte à une lecture redescend à la suivante, et la moyenne la lisse. C’est ce que fait readAveraged(16), et cela coûte environ 32 ms d’attente (16 lectures espacées de 2 ms), ce que tu ne remarqueras pas.
Deux limites :
- Une moyenne plus grande réagit plus lentement. Seize, c’est un bon début.
- La moyenne ne peut pas arrêter le bégaiement quand la valeur vraie repose juste sur la ligne. Un 1500 bien lisse contre un seuil de 1500, c’est encore un pile ou face.
Nous ajoutons donc une seconde idée.
Remède 2 : deux seuils
Pense à un thermostat. Le chauffage ne s’allume pas à 20 degrés pour s’éteindre à 20 degrés : il claquerait toute la nuit. Il s’allume plutôt quand la pièce tombe sous, disons, 19, et ne s’éteint qu’une fois au-dessus de 21. Entre les deux, il continue ce qu’il faisait.
C’est l’hystérésis : des seuils de basculement différents selon le sens dans lequel va le signal [7]. Le composant électronique qui fait ça s’appelle une bascule de Schmitt (Schmitt trigger) [7]. En code, pas besoin de composant, juste une mémoire (alarmOn) et deux nombres :
- l’alarme s’allume quand la valeur tombe sous
LOW_LIMIT, - l’alarme ne s’éteint que quand la valeur monte au-dessus de
HIGH_LIMIT, - entre les deux, rien ne change. Un interrupteur à bascule se comporte ainsi : il reste là où tu l’as laissé [8].
L’écart entre les deux nombres est la marge. Choisis-la plus grande que les oscillations que tu vois quand tu ne bouges rien (regarde les nombres les plus bas et les plus hauts dans le moniteur série), et plus petite que l’écart entre tes deux situations.
Là où l’image s’arrête. Un thermostat a une pièce lente derrière lui. Notre code réagit aussi vite qu’il lit : la marge est donc notre principale protection.
Le programme complet :
// Tinker Mission, leçon K3 : une alarme de lumière à deux seuils (hystérésis)
// Câblage :
// Pont diviseur à LDR : 3V3 -> LDR -> GPIO 34 -> résistance de 10 kohms -> GND
// DEL : GPIO 26 -> 220 ohms -> grande patte de la DEL ; petite patte 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)
// L'alarme s'ALLUME quand la lecture tombe sous LOW_LIMIT (il fait sombre),
// et ne s'ÉTEINT que lorsque la lecture remonte au-dessus de HIGH_LIMIT.
// Entre les deux limites, rien ne change. Remplace les nombres par tes propres mesures.
const int LDR_PIN = 34;
const int LED_PIN = 26;
const int BUZZER_PIN = 25;
const int LOW_LIMIT = 1200; // alarme ALLUMÉE sous cette valeur
const int HIGH_LIMIT = 1600; // alarme ÉTEINTE au-dessus (l'écart entre les deux limites est la marge)
int alarmOn = 0; // 0 = calme, 1 = alarme
int readAveraged(int howMany) {
long total = 0;
for (int i = 0; i < howMany; i++) {
total = total + analogRead(LDR_PIN);
delay(2);
}
return total / howMany;
}
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
pinMode(BUZZER_PIN, OUTPUT);
analogSetPinAttenuation(LDR_PIN, ADC_11db);
}
void loop() {
int value = readAveraged(16);
if (alarmOn == 0) {
if (value < LOW_LIMIT) {
alarmOn = 1; // il vient de faire sombre
}
} else {
if (value > HIGH_LIMIT) {
alarmOn = 0; // il fait de nouveau nettement clair
}
}
if (alarmOn == 1) {
digitalWrite(LED_PIN, HIGH);
digitalWrite(BUZZER_PIN, HIGH);
} else {
digitalWrite(LED_PIN, LOW);
digitalWrite(BUZZER_PIN, LOW);
}
Serial.print("value: ");
Serial.print(value);
Serial.print(" alarm: ");
Serial.println(alarmOn);
delay(100);
}
Télécharger le dossier du croquis (.zip)
alarmOn est une variable qui garde l’état en mémoire : 0 pour calme, 1 pour alarme. Les deux blocs if imbriqués sont toute l’astuce. Celui qui s’exécute dépend de ce que dit alarmOn. Les symboles < et > veulent dire « plus petit que » et « plus grand que ».
Dépannage.
- L’alarme ne s’allume jamais : ta
LOW_LIMITest sous la lecture la plus sombre que tu obtiens. Augmente-la, après avoir vérifié tes propres nombres. - L’alarme s’allume mais ne s’éteint jamais :
HIGH_LIMITest au-dessus de la lecture la plus lumineuse. Baisse-la. - Ça bégaie encore : élargis la marge, ou éloigne la LDR des lumières qui clignotent et des ombres qui bougent.
Fais tes propres modifications
Change une seule chose, téléverse, observe.
- Sans marge. Mets
HIGH_LIMITégale àLOW_LIMIT. Le bégaiement revient-il au crépuscule ? - Moins de lectures. Remplace
readAveraged(16)parreadAveraged(1). Qu’est-ce qui change dans le moniteur série ? - Inverse. Fais sonner l’alarme quand la pièce devient plus lumineuse, comme une alarme « lumière allumée ». Quelles parties du programme s’échangent ?
Vérifie-toi
Trois petites questions. Rien n’est enregistré, prends ton temps.
Par défaut, quelle plage de valeurs analogRead() renvoie-t-il sur un ESP32 ?
- De 0 à 1023
- De 0 à 4095
- De 0 à 255
En pleine lumière, ton capteur lit environ 2400, et avec ta main dessus, environ 600. Quel premier seuil est le plus sensé ?
- 4095
- 600
- Environ 1500, entre les deux
Voir la réponse
Environ 1500, entre les deux. Un seuil se place entre les deux situations que tu veux distinguer, avec de la marge de chaque côté. Commence par relever les nombres de ton propre montage, car les puces diffèrent entre elles de plusieurs pour cent [3]. (2400 et 600 sont des nombres d’exemple, pas une mesure.)
Avec LOW_LIMIT à 1200 et HIGH_LIMIT à 1600, l’alarme est allumée et la lecture monte à 1400. Que se passe-t-il ?
- L’alarme reste allumée : elle ne s’éteint qu’au-dessus de 1600
- L’alarme s’éteint, car 1400 dépasse 1200
- L’alarme s’éteint, car la valeur a changé
Voir la réponse
L’alarme reste allumée : elle ne s’éteint qu’au-dessus de 1600. Entre les deux limites, rien ne change. Avoir des seuils de basculement différents selon que le signal monte ou descend, c’est ce qu’on appelle l’hystérésis [7].
Sources
Voir les 8 sources
- Espressif, documentation Arduino-ESP32, « ADC » (analogRead renvoie la valeur brute, non calibrée, d’une conversion ; analogReadMilliVolts renvoie des millivolts calibrés ; analogReadResolution par défaut 12 bits, de 0 à 4095 ; analogSetPinAttenuation ; une atténuation plus forte permet de mesurer une tension plus élevée ; tableau des plages mesurables par atténuation pour l’ESP32) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/adc.html
- Espressif, ESP-IDF Programming Guide, « Analog to Digital Converter (ADC) » (les résultats bruts font 12 bits par défaut, ce qui divise la plage d’entrée en 4096 niveaux ; atténuations de 0, 2,5, 6 et 12 dB ; tension de référence de 1100 mV par conception, valeur réelle entre 1000 et 1200 mV selon la puce) — https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/adc/index.html
- Espressif, « ESP32 Series Datasheet » v5.3, section 4.9.1 et tableaux des broches (deux CAN SAR de 12 bits, 18 canaux ; caractéristiques : DNL jusqu’à ±7 LSB, INL jusqu’à ±12 LSB, mesurées avec un condensateur de 100 nF sur l’entrée, entrée continue, 25 °C, Wi-Fi et Bluetooth coupés ; plage de mesure effective de 150 à 2450 mV à atten = 3, et précision moindre au-dessus d’une lecture de 3000 ; par défaut ±6 % d’écart entre les puces ; prendre plusieurs échantillons avec un filtre ou en faire la moyenne pour de meilleurs résultats ; la GPIO 34 est ADC1_CH6, les GPIO 32 à 39 sont ADC1, les GPIO 25, 26 et 27 sont ADC2) — https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf
- Adafruit, « Photocells », « Using a Photocell » (photorésistance reliée à l’alimentation et à une résistance fixe vers la masse, l’entrée analogique à leur jonction ; quand la résistance de la photorésistance diminue, la tension aux bornes de la résistance fixe de 10 kΩ augmente ; fonctionne en 3,3 V comme en 5 V ; une résistance de 10 kΩ sature en pleine lumière, une plus petite aide) — https://learn.adafruit.com/photocells/using-a-photocell
- Espressif, ESP-IDF Programming Guide, « GPIO & RTC GPIO » (les GPIO 34 à 39 sont uniquement des entrées ; les broches d’ADC2 ne peuvent pas servir quand le Wi-Fi est utilisé, utiliser plutôt une broche d’ADC1) — https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/gpio.html
- SparkFun, « Analog to Digital Conversion » (l’Arduino a un CAN de 10 bits, 2^10 = 1024, et analogRead renvoie de 0 à 1023) — https://learn.sparkfun.com/tutorials/analog-to-digital-conversion
- All About Circuits, « 555 Lab - Schmitt Trigger », Lessons in Electric Circuits, DIY Electronics Projects (une bascule de Schmitt est un comparateur analogique à hystérésis : tensions de seuil de basculement différentes selon que l’entrée passe de bas à haut ou de haut à bas) — https://www.allaboutcircuits.com/textbook/experiments/chpt-8/555-schmitt-trigger/
- All About Circuits, « Hysteresis », Lessons in Electric Circuits, Semiconductors (l’hystérésis est la propriété d’un système qui ne revient pas à son état d’origine une fois la cause du changement disparue ; un interrupteur à bascule en est un exemple simple) — https://www.allaboutcircuits.com/textbook/semiconductors/chpt-7/hysteresis/