Función map() de Arduino: uso, ejemplos y constrain
¿Cómo se usa la función map() de Arduino? Sintaxis, trampa de la división entera, límites con constrain, ejemplos con potenciómetro, servo y PWM, ESP32 y Pico.
La función map() de Arduino es un comando integrado que convierte, de forma proporcional, un valor de un rango numérico a otro. Si quieres pasar el valor de 0–1023 que lees de un potenciómetro a 0–180 grados para un servo, a un valor PWM de 0–255 para el brillo de un LED o a un porcentaje de 0–100 para mostrarlo en pantalla, lo resuelves con una sola línea. En pocas palabras, map() es una regla de conversión que adapta tu escala a la que necesitas.
Pero map() no es tan inocente como parece: solo trabaja con enteros, descarta la parte decimal y no limita el resultado al rango de destino. En este artículo verás paso a paso la fórmula, las sorpresas de la división entera, el uso seguro con constrain(), ejemplos reales de potenciómetro a servo y de sensor a PWM, y cómo se hace lo mismo con el ADC de 12 bits del ESP32 y con MicroPython en la Raspberry Pi Pico.

¿Qué es map() en Arduino y cómo funciona?
map() establece una proporción lineal entre dos rangos. Calcula en qué porcentaje de su rango se encuentra el valor de entrada y luego obtiene el número que ocupa la misma posición en el rango de destino. Su definición en el núcleo de Arduino es de una sola línea: (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min. Todos los parámetros y el valor devuelto son de tipo long; es decir, un entero con signo de 32 bits en el Uno. La sintaxis es map(valor, desdeMin, desdeMax, aMin, aMax) y no necesitas añadir ninguna librería.
| Parámetro | Significado | Ejemplo potenciómetro → servo |
|---|---|---|
| value (x) | Valor que se va a convertir | Resultado de analogRead(A0) |
| fromLow (in_min) | Límite inferior del rango de entrada | 0 |
| fromHigh (in_max) | Límite superior del rango de entrada | 1023 |
| toLow (out_min) | Límite inferior del rango de salida | 0 |
| toHigh (out_max) | Límite superior del rango de salida | 180 |
| Valor devuelto | Equivalente en el rango de destino (long) | Ángulo entre 0 y 180 |
Hagamos un ejemplo: con el potenciómetro justo en el centro, analogRead() devuelve aproximadamente 512. Para map(512, 0, 1023, 0, 180) primero se calcula 512 - 0 = 512, ese valor se multiplica por 180 - 0 = 180 y se obtiene 92160. Después se divide entre 1023: 92160 / 1023 = 90,09. Como la división entera descarta los decimales, el resultado es 90 grados; por último se suma el límite inferior de salida, que es 0. Si escribes los límites de salida al revés, el sentido también se invierte: map(x, 0, 1023, 255, 0) produce un valor que disminuye al subir el potenciómetro. Los rangos negativos también funcionan sin problema; puedes convertir el eje de un joystick en velocidad de motor hacia delante y hacia atrás con map(x, 0, 1023, -255, 255). La siguiente tabla resume las conversiones más habituales.
| Objetivo | Código | Nota |
|---|---|---|
| Potenciómetro → ángulo de servo | map(x, 0, 1023, 0, 180) | Para Servo.write() |
| Potenciómetro → PWM | map(x, 0, 1023, 0, 255) | Para analogWrite(); x / 4 da una distribución más uniforme |
| Lectura analógica → porcentaje | map(x, 0, 1023, 0, 100) | Para mostrar el porcentaje en pantalla |
| Joystick → velocidad y sentido del motor | map(x, 0, 1023, -255, 255) | El signo da el sentido, la magnitud la velocidad |
| Sentido inverso (oscuro → brillante) | map(x, 0, 1023, 255, 0) | Intercambia los límites de salida |
| ADC de 12 bits del ESP32 → PWM | map(x, 0, 4095, 0, 255) | En el ESP32 analogRead() devuelve 0–4095 |
Limitación de la división entera: ¿por qué map() no da decimales?
Como la división dentro de map() se hace con enteros, el resultado siempre se trunca hacia cero; la parte decimal no se redondea, simplemente se descarta. En un rango de destino estrecho esto se nota mucho. Por ejemplo, si escribes map(x, 0, 1023, 0, 10) para convertir el potenciómetro en un indicador de nivel de 0 a 10, obtienes esta tabla:
| Entrada (x) | Proporción real | Resultado 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 |
El problema real de la tabla es este: el resultado 0 lo producen 103 valores de entrada distintos (0–102), mientras que el valor máximo, 10, solo lo da una única entrada, la 1023. Si no giras el potenciómetro hasta el tope, tu indicador nunca llegará a 10. Si quieres una distribución uniforme, puedes aumentar en uno los dos límites superiores y escribir map(x, 0, 1024, 0, 11); así cada valor de salida corresponde a unos 93 valores de entrada y el resultado se mantiene entre 0 y 10. La segunda limitación es el desbordamiento: si el producto intermedio (x - in_min) * (out_max - out_min) supera el límite del long de 32 bits, es decir, unos 2.100 millones, el resultado se corrompe. Rangos grandes como map(50000, 0, 100000, 0, 100000) generan en el Uno un producto intermedio de 5.000 millones y dan un resultado incorrecto. La tercera limitación son los decimales: si para convertir una lectura analógica en una tensión de 0–5 V escribes map(x, 0, 1023, 0, 5), solo obtendrás los resultados 0, 1, 2, 3, 4 y 5. En ese caso debes escribir tu propia función map con decimales usando la misma fórmula:
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 junto con constrain
map() no considera el rango de destino como un límite; solo calcula una proporción. Si el valor de entrada sale del rango esperado, la salida también se desborda. Supón que has medido que un LDR da en realidad valores entre 200 y 900 y has escrito map(x, 200, 900, 0, 255). Cuando una linterna potente sube el valor a 980, el resultado es (980 - 200) * 255 / 700 = 284; si con el ambiente muy oscuro el valor baja a 150, obtienes -18. En el Uno, analogWrite() interpreta de forma distinta según el pin un valor mayor que 255; por ejemplo, en el pin 6 el 284 se trunca a 8 bits y se convierte en 28, es decir, un LED casi apagado. La solución es la función constrain(valor, inferior, superior): encaja el valor dentro de los límites dados. Hay dos órdenes correctos: limitar la entrada antes de map(), es decir, map(constrain(x, 200, 900), 200, 900, 0, 255), o limitar el resultado después de map(), es decir, constrain(map(x, 200, 900, 0, 255), 0, 255). Ambos impiden salirse de 0–255; si estás calibrando un sensor, limitar la entrada resulta más legible.
Tabla de conexiones: Arduino Uno, ESP32 y Pico
| Conexión | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Extremos del potenciómetro | 5V y GND | 3V3 y GND | 3V3 y GND |
| Terminal central del potenciómetro | A0 | GPIO 34 | GP26 (ADC0) |
| Punto medio del divisor LDR + 10 kΩ | A1 | GPIO 35 | GP27 (ADC1) |
| LED (con resistencia de 220 Ω) | D6 (PWM) | GPIO 25 | GP15 |
| Señal del servo (cable naranja) | D9 | GPIO 13 | GP16 |
| Rango de lectura del ADC | 10 bits (0–1023) | 12 bits (0–4095) | read_u16(): 0–65535 |
Paso a paso: ajustar el ángulo de un servo con un potenciómetro
- Conecta los dos extremos del potenciómetro de 10 kΩ a los pines 5V y GND de Arduino, y el terminal central a A0.
- Conecta el cable marrón del servo SG90 a GND, el rojo a 5V y el cable naranja de señal a D9.
- Comprueba que la librería Servo está instalada; viene con el IDE de Arduino y no tienes que descargar nada más.
- Carga el código siguiente y abre el Monitor Serie a 9600 baudios.
- Mientras giras el potenciómetro, observa que el valor bruto y el ángulo cambian a la vez y que el servo gira entre 0 y 180 grados.
- Si el servo se fuerza y zumba en los extremos, reduce la salida de map() a un rango más estrecho, como 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}En el código, analogRead() devuelve un valor de 10 bits, map() lo convierte en grados y constrain() garantiza que, aunque cambies el rango más adelante, al servo nunca llegue un ángulo fuera de 0–180. Como el ADC del Uno tiene algo de ruido, aunque no toques el potenciómetro el valor puede oscilar entre 511, 512 y 513, lo que hace temblar el servo. Promediar varias lecturas o llamar a servo.write() solo cuando el ángulo cambie más de 2 grados resuelve el problema en gran medida. Para más detalles puedes consultar los artículos problema de temblor del servo y filtrado de datos de sensores. Si te interesa saber cómo funciona un servo, ¿Qué es un servomotor? es un buen punto de partida.
Del sensor al PWM: brillo automático de un LED con LDR
map() no sirve solo con potenciómetros, sino con cualquier sensor analógico. En este ejemplo, un extremo del LDR va a 5V y el otro a A1; entre A1 y GND hay además una resistencia de 10 kΩ. Con esta conexión, cuanta más luz hay, menos resistencia tiene el LDR y más sube la tensión en A1. Primero anota en el Monitor Serie los valores leídos en una habitación oscura y con luz; por ejemplo, 150 y 850. Esos dos números son los límites de calibración. El código enciende más el LED cuanto más oscuro se pone el ambiente, por eso el rango de salida se escribe al revés: de 255 a 0. Para el principio de funcionamiento del LDR, consulta Sensor de luz LDR, y para los fundamentos del PWM, ¿Qué es el 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() en el ESP32: ADC de 12 bits y PWM LEDC
En el ESP32, map() funciona igual; lo que cambia es el rango de entrada. El ADC del ESP32 tiene por defecto una resolución de 12 bits, es decir, analogRead() devuelve 0–4095 en lugar de 0–1023. Si en el código que traes del Uno dejas map(x, 0, 1023, ...), agotarás todo el rango de salida en el primer cuarto del potenciómetro y en el resto los valores se desbordarán hasta cuatro veces el rango de destino. Por eso, en el ESP32 escribe la entrada como 0–4095 o baja a 10 bits con analogReadResolution(10). En el PWM, el ESP32 usa la unidad LEDC; con el núcleo de Arduino 3.x llegó ledcAttach(pin, frecuencia, resolución), mientras que en 2.x se usan ledcSetup() y ledcAttachPin(), basadas en canales. El código siguiente compila en ambas versiones. Como los pines ADC2 no se pueden leer con el Wi-Fi activado, conectamos el potenciómetro al GPIO 34, que pertenece a ADC1. Si quieres mover un servo con el ESP32, puedes usar la línea map(x, 0, 4095, 0, 180) con la misma lógica y la librería ESP32Servo.
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}El ADC del ESP32 tiene una peculiaridad que debes conocer: no es lineal en los extremos. Con la atenuación predeterminada, las tensiones por debajo de unos 0,1 V se leen como 0 y a partir de unos 3,1 V el valor se satura en 4095; entre medias, la medida se curva ligeramente. Por eso puedes llegar a 4095 sin girar el potenciómetro hasta el final, o notar una zona muerta al principio. La solución práctica es medir las lecturas mínima y máxima reales y usar esos límites en map() y constrain(). Si necesitas la tensión, en lugar de map() la función analogReadMilliVolts(), que usa la calibración de fábrica, da un resultado más preciso. Para las características generales de la placa puedes consultar ¿Qué es el ESP32?.
El equivalente de map() en Raspberry Pi Pico y MicroPython
En MicroPython no existe un map() ya hecho como en Arduino; el map() de Python hace algo totalmente distinto y aplica una función a una lista. Por eso escribes tú mismo la misma fórmula. En la Pico, ADC.read_u16() devuelve la medida física de 12 bits escalada a 16 bits, en el rango 0–65535, y PWM.duty_u16() también espera un ciclo de trabajo entre 0 y 65535. Como los enteros de Python tienen tamaño ilimitado, no sufres el problema de desbordamiento del Uno. La diferencia a la que debes prestar atención es que el operador // siempre redondea hacia menos infinito, mientras que el map() de C++ trunca hacia cero, así que en rangos negativos puedes ver una diferencia de 1 unidad entre los dos lenguajes. Si quieres un resultado decimal, basta con usar / en lugar de //. En el código, el potenciómetro se lee en GP26, el brillo del LED en GP15 y el servo en GP16 sigue el ángulo. Para el LED limitamos la entrada a 500–65000, porque el ADC de la Pico rara vez llega a los valores exactos 0 y 65535 en los extremos. En el servo, con PWM de 50 Hz, 0–180 grados corresponde, en la mayoría de los SG90, a pulsos de unos 500–2500 microsegundos. Si eres nuevo en la Pico, puedes empezar con ¿Qué es la Raspberry Pi Pico? y Fundamentos 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)Ideas de proyectos con map()
- Indicador de nivel: convierte el valor de un potenciómetro o de un sensor de sonido a 0–8 con map(x, 0, 1024, 0, 9) y muéstralo en una barra de 8 LED.
- Coche controlado con joystick: convierte el eje del joystick a un valor entre -255 y 255 y ajusta el sentido y la velocidad de los motores con el L298N.
- Voltímetro digital: convierte la lectura analógica a milivoltios y muéstrala en un LCD; los detalles están en el artículo Cómo hacer un voltímetro con Arduino.
- Porcentaje de humedad de una planta: convierte con constrain() y map() los valores de calibración en seco y en mojado del sensor de humedad del suelo a un porcentaje de 0–100.
- Instrumento musical con luz: convierte el valor del LDR o de la distancia con map() al rango de 200–2000 Hz y pásalo como frecuencia a la función tone().
- LED corredor con velocidad ajustable: convierte el potenciómetro con map(x, 0, 1023, 50, 500) en un tiempo de espera en milisegundos.
Errores frecuentes y cómo solucionarlos
| Síntoma | Causa | Solución |
|---|---|---|
| El resultado se sale del rango de destino | map() no limita | Limita la entrada o la salida con constrain() |
| Los resultados decimales salen siempre enteros | La división entera descarta los decimales | Escribe mapFloat() o reduce la unidad (mV en vez de V) |
| Nunca se llega al valor máximo | El valor máximo solo se da con una única entrada | Distribuye de forma uniforme con map(x, 0, 1024, 0, max + 1) |
| Resultados absurdos con números grandes | El producto intermedio supera el límite del long de 32 bits | Reduce los rangos o calcula con float o int64_t |
| En el ESP32 el valor llega demasiado pronto al máximo | El código está escrito para 0–1023 y el ADC da 0–4095 | Pon el rango de entrada en 0–4095 |
| Funciona en sentido contrario | Los límites de salida o la conexión del sensor están invertidos | Intercambia los límites inferior y superior de salida |
| El resultado es constante y sin sentido | in_min es igual a in_max, es decir, división por cero | Comprueba que los límites de calibración sean distintos |
La función map() es la traductora entre el mundo de los sensores y el de las salidas: ten presente la división entera, protege los límites con constrain() y, si indicas bien la resolución del ADC de tu placa, funciona con la misma lógica en Uno, ESP32 y Pico. Puedes repasar los fundamentos del potenciómetro en ¿Qué es un potenciómetro?. En la app de BlueGrays puedes ver paso a paso, con esquema del circuito y código, proyectos que usan map() como el LED corredor con velocidad ajustable, la lectura de intensidad de luz con LDR, el control de un servo con potenciómetro y el ajuste de brillo PWM con ESP32.
Preguntas frecuentes
¿Para qué sirve la función map() de Arduino?
map() convierte de forma proporcional un número de un rango a otro. Su uso más habitual es pasar el valor de 0–1023 leído con analogRead() a 0–180 grados para un servo o a un valor PWM de 0–255 para analogWrite(). No necesita librerías, viene incluida en el núcleo de Arduino.
¿La función map() devuelve números decimales?
No. map() trabaja con el tipo long y descarta la parte decimal en la división; por ejemplo, map(512, 0, 1023, 0, 5) da 2 y no 2,5. Si necesitas decimales, debes escribir con la misma fórmula una función mapFloat() con parámetros float o calcular el resultado en una unidad menor, como los milivoltios.
¿Cuál es la diferencia entre map() y constrain()?
map() convierte el valor de una escala a otra pero no lo limita; si la entrada está fuera del rango, la salida también se sale. constrain() no cambia de escala, solo encaja el valor entre los límites inferior y superior que le indiques. Para un uso seguro se combinan: map(constrain(x, 200, 900), 200, 900, 0, 255).
¿Cómo se ajusta el ángulo de un servo con un potenciómetro?
Conecta el terminal central del potenciómetro a A0 y el cable de señal del servo a D9. En loop() calcula el ángulo con la línea int angulo = map(analogRead(A0), 0, 1023, 0, 180); y envíalo al servo con servo.write(angulo). Si el servo tiembla, promedia varias lecturas o ignora los cambios pequeños.
¿map() funciona de forma distinta en el ESP32?
La fórmula es la misma, pero como el ADC del ESP32 es de 12 bits, analogRead() devuelve 0–4095. Por eso debes escribir el rango de entrada como map(x, 0, 4095, 0, 255). Como el ADC del ESP32 no es lineal en los extremos, medir y usar las lecturas mínima y máxima reales da mejores resultados.
¿Existe en MicroPython un equivalente de map() de Arduino?
No hay un equivalente ya hecho; el map() de Python es otra cosa, aplica una función a listas. Escribes una función corta con la fórmula (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min. Como en la Pico read_u16() devuelve 0–65535, el rango de entrada suele ser ese.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Luz secuencial LED con velocidad regulable
Seis LED se encienden uno tras otro y la luz parece correr de un extremo al otro.

Efecto coche fantástico con velocidad regulable
Una luz recorre seis LED de un extremo a otro, da la vuelta y vuelve a correr. Girando el mando del potenciómetro cambias al instante la velocidad de esa carrera: con el mando a un lado la luz casi…

Medir la intensidad de luz con LDR
¿Quieres ver en números cuánta luz hay en tu habitación? El LDR, una pequeña pieza sensible a la luz, mide la luz ambiente y el Arduino escribe el valor en la pantalla del ordenador cada medio…

Funcionamiento del servomotor con potenciómetro
A medida que giras el mando del potenciómetro, el brazo del servomotor gira con él: un extremo del mando equivale a cero grados y el otro a media vuelta.

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

Servomotor ESP32 (control mediante potenciómetro)
En este proyecto controlamos un servomotor SG90 mediante un potenciómetro. Ajustamos el ángulo del servo asignando el valor analógico leído en el potenciómetro al rango de 0 a 180 grados. La biblioteca ESP32Servo genera señales de servo en los GPIO adecuados del ESP32 que admiten salida; en este proyecto se utiliza GPIO 18. Este es un método de control básico para brazos robóticos, cardanes de cámara y mecanismos de puertas automáticas.

Servocontrol con joystick
Controla dos motores con un joystick, igual que si giraras una cámara de seguridad.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

