Fonction map() Arduino : utilisation, exemples et constrain
Comment utiliser la fonction map() d'Arduino ? Syntaxe, piège de la division entière, constrain, exemples potentiomètre, servo et PWM, ESP32 et Pico.
La fonction Arduino map() est une commande intégrée qui convertit proportionnellement une valeur d'une plage de nombres vers une autre plage. Quand tu veux transformer la valeur 0–1023 lue sur un potentiomètre en un angle de 0–180 degrés pour un servo, en une valeur PWM de 0–255 pour la luminosité d'une LED ou en un pourcentage de 0 à 100 à afficher à l'écran, elle le fait en une seule ligne. En bref, map() est un convertisseur de règle : elle adapte ton échelle d'origine à l'échelle visée.
Mais map() n'est pas aussi inoffensive qu'elle en a l'air : elle ne travaille qu'avec des entiers, jette la partie décimale et ne limite pas le résultat à la plage de sortie. Dans cet article, tu verras pas à pas la formule de la fonction, les surprises causées par la division entière, l'usage sûr avec constrain(), des exemples concrets du potentiomètre au servo et du capteur au PWM, ainsi que la façon de faire la même chose avec l'ADC 12 bits de l'ESP32 et avec le Raspberry Pi Pico en MicroPython.

Qu'est-ce que Arduino map() et comment ça marche ?
map() établit une proportion linéaire entre deux plages. Elle détermine à quel pourcentage de sa plage se situe la valeur d'entrée, puis calcule le nombre correspondant à la même position dans la plage de sortie. Sa définition dans le noyau Arduino tient en une ligne : (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min. Tous les paramètres et la valeur de retour sont de type long, c'est-à-dire un entier signé 32 bits sur l'Uno. La syntaxe est map(valeur, deMin, deMax, versMin, versMax) et tu n'as besoin d'ajouter aucune bibliothèque pour l'utiliser.
| Paramètre | Signification | Exemple potentiomètre → servo |
|---|---|---|
| value (x) | Valeur à convertir | Résultat de analogRead(A0) |
| fromLow (in_min) | Borne basse de la plage d'entrée | 0 |
| fromHigh (in_max) | Borne haute de la plage d'entrée | 1023 |
| toLow (out_min) | Borne basse de la plage de sortie | 0 |
| toHigh (out_max) | Borne haute de la plage de sortie | 180 |
| Valeur de retour | Valeur correspondante dans la plage de sortie (long) | Angle entre 0 et 180 |
Faisons un calcul d'exemple : quand le potentiomètre est exactement au milieu, analogRead() renvoie environ 512. Pour map(512, 0, 1023, 0, 180), on trouve d'abord 512 - 0 = 512, on le multiplie par 180 - 0 = 180 et on obtient 92160. On divise ensuite par 1023 : 92160 / 1023 = 90,09. Comme la division entière jette les décimales, le résultat est 90 degrés ; enfin on ajoute la borne basse de sortie, 0. Si tu écris les bornes de sortie à l'envers, le sens s'inverse aussi : map(x, 0, 1023, 255, 0) produit une valeur qui diminue quand le potentiomètre augmente. Les plages négatives marchent sans problème : tu peux convertir l'axe d'un joystick en vitesse de moteur avant-arrière avec map(x, 0, 1023, -255, 255). Le tableau ci-dessous récapitule les conversions les plus courantes.
| Objectif | Code | Remarque |
|---|---|---|
| Potentiomètre → angle de servo | map(x, 0, 1023, 0, 180) | Pour Servo.write() |
| Potentiomètre → PWM | map(x, 0, 1023, 0, 255) | Pour analogWrite() ; x / 4 donne une répartition plus égale |
| Lecture analogique → pourcentage | map(x, 0, 1023, 0, 100) | Pour afficher un pourcentage à l'écran |
| Joystick → vitesse et sens du moteur | map(x, 0, 1023, -255, 255) | Le signe donne le sens, la valeur absolue la vitesse |
| Sens inversé (obscurité → lumineux) | map(x, 0, 1023, 255, 0) | Inverse les bornes de sortie |
| ADC 12 bits ESP32 → PWM | map(x, 0, 4095, 0, 255) | Sur l'ESP32, analogRead() renvoie 0–4095 |
Limite de la division entière : pourquoi map() ne donne-t-elle pas de décimales ?
La division dans map() se fait avec des entiers, donc le résultat est toujours tronqué vers zéro ; la partie décimale n'est pas arrondie, elle est tout simplement supprimée. Sur une plage de sortie étroite, cela devient très visible. Par exemple, si tu écris map(x, 0, 1023, 0, 10) pour convertir un potentiomètre en indicateur de niveau de 0 à 10, tu obtiens ce tableau :
| Entrée (x) | Rapport réel | Résultat de map() |
|---|---|---|
| 0 | 0,000 | 0 |
| 102 | 0,997 | 0 |
| 103 | 1,007 | 1 |
| 512 | 5,005 | 5 |
| 1022 | 9,990 | 9 |
| 1023 | 10,000 | 10 |
Le vrai problème du tableau, c'est que 103 valeurs d'entrée différentes (0–102) donnent le résultat 0, alors que la valeur la plus haute, 10, n'est produite que par une seule entrée, 1023. Si tu ne tournes pas le potentiomètre jusqu'au bout, ton indicateur n'atteindra jamais 10. Pour une répartition égale, tu peux augmenter les deux bornes hautes de 1 et écrire map(x, 0, 1024, 0, 11) : chaque valeur de sortie correspond alors à environ 93 valeurs d'entrée et le résultat reste entre 0 et 10. La deuxième limite est le dépassement : si le produit intermédiaire (x - in_min) * (out_max - out_min) dépasse la limite du long 32 bits, soit environ 2,1 milliards, le résultat est faussé. Des plages larges comme map(50000, 0, 100000, 0, 100000) produisent sur l'Uno un produit intermédiaire de 5 milliards et donnent un mauvais résultat. La troisième limite est le besoin de décimales : si tu écris map(x, 0, 1023, 0, 5) pour convertir une lecture analogique en tension de 0 à 5 V, tu n'obtiens que 0, 1, 2, 3, 4 et 5. Dans ce cas, tu dois écrire ta propre fonction map décimale avec la même formule :
1// Ondalikli map fonksiyonu / Floating-point map function
2float mapFloat(float x, float inMin, float inMax, float outMin, float outMax) {
3 return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
4}
5
6void setup() {
7 Serial.begin(9600);
8}
9
10void loop() {
11 int raw = analogRead(A0); // 0-1023 ham deger / raw value
12 float volt = mapFloat(raw, 0, 1023, 0.0, 5.0); // 0.00-5.00 V
13 long milliVolt = map(raw, 0, 1023, 0, 5000); // tamsayi mV / integer mV
14 int percent = map(raw, 0, 1023, 0, 100); // tamsayi yuzde / integer percent
15
16 Serial.print(F("Ham / Raw: "));
17 Serial.print(raw);
18 Serial.print(F(" V: "));
19 Serial.print(volt, 2);
20 Serial.print(F(" mV: "));
21 Serial.print(milliVolt);
22 Serial.print(F(" %: "));
23 Serial.println(percent);
24 delay(500);
25}Utilisation avec constrain
map() ne considère pas la plage de sortie comme une limite ; elle calcule seulement une proportion. Si la valeur d'entrée sort de la plage attendue, la sortie sort aussi. Imaginons que tu aies mesuré qu'une LDR donne en réalité des valeurs entre 200 et 900 et que tu aies écrit map(x, 200, 900, 0, 255). Quand une lampe torche puissante fait monter la valeur à 980, le résultat est (980 - 200) * 255 / 700 = 284 ; si la valeur tombe à 150 dans une pièce très sombre, tu obtiens -18. Sur l'Uno, analogWrite() interprète différemment, selon la broche, une valeur supérieure à 255 ; par exemple sur la broche 6, 284 est tronqué à 8 bits et devient 28, c'est-à-dire une LED presque éteinte. La solution est la fonction constrain(valeur, bas, haut) : elle comprime la valeur entre les bornes données. Il y a deux bons ordres : limiter l'entrée avant map(), soit map(constrain(x, 200, 900), 200, 900, 0, 255), ou limiter le résultat après map(), soit constrain(map(x, 200, 900, 0, 255), 0, 255). Les deux empêchent de sortir de 0–255 ; si tu fais un étalonnage de capteur, limiter l'entrée est plus lisible.
Tableau de branchement : Arduino Uno, ESP32 et Pico
| Connexion | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Bornes extérieures du potentiomètre | 5V et GND | 3V3 et GND | 3V3 et GND |
| Borne centrale du potentiomètre | A0 | GPIO 34 | GP26 (ADC0) |
| Point milieu du diviseur LDR + 10 kΩ | A1 | GPIO 35 | GP27 (ADC1) |
| LED (avec résistance de 220 Ω) | D6 (PWM) | GPIO 25 | GP15 |
| Signal du servo (fil orange) | D9 | GPIO 13 | GP16 |
| Plage de lecture de l'ADC | 10 bits (0–1023) | 12 bits (0–4095) | read_u16() : 0–65535 |
Pas à pas : régler l'angle d'un servo avec un potentiomètre
- Relie les deux bornes extérieures du potentiomètre de 10 kΩ aux broches 5V et GND de l'Arduino, et la borne centrale à A0.
- Relie le fil marron du servo SG90 à GND, le rouge à 5V et le fil de signal orange à D9.
- Vérifie que la bibliothèque Servo est installée ; elle est fournie avec l'IDE Arduino, tu n'as rien d'autre à télécharger.
- Téléverse le code ci-dessous et ouvre le moniteur série à 9600 bauds.
- En tournant le potentiomètre, observe que la valeur brute et l'angle changent ensemble à l'écran et que le servo tourne entre 0 et 180 degrés.
- Si le servo force et bourdonne aux extrémités, resserre la sortie de map() sur une plage plus étroite, comme 10–170.
1#include <Servo.h>
2
3const int POT_PIN = A0; // potansiyometre orta ucu / potentiometer wiper
4const int SERVO_PIN = 9; // servo sinyal pini / servo signal pin
5
6Servo servo;
7
8void setup() {
9 servo.attach(SERVO_PIN);
10 Serial.begin(9600);
11}
12
13void loop() {
14 int raw = analogRead(POT_PIN); // 0-1023 ham deger / raw value
15 int angle = map(raw, 0, 1023, 0, 180); // dereceye cevir / convert to degrees
16 angle = constrain(angle, 0, 180); // guvenlik siniri / safety limit
17 servo.write(angle);
18
19 Serial.print(F("Ham / Raw: "));
20 Serial.print(raw);
21 Serial.print(F(" Aci / Angle: "));
22 Serial.println(angle);
23 delay(20); // servoya zaman tani / give the servo time
24}Dans le code, analogRead() renvoie une valeur sur 10 bits, map() la convertit en degrés et constrain() garantit qu'aucun angle hors de 0–180 n'est envoyé au servo, même si tu modifies la plage plus tard. Comme l'ADC de l'Uno est légèrement bruité, la valeur peut osciller entre 511, 512 et 513 même si tu ne touches pas au potentiomètre, ce qui fait trembler le servo. Faire la moyenne de plusieurs lectures ou n'appeler servo.write() que si l'angle change de plus de 2 degrés règle en grande partie le problème. Pour plus de détails, consulte les articles problème de tremblement du servo et filtrage des données de capteur. Si tu veux comprendre le fonctionnement d'un servo, Qu'est-ce qu'un servomoteur ? est un bon point de départ.
Du capteur au PWM : luminosité automatique d'une LED avec une LDR
map() ne sert pas qu'avec les potentiomètres, elle fonctionne avec tous les capteurs analogiques. Dans cet exemple, une borne de la LDR est reliée à 5V et l'autre à A1 ; une résistance de 10 kΩ est aussi placée entre A1 et GND. Avec ce montage, plus la lumière augmente, plus la résistance de la LDR baisse et plus la tension sur A1 monte. Note d'abord dans le moniteur série les valeurs lues dans une pièce sombre et en pleine lumière ; par exemple 150 et 850. Ces deux nombres sont les bornes d'étalonnage. Le code fait briller la LED davantage à mesure que l'environnement s'assombrit, donc la plage de sortie est écrite à l'envers : de 255 à 0. Pour le principe de fonctionnement de la LDR, regarde Capteur de lumière LDR, et pour les bases du PWM, Qu'est-ce que le PWM ?.
1const int LDR_PIN = A1; // LDR + 10k bolucu / LDR + 10k divider
2const int LED_PIN = 6; // PWM pini / PWM pin
3const int DARK = 150; // karanlikta olculen / measured in the dark
4const int BRIGHT = 850; // aydinlikta olculen / measured in bright light
5
6void setup() {
7 pinMode(LED_PIN, OUTPUT);
8 Serial.begin(9600);
9}
10
11void loop() {
12 int raw = analogRead(LDR_PIN);
13 int limited = constrain(raw, DARK, BRIGHT); // once sinirla / limit first
14 int pwm = map(limited, DARK, BRIGHT, 255, 0); // karanlik = parlak / dark = bright
15 analogWrite(LED_PIN, pwm);
16
17 Serial.print(raw);
18 Serial.print(F(" -> "));
19 Serial.println(pwm);
20 delay(100);
21}map() sur ESP32 : ADC 12 bits et PWM LEDC
Sur l'ESP32, map() fonctionne de la même façon, seule la plage d'entrée change. L'ADC de l'ESP32 a par défaut une résolution de 12 bits, donc analogRead() renvoie 0–4095 au lieu de 0–1023. Si tu laisses map(x, 0, 1023, ...) dans un code porté depuis l'Uno, tu épuises toute la plage de sortie dès le premier quart de la course du potentiomètre, et sur le reste les valeurs dépassent jusqu'à quatre fois la plage cible. Sur l'ESP32, écris donc l'entrée en 0–4095 ou redescends à 10 bits avec analogReadResolution(10). Côté PWM, l'ESP32 utilise le périphérique LEDC ; le noyau Arduino 3.x a introduit ledcAttach(broche, fréquence, résolution), alors que la 2.x utilise ledcSetup() et ledcAttachPin() basés sur les canaux. Le code ci-dessous compile dans les deux versions. Comme les broches ADC2 ne sont pas lisibles quand le Wi-Fi est actif, on branche le potentiomètre sur le GPIO 34, relié à l'ADC1. Si tu veux piloter un servo sur l'ESP32, tu peux utiliser la ligne map(x, 0, 4095, 0, 180) avec la bibliothèque ESP32Servo, selon la même logique.
1const int POT_PIN = 34; // ADC1 pini, yalniz giris / ADC1 pin, input only
2const int LED_PIN = 25; // PWM cikisi / PWM output
3const int PWM_FREQ = 5000; // 5 kHz
4const int PWM_RES = 8; // 8 bit: 0-255
5
6#if ESP_ARDUINO_VERSION_MAJOR < 3
7const int PWM_CH = 0; // 2.x icin LEDC kanali / LEDC channel for 2.x
8#endif
9
10void setup() {
11 Serial.begin(115200);
12 analogReadResolution(12); // 0-4095
13#if ESP_ARDUINO_VERSION_MAJOR >= 3
14 ledcAttach(LED_PIN, PWM_FREQ, PWM_RES);
15#else
16 ledcSetup(PWM_CH, PWM_FREQ, PWM_RES);
17 ledcAttachPin(LED_PIN, PWM_CH);
18#endif
19}
20
21void loop() {
22 int raw = analogRead(POT_PIN); // 0-4095
23 int duty = map(raw, 0, 4095, 0, 255); // 12 bit -> 8 bit
24 duty = constrain(duty, 0, 255);
25#if ESP_ARDUINO_VERSION_MAJOR >= 3
26 ledcWrite(LED_PIN, duty); // 3.x: pin numarasi / pin number
27#else
28 ledcWrite(PWM_CH, duty); // 2.x: kanal numarasi / channel number
29#endif
30 Serial.printf("%d -> %d\n", raw, duty);
31 delay(20);
32}L'ADC de l'ESP32 a un défaut à connaître : il n'est pas linéaire aux extrémités. Avec le réglage d'atténuation par défaut, les tensions inférieures à environ 0,1 V sont lues comme 0 et, à partir de 3,1 V environ, la valeur sature à 4095 ; entre les deux, la mesure est légèrement courbe. Tu peux donc atteindre 4095 sans tourner le potentiomètre à fond, ou sentir une zone morte au début. La solution pratique est de mesurer les plus petites et plus grandes lectures réelles et d'utiliser ces bornes dans map() et constrain(). Si tu as besoin de la tension, la fonction analogReadMilliVolts(), qui utilise l'étalonnage d'usine, donne un résultat plus précis que map. Pour les caractéristiques générales de la carte, consulte Qu'est-ce que l'ESP32 ?.
Équivalent de map() sur Raspberry Pi Pico et MicroPython
En MicroPython, il n'existe pas de map() prête à l'emploi comme sur Arduino ; le map() de Python fait tout autre chose et applique une fonction à une liste. Tu écris donc toi-même la même formule. Sur le Pico, ADC.read_u16() renvoie la mesure physique sur 12 bits mise à l'échelle sur 16 bits, dans la plage 0–65535 ; PWM.duty_u16() attend lui aussi un rapport cyclique entre 0 et 65535. Comme les entiers Python sont de taille illimitée, tu n'as pas le problème de dépassement de l'Uno. La différence à surveiller est que l'opérateur // arrondit toujours vers moins l'infini, alors que map() en C++ tronque vers zéro ; tu peux donc voir un écart d'une unité entre les deux langages sur les plages négatives. Si tu veux un résultat décimal, utilise / à la place de //. Dans le code, le potentiomètre est lu sur GP26, la luminosité de la LED sur GP15 et le servo sur GP16 suivent la valeur. Pour la LED, on limite l'entrée à 500–65000, car l'ADC du Pico atteint rarement exactement 0 et 65535 aux extrémités. Côté servo, avec un PWM à 50 Hz, 0–180 degrés correspond pour la plupart des SG90 à une impulsion d'environ 500–2500 microsecondes. Si le Pico est nouveau pour toi, commence par Qu'est-ce que le Raspberry Pi Pico ? et les bases de MicroPython.
1from machine import ADC, Pin, PWM
2import time
3
4pot = ADC(26) # GP26 = ADC0
5led = PWM(Pin(15)) # LED GP15
6led.freq(1000)
7servo = PWM(Pin(16)) # servo sinyal GP16 / servo signal GP16
8servo.freq(50) # 50 Hz = 20 ms periyot / period
9
10def map_range(x, in_min, in_max, out_min, out_max):
11 # Arduino map() karsiligi (tamsayi) / Arduino map() equivalent (integer)
12 return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
13
14def constrain(x, low, high):
15 # degeri sinirla / clamp the value
16 return max(low, min(x, high))
17
18while True:
19 raw = pot.read_u16() # 0-65535
20 percent = map_range(raw, 0, 65535, 0, 100) # yuzde / percent
21 duty = map_range(constrain(raw, 500, 65000), 500, 65000, 0, 65535)
22 led.duty_u16(duty) # LED parlakligi / LED brightness
23 angle = map_range(raw, 0, 65535, 0, 180) # derece / degrees
24 pulse_us = map_range(angle, 0, 180, 500, 2500) # darbe suresi / pulse width
25 servo.duty_ns(pulse_us * 1000) # mikrosaniye -> nanosaniye / us -> ns
26 print(raw, percent, angle, pulse_us)
27 time.sleep_ms(50)Idées de projets avec map()
- Indicateur de niveau : convertis la valeur d'un potentiomètre ou d'un capteur sonore en 0–8 avec map(x, 0, 1024, 0, 9) et affiche-la sur une barre de 8 LED.
- Voiture pilotée au joystick : convertis l'axe d'un joystick en -255 à 255 et règle le sens et la vitesse des moteurs avec un L298N.
- Voltmètre numérique : convertis la lecture analogique en millivolts et affiche-la sur un LCD ; les détails sont dans l'article fabriquer un voltmètre Arduino.
- Pourcentage d'humidité d'une plante : convertis les valeurs d'étalonnage sec et humide d'un capteur d'humidité du sol en pourcentage 0–100 avec constrain() et map().
- Instrument de musique à la lumière : convertis la valeur d'une LDR ou d'une distance en plage de 200–2000 Hz avec map() et donne-la comme fréquence à tone().
- LED chenillard à vitesse réglable : convertis le potentiomètre en temps d'attente en millisecondes avec map(x, 0, 1023, 50, 500).
Erreurs courantes et solutions
| Symptôme | Cause | Solution |
|---|---|---|
| Le résultat sort de la plage de sortie | map() ne limite pas | Limite l'entrée ou la sortie avec constrain() |
| Les résultats décimaux sont toujours entiers | La division entière jette les décimales | Écris mapFloat() ou réduis l'unité (mV au lieu de V) |
| La valeur maximale n'est jamais atteinte | La valeur haute n'est produite que par une seule entrée | Répartis de façon égale avec map(x, 0, 1024, 0, max + 1) |
| Résultat absurde avec de grands nombres | Le produit intermédiaire dépasse la limite du long 32 bits | Réduis les plages ou calcule avec float ou int64_t |
| Sur ESP32, la valeur plafonne trop tôt | Le code est écrit pour 0–1023 alors que l'ADC donne 0–4095 | Mets la plage d'entrée à 0–4095 |
| Le sens est inversé | Bornes de sortie ou branchement du capteur inversés | Échange les bornes basse et haute de sortie |
| Résultat constant et absurde | in_min égale in_max, donc division par zéro | Vérifie que les bornes d'étalonnage sont différentes |
La fonction map() est la traductrice entre le monde des capteurs et celui des sorties : garde la division entière en tête, protège les bornes avec constrain() et, si tu indiques la bonne résolution d'ADC de ta carte, elle fonctionne avec la même logique sur Uno, ESP32 et Pico. Tu peux réviser les bases du potentiomètre dans l'article Qu'est-ce qu'un potentiomètre ?. Dans l'application BlueGrays, tu peux étudier pas à pas, avec schéma de montage et code, des projets utilisant map() comme la LED chenillard à vitesse réglable, la lecture de l'intensité lumineuse avec une LDR, le contrôle d'un servo par potentiomètre et le réglage de luminosité PWM avec l'ESP32.
Questions fréquentes
À quoi sert la fonction map() d'Arduino ?
map() convertit proportionnellement un nombre d'une plage vers une autre. Son usage le plus courant est de transformer la valeur 0–1023 lue par analogRead() en 0–180 degrés pour un servo ou en valeur PWM 0–255 pour analogWrite(). Elle ne demande aucune bibliothèque, elle est fournie avec le noyau Arduino.
La fonction map() renvoie-t-elle des nombres décimaux ?
Non. map() travaille avec le type long et jette la partie décimale dans la division ; par exemple map(512, 0, 1023, 0, 5) donne 2 et non 2,5. Si tu as besoin de décimales, écris une fonction mapFloat() avec des paramètres float et la même formule, ou calcule le résultat dans une unité plus petite comme le millivolt.
Quelle est la différence entre map() et constrain() ?
map() convertit la valeur d'une échelle à l'autre mais ne la limite pas ; si l'entrée est hors plage, la sortie l'est aussi. constrain() ne change pas l'échelle, elle comprime seulement la valeur entre les bornes basse et haute que tu définis. Pour un usage sûr, on écrit les deux ensemble : map(constrain(x, 200, 900), 200, 900, 0, 255).
Comment régler l'angle d'un servo avec un potentiomètre ?
Relie la borne centrale du potentiomètre à A0 et le fil de signal du servo à D9. Dans loop(), calcule l'angle avec la ligne int angle = map(analogRead(A0), 0, 1023, 0, 180); et envoie-le au servo avec servo.write(angle). Si le servo tremble, fais la moyenne de plusieurs lectures ou ignore les petites variations.
map() fonctionne-t-elle différemment sur ESP32 ?
La formule est la même, mais comme l'ADC de l'ESP32 est sur 12 bits, analogRead() renvoie 0–4095. Tu dois donc écrire la plage d'entrée sous la forme map(x, 0, 4095, 0, 255). Comme l'ADC de l'ESP32 n'est pas linéaire aux extrémités, mesurer et utiliser les plus petites et plus grandes lectures réelles donne de meilleurs résultats.
Existe-t-il un équivalent de map() d'Arduino en MicroPython ?
Il n'y en a pas de prêt à l'emploi ; le map() de Python est une autre construction qui applique une fonction à des listes. Tu écris une courte fonction avec la formule (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min. Sur le Pico, read_u16() renvoie 0–65535, donc la plage d'entrée correspond généralement à ces valeurs.
Projets à réaliser après cet article
Voir tous les projets
Chenillard à LED à vitesse réglable
Six LED s'allument l'une après l'autre et la lumière semble courir d'un bout à l'autre.

Chenillard K2000 à vitesse réglable
Une lumière court d'un bout à l'autre de six LED, fait demi-tour et repart. En tournant le bouton du potentiomètre, tu changes aussitôt la vitesse de sa course : bouton d'un côté, la lumière file…

Mesurer l'intensité lumineuse avec une LDR
Envie de voir en chiffres à quel point ta chambre est lumineuse ? Le LDR, une petite pièce sensible à la lumière, mesure la lumière ambiante, et l'Arduino écrit la valeur sur l'écran de ton…

Utilisation d'un servomoteur avec un potentiomètre
Quand tu tournes le bouton du potentiomètre, le bras du servomoteur tourne avec lui : un bout du bouton correspond à zéro degré, l'autre à un demi-tour.

Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
Dans ce projet, nous contrôlons la luminosité d'une LED de manière analogique à l'aide d'un potentiomètre. La broche ADC de l'ESP32 lit la tension entre 0 et 3,3 V provenant du potentiomètre, puis cette valeur est convertie en signal PWM (modulation de largeur d'impulsion) envoyé à la LED. Ainsi, la LED s'allume et s'éteint progressivement. Avec Arduino Core 3.0+, analogWrite() est utilisable directement; sur ESP32-S2/S3, la résolution de l'ADC est fixée à 12 bits.

Servomoteur ESP32 (commande par potentiomètre)
Dans ce projet, nous contrôlons un servomoteur SG90 à l'aide d'un potentiomètre. Nous réglons l'angle du servomoteur en mappant la valeur analogique lue par le potentiomètre sur une plage de 0 à 180 degrés. La bibliothèque ESP32Servo génère des signaux de servomoteur sur les GPIO appropriés de l'ESP32 pouvant fonctionner en sortie ; ce projet utilise GPIO 18. Il s'agit d'une méthode de contrôle fondamentale pour les bras robotiques, les cardans de caméra et les mécanismes de portes automatiques.

Servocommande avec joystick
Pilote deux moteurs avec un joystick, comme si tu orientais une caméra de surveillance.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

