No tienes acceso a esta clase

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

Salida Digital con ESP32

18/30
Recursos

Aportes 9

Preguntas 2

Ordenar por:

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

Comparto mi codigo para 2 LED’s:

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"

#define LED_PIN 2
#define LED2_PIN 12
#define BLINK_TIME 1000

void app_main(void)
{
    int led_state = 0;
    
    // Configurar los pines de los LED
    gpio_pad_select_gpio(LED_PIN);
    gpio_pad_select_gpio(LED2_PIN);
    gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
    gpio_set_direction(LED2_PIN, GPIO_MODE_OUTPUT);

    while (1)
    {
        // Encender y apagar los LED
        gpio_set_level(LED_PIN, led_state);
        gpio_set_level(LED2_PIN, led_state);
        led_state = !led_state;

        // Retrasar la ejecución del bucle para crear un patrón de parpadeo
        vTaskDelay(BLINK_TIME / portTICK_PERIOD_MS);
    }
}

Reemplazando “vTaskDelay(BLINK_TIME / portTICK_PERIOD_MS)”; por “vTaskDelay(1);” en digital-output.c, vamos a tener el LED prendido por un TICK y apagado otro TICK. De esta manera, con un osciliscopio podemos medir la duracion del TICK. Les dejo la captura de pantalla del osciloscopio. El resultado fué el LED prendiéndose 50 veces por segundo y la duración del TICK fué de 10ms.

En la captura de pantalla, la duracion del TICK Delta X que es 9.999610000ms

Esta línea de código está escrita en el lenguaje de programación C para programar microcontroladores ESP32 utilizando el FreeRTOS, un sistema operativo en tiempo real para sistemas embebidos.

La función vTaskDelay() es una función proporcionada por FreeRTOS que suspende la tarea actual durante un período de tiempo determinado. En este caso, la tarea se suspenderá durante un tiempo determinado por BLINK_TIME dividido por portTICK_PERIOD_MS.

BLINK_TIME es una constante que representa el tiempo que debe permanecer encendido o apagado un LED, por ejemplo, mientras que portTICK_PERIOD_MS es una constante que representa el tiempo base de FreeRTOS en milisegundos. Esta constante se utiliza para convertir el tiempo de espera deseado en ticks de reloj, que es la unidad de tiempo utilizada por FreeRTOS.

En resumen, esta línea de código suspende la tarea actual durante un tiempo determinado para controlar el parpadeo de un LED conectado a un microcontrolador ESP32 utilizando FreeRTOS.

Comparto mi código que te ayuda a no escribir mucho al momento de poner un pin como salida.

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"

#define LED_pin 2
#define blink_time 500

void app_main(void)
{
    int led_state = 0;
    gpio_reset_pin(LED_pin);
    //gpio_set_direction(LED_pin, GPIO_MODE_OUTPUT);
    gpio_set_direction(LED_pin, 2);//otro modo de poner un gpio como salida

    while(1){
        gpio_set_level(LED_pin, led_state);
        led_state = !led_state;
        vTaskDelay(blink_time / portTICK_PERIOD_MS);
    }
}

les comparto mi código, que viene también con administración de errores, que se activa con un contador.

/*
    Este codigo hace parpadear el led que esta conectado al puerto
    GPIO 02 de la tarjeta ESP32 wroom32
    primero se importan las librerias que se usaran en el codigo
    se estara empleando el sistema operativo freeRTOS y una funcion
    del mismo llamada task.h
*/
#include <stdio.h>
#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

//se define el puerto que se usara (02)
#define led1 2
static const char* tag = "MyModule";

uint8_t led_level =0;
uint8_t count = 0;


// se inicializan las funciones que inician el led y
// la que lo hace parpadear
esp_err_t init_led(void);
esp_err_t blink_led(void);

void app_main(void)
{
   init_led();

   while(1)
   {
        vTaskDelay(200 / portTICK_PERIOD_MS); // 200ms de periodo
        blink_led(); //llama la funcion de parpadeo
        count +=1;
        if (count >30)
        {
            count = 0;
        }
        
        if(count < 10)
        {
            ESP_LOGI(tag,"value: %u.",count);
        }
        if (count >= 10 && count < 20)
        {
            ESP_LOGW(tag,"value: %u.",count);
        }
        if (count >= 20)
        {
            ESP_LOGE(tag,"value: %u.",count);
        }
        
        //printf("led level: %u\n", led_level); //imprime la salida del puerto 2
   } 
}

// funcion para inicializar el puerto 2
esp_err_t init_led(void)
{
    gpio_reset_pin(led1);
    gpio_set_direction(led1, GPIO_MODE_DEF_OUTPUT);
    return ESP_OK;
}

//funcion para intermitencia entre on/off del GPIO 02
esp_err_t blink_led(void)
{
    led_level = !led_level;
    gpio_set_level(led1,led_level);
    return ESP_OK;
}

Este es mi codigo para un modulo con led RGB
.

#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

bool state_red   = false;
bool state_green = false;
bool state_blue  = false;

const TickType_t blink_delay = 1000 / 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);

    while (true)
    {
        gpio_set_level(LED_RED_PIN,   state_red);
        state_red = !state_red;
        vTaskDelay(blink_delay);

        gpio_set_level(LED_GREEN_PIN, state_green);
        state_green = !state_green;
        vTaskDelay(blink_delay);
        
        gpio_set_level(LED_BLUE_PIN,  state_blue);
        state_blue = !state_blue;
        vTaskDelay(blink_delay);
    }
}
 
Les comparto mi código con unos cambios en los logs usando esp\_log.h : ```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 LED_DELAY 500 //Global variables static const char* TAG = "ESP32"; uint8_t led_state = 0; uint8_t count = 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 led_blink(void); //main function void app_main(void) { led_init(); while (true) { led_blink(); vTaskDelay(pdMS_TO_TICKS(LED_DELAY)); if (count > 30) { count = 0; } if (count < 10) { ESP_LOGI(TAG, "Value %u", count); } else if (count >= 10 && count < 20) { ESP_LOGW(TAG, "Value %u", count); } else if (count >= 20 && count < 30) { ESP_LOGE(TAG, "Value %u", count); } printf("LED state: %u\n", led_state); count++; } } //------------------------------ 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 led_blink(void) { led_state = !led_state; gpio_set_level(LED1, led_state); return ESP_OK; } //------------------------------ ```//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 LED\_DELAY    500 //Global variablesstatic const char\* TAG = "ESP32";*uint8\_t* led\_state = 0;*uint8\_t* count = 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* led\_blink(void); //main functionvoid app\_main(void) {   led\_init();    while (true) {      led\_blink();      vTaskDelay(pdMS\_TO\_TICKS(LED\_DELAY));      if (count > 30) {         count = 0;      }      if (count < 10) {         ESP\_LOGI(TAG, "Value %u", count);      }      else if (count >= 10 && count < 20) {         ESP\_LOGW(TAG, "Value %u", count);      }      else if (count >= 20 && count < 30) {         ESP\_LOGE(TAG, "Value %u", count);      }       printf("LED state: %u\n", led\_state);      count++;   }}//------------------------------ 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* led\_blink(void) {   led\_state = !led\_state;   gpio\_set\_level(LED1, led\_state);    return ESP\_OK;}//------------------------------

Otra manera de visualizar el cambio para no tener que montar el circuito en la protoboard es midiendo el voltaje con un multímetro

Les comparto mi código para 4 leds con efecto de va y ven.

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"

#define LED_GPIO_23 23
#define LED_GPIO_22 22
#define LED_GPIO_21 21
#define LED_GPIO_05 05
#define BLINK_TIME 1000

void app_main(void)
{
    // Declarar un array para almacenar los estados de los LEDs.
    char estadoLEDs[6][5] = {
        "1000",
        "0100",
        "0010",
        "0001",
        "0010",
        "0100"
    };

    int estadoLED23 = 0;
    int estadoLED22 = 0;
    int estadoLED21 = 0;
    int estadoLED05 = 0;

  gpio_reset_pin(LED_GPIO_23);
  gpio_reset_pin(LED_GPIO_22);
  gpio_reset_pin(LED_GPIO_21);
  gpio_reset_pin(LED_GPIO_05);

  gpio_set_direction(LED_GPIO_23, GPIO_MODE_OUTPUT);
  gpio_set_direction(LED_GPIO_22, GPIO_MODE_OUTPUT);
  gpio_set_direction(LED_GPIO_21, GPIO_MODE_OUTPUT);
  gpio_set_direction(LED_GPIO_05, GPIO_MODE_OUTPUT);

  while (1)
  {
    int i;
    for ( i = 0; i < 6; i++)
    {
        estadoLED23 = estadoLEDs[i][0] - '0';
        estadoLED22 = estadoLEDs[i][1] - '0';
        estadoLED21 = estadoLEDs[i][2] - '0';
        estadoLED05 = estadoLEDs[i][3] - '0';
        
        printf("estadoLEDs[%d]: %s \n", i, estadoLEDs[i]);
        printf("estadoLED1: %d \n", estadoLED23);
        printf("estadoLED2: %d \n", estadoLED22);
        printf("estadoLED3: %d \n", estadoLED21);
        printf("estadoLED4: %d \n", estadoLED05);
        printf("\n");

        gpio_set_level(LED_GPIO_23, estadoLED23);
        gpio_set_level(LED_GPIO_22, estadoLED22);
        gpio_set_level(LED_GPIO_21, estadoLED21);
        gpio_set_level(LED_GPIO_05, estadoLED05);

        vTaskDelay(BLINK_TIME / (portTICK_PERIOD_MS*16));
    }
  }
}