Contenido del curso
Entrada Digital con ESP32
Martín Gutiérrez Hernández
Estudiante
Harrison Malagon
Estudiante
Carlos Andres Betancourt Perez
Estudiante
Mariana Valencia Gallego
Estudiante
Luis Ariel Torres
EstudianteCarlos Andres Betancourt Perez
Estudiante
Fabio Quimbay
Estudiante
Diana Martinez
EstudianteMartín Gutiérrez Hernández
EstudianteDiana Martinez
Estudiante
Gabriel Obregón
Estudiante
Julio Cardenas
EstudianteJulio Cardenas
Estudiante
Jesús Ramon
EstudianteLuis Ariel Torres
EstudianteHarrison Malagon
Estudiante
Rogelio Meza
EstudiantePull-Up y Pull-Down
Dentro del esp32 podemos activar estas resistencias y así ahorrarnos una resistencia, yo active la resistencia pull-down configurándola desde una estructura pero también se puede activar por medio de la función gpio_set_pull_mode()
!codigo usado
!gif de circuito
Gracias Martin, hice mi codigo usando la función:
#include <stdio.h> #include "freertos/FreeRTOS.h" #include "driver/gpio.h" #define LED_PIN 2 #define BTN_PIN 14 void app_main(void) { int led_state = 0; // Configuración de pines gpio_reset_pin(LED_PIN); gpio_reset_pin(BTN_PIN); gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT); gpio_set_direction(BTN_PIN, GPIO_MODE_INPUT); // Configuración de pull-up o pull-down // gpio_set_pull_mode(BTN_PIN, GPIO_PULLUP_ONLY); // Si el pulsador conecta a GND gpio_set_pull_mode(BTN_PIN, GPIO_PULLDOWN_ONLY); // Si el pulsador conecta a VCC gpio_set_level(LED_PIN, led_state); while (1) { // Lee el estado del pulsador led_state = gpio_get_level(BTN_PIN); // Actualiza el estado del LED con el estado del pulsador gpio_set_level(LED_PIN, led_state); } }
excelente, muy parecido a las estructuras que se usan en STM32 con HAL en el stm32cube IDE
Es tonto, pero me sentí muy feliz de que funcionara todo a la primera :D
Modificando un poco el programa para que ponga en la salida el valor que leyo en la entrada, pero invertido, agregando un delay de 500ms y conectando con un cable la entrada con la salida "en este caso no es necesario la resistencia de pull-up", nos queda el led parpadeando una ves por segundo. Como la salida esta conectada con la entrada, el ESP32 lee el estado actual del LED en el pin de entrada, lo invierte, modifica el estado del led, espera 500ms y vuelve a empezar. Asi se ve en un osciloscopio:
Este seria el código:
#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "driver/gpio.h" #define LED_PIN 4 #define BTN_PIN 14 void app_main(void) { int led_state = 0; gpio_reset_pin(LED_PIN); gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT); gpio_set_direction(BTN_PIN, GPIO_MODE_INPUT); gpio_set_level(LED_PIN, led_state); while (1) { led_state = gpio_get_level(BTN_PIN); gpio_set_level(LED_PIN, !led_state); vTaskDelay(50); } }
Hola aquí comparto el código con algunas correcciones ya que el de la clase reinicia el microcontorlador cada cierto tiempo:
//incluimos las librerias necesarias #include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "driver/gpio.h" #include "esp_log.h" //Privated defines #define LED1 19 #define PUSH 25 //Global variables static const char* TAG = "ESP32"; uint8_t led_state = 0; uint8_t last_state = 0; //function prototypes static void esp_logs(esp_err_t* err, char* ok, char* fail); static esp_err_t led_init(void); static esp_err_t push_button_init(void); //main function void app_main(void) { led_init(); push_button_init(); //apagamos el led inicialmente gpio_set_level(LED1, led_state); ESP_LOGI(TAG, "LED state: %u", led_state); while (true) { led_state = gpio_get_level(PUSH); if (led_state != last_state) { gpio_set_level(LED1, led_state); ESP_LOGI(TAG, "LED state: %u", led_state); last_state = led_state; } vTaskDelay(pdMS_TO_TICKS(10)); } } //------------------------------ static void esp_logs(esp_err_t* err, char* ok, char* fail) { if (*err == ESP_OK) ESP_LOGI(TAG, "%s", ok); else ESP_LOGE(TAG, "%s", fail); } //-------------------------------- static esp_err_t led_init(void) { esp_err_t err; err = gpio_reset_pin(LED1); esp_logs(&err, "LED Reset Done", "LED Reset Failed!!"); err = gpio_set_direction(LED1, GPIO_MODE_OUTPUT); esp_logs(&err, "LED GPIO config Done", "LED GPIO config Failed!!"); return err; } //------------------------------ static esp_err_t push_button_init(void) { esp_err_t err; err = gpio_set_direction(PUSH, GPIO_MODE_INPUT); esp_logs(&err, "BUTTON GPIO config Done", "BUTTON GPIO config Failed!!"); return err; } //------------------------------ ```//incluimos las librerias necesarias#include \<stdio.h>#include "freertos/FreeRTOS.h"#include "freertos/task.h"#include "driver/gpio.h"#include "esp\_log.h" //Privated defines#define LED1 19#define PUSH 25 //Global variablesstatic const char\* TAG = "ESP32";*uint8\_t* led\_state = 0;*uint8\_t* last\_state = 0; //function prototypesstatic void esp\_logs(*esp\_err\_t*\* *err*, char\* *ok*, char\* *fail*);static *esp\_err\_t* led\_init(void);static *esp\_err\_t* push\_button\_init(void); //main functionvoid app\_main(void) { led\_init(); push\_button\_init(); //apagamos el led inicialmente gpio\_set\_level(LED1, led\_state); ESP\_LOGI(TAG, "LED state: %u", led\_state); while (true) { led\_state = gpio\_get\_level(PUSH); if (led\_state != last\_state) { gpio\_set\_level(LED1, led\_state); ESP\_LOGI(TAG, "LED state: %u", led\_state); last\_state = led\_state; } vTaskDelay(pdMS\_TO\_TICKS(10)); }}//------------------------------ static void esp\_logs(*esp\_err\_t*\* *err*, char\* *ok*, char\* *fail*) { if (\**err* == ESP\_OK) ESP\_LOGI(TAG, "%s", *ok*); else ESP\_LOGE(TAG, "%s", *fail*);}//-------------------------------- static *esp\_err\_t* led\_init(void) { *esp\_err\_t* err; err = gpio\_reset\_pin(LED1); esp\_logs(\&err, "LED Reset Done", "LED Reset Failed!!"); err = gpio\_set\_direction(LED1, GPIO\_MODE\_OUTPUT); esp\_logs(\&err, "LED GPIO config Done", "LED GPIO config Failed!!"); return err;}//------------------------------ static *esp\_err\_t* push\_button\_init(void) { *esp\_err\_t* err; err = gpio\_set\_direction(PUSH, GPIO\_MODE\_INPUT); esp\_logs(\&err, "BUTTON GPIO config Done", "BUTTON GPIO config Failed!!"); return err;}//------------------------------
Por favor, excuseme por mi pregunta, pero tal vez podrían orientarme sobre que fuente se está usando para esta práctica? Entiendo que es una fuente de 5V DC ?
Ú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.
¿Qué es un strapping pin y cual es su función?
Los Strapping Pins son pines de uso específico, que si bien se pueden usar con otros fines, están diseñados para funcionar como una especie de configuración por hardware que dependiendo cómo se conecten es cómo podemos poner el chip en modo de programación, o reiniciarlo.
Así que es buena idea dejarlos libres para esos usos.
Lectura de Señales de Entrada con GPIO en el ESP32
Ahora que ya sabes cómo controlar las salidas de señales con tu ESP32, vamos a aprender la operación contraria: leer señales de entrada utilizando los pines GPIO. Para ello, construiremos un circuito específico.
Descripción del Circuito
El circuito que usaremos es similar al de la clase anterior, donde controlamos un LED. La diferencia es que ahora agregamos un push button (botón pulsador), que permitirá enviar una señal digital 1 o 0 según su estado.
Configuración Pull-Down
Este circuito utiliza una configuración pull-down, lo que significa que:
Cuando el botón se presiona, la señal cambia a 1 lógico y el ESP32 detecta este cambio.
Conexión del Push Button
Función de la Resistencia
La resistencia pull-down es clave para:
Código para Leer la Entrada Digital
Vamos a modificar el código anterior para que el LED se encienda solo cuando se presione el botón.
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "driver/gpio.h"
#define LED_PIN 4
#define BTN_PIN 14
void app_main(void)
{
int led_state = 0;
gpio_reset_pin(LED_PIN);
gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
gpio_set_direction(BTN_PIN, GPIO_MODE_INPUT);
gpio_set_level(LED_PIN, led_state);
while (1)
{
led_state = gpio_get_level(BTN_PIN);
gpio_set_level(LED_PIN, led_state);
}
}
Explicación del Código
De este modo, cuando presionemos el botón, el LED se encenderá. Cuando lo soltemos, el LED se apagará.
Compilación y Prueba del Código
Compilar el código
Flashear el Microcontrolador
Probar el Circuito
Uso de Wokwi.com para Simulación
Si no tienes el hardware físico, puedes probar este circuito en, un simulador de ESP32.
Ventajas de Wokwi.com
Ejecutando la Simulación
Limitaciones del Simulador
❌ No soporta Bluetooth ni Wi-Fi. ✅ Funciona perfectamente para entradas y salidas digitales, sensores y pantallas LCD.
✅ Es gratuito y fácil de usar.
Conclusión y Próximos Pasos
Hemos aprendido a leer señales de entrada digital con ESP32 y a probar el código en hardware real y en simulación. Ahora dominas:
✅ Configuración de pines GPIO como entrada y salida.
✅ Uso de resistencias pull-down para señales estables.
✅ Interacción con botones para controlar dispositivos.
✅ Simulación de circuitos en Wokwi.com.
Esta es la diferencia entre pull up y pull down. . .
El switch lo conecte en pull-up. De esta manera la logica del programa queda al reves . .
#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "driver/gpio.h" #define LED_RED_PIN 4 #define LED_GREEN_PIN 0 #define LED_BLUE_PIN 12 #define SW_KY040_PIN 34 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; void app_main(void) { gpio_reset_pin(LED_RED_PIN); gpio_reset_pin(LED_GREEN_PIN); gpio_reset_pin(LED_BLUE_PIN); 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); gpio_set_level(LED_RED_PIN, state_red); gpio_set_level(LED_GREEN_PIN, state_green); gpio_set_level(LED_BLUE_PIN, state_blue); 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); } }
La conexión pull-up y pull-down se refiere a cómo se conecta una resistencia en un circuito electrónico para mantener un valor específico en un pin de entrada o salida.
En la conexión pull-up, una resistencia se conecta entre el pin de entrada o salida y una fuente de voltaje positivo (VCC), que generalmente es 5V en sistemas electrónicos digitales. Esto significa que cuando el pin está en estado "abierto" o no se está usando, la resistencia tira del voltaje del pin hacia el VCC, manteniéndolo en un estado lógico alto (1).
Por otro lado, en la conexión pull-down, la resistencia se conecta entre el pin de entrada o salida y una fuente de voltaje negativo (GND). Esto significa que cuando el pin está en estado "abierto" o no se está usando, la resistencia tira del voltaje del pin hacia el GND, manteniéndolo en un estado lógico bajo (0).
La conexión pull-up y pull-down se utilizan comúnmente en la entrada de botones o interruptores, para asegurar que la entrada tenga un valor definido incluso cuando el botón o interruptor no está activado. También se pueden usar en la salida de un circuito, para garantizar que el pin esté en un estado definido si el circuito está desconectado o no se está utilizando.
Es importante tener en cuenta que la elección de una conexión pull-up o pull-down depende del diseño específico del circuito y de su funcionamiento.
Excelente, las resistencias pull-up y pull-down tambien se utilizan cuando la entrada esta conectada a una salida tipo open colector como son por ejemplo los sensores de efecto hall de los motores brushless.
Esta página tambien tiene un excelente Pin Out : https://lastminuteengineers.com/esp32-pinout-reference/
Esta es la documentación para configurar el GPIO como pull/down : documentación
Hay que recodar que los pines GPIO 34-39 son solo de entrada. Estos pines no cuentan con un controlador de salida o un circuito interno pull-up/pull-down.
En mi caso quise hacer una pequeña variación utilizando el botón en configuración pull up, el pin 16 como entrada y cambiando el estado cada que presione el botón sin la necesidad de mantenerlo presionado (me gusta más asi), mi resultado fue este:
#include <stdio.h> #include "freertos/FreeRTOS.h" //Libreria para funciones con RTOS. #include "freertos/task.h" //Libreria para manejo de procesos. #include "driver/gpio.h" //Libreria para controladores de gpio. /* El programa prende y apaga un led cada que se presiona un boton utilizando GPIO. **Nota: La lógica del funcionamiento del boton esta diseñado para un boton con resistor en configuración pull. ** La entrada del boton está normalmente en 1 y cuando se presiona, detecta un 0. */ #define LED_PIN 4 //Establece macros para operar pines GPIO. #define Input_PIN 16 void app_main(void) { int led_state = 0; gpio_reset_pin(LED_PIN); //Configura internamente pines de entrada y salida. gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT ); gpio_set_direction(Input_PIN, GPIO_MODE_INPUT ); gpio_set_level(LED_PIN, 1); //Asegura led apagado. vTaskDelay(1000 / portTICK_PERIOD_MS); gpio_set_level(LED_PIN, 0); //Asegura led apagado. vTaskDelay(1000 / portTICK_PERIOD_MS); gpio_set_level(LED_PIN, 1); //Asegura led apagado. //Indicador de inicio de programa exitoso con blink de led a utilizar. vTaskDelay(1000 / portTICK_PERIOD_MS); gpio_set_level(LED_PIN, 0); //Asegura led apagado. while(1){ //Repite ciclo de lectura y proceso infinitamente. if(gpio_get_level(Input_PIN) == 0){ led_state = !led_state; //Cambia estado de led cuando se detecta que el boton está presionado. gpio_set_level(LED_PIN, led_state); while(gpio_get_level(Input_PIN) == 0){ //Evita continuar hasta que el boton deje de estar presionado. vTaskDelay(10/ portTICK_PERIOD_MS); } } else{} } }
