Control PWM con ESP32 y LEDC

Clase 22 de 30 • Curso de IoT: Programación de Microcontroladores ESP32

Clase anteriorSiguiente clase

Victor Armando Avendaño Osorio

student•

Compre el osciloscopio para armar junto con el esp32 <3

Fabio Quimbay

student•

Se ve muy chevere esta práctica con el osciloscopio, podrías por favor sugerirme éste u otro osciloscopio?, pues me gustaría poder también tenerlo para las prácticas. Muchas gracias de antemano!

Jesús Ramon

student•

puede compartir su codigo porfavor

Gabriel Andrés Alzate Acuña

student•

Para responder unas preguntas en los otros comentarios dejo una foto del mismo ejercicio pero manipulando la velocidad de giro de un motor.

El único cambio es que uso el pin 15 de salida porque es el que tengo en la tarjeta con PWM.

El osciloscopio es de bolsillo, es un DSO v3 de la empresa seed studio.

Fabio Quimbay

student•

Buenas noches Profe Diana, para esta pràctica con el ESP32-CAM comprendo que estas usando una fuente externa, no estoy seguro si pueda usar la misma provista por el puerto USB de mi computadora o tal vez sea mejor comprar comprar un regulador de voltage, si asì es .. podrías por favor sugerirme alguno en particular? De antemano, muchas gracias!

Diana Martinez

student•

Únicamente es un cable USB con un cargador de celular cualquiera, pues la tarjeta funciona a 5V y la corriente consumida en este curso es mínima.

Julio Cardenas

student•

No tengo potenciometro pero lo simule con una funcion. . Segui el ejemplo del manual .

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "driver/adc.h"
#include "esp_adc_cal.h"
#include "driver/ledc.h"

#define LED_PIN       25
#define LED_RED_PIN   4
#define LED_GREEN_PIN 0
#define LED_BLUE_PIN  12

#define SW_KY040_PIN  34 

bool state_led   = false;
bool state_red   = false;
bool state_green = false;
bool state_blue  = false;


const TickType_t blink_delay    = 1000 / portTICK_PERIOD_MS;
const TickType_t debounce_delay =   50 / portTICK_PERIOD_MS;
const TickType_t digital_delay  =  100 / portTICK_PERIOD_MS;
const TickType_t battVolt_delay = 2000 / portTICK_PERIOD_MS;
const TickType_t pwm_delay =       500 / portTICK_PERIOD_MS;

TaskHandle_t ledHandle;
TaskHandle_t swky040Handle;
TaskHandle_t battVoltHandle;
TaskHandle_t pwmHandle;

uint32_t raw_value;
uint32_t milivolts;
static esp_adc_cal_characteristics_t adc1_chars;

//en el cado del gpio35 el divisor de voltaje esta compuesto por dos resistencias de 100k
// Esto quiere decir que llega mitad del voltaje de la bateria.
// Para obtener el valor correcto hay que multiplicar el valor medido por dos
// como el valor del voltaje medido es milivoltios  para obtener los voltios hay que
// dividir por 1000. De hay el factor de conversion de 0.002 
double voltage_divider_factor = 0.002;
double battery_volt;

int32_t duty_cycle   = 0;
int32_t dc_increment = 64;

void refresh_led(void *args)
{
    while (true)
    {
        state_led = !state_led;
        gpio_set_level(LED_PIN, state_led);
        vTaskDelay(blink_delay);
    }     
}

void refresh_swky040(void *args) 
{
    while (true)
    {    
        //El switch esta conectado en pull up
        //su estado normal es alto
        //cuando se oprime su estado es bajo    
        state_red = gpio_get_level(SW_KY040_PIN);
        gpio_set_level(LED_RED_PIN, !state_red);
        if (!state_red) vTaskDelay(debounce_delay);
        vTaskDelay(digital_delay);
    }
}

void refresh_battVolt(void *args) 
{
    while (true)
    {    
        raw_value = adc1_get_raw(ADC1_CHANNEL_7);
        milivolts = esp_adc_cal_raw_to_voltage(raw_value, &adc1_chars);
        battery_volt = milivolts;
        battery_volt = battery_volt * voltage_divider_factor;
        printf("raw value: %ld milivolts: %ld battery: %f\n",raw_value, milivolts, battery_volt);
        vTaskDelay(battVolt_delay);
    }
}

void refresh_pwm_led(void *args)
{
    while (true)
    {
        duty_cycle = duty_cycle + dc_increment;
        if (duty_cycle > 4096)
        {
            duty_cycle = 4095;
            dc_increment = - dc_increment;
        }
        if (duty_cycle < 0)
        {
            duty_cycle = 0;
            dc_increment = - dc_increment;
        }
        ESP_ERROR_CHECK(ledc_set_duty(LEDC_HIGH_SPEED_MODE, LEDC_CHANNEL_0, duty_cycle));
        ESP_ERROR_CHECK(ledc_update_duty(LEDC_HIGH_SPEED_MODE, LEDC_CHANNEL_0));       
        vTaskDelay(pwm_delay);
    }
}


void app_main(void)
{
    //reset pines de salida
    gpio_reset_pin(LED_PIN);

    gpio_reset_pin(LED_RED_PIN);
    //gpio_reset_pin(LED_GREEN_PIN);
    gpio_reset_pin(LED_BLUE_PIN);
    
    // coloca los pines en estado de salida o entrada
    gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
    
    gpio_set_direction(LED_RED_PIN, GPIO_MODE_OUTPUT);
    //gpio_set_direction(LED_GREEN_PIN, GPIO_MODE_OUTPUT);
    gpio_set_direction(LED_BLUE_PIN, GPIO_MODE_OUTPUT);
    
    gpio_set_direction(SW_KY040_PIN, GPIO_MODE_INPUT);

    //coloca los leds rgb en apagado
    gpio_set_level(LED_RED_PIN,   state_red);
    //gpio_set_level(LED_GREEN_PIN, state_green);
    gpio_set_level(LED_BLUE_PIN,  state_blue);


    //En el chip Lora32, esp32 con radio LORA, OLED Display, cargador bateria LIPO:
    //El gpio35 lee a traves de un divisor de 2 resistencias de 100k el voltaje de la
    //   bateria.
    //El gpio35 corresponde al ADC1_CHANNEL7

    //calibramos el adc1
    esp_adc_cal_characterize(
        ADC_UNIT_1,             //apuntamos al adc 1
        ADC_ATTEN_DB_11,        //Rango lineal entre 150-2450 mv
        ADC_WIDTH_BIT_12,       //0 a 4095
        0,                      //
        &adc1_chars);           //resultado de la calibracion 

    ESP_ERROR_CHECK(adc1_config_width(ADC_WIDTH_BIT_12));  
    ESP_ERROR_CHECK(adc1_config_channel_atten(ADC1_CHANNEL_7, ADC_ATTEN_DB_11));  
    

    //pwm timer config 
    ledc_timer_config_t ledc_timer = {
        .speed_mode       = LEDC_HIGH_SPEED_MODE,
        .duty_resolution  = LEDC_TIMER_12_BIT,
        .timer_num        = LEDC_TIMER_0,
        .freq_hz          = 4000,  // Set output frequency at 4 kHz
        .clk_cfg          = LEDC_AUTO_CLK
    };
    ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer));

    // Prepare and then apply the LEDC PWM channel configuration
    ledc_channel_config_t ledc_channel = {
        .speed_mode     = LEDC_HIGH_SPEED_MODE,
        .channel        = LEDC_CHANNEL_0,
        .timer_sel      = LEDC_TIMER_0,
        .intr_type      = LEDC_INTR_DISABLE,
        .gpio_num       = LED_GREEN_PIN,
        .duty           = 0, // Set duty to 0%
        .hpoint         = 0
    };
    ESP_ERROR_CHECK(ledc_channel_config(&ledc_channel));

    //creamos la tarea asociandola al segundo core
    xTaskCreatePinnedToCore(
        refresh_led,    //Nombre de la funcion que implementa la tarea
        "refresh_led",  //Nombre descriptivo de la tarea con fines de debugging
        2048,           //El tamaño del task stack en bytes
        NULL,           //pointer a un parametro cuando la tarea esta siendo creada
        5,              //Prioridad de la tarea un numero
        &ledHandle,     //apuntador para referenciar la tarea. 
        1               // core 0 y core 1
    );

    xTaskCreatePinnedToCore(
        refresh_swky040,   //Nombre de la funcion que implementa la tarea
        "refresh_swky040", //Nombre descriptivo de la tarea con fines de debugging
        2048,              //El tamaño del task stack en bytes
        NULL,              //pointer a un parametro cuando la tarea esta siendo creada
        10,                //Prioridad de la tarea un numero
        &swky040Handle,    //apuntador para referenciar la tarea. 
        1                  // core 0 y core 1
    );
    
    xTaskCreatePinnedToCore(
        refresh_battVolt,   //Nombre de la funcion que implementa la tarea
        "refresh_battVolt", //Nombre descriptivo de la tarea con fines de debugging
        2048,              //El tamaño del task stack en bytes
        NULL,              //pointer a un parametro cuando la tarea esta siendo creada
        5,                 //Prioridad de la tarea un numero
        &battVoltHandle,        //apuntador para referenciar la tarea. 
        1                  // core 0 y core 1
    );
   
   xTaskCreatePinnedToCore(
        refresh_pwm_led,   //Nombre de la funcion que implementa la tarea
        "refresh_pwm_led", //Nombre descriptivo de la tarea con fines de debugging
        2048,              //El tamaño del task stack en bytes
        NULL,              //pointer a un parametro cuando la tarea esta siendo creada
        5,                 //Prioridad de la tarea un numero
        &pwmHandle,        //apuntador para referenciar la tarea. 
        1                  // core 0 y core 1
    );
   
}

José Alberto Raygada Agüero

student•

Definitivamente con un oscilador se puede apreciar mucho mejor lo interesante de esta práctica. Los osciladores profesionales son bastante caros pero uno como este (tipo mini para principiantes) se puede conseguir en Amazon en un rango de precios entre $50 y $150 bajo la descripción de pocket Digital Storage Oscillator (DSO).

Javier Bornia

student•

Alguien podria dar un ejemplo de como se migra este codigo adc_oneshot y adc_continuous, ya que el driver/adc.h esta deprecado?

Jesús Daniel Garza Camarena

student•

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "esp_adc/adc_oneshot.h"
#include "driver/adc.h"
#include "driver/ledc.h" //PWM

#define LEDC_TIMER     LEDC_TIMER_0// Timer que usarémos
#define LEDC_MODE      LEDC_HIGH_SPEED_MODE // Modo de velocidad
#define LEDC_OUTPUT    2 // Pin de salida
#define LEDC_CHANNEL   LEDC_CHANNEL_0 // Canal de control
#define LEDC_DUTY_RES  LEDC_TIMER_12_BIT // Resolución en bits
#define LEDC_FREQUENCY 5000 // Frecuencia de funcionamiento
#define LEDC_DUTY      0 // Valor inicial
#define LEDC_HPOINT    0 // Ajuste de fase

//D35 - ADC1_7
#define EXAMPLE_ADC1_CHAN34 ADC_CHANNEL_7       //Canal ADC a utilizar
#define EXAMPLE_ADC_ATTEN ADC_ATTEN_DB_11       //Atenuacion de la señal de entrada


adc_oneshot_unit_handle_t adc1_handle;          //Configuracion de la entrada analoga digital, variable tipo oneshot

adc_oneshot_unit_init_cfg_t init_config1 = {    //Configuracion general del ADC
    .unit_id = ADC_UNIT_1,                      //Uso del ADC1
    .ulp_mode = ADC_ULP_MODE_DISABLE,           //modo bajo consumo de energia desactivado
};

adc_oneshot_chan_cfg_t config = {               //Parametros especificos del ADC
    .atten = EXAMPLE_ADC_ATTEN,                 //Atenuacion
    .bitwidth = ADC_BITWIDTH_12,                //Ancho de bits
};

static int raw_value;

void app_main(void)
{
  ledc_timer_config_t ledc_timer = 
  {
    .speed_mode      = LEDC_MODE,
    .timer_num       = LEDC_TIMER,
    .duty_resolution = LEDC_DUTY_RES,
    .freq_hz         = LEDC_FREQUENCY,
    .clk_cfg         = LEDC_AUTO_CLK
  };
  
  ledc_timer_config(&ledc_timer);//pasa toda la estructura

  ledc_channel_config_t ledc_channel = 
  {
    .speed_mode = LEDC_MODE,
    .channel    = LEDC_CHANNEL,
    .timer_sel  = LEDC_CHANNEL,
    .intr_type  = LEDC_INTR_DISABLE,
    .gpio_num   = LEDC_OUTPUT,
    .duty       = LEDC_DUTY,
    .hpoint     = LEDC_HPOINT
  };

  ledc_channel_config(&ledc_channel);
  
    //Nuevo instancia ADC con las configuraciones establecidas anteriormente
    ESP_ERROR_CHECK(adc_oneshot_new_unit(&init_config1, &adc1_handle));

    //Uso del canal especifico con la configuracion
    adc_oneshot_config_channel(adc1_handle,EXAMPLE_ADC1_CHAN34, &config);

    while(1)
    {
        //Lectura del valor analogico  con la funcion adc_one_shot_read
        ESP_ERROR_CHECK(adc_oneshot_read(adc1_handle, EXAMPLE_ADC1_CHAN34, &raw_value));    //(identificador de instancia,canal de instancia a leer, lugar donde se guardará la variable)    
        
        //Impresion del valor 
        printf("adc raw: %d\n", raw_value);
        ledc_set_duty(LEDC_MODE, LEDC_CHANNEL, raw_value);
        ledc_update_duty(LEDC_MODE, LEDC_CHANNEL);
        //Retraso
        vTaskDelay(200/portTICK_PERIOD_MS);
    }

    adc_oneshot_del_unit(adc1_handle);      //Gestion de memoria y recursos (eliminar/liberar)
}

Gabriel Obregón

student•

Implementación de una Señal PWM en ESP32

1. Introducción

En esta práctica, aprenderemos a generar una señal PWM (Modulación por Ancho de Pulso) con ESP32 usando Visual Studio Code. Para ello, utilizaremos un circuito que ya empleamos en la lectura de señales analógicas, modificándolo para generar una salida PWM que nos permitirá controlar la intensidad de un LED a través de un potenciómetro.

2. Configuración del Entorno y Circuito

Antes de comenzar con el código, asegurémonos de contar con:

ESP32 correctamente conectada.
Potenciómetro para la entrada analógica.
LED conectado a un pin de salida PWM.
Documentación del pinout de la placa para seleccionar pines adecuados.

3. Lectura de Señal Analógica

El siguiente código permite leer un valor analógico y mostrarlo en la consola:

#include <stdio.h>

#include "freertos/FreeRTOS.h"

#include "freertos/task.h"

#include "driver/adc.h"

void app_main(void) {

int32_t raw_value;

adc2_config_channel_atten(ADC2_CHANNEL_6, ADC_ATTEN_DB_0);

while (1) {

adc2_get_raw(ADC2_CHANNEL_6, ADC_WIDTH_BIT_12, &raw_value);

printf("adc raw: %d\n", raw_value);

vTaskDelay(1000 / portTICK_PERIOD_MS);

}

4. Configuración del PWM en ESP32

Agregamos la librería necesaria:

#include "driver/ledc.h"

Definimos constantes clave:

#define LEDC_TIMER LEDC_TIMER_0

#define LEDC_MODE LEDC_HIGH_SPEED_MODE

#define LEDC_OUTPUT 12

#define LEDC_CHANNEL LEDC_CHANNEL_0

#define LEDC_DUTY_RES LEDC_TIMER_12_BIT

#define LEDC_FREQUENCY 5000

#define LEDC_DUTY 0

#define LEDC_HPOINT 0

Configuración del Temporizador (Timer)

ledc_timer_config_t ledc_timer = {

.speed_mode = LEDC_MODE,

.timer_num = LEDC_TIMER,

.duty_resolution = LEDC_DUTY_RES,

.freq_hz = LEDC_FREQUENCY,

.clk_cfg = LEDC_AUTO_CLK

};

ledc_timer_config(&ledc_timer);

Configuración del Canal PWM

ledc_channel_config_t ledc_channel = {

.speed_mode = LEDC_MODE,

.channel = LEDC_CHANNEL,

.timer_sel = LEDC_TIMER,

.intr_type = LEDC_INTR_DISABLE,

.gpio_num = LEDC_OUTPUT,

.duty = LEDC_DUTY,

.hpoint = LEDC_HPOINT

};

ledc_channel_config(&ledc_channel);

5. Implementación de la Señal PWM

Dentro del bucle principal, ajustamos el PWM según la entrada analógica:

while (1) {

adc2_get_raw(ADC2_CHANNEL_6, ADC_WIDTH_BIT_12, &raw_value);

printf("adc raw: %d\n", raw_value);

ledc_set_duty(LEDC_MODE, LEDC_CHANNEL, raw_value);

ledc_update_duty(LEDC_MODE, LEDC_CHANNEL);

vTaskDelay(1000 / portTICK_PERIOD_MS);

}

Carlos Andres Betancourt Perez

student•

comparto el codigo con algunas optimizaciones, ya que no comprendo para que definio la estructura de ledc_channel si en los parametros de las funciones no le pasa las variables de esa estructura sino puras macros de IDF.

//incluimos las librerias necesarias
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_adc/adc_oneshot.h"
#include "driver/ledc.h"
#include "esp_log.h"

//defines
#define LEDR_PIN      17
#define LEDG_PIN      18
#define LEDB_PIN      5

//variables globales
adc_oneshot_unit_handle_t adc1_handle;
adc_oneshot_unit_init_cfg_t adc1_config = {
    .unit_id = ADC_UNIT_1,
    .ulp_mode = ADC_ULP_MODE_DISABLE,
};
adc_oneshot_chan_cfg_t config = {
    .bitwidth = ADC_BITWIDTH_12,
    .atten = ADC_ATTEN_DB_11,
};

void app_main(void) {
    ledc_timer_config_t ledc_timer = {
        .speed_mode = LEDC_HIGH_SPEED_MODE,
        .timer_num = LEDC_TIMER_0,
        .duty_resolution = LEDC_TIMER_12_BIT,
        .freq_hz = 5000,
        .clk_cfg = LEDC_AUTO_CLK
    };
    ledc_channel_config_t ledr_chnl = {
        .speed_mode = LEDC_HIGH_SPEED_MODE,
        .channel = LEDC_CHANNEL_0,
        .timer_sel = LEDC_TIMER_0,
        .intr_type = LEDC_INTR_DISABLE, //interrupciones deshabilitadas
        .gpio_num = LEDR_PIN,   //pin de salida PWM
        .duty = 0,      //ciclo util inicial
        .hpoint = 0     //ajuste de fase
    };
    ledc_channel_config_t ledg_chnl = {
        .speed_mode = LEDC_HIGH_SPEED_MODE,
        .channel = LEDC_CHANNEL_0,
        .timer_sel = LEDC_TIMER_0,
        .intr_type = LEDC_INTR_DISABLE, //interrupciones deshabilitadas
        .gpio_num = LEDG_PIN,   //pin de salida PWM
        .duty = 0,      //ciclo util inicial
        .hpoint = 0     //ajuste de fase
    };
    ledc_channel_config_t ledb_chnl = {
        .speed_mode = LEDC_HIGH_SPEED_MODE,
        .channel = LEDC_CHANNEL_0,
        .timer_sel = LEDC_TIMER_0,
        .intr_type = LEDC_INTR_DISABLE, //interrupciones deshabilitadas
        .gpio_num = LEDB_PIN,   //pin de salida PWM
        .duty = 0,      //ciclo util inicial
        .hpoint = 0     //ajuste de fase
    };
    int adc_value;
    uint32_t duty_red = 0;
    uint32_t duty_green = 0;
    uint32_t duty_blue = 0;

    //configuramos el timer para el PWM del LED
    ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer));
    //configuramos el canal PWM para el led rojo, verde y azul
    ESP_ERROR_CHECK(ledc_channel_config(&ledr_chnl));
    ESP_ERROR_CHECK(ledc_channel_config(&ledg_chnl));
    ESP_ERROR_CHECK(ledc_channel_config(&ledb_chnl));

    //init ADC1
    ESP_ERROR_CHECK(adc_oneshot_new_unit(&adc1_config, &adc1_handle));
    // config ADC1
    ESP_ERROR_CHECK(adc_oneshot_config_channel(adc1_handle, ADC_CHANNEL_4, &config));

    while (true) {
        //leemos el canal del ADC
        ESP_ERROR_CHECK(adc_oneshot_read(adc1_handle, ADC_CHANNEL_4, &adc_value));
        printf("ADC read value: %d\n", adc_value);

        //ajustamos el ciclo util proporcional al valor analogico leido
        duty_red = 4095 - adc_value;
        duty_green = 4095 - adc_value / 3;
        duty_blue = 4095 - adc_value / 2;

        //actualizamos el ciclo util de los 3 canales PWM
        ledc_set_duty(ledr_chnl.speed_mode, ledr_chnl.channel, duty_red);
        ledc_update_duty(ledr_chnl.speed_mode, ledr_chnl.channel);
        ledc_set_duty(ledg_chnl.speed_mode, ledg_chnl.channel, duty_green);
        ledc_update_duty(ledg_chnl.speed_mode, ledg_chnl.channel);
        ledc_set_duty(ledb_chnl.speed_mode, ledb_chnl.channel, duty_blue);
        ledc_update_duty(ledb_chnl.speed_mode, ledb_chnl.channel);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}
//-------------------------------

Control PWM con ESP32 y LEDC

Introducción

Introducción a los microcontroladores

La importancia de la industria IoT

Tipos de computadoras

Cómo escoger un microcontrolador

Hardware

Características del ESP32

ESP-IDF

Documentación oficial del ESP-IDF

Instalación del ESP-IDF en Windows

Instalación de ESP-IDF en macOS Ventura con M1 y Python 3.10

Instalación de ESP-IDF en Ubuntu 22.04 con Python 3.10

Lista de materiales

Proyectos con ESP-IDF

Primer proyecto

API Core

Hola mundo con ESP-IDF

Sistemas Operativos en Tiempo Real

FreeRTOS con ESP32

Ciclo de vida de las tareas con FreeRTOS

Almacenamiento con ESP32

Peripherals API

Salida Digital con ESP32

Entrada Digital con ESP32

Entrada Analógica con ESP32

Modulación de Ancho de Pulsos

Control PWM con ESP32 y LEDC

Servidor Web

Redes y protocolos de Internet

Redes WiFi

Loop de eventos

Conexión WiFi con ESP32

Servidor HTTP básico con ESP32

Smart Light

Dimmer LED via HTTP con ESP32

Aplicación Web con ESP32

Despedida

Tu primer proyecto de IoT con ESP32