No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Entrada Digital con ESP32

19/30
Recursos

Aportes 9

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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

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

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

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);
    }
}
Hola aquí comparto el código con algunas correcciones ya que el de la clase reinicia el microcontorlador cada cierto tiempo: ```js //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;}//------------------------------

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.

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: ```js #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{} } } ```