El ESP32 es un microcontrolador versátil y potente que ofrece una amplia gama de funcionalidades para proyectos electrónicos. Una de las características más interesantes del ESP32 es su capacidad para generar señales PWM, una técnica esencial en el control de motores, luces LED y otros dispositivos. En este artículo, exploraremos los conceptos básicos de cómo generar señales PWM en el ESP32 y cómo esta función puede ser utilizada en tus proyectos de electrónica. ¡Sigue leyendo para descubrir más!

Si alguna vez has jugado con Arduino, sabes lo fácil que es generar una señal PWM con él. analogWrite() Función: simplemente especifique el pin a usar y el ciclo de trabajo y estará listo para comenzar.

Pero con el ESP32 es como jugar a un nivel un poco más difícil. Obtenemos más controles (¡sí!), pero también tenemos que usarlos sabiamente (lo cual es un poco complicado). El ESP32 requiere que especifiquemos algunas cosas más, como la frecuencia PWM, la resolución PWM, qué canal usar y, por supuesto, el ciclo de trabajo y el número de pin. Uf, eso parece mucho, ¡pero no te preocupes!

Esta guía le dirá todo lo que necesita saber sobre PWM en ESP32, desde los conceptos básicos hasta ejemplos prácticos.

Pines ESP32 PWM

Con el ESP32, la salida PWM es posible en todos los pines GPIO, con la excepción de los cuatro pines GPIO de solo entrada. Los GPIO resaltados a continuación son compatibles con PWM.

PWM en ESP32

El ESP32 tiene dos periféricos PWM: el Dispositivo periférico de control de LED (LEDC) y eso Dispositivo periférico para control de motores con modulador de ancho de pulso (MCPWM).

El periférico MCPWM está destinado al control del motor y tiene características adicionales como zona muerta y frenado automático. El dispositivo periférico LEDC, por otro lado, está diseñado específicamente para controlar LED y tiene funciones como atenuación automática y funciones avanzadas. Sin embargo, también se puede utilizar para generar señales PWM para otros fines.

En este tutorial nos centraremos principalmente en el periférico LEDC.

frecuencia pwm

El periférico LEDC, como la mayoría de los controladores PWM, utiliza un temporizador para generar señales PWM.

Imagine un cronómetro que “hace tictac” y cuenta hasta alcanzar un número máximo. En este punto se pone a cero y comienza de nuevo el siguiente ciclo de conteo. El tiempo entre estos reinicios (es decir, cuánto tiempo se tarda en alcanzar el valor máximo) representa el frecuencia pwm y se mide en Hercios (Hz). Por ejemplo, si especificamos una frecuencia de 1 Hz, el temporizador tardará 1 segundo en contar desde 0 hasta el valor máximo antes de comenzar el siguiente ciclo. Si especificamos una frecuencia de 1000 Hz, el temporizador sólo necesita 1 milisegundo para contar desde 0 hasta el valor máximo.

El ESP32 puede generar una señal PWM con una frecuencia de hasta 40 MHz.

resolución pwm

¿Qué es exactamente este valor “máximo”? El valor “máximo” está determinado por el resolución pwmSi la resolución PWM es de “n” bits, el temporizador cuenta de 0 a 2^norte-1 antes de que se reinicie. Por ejemplo, si configuramos el temporizador con una frecuencia de 1 Hz y una resolución de 8 bits, el temporizador tardará 1 segundo en contar de 0 a 255 (2^octavo). A una frecuencia de 1 Hz y una resolución de 16 bits, el temporizador todavía dura 1 segundo, pero cuenta de 0 a 65.535 (2^dieciséis).

Es importante comprender que a mayor resolución esencialmente tenemos más «incrementos de temporizador» dentro del mismo período de tiempo especificado. Entonces lo que tenemos es más «la granularidad“ en la información del tiempo.

La resolución PWM del ESP32 se puede ajustar de 1 a 16 bits. Esto significa que el ciclo de trabajo se puede aumentar hasta 65.536 (2^dieciséis) niveles diferentes. Por ejemplo, tiene la opción de encender LED con sutiles diferencias de brillo o hacer funcionar motores a velocidades muy precisas.

nivel de utilización

A continuación definimos el nivel de utilización de la salida PWM. El ciclo de trabajo es la cantidad de tics del temporizador que la salida PWM permanece alta antes de pasar a BAJA. Este valor se almacena en el registro de captura/comparación (CCR) del temporizador.

Cuando se reinicia el temporizador, la salida PWM aumenta. Cuando el temporizador alcanza el valor almacenado en el registro de captura/comparación, la salida PWM baja. Sin embargo, el cronómetro sigue contando. Una vez que el temporizador alcanza su valor máximo, la salida PWM vuelve a ser alta y el temporizador se reinicia para comenzar a contar para el siguiente período.

Por ejemplo, imaginemos que queremos generar una señal PWM con una frecuencia de 1000 Hz, resolución de 8 bits y un ciclo de trabajo del 75%. Con resolución de 8 bits, el valor máximo del temporizador es 255 (2^octavo-1). A una frecuencia de 1000 Hz, el temporizador tarda 1 ms (0,001 s) en contar de 0 a 255. El ciclo de trabajo del PWM está establecido en 75%, lo que significa que el valor 256 * 75% = 192 se almacena en el registro de captura/comparación. En este caso, la salida PWM se establece en alta cuando se reinicia el temporizador. La salida PWM permanece alta hasta que el contador llega a 192 y luego baja. Una vez que el temporizador llega a 255, la salida PWM vuelve a ser alta y el temporizador se reinicia para comenzar a contar para el siguiente período.

canales pwm

Ahora pasemos al concepto de canal. Un canal representa una señal de salida PWM única.

El ESP32 tiene 16 canales, lo que significa que puede generar 16 formas de onda PWM únicas. Estos canales se dividen en dos grupos de 8 canales cada uno: 8 canales de alta velocidad y 8 canales de baja velocidad.

Los canales de alta velocidad se implementan en hardware y, por lo tanto, pueden realizar cambios automáticos y sin problemas en el ciclo de trabajo de PWM. Los canales de baja velocidad, por otro lado, no tienen estas características y dependen del software para modificar su ciclo de trabajo.

Dentro de cada grupo, 8 canales comparten 4 temporizadores, lo que significa que dos canales comparten el mismo temporizador. Dado que el temporizador determina la frecuencia, es importante comprender que no podemos ajustar de forma independiente la frecuencia de cada canal dentro de un par. Sin embargo, podemos controlar el ciclo de trabajo PWM de cada canal de forma independiente.

En resumen, un ESP32 tiene 16 canales PWM que pueden operar en ocho frecuencias diferentes, y cada uno de estos canales puede operar en un ciclo de trabajo diferente.

Para generar una señal PWM en un pin específico, «conecte» ese pin a un canal. Este enlace le indica al ESP32 que emita la forma de onda PWM generada por el canal en el pin especificado. Se pueden conectar varios pines al mismo canal, lo que significa que todos pueden emitir la misma señal PWM. Aunque todos los pines GPIO admiten salida PWM, el ESP32 solo tiene 16 canales, por lo que solo se pueden generar 16 formas de onda PWM diferentes al mismo tiempo. Esto no limita la cantidad de pines que pueden emitir señales PWM, pero sí limita la variedad de señales que pueden emitirse simultáneamente.

En la práctica, si tiene un conjunto de LED que desea que parpadeen en perfecta sincronización, puede configurar un solo canal con una frecuencia y un ciclo de trabajo específicos y luego conectar todos los pines relevantes (aquellos conectados a los LED) a ese canal. Sin embargo, cuando se trabaja con servos, especialmente en situaciones como un brazo robótico donde cada articulación (servo) debe controlarse de forma independiente, es beneficioso asignar diferentes pines a diferentes canales.

Selección de frecuencia y resolución PWM.

El ESP32 puede generar una señal PWM con una frecuencia de hasta 40 MHz, con la resolución PWM ajustable de 1 a 16 bits. Pero eso no significa que puedas configurar una frecuencia de 40 MHz y una resolución de 16 bits al mismo tiempo. Porque la frecuencia máxima de PWM y la resolución dependen de la fuente del reloj.

Para ilustrar esto, consideremos un reloj (ya sea un reloj de CPU o un temporizador) que funciona a una frecuencia de 40 MHz. En este caso, la frecuencia PWM máxima alcanzable también es de 40 MHz. No podemos generar una onda PWM más rápido de lo que permite nuestro reloj.

¿Y qué pasa con la resolución? Bueno, la resolución en realidad se trata de cuán finamente podemos dividir un período de la onda PWM en diferentes ciclos de trabajo. Y aquí está la conclusión: dividir la onda PWM requiere sincronización de la CPU con PWM_freq * 2^{Resolución_PWM}. ¿Por qué? Porque para crear estos ciclos de trabajo es necesario poder crear estos intervalos de tiempo.

Esto deja claros dos puntos importantes:

• Frecuencia_PWM * 2^{Resolución_PWM} no puede exceder la frecuencia del reloj.
• La frecuencia y la resolución de PWM son interdependientes. Cuanto mayor sea la frecuencia PWM, menor será la resolución del ciclo de trabajo (y viceversa).

Respectivamente Documentación expresivaLa fuente del reloj del temporizador de baja velocidad LEDC es un reloj APB de 80 MHz. Como pauta general, debes mantener PWM_freq * 2^{Resolución_PWM} por debajo de 80 MHz.

Además, la documentación de Espressif contiene ejemplos que lo demuestran:

• Una frecuencia PWM de 5 kHz puede tener una resolución de ciclo de trabajo máxima de 13 bits, lo que da como resultado una resolución de ~0,012 % o 2.¹³=8192 niveles discretos.
• A una frecuencia PWM de 20 MHz, la resolución máxima del ciclo de trabajo puede ser de 2 bits, lo que corresponde a una resolución del 25%, es decir, 2²=4 niveles discretos.
• Una frecuencia PWM de 40 MHz puede tener una resolución de ciclo de trabajo de tan solo 1 bit, lo que significa que el ciclo de trabajo permanece fijo en el 50 % y no se puede ajustar.

Si nada de esto tiene sentido para usted, considere esto: Arduino Uno ofrece una forma de onda PWM de ~490 Hz a 8 bits. Eso es más que suficiente para atenuar un LED de manera uniforme. Así que siempre puedes empezar por ahí (frecuencia de 500 Hz, resolución de 8 bits) y luego experimentar.

Generar señal PWM con la biblioteca LEDC

¡Comencemos ahora mismo! El núcleo ESP32 Arduino incluye la biblioteca LEDClo que facilita la gestión de la modulación de ancho de pulso (PWM) en el ESP32. Si bien la biblioteca LEDC está diseñada para controlar LED, también se puede utilizar para otras aplicaciones donde las formas de onda PWM son útiles, como por ejemplo: B. la salida de “música” a través de parlantes piezoeléctricos y el accionamiento de motores.

Los siguientes pasos muestran cómo generar una señal PWM con el ESP32 usando la biblioteca LEDC usando el IDE de Arduino.

1. Seleccionar un canal PWM: Hay 16 canales para elegir, numerados del 0 al 15.
2. Determinar la frecuencia PWM: Puede llegar hasta 40 MHz, pero para nuestro ejemplo de desvanecimiento de LED una frecuencia de 500 Hz debería ser suficiente.
3. Determinar la resolución PWM: Varía de 1 a 16 bits. El número de etapas del ciclo de trabajo discreto está determinado por 2^resolución. Por ejemplo, si configura la resolución en 8 bits, obtendrá 256 niveles de ciclo de trabajo discretos. [0–255]. Por otro lado, la resolución de 16 bits proporciona 65.536 niveles de ciclo de trabajo discretos. [0–65535].
4. Seleccione los pines GPIO: Seleccione uno o más pines GPIO en el ESP32 para emitir la señal PWM.
5. Configurando el canal PWM: Configure el canal PWM seleccionado con la frecuencia y resolución seleccionadas a través del ledcSetup(canal, frecuencia, resolución) Función.
6. Fije los pasadores al canal.: Conecte los pines seleccionados al canal seleccionado usando el ledcAttachPin(pin, canal) Función.
7. Configuración del ciclo de trabajo: Finalmente, configure el valor del ciclo de trabajo real para un canal específico usando el ledcWrite(canal, ciclo de trabajo) Función.

Ejemplo 1: atenuar un LED

Aquí hay un boceto de ejemplo rápido que muestra cómo atenuar un LED, perfecto para demostrar la generación de PWM en el ESP32.

alambrado

El cableado es muy sencillo. Tome un LED y una resistencia limitadora de corriente de 330 Ω y conéctelos a la placa como se muestra en la imagen a continuación. Conecte la pata más larga del LED, el ánodo, a través de la resistencia de 330 Ω al pin GP18 y la pata más corta al pin de tierra de su ESP32.

código

Copie el siguiente código en su IDE de Arduino.

const int PWM_CHANNEL = 0;    // ESP32 has 16 channels which can generate 16 independent waveforms
const int PWM_FREQ = 500;     // Recall that Arduino Uno is ~490 Hz. Official ESP32 example uses 5,000Hz
const int PWM_RESOLUTION = 8; // We'll use same resolution as Uno (8 bits, 0-255) but ESP32 can go up to 16 bits 

// The max duty cycle value based on PWM resolution (will be 255 if resolution is 8 bits)
const int MAX_DUTY_CYCLE = (int)(pow(2, PWM_RESOLUTION) - 1); 

const int LED_OUTPUT_PIN = 18;

const int DELAY_MS = 4;  // delay between fade increments

void setup() {

  // Sets up a channel (0-15), a PWM duty cycle frequency, and a PWM resolution (1 - 16 bits) 
  // ledcSetup(uint8_t channel, double freq, uint8_t resolution_bits);
  ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RESOLUTION);

  // ledcAttachPin(uint8_t pin, uint8_t channel);
  ledcAttachPin(LED_OUTPUT_PIN, PWM_CHANNEL);
}

void loop() {

  // fade up PWM on given channel
  for(int dutyCycle = 0; dutyCycle <= MAX_DUTY_CYCLE; dutyCycle++){   
    ledcWrite(PWM_CHANNEL, dutyCycle);
    delay(DELAY_MS);
  }

  // fade down PWM on given channel
  for(int dutyCycle = MAX_DUTY_CYCLE; dutyCycle >= 0; dutyCycle--){
    ledcWrite(PWM_CHANNEL, dutyCycle);   
    delay(DELAY_MS);
  }
}

Probando el ejemplo

Ahora sube el código a tu ESP32. Observará que el brillo del LED cambia suavemente de completamente apagado a completamente encendido y viceversa.

Explicación del código:

Al comienzo del boceto, se definen varias constantes para configurar las propiedades de PWM. primero la constante PWM_CHANNEL está definido y establecido en 0. ESP32 tiene 16 canales (0 a 15) y cada uno puede generar formas de onda independientes.

Entonces, PWM_FREQ está definido y establecido en 500. Esta es la frecuencia de nuestra señal PWM. Recuerde que el Arduino Uno usa ~490 Hz. Esto es suficiente para atenuar suavemente un LED.

Próximo, PWM_RESOLUTION se establece en 8. Esta es la resolución (en bits) de la señal PWM. Si bien usamos 8 bits (como Arduino Uno), ESP32 puede llegar hasta 16 bits.

const int PWM_CHANNEL = 0;
const int PWM_FREQ = 500;
const int PWM_RESOLUTION = 8;

Después de eso, MAX_DUTY_CYCLE se calcula usando la fórmula 2^{PWM_RESOLUCIÓN}−1. Este valor determina el ciclo de trabajo máximo alcanzable en función de la resolución elegida.

const int MAX_DUTY_CYCLE = (int)(pow(2, PWM_RESOLUTION) - 1);

Después LED_OUTPUT_PIN está fijado en 18. Este es el pin GPIO ESP32 al que está conectado el LED.

Y finalmente, DELAY_MS está definido y establecido en 4. Este es el retraso (en milisegundos) entre incrementos para controlar la velocidad de desvanecimiento del LED.

const int LED_OUTPUT_PIN = 18;
const int DELAY_MS = 4;

Durante la configuración el ledcSetup() Se llama a la función para configurar las propiedades de PWM con las constantes definidas previamente. Esta función toma tres argumentos: el canal PWM, la frecuencia PWM y la resolución PWM.

ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RESOLUTION);

Próximo ledcAttachPin() Con esta función, el pin GPIO se conecta al canal PWM, que es el encargado de generar la señal PWM. En este caso el de PWM_CHANNELque corresponde al canal 0 aparece en LED_OUTPUT_PINque corresponde a GPIO 16.

ledcAttachPin(LED_OUTPUT_PIN, PWM_CHANNEL);

El bucle será el primero. for El bucle aumenta iterativamente el ciclo de trabajo desde 0 hasta el valor máximo posible (MAX_DUTY_CYCLE). Esto hace que el LED se vuelva más brillante gradualmente.

for(int dutyCycle = 0; dutyCycle <= MAX_DUTY_CYCLE; dutyCycle++){   
  ledcWrite(PWM_CHANNEL, dutyCycle);
  delay(DELAY_MS);
}

El segundo for El bucle disminuye el ciclo de trabajo de MAX_DUTY_CYCLE a 0: Esto atenúa el LED gradualmente.

for(int dutyCycle = MAX_DUTY_CYCLE; dutyCycle >= 0; dutyCycle--){
  ledcWrite(PWM_CHANNEL, dutyCycle);   
  delay(DELAY_MS);
}

En ambos bucles for ledcWrite() Esta función se utiliza para ajustar el brillo del LED. Esta función acepta como argumentos el canal que genera la señal y el ciclo de trabajo.

ledcWrite(ledChannel, dutyCycle);

Ejemplo 2: la misma señal PWM en varios GPIO

Puede recibir la misma señal PWM en varios GPIO al mismo tiempo. Para hacer esto simplemente necesitas conectar estos GPIO al mismo canal.

alambrado

Agregue dos LED más a su circuito de la misma manera que el primero. Conéctelos a GPIO 19 y 21.

La siguiente imagen muestra cómo está todo conectado.

código

Ahora modifiquemos el ejemplo anterior para atenuar tres LED con la misma señal PWM del mismo canal.

const int PWM_CHANNEL = 0;    // ESP32 has 16 channels which can generate 16 independent waveforms
const int PWM_FREQ = 500;     // Recall that Arduino Uno is ~490 Hz. Official ESP32 example uses 5,000Hz
const int PWM_RESOLUTION = 8; // We'll use same resolution as Uno (8 bits, 0-255) but ESP32 can go up to 16 bits 

// The max duty cycle value based on PWM resolution (will be 255 if resolution is 8 bits)
const int MAX_DUTY_CYCLE = (int)(pow(2, PWM_RESOLUTION) - 1); 

const int LED_1_OUTPUT_PIN = 18;
const int LED_2_OUTPUT_PIN = 19;
const int LED_3_OUTPUT_PIN = 21;

const int DELAY_MS = 4;  // delay between fade increments

void setup() {

  // Sets up a channel (0-15), a PWM duty cycle frequency, and a PWM resolution (1 - 16 bits) 
  // ledcSetup(uint8_t channel, double freq, uint8_t resolution_bits);
  ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RESOLUTION);

  // ledcAttachPin(uint8_t pin, uint8_t channel);
  ledcAttachPin(LED_1_OUTPUT_PIN, PWM_CHANNEL);
  ledcAttachPin(LED_2_OUTPUT_PIN, PWM_CHANNEL);
  ledcAttachPin(LED_3_OUTPUT_PIN, PWM_CHANNEL);
}

void loop() {

  // fade up PWM on given channel
  for(int dutyCycle = 0; dutyCycle <= MAX_DUTY_CYCLE; dutyCycle++){   
    ledcWrite(PWM_CHANNEL, dutyCycle);
    delay(DELAY_MS);
  }

  // fade down PWM on given channel
  for(int dutyCycle = MAX_DUTY_CYCLE; dutyCycle >= 0; dutyCycle--){
    ledcWrite(PWM_CHANNEL, dutyCycle);   
    delay(DELAY_MS);
  }
}

Probando el ejemplo

Ahora sube el código a tu ESP32. Observará que los tres LED se apagan al mismo tiempo porque todos los GPIO emiten la misma señal PWM.

Explicación del código:

Si comparas este boceto con el primero verás que son muy parecidos y tienen pocas diferencias. Echemos un vistazo a estas diferencias.

En el ámbito global hay tres constantes más llamadas LED_1_OUTPUT_PIN, LED_2_OUTPUT_PINY LED_3_OUTPUT_PIN están definidos y establecidos en 18, 19 y 21 respectivamente. Esto indica que estamos tratando con tres LED separados, cada uno conectado a su propio pin GPIO en el ESP32.

const int LED_1_OUTPUT_PIN = 18;
const int LED_2_OUTPUT_PIN = 19;
const int LED_3_OUTPUT_PIN = 21;

La configuración luego muestra el ledcAttachPin() La función se llama tres veces en lugar de solo una vez como en el código anterior. Cada llamada de función conecta un pin GPIO diferente (LED_1_OUTPUT_PIN, LED_2_OUTPUT_PIN, LED_3_OUTPUT_PIN) con el mismo canal PWM (PWM_CHANNEL), es decir, se emite la misma señal PWM a los tres LED.

ledcAttachPin(LED_1_OUTPUT_PIN, PWM_CHANNEL);
ledcAttachPin(LED_2_OUTPUT_PIN, PWM_CHANNEL);
ledcAttachPin(LED_3_OUTPUT_PIN, PWM_CHANNEL);

Tenga en cuenta que a pesar de agregar más LED, nada cambia loop() Función. Esto se debe a que el mismo canal PWM controla todos los LED.

Ejemplo 3: atenuar un LED con el potenciómetro

Este boceto de ejemplo le muestra cómo atenuar un LED con el potenciómetro.

alambrado

Retire los dos LED adicionales que agregó a su circuito y agregue un potenciómetro. Conecte un pin exterior del potenciómetro a 3,3 V, el pin exterior opuesto a GND y el pin central (limpiador) a GPIO 34.

La siguiente imagen muestra cómo está todo conectado.

código

const int PWM_CHANNEL = 0;    // ESP32 has 16 channels which can generate 16 independent waveforms
const int PWM_FREQ = 500;     // Recall that Arduino Uno is ~490 Hz. Official ESP32 example uses 5,000Hz
const int PWM_RESOLUTION = 8; // We'll use same resolution as Uno (8 bits, 0-255) but ESP32 can go up to 16 bits 

// The max duty cycle value based on PWM resolution (will be 255 if resolution is 8 bits)
const int MAX_DUTY_CYCLE = (int)(pow(2, PWM_RESOLUTION) - 1); 

const int LED_OUTPUT_PIN = 18;
const int POT_PIN = 34;

const int DELAY_MS = 100;  // delay between fade increments

void setup() {

  // Sets up a channel (0-15), a PWM duty cycle frequency, and a PWM resolution (1 - 16 bits) 
  // ledcSetup(uint8_t channel, double freq, uint8_t resolution_bits);
  ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RESOLUTION);

  // ledcAttachPin(uint8_t pin, uint8_t channel);
  ledcAttachPin(LED_OUTPUT_PIN, PWM_CHANNEL);
}

void loop() {
  int dutyCycle = analogRead(POT_PIN);
  dutyCycle = map(dutyCycle, 0, 4095, 0, MAX_DUTY_CYCLE);
  ledcWrite(PWM_CHANNEL, dutyCycle);

  delay(DELAY_MS);
}

Probando el ejemplo

Ahora intente girar el potenciómetro completamente en una dirección y luego en la otra. Mira el LED. Esta vez verás que el brillo del LED cambia suavemente, desde completamente apagado en un extremo de la perilla del potenciómetro hasta completamente iluminado en el otro extremo.

Explicación del código:

¡De nuevo! Hay pocas diferencias entre este boceto y el primero. Echemos un vistazo a estas diferencias.

Una constante adicional llamada POT_PIN está definido en el ámbito global. Está configurado en 34, lo que significa que el potenciómetro está conectado al GPIO 34 en el ESP32 y se usa para determinar dinámicamente el ciclo de trabajo y, por lo tanto, el brillo del LED.

const int POT_PIN = 34;

Luego, en el bucle, en lugar de bucles for, habrá una función para aumentar y disminuir gradualmente el brillo del LED. analogRead(POT_PIN) llamado, que toma un valor bruto del potenciómetro.

int dutyCycle = analogRead(POT_PIN);

La lectura del potenciómetro, que oscila entre 0 y 4095, se asigna a un nuevo rango que oscila entre 0 y 4095. MAX_DUTY_CYCLE Uso de map() Función. Este mapeo alinea los valores del potenciómetro con los valores del ciclo de trabajo permitidos de la señal PWM. Esto garantiza que el brillo del LED se pueda cambiar en todo el rango.

dutyCycle = map(dutyCycle, 0, 4095, 0, MAX_DUTY_CYCLE);

Finalmente, esto ledcWrite() La función toma este valor mapeado y lo aplica directamente a la señal PWM, ajustando el brillo del LED en tiempo real según la posición del potenciómetro.

ledcWrite(PWM_CHANNEL, dutyCycle);

Conceptos básicos de ESP32: generar señal PWM en el ESP32

Si has experimentado con Arduino antes, seguramente estás familiarizado con lo sencillo que es generar una señal PWM utilizando la función analogWrite(): simplemente especificas el pin a utilizar y el ciclo de trabajo, ¡y listo!

Sin embargo, con el ESP32, es como jugar en un nivel un poco más difícil. Tenemos más controles (¡sí!), pero también tenemos que gestionarlos sabiamente (lo cual es un poco complicado). El ESP32 nos pide que seamos específicos sobre algunas cosas más, como la frecuencia de PWM, la resolución de PWM, el canal a utilizar, y, por supuesto, el ciclo de trabajo y el número de pin. ¡Uff, suena como mucho, pero no te preocupes!

Preguntas frecuentes

¿Cuáles son los pines PWM en el ESP32?

En el ESP32, la salida PWM es posible en todos los pines GPIO, excepto en cuatro pines GPIO que son solo de entrada. Los GPIO resaltados a continuación admiten PWM.

¿Qué periféricos PWM tiene el ESP32?

El ESP32 tiene dos periféricos PWM: el Periférico de Control de LED (LEDC) y el Periférico de Modulador de Ancho de Pulso de Control de Motor (MCPWM).

¿Cuál es la frecuencia máxima de PWM que puede generar el ESP32?

El ESP32 puede generar una señal PWM con una frecuencia de hasta 40 MHz.

¿Qué es la resolución PWM y cómo se ajusta en el ESP32?

La resolución de PWM en el ESP32 se puede ajustar de 1 a 16 bits. Esto significa que el ciclo de trabajo se puede ajustar hasta en 65,536 (2^16) niveles diferentes.

¿Cómo puedo generar una señal PWM en el ESP32 utilizando la biblioteca LEDC?

Para generar una señal PWM en el ESP32, puedes utilizar la biblioteca LEDC. Simplemente selecciona un canal PWM, determina la frecuencia PWM y la resolución, elige el pin GPIO y configura el canal PWM con esa configuración. Luego configura el ciclo de trabajo y listo.

¿Cómo puedo ajustar la luminosidad de un LED con el ESP32?

Para ajustar la luminosidad de un LED con el ESP32, puedes variar el ciclo de trabajo del PWM. Cuanto mayor sea el ciclo de trabajo, más brillante será el LED, y viceversa.

Conclusión

El ESP32 es una potente plataforma que permite generar señales PWM con una gran flexibilidad y control. Con la biblioteca LEDC, puedes configurar canales PWM, ajustar frecuencias y resoluciones, y controlar diversos dispositivos como LEDs, motores y más.

En resumen, con los conceptos básicos de generación de señal PWM en el ESP32 dominados, ¡estás listo para adentrarte en proyectos más avanzados y emocionantes!