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
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 ?
¿Qué es un strapping pin y cual es su función?
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.
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.
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.
La resistencia pull-down es clave para:
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);
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.
while (1)
{
led_state = gpio_get_level(BTN_PIN);
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á.
Compilar el código
Flashear el Microcontrolador
Probar el Circuito
Si no tienes el hardware físico, puedes probar este circuito en, un simulador de ESP32.
❌ No soporta Bluetooth ni Wi-Fi. ✅ Funciona perfectamente para entradas y salidas digitales, sensores y pantallas LCD.
✅ Es gratuito y fácil de usar.
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.