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鈥檚:

#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 鈥渧TaskDelay(BLINK_TIME / portTICK_PERIOD_MS)鈥; por 鈥渧TaskDelay(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));
    }
  }
}