Entrada Analógica con ESP32

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

Martín Gutiérrez Hernández

student•

Cambios en la versión 5.0

Hola trate de compilar el programa pero obtuve errores, cheque la documentación y en la versión 5.0 ya no están las funciones vistas en la clase, ahora el ADC tiene dos modos:

Oneshot mode
Converted continuous mode

En esta clase ocupamos el mode Oneshot y se configura por medio de estructuras y otras funciones, dejo el código abajo espero que les ayude.

Pablo Garrido Hernandez

student•

Excelente aporte 👀 dejo el codigo con comentarios:

#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"


#define EXAMPLE_ADC1_CHAN34 ADC_CHANNEL_6       //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)
{
    //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);

        //Retraso
        vTaskDelay(200/portTICK_PERIOD_MS);
    }

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

Joaquín Alejandro Domínguez Lozano

student•

pueden pasar el link de esa parte de la documentación?, pls

Jesús Ramon

student•

La librería "driver/adc.h" es una cabecera de la biblioteca de drivers de ESP-IDF (ESP32 IoT Development Framework) que proporciona funciones para controlar el convertidor analógico-digital (ADC) del ESP32.

Entre las funcionalidades que proporciona esta librería se incluyen:

Configuración del modo de trabajo del ADC (por ejemplo, modo de lectura de un solo canal o modo de lectura de múltiples canales). Configuración de la precisión de la conversión ADC (por ejemplo, 9 bits, 10 bits, 11 bits o 12 bits). Configuración de la fuente de referencia del ADC (por ejemplo, Vref o Vdd). Configuración de la ganancia de amplificación del ADC. Lectura del valor de la conversión ADC de uno o varios canales. Inicio, parada y configuración del temporizador de muestreo. En resumen, la librería "driver/adc.h" es una herramienta esencial para cualquier proyecto que requiera la lectura de señales analógicas en el ESP32, ya que proporciona funciones y macros para controlar el ADC y realizar conversiones ADC precisas y confiables en el ESP32.

Luis Lagardera

student•

La diferencia principal entre una señal analógica y una señal digital es que la primera se representa mediante una variación continua de voltaje o corriente respecto al tiempo, mientras que la digital se representa mediante niveles discretos de voltaje o corriente que representan bits digitales.

Patricio Cárdenas

student•

Las señales lógicas son aquellas que solo tienen dos posibles valores: 0 y 1, también conocidos como "falso" y "verdadero" o "apagado" y "encendido". Estas señales son utilizadas en sistemas digitales, como computadoras, y su valor se representa mediante voltajes específicos. Por ejemplo, un voltaje de 0 volts puede representar un valor "0" lógico, mientras que un voltaje de 5 voltios puede representar un valor "1" lógico. Las señales lógicas son muy precisas y fáciles de manipular mediante circuitos digitales como los que ya hemos armado.

Por otro lado, las señales analógicas son aquellas que pueden tener valores infinitos dentro de un rango determinado. Estas señales son comunes en sistemas de audio y video, y se representan mediante voltajes que varían continuamente. Por ejemplo, una señal de audio analógica puede tener un valor de voltaje de 0,5 volts para representar un sonido suave, y un valor de 2 volts para representar un sonido fuerte. Las señales analógicas son más complejas que las señales lógicas y pueden ser afectadas por la interferencia electromagnética y otros factores ambientales.

En definitiva, la principal diferencia entre señales lógicas y señales analógicas es que las primeras solo tienen dos posibles valores, mientras que las segundas pueden tener valores infinitos dentro de un rango determinado.

Gabriel Obregón

student•

Lectura de Entradas Analógicas con ESP32

1. Introducción

En esta clase, exploraremos la entrada analógica y su diferencia con la entrada digital. Más adelante, veremos cómo se puede simular una salida analógica utilizando una técnica especial.

1.1. Diferencia entre Señales Analógicas y Digitales

Señales analógicas: Representan fenómenos físicos del mundo real con valores continuos. Ejemplo: temperatura, voltaje, iluminación.
Señales digitales: Solo pueden tener dos estados (0 o 1, encendido o apagado).

Si ya conoces la diferencia, compártela en los comentarios para ayudar a otros.

2. ¿Cómo funciona una señal analógica?

Cuando trabajamos con señales analógicas, estamos midiendo variaciones de voltaje.

Un sensor de temperatura genera un voltaje proporcional a la temperatura medida.
Si la temperatura sube, el voltaje aumenta; si baja, el voltaje disminuye.

El ESP32 puede leer estas señales analógicas y convertirlas en valores digitales dentro de un rango de 0 a 4095 (para una resolución de 12 bits).

3. Construcción del Circuito

Para leer una señal analógica, utilizaremos un potenciómetro (trimpot) conectado a nuestra tarjeta ESP32.

3.1. Conexiones del Potenciómetro

Pin 1 → GND (tierra).
Pin 2 → Entrada analógica en ESP32.
Pin 3 → 5V.

Esto crea un divisor de tensión, permitiendo que la señal varíe según la posición del trimpot.

4. Identificación de Pines en ESP32

En el ESP32, los pines compatibles con señales analógicas están marcados como ADC (Conversión Analógica-Digital).

ESP32-CAM solo tiene ADC2, lo que significa que no puede usar Wi-Fi simultáneamente.
Si tu tarjeta soporta ADC1, es recomendable usarlo para evitar conflictos.

5. Programación en Visual Studio Code

Hemos creado un proyecto en VS Code y realizado la primera compilación. Ahora, programaremos la lectura de la señal analógica.

5.1. Importación de Librerías

#include <stdio.h>

#include "freertos/FreeRTOS.h"

#include "freertos/task.h"

#include "driver/adc.h"

FreeRTOS.h y task.h → Manejo de tareas y retardos.
adc.h → Permite leer valores de canales analógico-digitales.

5.2. Configuración del ADC

int32_t raw_value;

adc2_config_channel_atten(ADC2_CHANNEL_6, ADC_ATTEN_DB_0);

ADC2_CHANNEL_6 → Canal a leer.
ADC_ATTEN_DB_0 → Sin atenuación (lectura directa del voltaje).

5.3. Lectura y Visualización de Datos

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);

}

adc2_get_raw() → Obtiene el valor del ADC en 12 bits.
printf() → Imprime el valor en la terminal.
vTaskDelay(1000 / portTICK_PERIOD_MS); → Agrega un retardo de 1 segundo para evitar saturar la terminal.

5.4. Código Completo

#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);

}

6. Compilación y Monitoreo de Datos

Compilar el código y subirlo al ESP32.
Activar el monitor de la terminal para visualizar los valores.

Al mover el trimpot, los valores cambiarán en la terminal:

Sentido horario → Aumenta el valor.
Sentido antihorario → Disminuye el valor.

Esto ocurre porque el divisor de tensión modifica el voltaje de entrada al ADC del ESP32.

7. Aplicaciones Prácticas

Este mismo código puede utilizarse con otros sensores:

Fotoresistencias → Detectar luz.
Termistores → Medir temperatura.
Sensores de presión, humedad, gas, etc.

Ámbitos de aplicación

✔ Domótica → Sensores de temperatura y luz en casas inteligentes. ✔ Automatización industrial → Control de procesos en fábricas. ✔ IoT (Internet de las Cosas) → Monitoreo remoto de variables físicas.

8. Conclusión

🎉 ¡Felicidades! Ahora puedes leer señales analógicas con el ESP32.

📢 Próximos temas: ✅ Comparación entre sensores. ✅ Procesamiento avanzado de señales analógicas. ✅ Integración con módulos IoT.

🚀 ¡Nos vemos en la próxima clase! 🙌

Juan Sebastian Correa

student•

Tengo una consulta, Si la ESP32 funciona a 3,3v por que se esta conectando entre 0 a 5v el pot?

Diana Martinez

student•

Porque viene protegida para funcionar a ese voltaje si es necesario, ya que la mayoría de señales se suelen manejar a 5v

Diana Martinez

student•

Pero tu podrías usarla a 3.3v si así lo deseas.

Briggitte Tatiana Castañeda Camargo

student•

Para el caso de tener la ESP32-CAM Puedo ver los logs al tiempo que funciona el programa interno? o no se puede?. Lo pregunto por la aclaración que haces del uso en esta practica de la tarjeta LiLYGo.

Diana Martinez

student•

El problema con la ESP32-CAM es que no cuenta con el conector USB mientras está sobre la protoboard, por eso no estoy sacando logs, ahora, podrías conectar unos cables para unir los pines de las dos partes que conforman la ESP32-CAM, especialmente los de voltaje (5V y GND), y los de datos (TX, RX), y seguramente podrías ver los logs pues ya funcionaría el puerto USB de la segunda parte de la tarjeta.

Germán de Francesco

student•

Dejo el código que realicé utilizando la librería "esp_adc/adc_oneshot.h", ya que "driver/adc.h" está deprecada.

En mi caso, utilicé ADC1 (ADC_UNIT_1), canal 4 (ADC_CHANNEL_4).

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_adc/adc_oneshot.h"

adc_oneshot_unit_handle_t handle;
adc_oneshot_unit_init_cfg_t init_cfg = {
    .unit_id = ADC_UNIT_1,
};
adc_oneshot_chan_cfg_t chan_cfg = {
    .bitwidth = ADC_BITWIDTH_12,
    .atten = ADC_ATTEN_DB_12,
};

int raw_value;

void app_main(void)
{
    adc_oneshot_new_unit(&init_cfg, &handle);
    adc_oneshot_config_channel(handle, ADC_CHANNEL_4, &chan_cfg);

    while (1) {
        adc_oneshot_read(handle, ADC_CHANNEL_4, &raw_value);
        printf("ADC Raw Value: %d\n", raw_value);
        vTaskDelay(pdMS_TO_TICKS(250));
    }

    adc_oneshot_del_unit(handle);
}

Julio Cardenas

student•

El esp32 es un dispositivo que funciona a 3.3Voltios.
. Si tratams de medir voltajes mayores podemos destruirlo. Por ejemplo, medir 5 voltios. . Para hacerlo correctamente hay que emplear un divisor de voltaje .

. El potenciometro puede ser considerado como un divisor de voltaje. .

Juan Felipe Rodriguez Valencia

student•

Un divisor de voltaje es un circuito eléctrico que divide el voltaje de una fuente de alimentación entre dos o más resistencias conectadas en serie. El voltaje de salida de un divisor de voltaje es proporcional a la resistencia total del circuito y a la resistencia del elemento donde se mide el voltaje. Un divisor de voltaje se utiliza para reducir el voltaje de una fuente a un nivel adecuado para otro dispositivo o componente.

Mario Ruben Hernandez Carmona

student•

Hola, trate de compilar el código compartido por Diana pero no me funciono, tras leer la documentación encontré que el parámetro de atenuación debe de ir a 11 para poder registrar el cambio de la señal analogica.

enumerator ADC_ATTEN_DB_11: The input voltage of ADC will be attenuated extending the range of measurement by about 11 dB (3.55 x)

Otro pequeño cambio es el código del puerto escucha, no utiliza el postfijo 2 en el ADC: enumerator ADC_CHANNEL_9

Les comparto mi código, esta compilado utilizando esp-idf-v5.0.2

#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(ADC_CHANNEL_9, ADC_ATTEN_DB_11);

  while(1) {
    adc2_get_raw(ADC_CHANNEL_9, ADC_WIDTH_BIT_12, &raw_value);
    printf("adc raw: %ld\n", raw_value);
    printf("voltaje: %.2f\n", (5.0*raw_value)/4095);
    vTaskDelay(1000 / portTICK_PERIOD_MS);
  }
}

Edward John Rodriguez Soto

student•

Luis Alvarez

student•

Practica analog input, leer un valor analogico y mostrarlo en consola casa segundo.

Codigo:

Consola:

Puntos que aprendi con esta practica:

El ESP32 tiene 2 bloques de canales por asi decirlo ADC1 y ADC2 el ADC1 es recomendado cuando el dispositivo esta conectado a WI-FI porque ADC2 comparte hardware con el WI-FI y podria generar errores.
ADC1 tiene canales que van del 0 al 7 y ADC2 tiene canales del 0 al 9 y cada uni de estos canales corresponden a una terminal especifica del ESP32 llamada GPIO.
vTaskDelay(1000 / portTICK_PERIOD_MS); es convertir el delay en ticks que es la medida que entiende el SO de freertos.
Con resolución nos referimos a que tan confible es nuestra lectura entre mas valores de resolucion mas confiable sera el valor.
atenuacion nos indica que el ESP32 puede interpretar un rango de valores.

Practica extra

Realice basicamente con el mismo codigo la lectura de 2 entradas y calcule el promedio de ambas esto con la intencion de visulizar 2 potenciometreos diferentes uno de 20K y otro de 5K, donde podemos observa el recorrido entre una lectura y otra es mas sueve y en la otra los cambios son mas grandes.

Y como parte final solo agrefgue un If para visualizar dato promedio en rangos de bajo, medio y alto.

Juan Sebatian Ariza

student•

tengo una duda, por que si conecto la entrada analogica a 3,3V de 4095, estoy intentando caracterizar un sensor de humedad pero la lectura de la entrada analogica no varia acorde al voltage, y si lo conecto a 3,3 me da 4095 que es el valor que deveria tener con 5v

Diana Martinez

student•

Puede ser que el sensor venga limitado a ese valor o que haya que configurar algo en el IDF, la verdad desconozco cómo hacer eso exactamente, pero existen librerías en GitHub para los DHT, entonces podrías revisar su implementación y ver que te está faltado.

Ramón Felipe Miranda Hernández

student•

¿Cómo puedo convertir el valor leído raw_value del tipo int a float o double para mostrar el voltaje en el monitor serial?

Diana Martinez

student•

Creo que esto te sirve: https://stackoverflow.com/questions/13530209/how-to-convert-int-to-float-in-c

Julio Cardenas

student•

Mientras compilaba me dio el siguiente error:

#warning "legacy adc driver is deprecated, please migrate to use esp_adc/adc_oneshot.h and esp_adc/adc_continuous.h for oneshot mode and continuous mode drivers respectively"

Trate de emtender la libreria adc_one_shot y no entendi bien la documentacion y no encontre ejemplos. . . Hice el ejercicio con adc_driver para mi hardware que es un Lora32. Implemente varias tareas simultaneas en el core 1. . .

#include <stdio.h>
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "driver/adc.h"
#include "esp_adc_cal.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;

TaskHandle_t ledHandle;
TaskHandle_t swky040Handle;
TaskHandle_t battVoltHandle;

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;

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 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));  
    


    //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
    );
   
}

Entrada Analógica con ESP32

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