Entrada Digital con ESP32

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

Martín Gutiérrez Hernández

student•

Pull-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

Harrison Malagon

student•

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

Carlos Andres Betancourt Perez

student•

excelente, muy parecido a las estructuras que se usan en STM32 con HAL en el stm32cube IDE

Mariana Valencia Gallego

student•

Es tonto, pero me sentí muy feliz de que funcionara todo a la primera :D

Luis Ariel Torres

student•

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

Carlos Andres Betancourt Perez

student•

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

Fabio Quimbay

student•

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 ?

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.

Martín Gutiérrez Hernández

student•

¿Qué es un strapping pin y cual es su función?

Diana Martinez

student•

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.

Gabriel Obregón

student•

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:

Hay una resistencia conectada a tierra (GND).
En los diagramas eléctricos, "tierra" suele estar en la parte inferior y 5V en la parte superior.
La resistencia garantiza que la señal se mantenga en 0 lógico por defecto.

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

Tiene cuatro pines, de los cuales dos están conectados internamente.
Funciona como un puente entre la entrada y la salida de la señal.
Al presionar el botón, se genera continuidad en la corriente.

Función de la Resistencia

La resistencia pull-down es clave para:

Evitar cortocircuitos.
Asegurar que la señal tenga un estado bien definido.
- Por defecto: 0 lógico (señal baja).
- Al presionar el botón: 1 lógico (señal alta, 5V).

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

Definimos los pines del LED y del botón.
Configuramos el LED como salida y el botón como entrada.
Inicializamos el LED en estado apagado.
En el ciclo infinito:
- Leemos la entrada digital del botón con gpio_get_level(BTN_PIN).
- Asignamos ese valor al LED (gpio_set_level(LED_PIN, led_state)).

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
- Ejecutamos la compilación desde la terminal.
- Como ya se ha compilado antes, el proceso será más rápido.
Flashear el Microcontrolador
- Usamos el comando flash, indicando el puerto COM.
Probar el Circuito
- Observamos el LED en la protoboard:
  - Botón sin presionar → LED apagado.
  - Botón presionado → LED encendido.

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

Permite escribir código en ESP-IDF (aunque puede ser una versión anterior).
Simula el circuito electrónico con diagramas visuales.
Tres pestañas principales:
- main.c → Código principal.
- diagram.json → Configuración del circuito.
- Library Manager → Permite cargar archivos adicionales.
Posibilidad de agregar más componentes (como LEDs o sensores) con el botón +.

Ejecutando la Simulación

Abrimos el proyecto en Wokwi.
Hacemos clic en “Simular”.
Probamos el circuito:
- Clic en el botón virtual → El LED se enciende.
- Soltar el botón → El LED se apaga.

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.

Julio Cardenas

student•

Esta es la diferencia entre pull up y pull down. . .

Julio Cardenas

student•

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

Jesús Ramon

student•

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.

Luis Ariel Torres

student•

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.

Harrison Malagon

student•

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.

Rogelio Meza

student•

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{}
    }
}

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

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

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

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

#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{}
    }
}

Entrada Digital 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