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
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);
}
}
Hola Diana. No comprendí como se conecta la protoboard a conector USB con cables de donde obtiene la alimentación. Gracias por tu respuesta.
Me quede esperando como hacer la conexión del circuito y ver la prueba del mismo funcionando. Yo entendí en una de las clases pasadas como funciona la protoboard, pero lo que no se es como conectar el ESP32CAM a la protoboard.
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;
}
Ahora que ya hemos trabajado en la programación del chip, daremos el siguiente paso: comenzar a utilizar los diferentes periféricos de entrada y salida de nuestra tarjeta de desarrollo ESP32.
Para ello, aprenderemos sobre entradas y salidas de propósito general (GPIO), lo que nos permitirá leer o enviar señales digitales.
Podemos utilizar GPIO para:
En términos computacionales, una señal digital representa 1 o 0, que en términos eléctricos equivalen a 5V o 0V.
Para gestionar estas señales, utilizaremos la librería GPIO.
El circuito utilizado es el mismo que en la práctica del "Hola Mundo". Dependiendo de tu tarjeta de desarrollo, debes revisar la hoja de datos para saber qué pines puedes usar.
Si tu tarjeta ya cuenta con un LED incorporado, puedes usarlo sin necesidad de una protoboard. De lo contrario, deberás armar el circuito correctamente.
Ya tenemos creado un proyecto en Visual Studio Code. A continuación, presentamos el código completo:
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#define LED_PIN 4
#define BLINK_TIME 1000
void app_main(void)
{
int led_state = 0;
gpio_reset_pin(LED_PIN);
gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
while (1)
{
gpio_set_level(LED_PIN, led_state);
led_state = !led_state;
vTaskDelay(BLINK_TIME / portTICK_PERIOD_MS);
}
}
Librerías Importadas
Definiciones
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 :
//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;}//------------------------------
Configuración del LED
Bucle Infinito
Puedes elegir cualquier otro pin que permita salida digital.
El mismo principio utilizado para el LED puede aplicarse a otros dispositivos:
Los motores a pasos funcionan con un código binario. Cada señal eléctrica cambia el ángulo del motor de forma precisa.
Estos dispositivos manipulan señales eléctricas de manera controlada para generar movimientos exactos.
Tras escribir el código, procedemos a compilarlo. Si todo está correcto, no debería haber errores.
Para cargar el programa en la tarjeta de desarrollo, ejecutamos el comando de flasheo.
Nota: El puerto de conexión puede variar. En mi caso, es COM3, pero en tu computadora podría ser diferente.
Durante el flasheo, veremos en la terminal el progreso de la carga. Una vez finalizado, el código estará corriendo en el ESP32.
Después de la carga del programa, el LED debería parpadear según lo programado. 🚀
Luis Ariel Torres
Harrison Malagon
Claudio Palmieri
Diana Martinez
Vanessa Corredor
Diana Martinez
Rodrigo Josue Goitia Quiroga
Jesús Ramon
Oswaldo Díaz Ventura
Juan Felipe Rodriguez Valencia
Gabriel Obregón
Julio Cardenas
Carlos Andres Betancourt Perez
Luis Alberto Vargas Méndez
Mario Hernandez
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
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); } }
Hola Diana. No comprendí como se conecta la protoboard a conector USB con cables de donde obtiene la alimentación. Gracias por tu respuesta.
Las tarjetas traen un puerto USB como el de los celulares, simplemente ahí lo conectas y con eso ya pasa energía y datos, como un USB normal.
Me quede esperando como hacer la conexión del circuito y ver la prueba del mismo funcionando. Yo entendí en una de las clases pasadas como funciona la protoboard, pero lo que no se es como conectar el ESP32CAM a la protoboard.
Tienes razón, se pasó esa escena en la edición, pediré que se arregle. Muchas gracias. La ESP32-CAM tiene ya la forma para colocarla sobre la protoboard, del resto solo hay que conectarle los componentes respecto al diagrama, usando su pinout. Pero es que además, especialmente la ESP32-CAM, en esta práctica, no es necesario conectarle nada, esta tarjeta en específico ya trae un LED ultrabrillante, el que usamos en clases, así que solo es cuestión de configurar en el código el Pin al que está conectado. Si usas el mismo modelo que yo en el curso, es el pin 4, el código de la clase está en github, en los recursos de la clase, ese debería servirte.
¡Hola Vanessa! Ya hemos actualizado esta clase. Puedes revisarla para ver como funciona el circuito.
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; }
Ahora que ya hemos trabajado en la programación del chip, daremos el siguiente paso: comenzar a utilizar los diferentes periféricos de entrada y salida de nuestra tarjeta de desarrollo ESP32.
Para ello, aprenderemos sobre entradas y salidas de propósito general (GPIO), lo que nos permitirá leer o enviar señales digitales.
Aplicaciones de GPIO
Podemos utilizar GPIO para:
En términos computacionales, una señal digital representa 1 o 0, que en términos eléctricos equivalen a 5V o 0V.
Para gestionar estas señales, utilizaremos la librería GPIO.
Circuito a Utilizar
El circuito utilizado es el mismo que en la práctica del "Hola Mundo". Dependiendo de tu tarjeta de desarrollo, debes revisar la hoja de datos para saber qué pines puedes usar.
Si tu tarjeta ya cuenta con un LED incorporado, puedes usarlo sin necesidad de una protoboard. De lo contrario, deberás armar el circuito correctamente.
Ejemplo de Código en Visual Studio Code
Ya tenemos creado un proyecto en Visual Studio Code. A continuación, presentamos el código completo:
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#define LED_PIN 4
#define BLINK_TIME 1000
void app_main(void)
{
int led_state = 0;
gpio_reset_pin(LED_PIN);
gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
while (1)
{
gpio_set_level(LED_PIN, led_state);
led_state = !led_state;
vTaskDelay(BLINK_TIME / portTICK_PERIOD_MS);
}
}
Explicación del Código
Librerías Importadas
Definiciones
Configuración del LED
Bucle Infinito
Explicación del Circuito
Conexiones de Alimentación
Esquemático del Circuito
Puedes elegir cualquier otro pin que permita salida digital.
Aplicaciones Avanzadas
El mismo principio utilizado para el LED puede aplicarse a otros dispositivos:
1. Control de Motores
2. Motores a Pasos
Los motores a pasos funcionan con un código binario. Cada señal eléctrica cambia el ángulo del motor de forma precisa.
Aplicaciones avanzadas:
Estos dispositivos manipulan señales eléctricas de manera controlada para generar movimientos exactos.
Compilación y Flasheo del ESP32
Tras escribir el código, procedemos a compilarlo. Si todo está correcto, no debería haber errores.
Flasheo del Chip ESP32
Para cargar el programa en la tarjeta de desarrollo, ejecutamos el comando de flasheo.
Nota: El puerto de conexión puede variar. En mi caso, es COM3, pero en tu computadora podría ser diferente.
Durante el flasheo, veremos en la terminal el progreso de la carga. Una vez finalizado, el código estará corriendo en el ESP32.
Verificando el Funcionamiento
Después de la carga del programa, el LED debería parpadear según lo programado. 🚀
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 :
//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)); } } }