Aprender

PWM en ESP32 con ledcAttach y ledcWrite

Principiante

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
ESP32 DevKit: una perilla que regula el brillo de un LED en GPIO 4en vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
analogWrite() en GPIO 4 usa un canal LEDC: ocho bits a 1 kHz.

Un ESP32 no tiene pines PWM fijos. Su PWM viene de un bloque llamado LEDC, y cualquier pin con un controlador de salida puede ser una de sus salidas. Desde la versión 3.0 del núcleo de Arduino para ESP32, dos llamadas hacen todo: ledcAttach(pin, frequency, bits) configura el pin, y ledcWrite(pin, duty) define qué proporción de cada período está en alto. analogWrite() también funciona, sobre el mismo hardware.

El circuito de arriba es un ESP32 DevKit con un potenciómetro en GPIO 32 y un LED en GPIO 4. El sketch lee la perilla y llama a analogWrite(4, duty), así que girar la perilla regula el brillo del LED, y el monitor serie muestra la lectura y el ciclo útil que eligió. Abajo se ve qué hacen las llamadas de LEDC, medidas en la misma placa, y qué cambió respecto al núcleo 2.x que la mayoría de los tutoriales todavía usan.

ledcAttach y ledcWrite

El sketch de abajo conecta GPIO 4 a 5000 Hz con 8 bits de resolución, así que el ciclo útil va de 0 a 255, y escribe 64, una cuarta parte. Un jumper de GPIO 4 a GPIO 15 permite que la misma placa mida su propia salida con pulseIn(). Imprimió "high 50 us, low 150 us": un período de 200 microsegundos, que son 5000 Hz, en alto una cuarta parte del tiempo.

ledcAttach() devuelve true si encontró un canal y un temporizador para el pin, y false si no, así que conviene comprobarlo. Aquí falló en GPIO 34, uno de los pines de solo entrada, que no tienen controlador de salida. El pin es el nombre que se usa en todo lo demás: ledcWrite(4, 128) para la mitad, ledcRead(4) para el ciclo útil, ledcReadFreq(4) para la frecuencia, y ledcDetach(4) para liberar el canal.

ledcAttach a 5 kHz, medido con pulseIn
const int kLed = 4;
const int kProbe = 15;   // a jumper from GPIO 4

void setup() {
  Serial.begin(115200);
  pinMode(kProbe, INPUT);
  if (!ledcAttach(kLed, 5000, 8)) {
    Serial.println("ledcAttach failed");
  }
  ledcWrite(kLed, 64);   // 64 of 256: a quarter
  delay(5);
  Serial.print("high ");
  Serial.print(pulseIn(kProbe, HIGH));
  Serial.print(" us, low ");
  Serial.print(pulseIn(kProbe, LOW));
  Serial.println(" us");
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

analogWrite frente a ledcWrite

En un ESP32, analogWrite(pin, value) conecta el pin a un canal la primera vez que lo llamas, con 8 bits y 1000 Hz, y luego escribe el valor. Con analogWrite(4, 64) la misma medición imprimió "high 250 us, low 750 us": un período de 1 kHz, una cuarta parte en alto. Es la llamada correcta para un LED y para código que también debe compilar para un Uno.

Cuando la frecuencia importa, defínela por pin antes de escribir. analogWriteFrequency(4, 5000) y analogWriteResolution(4, 10), luego analogWrite(4, 256), imprimió otra vez "high 50 us, low 150 us", porque 256 de 1024 es una cuarta parte. Un controlador de motor, un ventilador o un zumbador normalmente necesita su propia frecuencia, y un servo necesita 50 Hz, por eso la mayoría de los tutoriales de ESP32 usan las llamadas de LEDC directamente.

Frecuencia frente a resolución

El temporizador LEDC cuenta un reloj, y un período son 2 elevado a la resolución cuentas. En un ESP32 clásico el reloj más rápido es el reloj APB de 80 MHz, así que la frecuencia por 2 elevado a los bits debe mantenerse por debajo de 80 millones (la guía LEDC de Espressif). Eso permite 13 bits a 5 kHz, 11 bits a 20 kHz y 10 bits a 40 kHz. Si pides más, un ESP32 real rechaza el attach.

Mokxi todavía no verifica ese límite: acepta cualquier frecuencia hasta 14 bits, así que una combinación que funcione aquí puede fallar en la placa. Elige la combinación según la aritmética anterior. Para un LED, 5 kHz a 8 bits es de sobra. Para un motor que no debe zumbear, 20 kHz a 10 bits o menos.

ledcChangeFrequency(pin, frequency, bits) reajusta un pin que ya está conectado, y ledcWriteTone(pin, 440) reproduce una onda cuadrada a medio ciclo útil, que es como un zumbador pasivo toca una nota. Aquí devolvió 440, y la mitad alta de cada período midió 1130 microsegundos, la mitad de un período de 440 Hz.

¿Cuántos canales PWM tiene un ESP32?

Un canal maneja un pin, y los canales a la misma frecuencia y resolución comparten un temporizador. La tabla de Espressif da al ESP32 clásico 16 canales en dos grupos, al S3 ocho y al C3 seis, y cada grupo tiene cuatro temporizadores. El núcleo 3.x los asigna por sí solo; ledcAttachChannel(pin, frequency, bits, channel) elige uno cuando lo necesitas.

El ESP32 clásico de Mokxi modela el grupo de alta velocidad: ocho canales y cuatro temporizadores. Conectando pin tras pin a 5000 Hz, el noveno ledcAttach() devolvió 0 aquí. Conectando cada pin a una frecuencia distinta, el quinto devolvió 0, porque cada frecuencia necesita su propio temporizador. Un ESP32 real también tiene el segundo grupo, así que el mismo sketch llega el doble de lejos, y la lección es la misma: las luces que se desvanecen juntas deben compartir una frecuencia.

"ledcSetup was not declared in this scope"

Este es el error que casi todos encuentran después de actualizar el paquete de placas ESP32. El núcleo 3.0 eliminó ledcSetup() y ledcAttachPin() y los fusionó en ledcAttach(), y ahora cada llamada a LEDC recibe el pin en lugar del número de canal (guía de migración de 2.x a 3.0 de Espressif). Un sketch escrito para 2.x se detiene en el Arduino IDE con 'ledcSetup' was not declared in this scope. ledcDetachPin() se convirtió en ledcDetach().

Mokxi acepta ambas formas, así que un tutorial antiguo corre aquí sin cambios: ledcSetup(0, 5000, 8) devolvió 5000, y después de ledcAttachPin(4, 0) y ledcWrite(0, 64) el pin midió "high 50 us" como antes. Eso es una comodidad, no lo que hace el Arduino IDE, así que porta el sketch antes de llevarlo a una placa. El cambio son tres líneas a dos: quita el canal, conecta por pin, escribe por pin.

El mismo PWM en el núcleo 2.x y el núcleo 3.x
// Core 2.x: by channel
ledcSetup(0, 5000, 8);
ledcAttachPin(4, 0);
ledcWrite(0, 64);

// Core 3.x: by pin
ledcAttach(4, 5000, 8);
ledcWrite(4, 64);

Abre este circuito en el editor. ESP32 DevKit: una perilla atenúa un LED en GPIO 4, cableado tal como se ejecuta al inicio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Qué pines del ESP32 pueden hacer PWM?

Cualquier pin con un controlador de salida: LEDC llega a las patillas a través de la matriz GPIO. No GPIO 34 a 39, que son solo de entrada, y mejor no GPIO 6 a 11, que son la flash.

¿Cómo arreglo "ledcSetup was not declared in this scope"?

Tienes el núcleo 3.x y un sketch para 2.x. Reemplaza ledcSetup(channel, freq, bits) y ledcAttachPin(pin, channel) con ledcAttach(pin, freq, bits), y pasa el pin a ledcWrite en lugar del canal.

¿Debo usar analogWrite o ledcWrite en un ESP32?

analogWrite para un LED con el 1 kHz y 8 bits predeterminados, o para código compartido con un Uno. ledcAttach y ledcWrite cuando la frecuencia o la resolución importan, como con un servomotor, un controlador de motor o un zumbador.

¿Por qué no funciona mi ledcWrite en el ESP32?

Normalmente un sketch de 2.x en el núcleo 3.x: ledcWrite(0, duty) ahora significa pin 0, no canal 0. Si no, ledcAttach falló (revisa su valor de retorno), el pin es solo de entrada, o la frecuencia y la resolución no caben en el reloj de 80 MHz.

¿Qué frecuencia PWM debo usar en un ESP32?

5 kHz de 8 a 13 bits para LEDs, 20 kHz hasta 11 bits para motores que no debas oír, 50 Hz para un servomotor, y la nota misma para un zumbador, con ledcWriteTone.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.