Fundamentos · 12 min de lectura

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.

Potenciómetro usado con la función map() de Arduino
El potenciómetro es el elemento de entrada que más se usa con map(): el valor leído de 0–1023 se convierte en un ángulo de servo o en un valor PWM.

¿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ámetroSignificadoEjemplo potenciómetro → servo
value (x)Valor que se va a convertirResultado de analogRead(A0)
fromLow (in_min)Límite inferior del rango de entrada0
fromHigh (in_max)Límite superior del rango de entrada1023
toLow (out_min)Límite inferior del rango de salida0
toHigh (out_max)Límite superior del rango de salida180
Valor devueltoEquivalente 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.

ObjetivoCódigoNota
Potenciómetro → ángulo de servomap(x, 0, 1023, 0, 180)Para Servo.write()
Potenciómetro → PWMmap(x, 0, 1023, 0, 255)Para analogWrite(); x / 4 da una distribución más uniforme
Lectura analógica → porcentajemap(x, 0, 1023, 0, 100)Para mostrar el porcentaje en pantalla
Joystick → velocidad y sentido del motormap(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 → PWMmap(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 realResultado de map()
00,0000
1020,9970
1031,0071
5125,0055
10229,9909
102310,00010

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:

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}
En el Uno, las operaciones con float son varias veces más lentas que con enteros y ocupan más memoria de programa. Si no necesitas decimales, usa el map() entero; si quieres precisión, reduce la unidad de destino. Por ejemplo, calcula la tensión en milivoltios en vez de voltios: map(raw, 0, 1023, 0, 5000) da 0–5000 mV y el mayor producto intermedio (5.115.000) queda muy por debajo del límite del long.

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.

En el núcleo de Arduino Uno (AVR), constrain() no es una función sino una macro y evalúa sus parámetros varias veces. Si escribes constrain(analogRead(A0), 200, 900), analogRead() puede ejecutarse varias veces y el valor comparado y el devuelto pueden ser distintos. Guarda primero la lectura en una variable y luego pon esa variable dentro de constrain().

Tabla de conexiones: Arduino Uno, ESP32 y Pico

ConexiónArduino UnoESP32Raspberry Pi Pico
Extremos del potenciómetro5V y GND3V3 y GND3V3 y GND
Terminal central del potenciómetroA0GPIO 34GP26 (ADC0)
Punto medio del divisor LDR + 10 kΩA1GPIO 35GP27 (ADC1)
LED (con resistencia de 220 Ω)D6 (PWM)GPIO 25GP15
Señal del servo (cable naranja)D9GPIO 13GP16
Rango de lectura del ADC10 bits (0–1023)12 bits (0–4095)read_u16(): 0–65535
Las entradas analógicas del ESP32 y de la Pico aceptan como máximo 3,3 V. Si por costumbre conectas los extremos del potenciómetro al pin de 5V, el terminal central llegará a 5 V y la entrada del ADC puede dañarse de forma permanente. En estas placas alimenta siempre el potenciómetro desde el pin 3V3; si usas un sensor con salida de 5 V, baja primero el nivel con un divisor de tensión.

Paso a paso: ajustar el ángulo de un servo con un potenciómetro

  1. Conecta los dos extremos del potenciómetro de 10 kΩ a los pines 5V y GND de Arduino, y el terminal central a A0.
  2. Conecta el cable marrón del servo SG90 a GND, el rojo a 5V y el cable naranja de señal a D9.
  3. Comprueba que la librería Servo está instalada; viene con el IDE de Arduino y no tienes que descargar nada más.
  4. Carga el código siguiente y abre el Monitor Serie a 9600 baudios.
  5. 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.
  6. Si el servo se fuerza y zumba en los extremos, reduce la salida de map() a un rango más estrecho, como 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}

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?.

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() 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.

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}

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.

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íntomaCausaSolución
El resultado se sale del rango de destinomap() no limitaLimita la entrada o la salida con constrain()
Los resultados decimales salen siempre enterosLa división entera descarta los decimalesEscribe mapFloat() o reduce la unidad (mV en vez de V)
Nunca se llega al valor máximoEl valor máximo solo se da con una única entradaDistribuye de forma uniforme con map(x, 0, 1024, 0, max + 1)
Resultados absurdos con números grandesEl producto intermedio supera el límite del long de 32 bitsReduce los rangos o calcula con float o int64_t
En el ESP32 el valor llega demasiado pronto al máximoEl código está escrito para 0–1023 y el ADC da 0–4095Pon el rango de entrada en 0–4095
Funciona en sentido contrarioLos límites de salida o la conexión del sensor están invertidosIntercambia los límites inferior y superior de salida
El resultado es constante y sin sentidoin_min es igual a in_max, es decir, división por ceroComprueba que los límites de calibración sean distintos
En lugar de escribir la calibración con números fijos, mídela en tiempo de ejecución: en setup() lee el sensor durante unos segundos, guarda el valor mínimo y el máximo, y luego usa esas variables en map() y constrain(). Si los dos valores quedan iguales, vuelve a los límites predeterminados para no dividir entre cero. Así el mismo código se ajusta solo a distintos LDR, potenciómetros y entornos. Los fundamentos de la lectura analógica los encuentras en el artículo ¿Qué es el ADC?.

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.

Ver todos los proyectos
Luz secuencial LED con velocidad regulable
AR-7Intermedio

Luz secuencial LED con velocidad regulable

Seis LED se encienden uno tras otro y la luz parece correr de un extremo al otro.

4.6(72)
148
Efecto coche fantástico con velocidad regulable
AR-8Intermedio

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…

4.5(60)
124
Medir la intensidad de luz con LDR
AR-11Principiante

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…

4.6(83)
143
Funcionamiento del servomotor con potenciómetro
AR-36Principiante
Premium

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.

4.6(37)
53
Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
ES-13Intermedio
Premium

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.

4.5(19)
32
Servomotor ESP32 (control mediante potenciómetro)
ES-16Intermedio
Premium

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.

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

Servocontrol con joystick

Controla dos motores con un joystick, igual que si giraras una cámara de seguridad.

4.7(42)
58