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.

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.
| Parametro | Significato | Esempio pot → servo |
|---|---|---|
| value (x) | Valore da convertire | risultato di analogRead(A0) |
| fromLow (in_min) | Limite inferiore dell'intervallo di ingresso | 0 |
| fromHigh (in_max) | Limite superiore dell'intervallo di ingresso | 1023 |
| toLow (out_min) | Limite inferiore dell'intervallo di uscita | 0 |
| toHigh (out_max) | Limite superiore dell'intervallo di uscita | 180 |
| Valore restituito | Corrispondente 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.
| Obiettivo | Codice | Nota |
|---|---|---|
| Potenziometro → angolo del servo | map(x, 0, 1023, 0, 180) | Per Servo.write() |
| Potenziometro → PWM | map(x, 0, 1023, 0, 255) | Per analogWrite(); x / 4 dà una distribuzione più uniforme |
| Lettura analogica → percentuale | map(x, 0, 1023, 0, 100) | Per mostrare la percentuale a display |
| Joystick → velocità e direzione del motore | map(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 → PWM | map(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 reale | Risultato di 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 |
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:
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}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.
Tabella dei collegamenti: Arduino Uno, ESP32 e Pico
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Estremi esterni del potenziometro | 5V e GND | 3V3 e GND | 3V3 e GND |
| Contatto centrale del potenziometro | A0 | GPIO 34 | GP26 (ADC0) |
| Punto centrale del partitore LDR + 10 kΩ | A1 | GPIO 35 | GP27 (ADC1) |
| LED (con resistenza da 220 Ω) | D6 (PWM) | GPIO 25 | GP15 |
| Segnale del servo (filo arancione) | D9 | GPIO 13 | GP16 |
| Intervallo di lettura ADC | 10 bit (0–1023) | 12 bit (0–4095) | read_u16(): 0–65535 |
Passo dopo passo: regolare l'angolo del servo con un potenziometro
- Collega i due estremi esterni del potenziometro da 10 kΩ ai pin 5V e GND di Arduino e il contatto centrale ad A0.
- Collega il filo marrone del servo SG90 a GND, quello rosso a 5V e il filo arancione del segnale a D9.
- Controlla che la libreria Servo sia installata: viene fornita con l'Arduino IDE e non devi scaricare nulla.
- Carica il codice seguente e apri il Monitor seriale a 9600 baud.
- Mentre giri il potenziometro, osserva sullo schermo il valore grezzo e l'angolo cambiare insieme e il servo ruotare tra 0 e 180 gradi.
- Se il servo si sforza e ronza ai finecorsa, restringi l'uscita di map() a un intervallo più stretto, come 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}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?.
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).
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.
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
| Sintomo | Causa | Soluzione |
|---|---|---|
| Il risultato esce dall'intervallo di destinazione | map() non limita il risultato | Limita l'ingresso o l'uscita con constrain() |
| I risultati decimali arrivano sempre interi | La divisione intera scarta i decimali | Scrivi mapFloat() o riduci l'unità (mV invece di V) |
| Il valore massimo non viene mai raggiunto | Il valore massimo si ottiene con un solo ingresso | Distribuisci in modo uniforme con map(x, 0, 1024, 0, max + 1) |
| Risultati assurdi con numeri grandi | Il prodotto intermedio supera il limite del long a 32 bit | Riduci gli intervalli o calcola con float o int64_t |
| Su ESP32 il valore arriva al massimo troppo presto | Il codice è scritto per 0–1023, l'ADC dà 0–4095 | Imposta l'intervallo di ingresso a 0–4095 |
| La direzione è invertita | Limiti di uscita o collegamento del sensore invertiti | Scambia i limiti inferiore e superiore di uscita |
| Il risultato è fisso e senza senso | in_min e in_max sono uguali, cioè divisione per zero | Controlla che i limiti di calibrazione siano diversi |
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.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED in sequenza a velocità regolabile
Sei LED si accendono uno dopo l'altro e la luce sembra correre da un'estremità all'altra.

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…

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…

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.

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.

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.

Servocomando con joystick
Comanda due motori con un joystick, proprio come se girassi una telecamera di sicurezza.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

