Bases · 12 min de lecture

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.

Potentiomètre utilisé avec la fonction Arduino map()
Le potentiomètre est l'élément d'entrée le plus courant avec map() : la valeur 0–1023 lue est convertie en angle de servo ou en valeur PWM.

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ètreSignificationExemple potentiomètre → servo
value (x)Valeur à convertirRésultat de analogRead(A0)
fromLow (in_min)Borne basse de la plage d'entrée0
fromHigh (in_max)Borne haute de la plage d'entrée1023
toLow (out_min)Borne basse de la plage de sortie0
toHigh (out_max)Borne haute de la plage de sortie180
Valeur de retourValeur 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.

ObjectifCodeRemarque
Potentiomètre → angle de servomap(x, 0, 1023, 0, 180)Pour Servo.write()
Potentiomètre → PWMmap(x, 0, 1023, 0, 255)Pour analogWrite() ; x / 4 donne une répartition plus égale
Lecture analogique → pourcentagemap(x, 0, 1023, 0, 100)Pour afficher un pourcentage à l'écran
Joystick → vitesse et sens du moteurmap(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 → PWMmap(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éelRésultat de map()
00,0000
1020,9970
1031,0071
5125,0055
10229,9909
102310,00010

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 :

C++ (Arduino IDE)
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}
Sur l'Uno, les calculs en float sont plusieurs fois plus lents que sur les entiers et consomment plus de mémoire programme. Si les décimales ne sont pas indispensables, utilise la map() entière ; si tu veux de la précision, réduis l'unité cible. Par exemple, calcule la tension en millivolts plutôt qu'en volts : map(raw, 0, 1023, 0, 5000) donne 0–5000 mV et le plus grand produit intermédiaire (5 115 000) reste bien en dessous de la limite du long.

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.

Dans le noyau Arduino Uno (AVR), constrain() n'est pas une fonction mais une macro, et elle évalue ses paramètres plusieurs fois. Si tu écris constrain(analogRead(A0), 200, 900), analogRead() peut s'exécuter plusieurs fois et la valeur comparée peut différer de la valeur retournée. Stocke d'abord la lecture dans une variable, puis passe cette variable à constrain().

Tableau de branchement : Arduino Uno, ESP32 et Pico

ConnexionArduino UnoESP32Raspberry Pi Pico
Bornes extérieures du potentiomètre5V et GND3V3 et GND3V3 et GND
Borne centrale du potentiomètreA0GPIO 34GP26 (ADC0)
Point milieu du diviseur LDR + 10 kΩA1GPIO 35GP27 (ADC1)
LED (avec résistance de 220 Ω)D6 (PWM)GPIO 25GP15
Signal du servo (fil orange)D9GPIO 13GP16
Plage de lecture de l'ADC10 bits (0–1023)12 bits (0–4095)read_u16() : 0–65535
Les entrées analogiques de l'ESP32 et du Pico acceptent 3,3 V au maximum. Si tu relies par habitude les bornes du potentiomètre à la broche 5V, la borne centrale monte à 5 V et l'entrée ADC peut être définitivement endommagée. Sur ces cartes, alimente toujours le potentiomètre par la broche 3V3 ; si tu utilises un capteur à sortie 5 V, abaisse d'abord le niveau avec un diviseur de tension.

Pas à pas : régler l'angle d'un servo avec un potentiomètre

  1. 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.
  2. Relie le fil marron du servo SG90 à GND, le rouge à 5V et le fil de signal orange à D9.
  3. 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.
  4. Téléverse le code ci-dessous et ouvre le moniteur série à 9600 bauds.
  5. 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.
  6. Si le servo force et bourdonne aux extrémités, resserre la sortie de map() sur une plage plus étroite, comme 10–170.
C++ (Arduino IDE)
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 ?.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

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ômeCauseSolution
Le résultat sort de la plage de sortiemap() ne limite pasLimite l'entrée ou la sortie avec constrain()
Les résultats décimaux sont toujours entiersLa 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 atteinteLa valeur haute n'est produite que par une seule entréeRépartis de façon égale avec map(x, 0, 1024, 0, max + 1)
Résultat absurde avec de grands nombresLe produit intermédiaire dépasse la limite du long 32 bitsRéduis les plages ou calcule avec float ou int64_t
Sur ESP32, la valeur plafonne trop tôtLe code est écrit pour 0–1023 alors que l'ADC donne 0–4095Mets 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 absurdein_min égale in_max, donc division par zéroVérifie que les bornes d'étalonnage sont différentes
Au lieu d'écrire l'étalonnage avec des nombres fixes, mesure-le à l'exécution : dans setup(), lis le capteur pendant quelques secondes, enregistre la plus petite et la plus grande valeur, puis utilise ces variables dans map() et constrain(). Si les deux valeurs restent égales, reviens aux bornes par défaut pour éviter la division par zéro. Ainsi, le même code s'adapte tout seul à différentes LDR, différents potentiomètres et différents environnements. Tu trouveras les bases de la lecture analogique dans l'article Qu'est-ce que l'ADC ?.

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.

Voir tous les projets
Chenillard à LED à vitesse réglable
AR-7Intermédiaire

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.

4.6(72)
148
Chenillard K2000 à vitesse réglable
AR-8Intermédiaire

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…

4.5(60)
124
Mesurer l'intensité lumineuse avec une LDR
AR-11Débutant

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…

4.6(83)
143
Utilisation d'un servomoteur avec un potentiomètre
AR-36Débutant
Premium

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.

4.6(37)
53
Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
ES-13Intermédiaire
Premium

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.

4.5(19)
32
Servomoteur ESP32 (commande par potentiomètre)
ES-16Intermédiaire
Premium

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.

4.3(29)
42
Servocommande avec joystick
AR-60Intermédiaire
Premium

Servocommande avec joystick

Pilote deux moteurs avec un joystick, comme si tu orientais une caméra de surveillance.

4.7(42)
58