¿Qué es PWM? Guía de analogWrite, ciclo de trabajo y frecuencia en Arduino

Los pines digitales de Arduino solo conocen dos estados: 0 V o 5 V. Entonces, ¿cómo bajas un LED a la mitad de brillo o haces que un motor gire despacio? La respuesta es el PWM (Pulse Width Modulation, modulación por ancho de pulso). El pin se enciende y se apaga muy deprisa y, cambiando la proporción de tiempo que está encendido, se ajusta la potencia media que llega a la carga. Los reguladores de LED, el control de velocidad de motores, los servos, la generación de sonido e incluso los cargadores de móvil usan esta técnica.

¿Cómo funciona el PWM?

Una señal PWM es una onda cuadrada: está un rato en HIGH, luego en LOW, y el ciclo se repite sin parar. La duración de un ciclo de encendido y apagado es el periodo, y la proporción del periodo en que la señal está en HIGH es el ciclo de trabajo (duty cycle). Con un 25 % de ciclo de trabajo la señal está encendida una cuarta parte del tiempo, así que un pin de 5 V se comporta de media como 1,25 V. El LED parpadea unas 490 veces por segundo; el ojo no puede seguirlo y solo ve el brillo medio. Un motor, gracias a su inercia, suaviza los pulsos y gira a la velocidad media.

Nuestros ojos no responden a la luz de forma lineal: notan muy bien los cambios con poca luz y mucho menos con mucha. Por eso un LED al 50 % de ciclo de trabajo parece bastante más brillante que la mitad. Para una atenuación que parezca natural se usa la corrección gamma que verás más abajo.

Frecuencia: ¿qué tan rápido es el PWM?

La frecuencia es cuántas veces por segundo se enciende y apaga la señal. En el Arduino Uno, los pines 5 y 6 funcionan a unos 980 Hz y los pines 3, 9, 10 y 11 a unos 490 Hz. Para un LED es más que suficiente. En los motores, en cambio, 490 Hz está dentro de lo audible y el motor puede silbar un poco; en el ESP32 y la Pico puedes subir la frecuencia a 20 kHz para que no se oiga. Subirla mucho más de lo necesario, eso sí, hace que los transistores y MOSFET se calienten.

Brillo de un LED con analogWrite

En Arduino el PWM se genera con analogWrite(pin, valor), con un valor entre 0 y 255. Aunque el nombre confunde, esta orden no produce una tensión analógica real, sino PWM. Solo funciona en los pines marcados con ~. El código siguiente enciende y apaga un LED despacio con un efecto de «respiración»:

1const int LED_PIN = 9;   // ~ işaretli PWM pini / PWM pin marked with ~
2
3void setup() {
4  pinMode(LED_PIN, OUTPUT);
5}
6
7void loop() {
8  for (int v = 0; v <= 255; v++) {   // yavaşça yan / fade in
9    analogWrite(LED_PIN, v);
10    delay(8);
11  }
12  for (int v = 255; v >= 0; v--) {   // yavaşça sön / fade out
13    analogWrite(LED_PIN, v);
14    delay(8);
15  }
16}

Controlar el brillo con un potenciómetro

Si conectas un potenciómetro a A0, puedes ajustar a mano el brillo del LED. analogRead() devuelve de 0 a 1023; al dividir entre 4 obtienes el rango 0–255 que espera analogWrite. La conexión del potenciómetro está en ¿Qué es un potenciómetro?

1void loop() {
2  int pot = analogRead(A0);   // 0–1023
3  analogWrite(9, pot / 4);    // 0–255
4}

Velocidad de un motor DC con PWM

Hasta un motor DC pequeño consume cientos de miliamperios, mientras que un pin de Arduino solo da con seguridad unos 20 mA. Por eso el motor se maneja con un transistor, un MOSFET o un controlador de motores como el L298N, y la señal PWM va a la entrada de velocidad del controlador. En el L298N esa entrada es el pin ENA (y ENB para el segundo motor); para usar PWM hay que quitarle el puente. Los pines IN1 e IN2 fijan el sentido de giro.

1const int ENA = 9;   // hız (PWM) / speed (PWM)
2const int IN1 = 8;   // yön / direction
3const int IN2 = 7;
4
5void setup() {
6  pinMode(ENA, OUTPUT);
7  pinMode(IN1, OUTPUT);
8  pinMode(IN2, OUTPUT);
9  digitalWrite(IN1, HIGH);   // ileri / forward
10  digitalWrite(IN2, LOW);
11}
12
13void loop() {
14  analogWrite(ENA, 255);  delay(2000);   // tam hız / full speed
15  analogWrite(ENA, 150);  delay(2000);   // orta hız / medium speed
16  analogWrite(ENA, 0);    delay(2000);   // dur / stop
17}

¿Servomotor y PWM son lo mismo?

Los servos también se controlan con pulsos, pero con otra lógica: la posición la marca el ancho del pulso, no el ciclo de trabajo. Un servo espera 50 pulsos por segundo (50 Hz); un pulso de 1 milisegundo significa unos 0°, 1,5 ms son 90° y 2 ms son 180°. analogWrite no puede generar esa temporización, por eso los servos usan la librería Servo. Los detalles están en ¿Qué es un servomotor?

Una tensión analógica real a partir del PWM: el filtro RC

A veces necesitas de verdad una tensión estable, por ejemplo como referencia para un amplificador operacional o para sacar audio. En ese caso pasas el PWM por un filtro paso bajo hecho con una resistencia y un condensador. Con 10 kΩ y 10 µF la constante de tiempo es de 0,1 segundos; la salida queda bastante lisa pero responde despacio a los cambios. Puedes probar otros valores con la calculadora Constante de tiempo RC. El ESP32 clásico tiene además dos DAC en los GPIO 25 y 26 con salida analógica real.

PWM en el ESP32: LEDC

En el ESP32 el PWM lo genera un hardware llamado LEDC, y tú eliges la frecuencia y la resolución. En el núcleo de Arduino 3.x se usan ledcAttach(pin, frecuencia, resolución) y ledcWrite(pin, valor); las versiones 2.x antiguas tenían las órdenes por canales ledcSetup y ledcAttachPin. El ejemplo siguiente atenúa un LED a 5 kHz y 8 bits:

1const int LED_PIN = 2;
2
3void setup() {
4  ledcAttach(LED_PIN, 5000, 8);   // 5 kHz, 8 bit (0–255) — ESP32 Arduino core 3.x
5}
6
7void loop() {
8  for (int d = 0; d <= 255; d++) { ledcWrite(LED_PIN, d); delay(5); }
9  for (int d = 255; d >= 0; d--) { ledcWrite(LED_PIN, d); delay(5); }
10}

PWM en la Raspberry Pi Pico (MicroPython)

En la Pico todos los GPIO pueden dar PWM. En MicroPython se usa la clase PWM: la frecuencia se fija con freq() y el ciclo de trabajo con duty_u16(), que admite valores de 0 a 65535:

1from machine import Pin, PWM
2import time
3
4led = PWM(Pin(15))
5led.freq(1000)                        # 1 kHz
6
7while True:
8    for d in range(0, 65536, 512):    # yavaşça yan / fade in
9        led.duty_u16(d)
10        time.sleep_ms(5)
11    for d in range(65535, -1, -512):  # yavaşça sön / fade out
12        led.duty_u16(d)
13        time.sleep_ms(5)

Ideas de proyectos con PWM

• LED que respira: una luz de estado que se enciende y apaga despacio, como los aparatos en reposo.
• Lámpara de escritorio regulable: una lámpara LED cuyo brillo ajustas con un potenciómetro.
• Ventilador según la temperatura: acelera el ventilador a medida que sube la temperatura medida con un DHT11.
• Mezcla de colores: crea millones de colores en un LED RGB con tres canales PWM.
• Coche robot: suaviza los giros ajustando por separado la velocidad de dos motores.
• Lámpara amanecer: sube poco a poco la luz durante 15 minutos antes de que suene el despertador.

Errores comunes y cómo solucionarlos

• analogWrite en un pin sin PWM: en el Uno, los pines sin ~ solo pueden estar encendidos o apagados; de 128 hacia arriba cuenta como encendido y por debajo como apagado.
• Pines 9 y 10 con la librería Servo: en el Uno la librería Servo usa el Timer1 y desactiva el PWM de esos dos pines; pasa el LED o el motor a otro pin PWM.
• Pines 3 y 11 con tone(): tone() usa el Timer2 y estropea el PWM de esos pines.
• Conectar un motor directamente a un pin: usa siempre un transistor, un MOSFET o un controlador de motores.
• Desbordamiento en el cálculo gamma: v * v supera el límite de int; añade la conversión a (long).
• Creer que el PWM es analógico de verdad: el multímetro muestra la media, pero la señal sigue saltando entre 0 y 5 V; para circuitos sensibles usa un filtro RC o un DAC.

El PWM es una de las ideas más útiles que aprenderás con Arduino: LED, motores, ventiladores y altavoces se controlan con este sencillo truco. Para lo básico, echa un vistazo a ¿Qué es un LED?; en la app BlueGrays encontrarás proyectos de atenuación de LED con PWM, brillo con potenciómetro y transiciones de color RGB, paso a paso y con código.