Clase 20 de 30 • Curso de IoT: Programación de Microcontroladores ESP32
Contenido del curso
Martín Gutiérrez Hernández
Pablo Garrido Hernandez
Joaquín Alejandro Domínguez Lozano
Jesús Ramon
Luis Lagardera
Patricio Cárdenas
Gabriel Obregón
Juan Sebastian Correa
Diana Martinez
Diana Martinez
Briggitte Tatiana Castañeda Camargo
Diana Martinez
Germán de Francesco
Julio Cardenas
Juan Felipe Rodriguez Valencia
Mario Ruben Hernandez Carmona
Edward John Rodriguez Soto
Felipe de Jesús Rivera López
Luis Alvarez
Juan Sebatian Ariza
Diana Martinez
Ramón Felipe Miranda Hernández
Diana Martinez
Julio Cardenas
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:
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. !codigo de ADC
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) }
pueden pasar el link de esa parte de la documentación?, pls
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.
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.
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.
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
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.
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
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).
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"
5.2. Configuración del ADC
int32_t raw_value;
adc2_config_channel_atten(ADC2_CHANNEL_6, ADC_ATTEN_DB_0);
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);
}
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
Al mover el trimpot, los valores cambiarán en la terminal:
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:
Á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! 🙌
Tengo una consulta, Si la ESP32 funciona a 3,3v por que se esta conectando entre 0 a 5v el pot?
Porque viene protegida para funcionar a ese voltaje si es necesario, ya que la mayoría de señales se suelen manejar a 5v
Pero tu podrías usarla a 3.3v si así lo deseas.
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.
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.
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); }
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
.
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.
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); } }
Practica analog input, leer un valor analogico y mostrarlo en consola casa segundo.
Codigo:
Consola:
Puntos que aprendi con esta practica:
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.
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
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.
¿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?
Creo que esto te sirve: https://stackoverflow.com/questions/13530209/how-to-convert-int-to-float-in-c
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 ); }
