Basi · 11 min di lettura

Funzione map() Arduino: Come Usarla, Esempi e constrain()

Come si usa la funzione map() di Arduino? Sintassi, trappola della divisione intera, constrain(), esempi con potenziometro, servo e PWM, ESP32 e Pico.

La funzione map() di Arduino è un comando integrato che converte in modo proporzionale un valore da un intervallo numerico a un altro. Se vuoi trasformare i valori 0–1023 letti da un potenziometro in 0–180 gradi per un servo, in un valore PWM 0–255 per la luminosità di un LED o in una percentuale 0–100 da mostrare a display, ti basta una riga. In breve, map() è un convertitore di scala: adatta la scala che hai a quella che ti serve.

Però map() non è innocua come sembra: lavora solo con numeri interi, scarta la parte decimale e non limita il risultato all'intervallo di destinazione. In questo articolo vedrai passo passo la formula, le sorprese causate dalla divisione intera, l'uso sicuro con constrain(), esempi reali dal potenziometro al servo e dal sensore al PWM, e come si fa lo stesso lavoro con l'ADC a 12 bit dell'ESP32 e con MicroPython sul Raspberry Pi Pico.

Potenziometro usato con la funzione map() di Arduino
Il potenziometro è l'elemento di ingresso più usato con map(): il valore letto 0–1023 viene convertito in angolo del servo o in valore PWM.

Cos'è map() in Arduino e come funziona?

map() stabilisce una proporzione lineare tra due intervalli. Calcola in quale posizione percentuale si trova il valore nel suo intervallo di ingresso, poi calcola il numero corrispondente alla stessa posizione nell'intervallo di uscita. Nel core di Arduino la definizione è una sola riga: (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min. Tutti i parametri e il valore restituito sono di tipo long, cioè interi a 32 bit con segno su Uno. La sintassi è map(valore, daMin, daMax, aMin, aMax) e non serve includere nessuna libreria.

ParametroSignificatoEsempio pot → servo
value (x)Valore da convertirerisultato di analogRead(A0)
fromLow (in_min)Limite inferiore dell'intervallo di ingresso0
fromHigh (in_max)Limite superiore dell'intervallo di ingresso1023
toLow (out_min)Limite inferiore dell'intervallo di uscita0
toHigh (out_max)Limite superiore dell'intervallo di uscita180
Valore restituitoCorrispondente nell'intervallo di uscita (long)angolo tra 0 e 180

Facciamo un esempio: con il potenziometro a metà corsa analogRead() restituisce circa 512. Per map(512, 0, 1023, 0, 180) si calcola prima 512 - 0 = 512, che viene moltiplicato per 180 - 0 = 180 e dà 92160. Poi si divide per 1023: 92160 / 1023 = 90,09. Poiché la divisione intera scarta i decimali, il risultato è 90 gradi; infine si somma il limite inferiore di uscita, cioè 0. Se inverti i limiti di uscita, si inverte anche il verso: map(x, 0, 1023, 255, 0) produce un valore che diminuisce quando il potenziometro aumenta. Funzionano anche gli intervalli negativi: con map(x, 0, 1023, -255, 255) puoi convertire l'asse di un joystick in velocità del motore avanti-indietro. La tabella seguente riassume le conversioni più usate.

ObiettivoCodiceNota
Potenziometro → angolo del servomap(x, 0, 1023, 0, 180)Per Servo.write()
Potenziometro → PWMmap(x, 0, 1023, 0, 255)Per analogWrite(); x / 4 dà una distribuzione più uniforme
Lettura analogica → percentualemap(x, 0, 1023, 0, 100)Per mostrare la percentuale a display
Joystick → velocità e direzione del motoremap(x, 0, 1023, -255, 255)Il segno dà la direzione, il valore la velocità
Direzione inversa (buio → luminoso)map(x, 0, 1023, 255, 0)Scambia i limiti di uscita
ADC a 12 bit ESP32 → PWMmap(x, 0, 4095, 0, 255)Su ESP32 analogRead() restituisce 0–4095

Limite della divisione intera: perché map() non restituisce decimali?

Poiché la divisione dentro map() è fatta con numeri interi, il risultato viene sempre troncato verso zero: la parte decimale non viene arrotondata, ma semplicemente scartata. In un intervallo di uscita stretto la cosa si nota molto. Se per esempio scrivi map(x, 0, 1023, 0, 10) per ottenere un indicatore di livello 0–10, ottieni questa tabella:

Ingresso (x)Rapporto realeRisultato di map()
00,0000
1020,9970
1031,0071
5125,0055
10229,9909
102310,00010

Il vero problema della tabella è questo: il risultato 0 è prodotto da 103 valori di ingresso diversi (0–102), mentre il valore massimo 10 lo dà un solo ingresso, cioè 1023. Se non giri il potenziometro fino in fondo, l'indicatore non raggiunge mai 10. Per una distribuzione uniforme puoi aumentare di uno entrambi i limiti superiori e scrivere map(x, 0, 1024, 0, 11): così ogni valore di uscita corrisponde a circa 93 valori di ingresso e il risultato resta comunque tra 0 e 10. Il secondo limite è l'overflow: se il prodotto intermedio (x - in_min) * (out_max - out_min) supera il limite del long a 32 bit, cioè circa 2,1 miliardi, il risultato è errato. Intervalli grandi come map(50000, 0, 100000, 0, 100000) generano su Uno un prodotto intermedio di 5 miliardi e danno un risultato sbagliato. Il terzo limite è la necessità dei decimali: se per convertire la lettura analogica in tensione 0–5 V scrivi map(x, 0, 1023, 0, 5), ottieni solo 0, 1, 2, 3, 4 e 5. In questo caso devi scrivere con la stessa formula una tua funzione map con decimali:

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}
Su Uno le operazioni in virgola mobile sono diverse volte più lente di quelle intere e occupano più memoria programma. Se i decimali non sono indispensabili, usa map() intera; se vuoi precisione, riduci l'unità di destinazione. Per esempio calcola la tensione in millivolt invece che in volt: map(raw, 0, 1023, 0, 5000) dà 0–5000 mV e il prodotto intermedio massimo (5.115.000) resta molto sotto il limite del long.

Uso combinato con constrain

map() non considera l'intervallo di destinazione un limite: calcola soltanto una proporzione. Se il valore in ingresso esce dall'intervallo previsto, anche l'uscita esce. Supponi di aver misurato che un LDR dà in realtà valori tra 200 e 900 e di aver scritto map(x, 200, 900, 0, 255). Quando una torcia potente porta il valore a 980, il risultato è (980 - 200) * 255 / 700 = 284; se l'ambiente è molto buio e il valore scende a 150, ottieni -18. Su Uno analogWrite() interpreta in modo diverso i valori maggiori di 255 a seconda del pin; per esempio sul pin 6 il valore 284 viene troncato a 8 bit e diventa 28, cioè un LED quasi spento. La soluzione è la funzione constrain(valore, min, max): comprime il valore entro i limiti dati. Ci sono due ordini corretti: limitare l'ingresso prima di map(), cioè map(constrain(x, 200, 900), 200, 900, 0, 255), oppure limitare il risultato dopo map(), cioè constrain(map(x, 200, 900, 0, 255), 0, 255). Entrambi impediscono di uscire da 0–255; se stai calibrando un sensore, limitare l'ingresso è più leggibile.

Nel core Arduino Uno (AVR) constrain() non è una funzione ma una macro e valuta i suoi parametri più volte. Se scrivi constrain(analogRead(A0), 200, 900), analogRead() può essere eseguita più volte e il valore confrontato può essere diverso da quello restituito. Salva prima la lettura in una variabile, poi usa quella variabile dentro constrain().

Tabella dei collegamenti: Arduino Uno, ESP32 e Pico

CollegamentoArduino UnoESP32Raspberry Pi Pico
Estremi esterni del potenziometro5V e GND3V3 e GND3V3 e GND
Contatto centrale del potenziometroA0GPIO 34GP26 (ADC0)
Punto centrale del partitore LDR + 10 kΩA1GPIO 35GP27 (ADC1)
LED (con resistenza da 220 Ω)D6 (PWM)GPIO 25GP15
Segnale del servo (filo arancione)D9GPIO 13GP16
Intervallo di lettura ADC10 bit (0–1023)12 bit (0–4095)read_u16(): 0–65535
Gli ingressi analogici di ESP32 e Pico accettano al massimo 3,3 V. Se per abitudine colleghi gli estremi del potenziometro al pin 5V, il contatto centrale arriva a 5 V e l'ingresso ADC può danneggiarsi in modo permanente. Su queste schede alimenta sempre il potenziometro dal pin 3V3; se usi un sensore con uscita a 5 V, abbassa prima il livello con un partitore di tensione.

Passo dopo passo: regolare l'angolo del servo con un potenziometro

  1. Collega i due estremi esterni del potenziometro da 10 kΩ ai pin 5V e GND di Arduino e il contatto centrale ad A0.
  2. Collega il filo marrone del servo SG90 a GND, quello rosso a 5V e il filo arancione del segnale a D9.
  3. Controlla che la libreria Servo sia installata: viene fornita con l'Arduino IDE e non devi scaricare nulla.
  4. Carica il codice seguente e apri il Monitor seriale a 9600 baud.
  5. Mentre giri il potenziometro, osserva sullo schermo il valore grezzo e l'angolo cambiare insieme e il servo ruotare tra 0 e 180 gradi.
  6. Se il servo si sforza e ronza ai finecorsa, restringi l'uscita di map() a un intervallo più stretto, come 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}

Nel codice analogRead() restituisce un valore a 10 bit, map() lo converte in gradi e constrain() garantisce che al servo non arrivi mai un angolo fuori da 0–180, anche se in futuro cambierai l'intervallo. Poiché l'ADC di Uno è un po' rumoroso, il valore può oscillare tra 511, 512 e 513 anche senza toccare il potenziometro, e questo fa vibrare il servo. Fare la media di alcune letture o chiamare servo.write() solo quando l'angolo cambia di più di 2 gradi risolve in gran parte il problema. Per i dettagli puoi leggere gli articoli sul tremolio del servo e sul filtraggio dei dati dei sensori. Se vuoi capire come funziona un servo, Che cos'è un servomotore? è un buon punto di partenza.

Dal sensore al PWM: luminosità automatica del LED con un LDR

map() non serve solo con i potenziometri, ma con qualsiasi sensore analogico. In questo esempio un capo dell'LDR è collegato a 5V e l'altro ad A1; tra A1 e GND c'è anche una resistenza da 10 kΩ. Con questo collegamento, quando la luce aumenta la resistenza dell'LDR diminuisce e la tensione su A1 sale. Prima annota dal Monitor seriale i valori letti in una stanza buia e alla luce, per esempio 150 e 850: sono i limiti di calibrazione. Il codice fa brillare di più il LED man mano che l'ambiente si oscura, perciò l'intervallo di uscita è scritto al contrario: da 255 a 0. Per il principio di funzionamento dell'LDR dai un'occhiata a Sensore di luce LDR, e per le basi del PWM a Che cos'è il 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() su ESP32: ADC a 12 bit e PWM LEDC

Su ESP32 map() funziona allo stesso modo, cambia solo l'intervallo di ingresso. L'ADC dell'ESP32 ha per impostazione predefinita una risoluzione di 12 bit, quindi analogRead() restituisce 0–4095 invece di 0–1023. Se nel codice portato da Uno lasci map(x, 0, 1023, ...), esaurisci tutto l'intervallo di uscita nel primo quarto di corsa del potenziometro e nella parte restante i valori superano fino a quattro volte l'intervallo di destinazione. Per questo su ESP32 scrivi l'ingresso come 0–4095 oppure scendi a 10 bit con analogReadResolution(10). Per il PWM l'ESP32 usa l'unità LEDC: con il core Arduino 3.x è arrivata la funzione ledcAttach(pin, frequenza, risoluzione), mentre con la 2.x si usano ledcSetup() e ledcAttachPin() basate sui canali. Il codice seguente compila con entrambe le versioni. Poiché con il Wi-Fi attivo i pin ADC2 non si possono leggere, colleghiamo il potenziometro al GPIO 34, che appartiene all'ADC1. Per pilotare un servo su ESP32 puoi usare con la libreria ESP32Servo la stessa logica, con la riga map(x, 0, 4095, 0, 180).

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 dell'ESP32 ha un'abitudine che devi conoscere: agli estremi non è lineare. Con l'attenuazione predefinita le tensioni sotto circa 0,1 V vengono lette come 0 e oltre circa 3,1 V il valore satura a 4095; nel mezzo la misura è leggermente curva. Per questo potresti raggiungere 4095 senza girare il potenziometro fino in fondo, o sentire una zona morta all'inizio. La soluzione pratica è misurare le letture minima e massima reali e usare questi limiti in map() e constrain(). Se ti serve la tensione, la funzione analogReadMilliVolts(), che usa la calibrazione di fabbrica, dà un risultato più accurato di map. Per le caratteristiche generali della scheda puoi leggere Che cos'è l'ESP32?.

Raspberry Pi Pico e MicroPython: l'equivalente di map()

In MicroPython non esiste un map() già pronto come in Arduino; il map() di Python fa tutt'altro e applica una funzione a una lista. Per questo scrivi la stessa formula da solo. Sul Pico ADC.read_u16() restituisce la misura fisica a 12 bit scalata a 16 bit, nell'intervallo 0–65535; anche PWM.duty_u16() si aspetta un duty cycle tra 0 e 65535. Poiché gli interi di Python hanno dimensione illimitata, non incontri il problema di overflow di Uno. La differenza a cui devi fare attenzione è che l'operatore // arrotonda sempre verso meno infinito, mentre map() in C++ tronca verso zero, quindi negli intervalli negativi puoi vedere una differenza di 1 unità tra i due linguaggi. Se vuoi un risultato decimale, basta usare / al posto di //. Nel codice il potenziometro è letto da GP26, la luminosità del LED su GP15 e il servo su GP16 ne seguono il valore. Per il LED limitiamo l'ingresso a 500–65000, perché l'ADC del Pico raramente raggiunge esattamente 0 e 65535 agli estremi. Per il servo, a 50 Hz di PWM, 0–180 gradi corrispondono per la maggior parte degli SG90 a impulsi di circa 500–2500 microsecondi. Se sei alle prime armi con il Pico, puoi iniziare con Che cos'è il Raspberry Pi Pico? e le basi di 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)

Idee di progetto con map()

  • Indicatore di livello: converti il valore di un potenziometro o di un sensore audio in 0–8 con map(x, 0, 1024, 0, 9) e mostralo su una barra di 8 LED.
  • Auto controllata da joystick: converti l'asse di un joystick in un valore tra -255 e 255 e regola direzione e velocità dei motori con un L298N.
  • Voltmetro digitale: converti la lettura analogica in millivolt e mostrala su un LCD; i dettagli sono nell'articolo Costruire un voltmetro con Arduino.
  • Percentuale di umidità del terreno: converti in una percentuale 0–100, con constrain() e map(), i valori di calibrazione a secco e a bagnato del sensore di umidità del terreno.
  • Strumento musicale a luce: converti il valore dell'LDR o della distanza nell'intervallo 200–2000 Hz con map() e passalo come frequenza alla funzione tone().
  • LED scorrevole a velocità regolabile: converti il potenziometro in un tempo di attesa in millisecondi con map(x, 0, 1023, 50, 500).

Errori comuni e come risolverli

SintomoCausaSoluzione
Il risultato esce dall'intervallo di destinazionemap() non limita il risultatoLimita l'ingresso o l'uscita con constrain()
I risultati decimali arrivano sempre interiLa divisione intera scarta i decimaliScrivi mapFloat() o riduci l'unità (mV invece di V)
Il valore massimo non viene mai raggiuntoIl valore massimo si ottiene con un solo ingressoDistribuisci in modo uniforme con map(x, 0, 1024, 0, max + 1)
Risultati assurdi con numeri grandiIl prodotto intermedio supera il limite del long a 32 bitRiduci gli intervalli o calcola con float o int64_t
Su ESP32 il valore arriva al massimo troppo prestoIl codice è scritto per 0–1023, l'ADC dà 0–4095Imposta l'intervallo di ingresso a 0–4095
La direzione è invertitaLimiti di uscita o collegamento del sensore invertitiScambia i limiti inferiore e superiore di uscita
Il risultato è fisso e senza sensoin_min e in_max sono uguali, cioè divisione per zeroControlla che i limiti di calibrazione siano diversi
Invece di scrivere la calibrazione con numeri fissi, misurala durante l'esecuzione: in setup() leggi il sensore per qualche secondo, memorizza il valore minimo e massimo, poi usa queste variabili in map() e constrain(). Se i due valori restano uguali, torna ai limiti predefiniti per non dividere per zero. In questo modo lo stesso codice si adatta a LDR, potenziometri e ambienti diversi. Trovi le basi della lettura analogica nell'articolo Che cos'è l'ADC?.

La funzione map() è il traduttore tra il mondo dei sensori e quello delle uscite: tieni a mente la divisione intera, proteggi i limiti con constrain() e, se indichi correttamente la risoluzione dell'ADC della tua scheda, funziona con la stessa logica su Uno, ESP32 e Pico. Puoi ripassare le basi del potenziometro in Che cos'è un potenziometro?. Nell'app BlueGrays trovi passo passo, con schema del circuito e codice, progetti che usano map() come il LED scorrevole a velocità regolabile, la lettura dell'intensità luminosa con LDR, il controllo del servo con potenziometro e la regolazione della luminosità PWM con ESP32.

Domande frequenti

A cosa serve la funzione map() di Arduino?

map() converte in modo proporzionale un numero da un intervallo a un altro. L'uso più comune è trasformare il valore 0–1023 letto con analogRead() in 0–180 gradi per un servo o in un valore PWM 0–255 per analogWrite(). Non richiede librerie ed è già inclusa nel core di Arduino.

La funzione map() restituisce numeri decimali?

No. map() lavora con il tipo long e nella divisione scarta la parte decimale; per esempio map(512, 0, 1023, 0, 5) dà 2 e non 2,5. Se ti servono i decimali, scrivi con la stessa formula una funzione mapFloat() con parametri float oppure calcola il risultato in un'unità più piccola, come il millivolt.

Qual è la differenza tra map() e constrain()?

map() converte il valore da una scala all'altra ma non lo limita: se l'ingresso è fuori intervallo, anche l'uscita lo è. constrain() invece non cambia scala, ma comprime il valore tra il limite inferiore e quello superiore che indichi. Per un uso sicuro si scrivono insieme: map(constrain(x, 200, 900), 200, 900, 0, 255).

Come si regola l'angolo di un servo con un potenziometro?

Collega il contatto centrale del potenziometro ad A0 e il filo del segnale del servo a D9. In loop() calcola l'angolo con la riga int angolo = map(analogRead(A0), 0, 1023, 0, 180); e invialo al servo con servo.write(angolo). Se il servo trema, fai la media di alcune letture o ignora le piccole variazioni.

map() funziona in modo diverso su ESP32?

La formula è la stessa, ma poiché l'ADC dell'ESP32 è a 12 bit, analogRead() restituisce 0–4095. Per questo devi scrivere l'intervallo di ingresso come map(x, 0, 4095, 0, 255). Poiché l'ADC dell'ESP32 non è lineare agli estremi, misurare e usare le letture minima e massima reali dà risultati migliori.

Esiste un equivalente di map() di Arduino in MicroPython?

Non esiste un equivalente già pronto; il map() di Python è una struttura diversa che applica una funzione alle liste. Scrivi una breve funzione con la formula (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min. Sul Pico read_u16() restituisce 0–65535, quindi l'intervallo di ingresso di solito è questo.

Vedi tutti i progetti
LED in sequenza a velocità regolabile
AR-7Intermedio

LED in sequenza a velocità regolabile

Sei LED si accendono uno dopo l'altro e la luce sembra correre da un'estremità all'altra.

4.6(72)
148
Effetto Supercar a velocità regolabile
AR-8Intermedio

Effetto Supercar a velocità regolabile

Una luce corre su sei LED da un'estremità all'altra, torna indietro e riparte. Girando la manopola del potenziometro cambi subito la velocità della corsa: con la manopola da un lato la luce quasi…

4.5(60)
124
Misurare l'intensità luminosa con LDR
AR-11Principiante

Misurare l'intensità luminosa con LDR

Vuoi vedere quanto è luminosa la tua stanza sotto forma di numero? L'LDR, un piccolo componente sensibile alla luce, misura la luce ambiente e l'Arduino scrive il valore sullo schermo del computer…

4.6(83)
143
Funzionamento del servomotore con potenziometro
AR-36Principiante
Premium

Funzionamento del servomotore con potenziometro

Mentre giri la manopola del potenziometro, il braccio del servomotore ruota insieme a lei: un'estremità della manopola corrisponde a zero gradi, l'altra a mezzo giro.

4.6(37)
53
Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
ES-13Intermedio
Premium

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)

In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.

4.5(19)
32
Servomotore ESP32 (controllo tramite potenziometro)
ES-16Intermedio
Premium

Servomotore ESP32 (controllo tramite potenziometro)

In questo progetto controlliamo un servomotore SG90 tramite un potenziometro. Regoliamo l'angolo del servomotore mappando il valore analogico letto dal potenziometro su un intervallo compreso tra 0 e 180 gradi. La libreria ESP32Servo genera segnali per servomotori sui GPIO adatti dell'ESP32 che possono funzionare come uscite; in questo progetto si utilizza GPIO 18. Si tratta di un metodo di controllo fondamentale per bracci robotici, gimbal per telecamere e meccanismi di porte automatiche.

4.3(29)
42
Servocomando con joystick
AR-60Intermedio
Premium

Servocomando con joystick

Comanda due motori con un joystick, proprio come se girassi una telecamera di sicurezza.

4.7(42)
58