ESP32 FreeRTOS: doble núcleo, tareas, colas y semáforos
ESP32 FreeRTOS: xTaskCreatePinnedToCore, prioridades, delay frente a vTaskDelay, colas, semáforos, pila y watchdog; LED, sensor y servidor web a la vez.
ESP32 FreeRTOS es el sistema operativo en tiempo real que ya funciona dentro del ESP32 y que te permite hacer varias cosas a la vez. Todo programa para ESP32 que escribes en el Arduino IDE se ejecuta en realidad sobre FreeRTOS: tus funciones setup() y loop() corren dentro de una tarea llamada loopTask en uno de los dos núcleos del ESP32. Creando tus propias tareas puedes hacer parpadear un LED mientras lees un sensor y atiendes peticiones de un servidor web al mismo tiempo, sin que ninguna frene a las demás. El esquema de "varias cosas a la vez" que intentas montar con millis() en un Arduino Uno queda mucho más limpio en el ESP32.
En esta guía aprenderás cómo se reparten los dos núcleos del ESP32 y en cuál de ellos funciona el WiFi. Después crearemos tareas con xTaskCreatePinnedToCore, las fijaremos a un núcleo concreto, ajustaremos prioridades y veremos la diferencia entre delay() y vTaskDelay(). Usaremos una cola (queue) para compartir datos de forma segura entre tareas, un semáforo para despertar una tarea desde la interrupción de un botón y un mutex para proteger el Monitor Serie compartido. Tras ver el tamaño de pila y los errores del watchdog, montaremos un ejemplo completo con un LED, un sensor y un servidor web funcionando a la vez. Al final hay una breve comparación con los dos núcleos de la Raspberry Pi Pico.

¿Qué es ESP32 FreeRTOS y cómo funcionan los dos núcleos?
En FreeRTOS cada trabajo es una tarea (task). Una tarea es una función normal de C con su propia pila y su propia prioridad, que suele contener un bucle infinito. En cada núcleo, el planificador (scheduler) de FreeRTOS elige la tarea de mayor prioridad entre las que están listas. Cuando una tarea espera con vTaskDelay(), espera datos de una cola o espera un semáforo, el núcleo pasa enseguida a otra tarea. Las tareas con la misma prioridad se turnan en cada tick. En el núcleo Arduino del ESP32 un tick dura 1 ms (1000 ticks por segundo), así que vTaskDelay(100) espera unos 100 ms. El ESP32 clásico tiene dos núcleos: el núcleo 0 (PRO_CPU) y el núcleo 1 (APP_CPU). Espressif coloca las comunicaciones inalámbricas en el núcleo 0 y tu código en el núcleo 1, para que el WiFi no interrumpa tu bucle. Con la configuración por defecto de Arduino, esto es lo que corre en cada núcleo:
| Tarea | Núcleo | Prioridad | Función |
|---|---|---|---|
| loopTask (setup y loop) | 1 | 1 | Tu código Arduino, pila de 8192 bytes |
| Controlador WiFi | 0 | 23 | Radio y protocolo WiFi |
| lwIP (tcpip) | 0 | 18 | Pila TCP/IP, paquetes web y MQTT |
| Bluetooth (BT/BLE) | 0 | Alta | Controlador Bluetooth y Bluedroid |
| esp_timer | 0 | 22 | Temporizadores por software |
| IDLE0 e IDLE1 | 0 y 1 | 0 | Tareas inactivas; alimentan el watchdog y liberan la memoria de las tareas borradas |
Esta tabla deja dos lecciones importantes. La primera: las tareas de WiFi y TCP/IP tienen una prioridad muy alta; si pones una tarea pesada tuya en el núcleo 0, la interrumpirán cada vez que llegue tráfico de red, y si tú las mantienes ocupadas mucho tiempo, el WiFi se resiente. La segunda: loopTask solo tiene prioridad 1; si pones en el núcleo 1 una tarea de mayor prioridad que nunca espera, loop() no llegará a ejecutarse. El ESP32-S3 también tiene doble núcleo. En cambio, el ESP32-S2, el ESP32-C3 y el ESP32-C6 son de un solo núcleo; en ellos puedes crear tareas igualmente, pero todas comparten el mismo núcleo.
Esquema de conexión
Para los ejemplos de este artículo basta con un ESP32 DevKit, dos LED, un potenciómetro y un pulsador. El LED azul de la placa está en el GPIO 2; conecta el segundo LED al GPIO 4 con una resistencia de 220 Ω. El potenciómetro va al GPIO 34, un canal del ADC1, porque los pines del ADC2 no se pueden leer con el WiFi encendido.
| Componente | Pin del ESP32 | Nota |
|---|---|---|
| LED integrado | GPIO 2 | Viene en la mayoría de DevKits |
| Segundo LED | GPIO 4 | Resistencia en serie de 220 Ω, pata corta a GND |
| Cursor del potenciómetro | GPIO 34 | Solo entrada, ADC1; patas exteriores a 3V3 y GND |
| Pulsador | GPIO 27 | La otra pata a GND, con INPUT_PULLUP |
Primeras tareas con xTaskCreatePinnedToCore
En el primer ejemplo hacemos parpadear dos LED con dos tareas distintas, a velocidades diferentes y en núcleos diferentes. Cada función de tarea tiene la forma void funcion(void *parametro) y contiene un bucle infinito. xTaskCreatePinnedToCore(), que arranca la tarea, también le dice en qué núcleo debe ejecutarse. Fíjate en que usamos la misma función de tarea dos veces y le pasamos cada vez una estructura de ajustes distinta; gracias al parámetro, una sola función controla dos LED de forma independiente.
1// İki LED, iki görev, iki çekirdek / two LEDs, two tasks, two cores
2struct LedAyari {
3 int pin; // LED pini / LED pin
4 int beklemeMs; // yarım periyot / half period
5};
6
7LedAyari led1 = {2, 250}; // dahili LED, hızlı / onboard LED, fast
8LedAyari led2 = {4, 700}; // harici LED, yavaş / external LED, slow
9
10void ledGorevi(void *parametre) {
11 LedAyari *ayar = (LedAyari *)parametre;
12 pinMode(ayar->pin, OUTPUT);
13 for (;;) { // görev asla bitmez / a task never returns
14 digitalWrite(ayar->pin, !digitalRead(ayar->pin));
15 vTaskDelay(pdMS_TO_TICKS(ayar->beklemeMs)); // çekirdeği bırak / give the core away
16 }
17}
18
19void setup() {
20 Serial.begin(115200);
21 // fonksiyon, ad, yığın (bayt), parametre, öncelik, tutamaç, çekirdek
22 // function, name, stack (bytes), parameter, priority, handle, core
23 xTaskCreatePinnedToCore(ledGorevi, "LED1", 2048, &led1, 1, NULL, 0);
24 xTaskCreatePinnedToCore(ledGorevi, "LED2", 2048, &led2, 1, NULL, 1);
25}
26
27void loop() {
28 Serial.printf("loop() cekirdek / core: %d\n", xPortGetCoreID());
29 delay(1000); // ESP32'de delay de çekirdeği bırakır / delay yields on ESP32 too
30}Al cargar el código, los dos LED parpadean de forma independiente y el Monitor Serie muestra que loop() se ejecuta en el núcleo 1. Estos son los parámetros de la función:
| Parámetro | Valor en el ejemplo | Significado |
|---|---|---|
| pvTaskCode | ledGorevi | La función que ejecuta la tarea |
| pcName | "LED1" | Nombre que se ve al depurar, hasta 16 caracteres |
| usStackDepth | 2048 | Tamaño de la pila; en el ESP32 va en bytes |
| pvParameters | &led1 | Puntero que se pasa a la tarea; debe apuntar a una variable global o static |
| uxPriority | 1 | Prioridad, de 0 (la más baja) a 24 |
| pvCreatedTask | NULL | Identificador para detener o vigilar la tarea más adelante |
| xCoreID | 0 o 1 | Núcleo en el que corre; con tskNO_AFFINITY se ejecuta en el que esté libre |
delay(), vTaskDelay() y vTaskDelayUntil(): diferencias
En un Arduino Uno, delay() mantiene el procesador totalmente ocupado; mientras espera no se ejecuta nada más. En el ESP32 es distinto: delay() del núcleo Arduino en realidad llama a vTaskDelay(). Así que cuando escribes delay(100), tu tarea duerme 100 ms y el núcleo pasa mientras tanto a otras tareas. Por eso delay() también funciona dentro de las tareas; aun así, escribir vTaskDelay(pdMS_TO_TICKS(100)) en código FreeRTOS deja más clara tu intención. La diferencia real está en los métodos que esperan manteniendo ocupado el procesador: delayMicroseconds() y los bucles vacíos como while (millis() - t < 500) {} nunca liberan el núcleo. Explicamos con detalle el esquema de millis() en Arduino en millis() frente a delay().
| Método | ¿Libera el núcleo? | Cuándo usarlo |
|---|---|---|
| delay(ms) | Sí (en el ESP32 llama a vTaskDelay) | Esperas sencillas dentro de loop() |
| vTaskDelay(pdMS_TO_TICKS(ms)) | Sí | Esperas en tareas; el retardo se suma al tiempo de trabajo |
| vTaskDelayUntil(&ultimo, periodo) | Sí | Muestreo a intervalo fijo; periodo exacto sin importar el tiempo de trabajo |
| delayMicroseconds(us) | No | Esperas de microsegundos en protocolos de sensores |
| while (millis() - t < ms) {} | No | No lo uses en tareas FreeRTOS; deja sin tiempo a las demás |
Si un bucle funciona con vTaskDelay(100) y el trabajo dura 15 ms, el bucle se repite cada 115 ms y el error se acumula con el tiempo. Si quieres leer un sensor exactamente cada 100 ms, usa vTaskDelayUntil(): la función recuerda la hora del último despertar y despierta la tarea justo un periodo después cada vez. La tarea del sensor de la siguiente sección usa este método.
Prioridades de las tareas: ¿cuál se ejecuta primero?
Si en un núcleo hay varias tareas listas, siempre se ejecuta la de mayor prioridad. Una tarea de prioridad menor solo consigue el núcleo cuando las de mayor prioridad están esperando. Es lo que se llama planificación expropiativa por prioridades: en cuanto llegan los datos que espera una tarea de alta prioridad, la de menor prioridad se interrumpe. Así puedes dar alta prioridad a los trabajos que necesitan responder rápido, pero hay una trampa: si una tarea de alta prioridad nunca espera, las que están por debajo nunca se ejecutan. En la práctica funciona bien este esquema:
- Prioridad 1: Trabajos sin prisa, como actualizar una pantalla, escribir en el Monitor Serie o un servidor web. loop() también está en este nivel.
- Prioridad 2–3: Trabajos que deben hacerse a tiempo, como lecturas periódicas de sensores, bucles de control y gestión de botones.
- Prioridad 4–5: Tareas cortas que despierta una interrupción y que deben responder de inmediato.
- Evita: No des a tus tareas prioridad 18 o superior; esos niveles son del WiFi, del TCP/IP y de los temporizadores del sistema.
Compartir datos entre tareas de forma segura con una cola
La primera idea para pasar datos entre tareas es una variable global, pero dos tareas pueden acceder a ella al mismo tiempo. Si una tarea lee una estructura de varios bytes mientras otra la escribe, obtiene un valor mitad viejo y mitad nuevo; como estos fallos aparecen pocas veces y al azar, son muy difíciles de encontrar. La solución de FreeRTOS es la cola. Una cola es una fila de elementos de tamaño fijo que mueve los datos copiándolos: la tarea que envía deja una copia con xQueueSend() y la que recibe la recoge con xQueueReceive(). Si la cola está vacía, la tarea receptora duerme y no gasta CPU; en cuanto llegan datos, se despierta. En el ejemplo de abajo una tarea lee el potenciómetro exactamente cada 100 ms y mete la medida en la cola junto con una marca de tiempo; una segunda tarea procesa cada medida que sale de la cola.
1// Sensör görevi -> kuyruk -> işleyici görev / sensor task -> queue -> consumer task
2const int POT_PIN = 34; // ADC1 pini / ADC1 pin
3
4struct Olcum {
5 uint16_t ham; // 0-4095 ham değer / raw value
6 float volt; // gerilim / voltage
7 uint32_t zaman; // ms cinsinden zaman / timestamp in ms
8};
9
10QueueHandle_t olcumKuyrugu;
11
12void sensorGorevi(void *parametre) {
13 TickType_t sonUyanma = xTaskGetTickCount();
14 for (;;) {
15 Olcum o;
16 o.ham = analogRead(POT_PIN);
17 o.volt = analogReadMilliVolts(POT_PIN) / 1000.0f;
18 o.zaman = millis();
19 if (xQueueSend(olcumKuyrugu, &o, 0) != pdPASS) { // kuyruk doluysa bekleme / don't wait if full
20 Serial.println("Kuyruk dolu / Queue full");
21 }
22 vTaskDelayUntil(&sonUyanma, pdMS_TO_TICKS(100)); // tam 100 ms periyot / exact 100 ms period
23 }
24}
25
26void isleyiciGorev(void *parametre) {
27 Olcum o;
28 for (;;) {
29 // veri gelene kadar uyu / sleep until data arrives
30 if (xQueueReceive(olcumKuyrugu, &o, portMAX_DELAY) == pdPASS) {
31 Serial.printf("%lu ms ham/raw: %4u %.2f V bekleyen/waiting: %u\n",
32 (unsigned long)o.zaman, o.ham, o.volt,
33 (unsigned)uxQueueMessagesWaiting(olcumKuyrugu));
34 }
35 }
36}
37
38void setup() {
39 Serial.begin(115200);
40 olcumKuyrugu = xQueueCreate(10, sizeof(Olcum)); // 10 ölçümlük kuyruk / queue of 10 readings
41 if (olcumKuyrugu == NULL) {
42 Serial.println("Kuyruk olusturulamadi / Queue creation failed");
43 return;
44 }
45 xTaskCreatePinnedToCore(sensorGorevi, "Sensor", 3072, NULL, 2, NULL, 1);
46 xTaskCreatePinnedToCore(isleyiciGorev, "Isleyici", 3072, NULL, 1, NULL, 1);
47}
48
49void loop() {
50 vTaskDelay(pdMS_TO_TICKS(1000)); // loop'un burada işi yok / loop has nothing to do here
51}Como la prioridad de la tarea del sensor (2) es mayor que la de la tarea que procesa (1), las medidas siempre se toman a tiempo. Aunque la tarea que procesa vaya lenta un momento, por ejemplo al escribir en una tarjeta SD, no se pierde ninguna medida: esperan su turno en la cola de 10 elementos. Si la cola se llena, xQueueSend() devuelve un error sin esperar y te das cuenta. Si solo necesitas el valor más reciente, por ejemplo para mostrar la temperatura actual en una pantalla, puedes crear una cola de un solo elemento, escribir en ella con xQueueOverwrite() y leer el valor sin sacarlo con xQueuePeek(). Usaremos este método en el último ejemplo.
Semáforo y mutex: despertar una tarea desde una interrupción y proteger un recurso compartido
Un semáforo binario es como una bandera que permite a una tarea esperar un evento. Su uso más habitual son las interrupciones: la rutina de interrupción (ISR) de un botón debe ser muy corta, así que no hace el trabajo de verdad, solo entrega el semáforo; la tarea que esperaba ese semáforo se despierta y hace el trabajo. Explicamos las bases de las interrupciones en el artículo interrupciones en Arduino. Un mutex garantiza que solo una tarea a la vez use un recurso compartido, como el puerto serie, el bus I2C o una pantalla. Si dos tareas llaman a Serial.printf() en el mismo momento, sus líneas pueden mezclarse; con un mutex cada tarea toma el cerrojo antes de escribir y lo suelta al terminar. En el código de abajo cada pulsación del botón cambia el estado del segundo LED, y dos tareas escriben en el mismo Monitor Serie sin mezclar sus mensajes.
1const int BUTON_PIN = 27; // butonun diğer ucu GND / other leg to GND
2const int LED_PIN = 4;
3
4SemaphoreHandle_t butonSemaforu; // kesme -> görev sinyali / ISR -> task signal
5SemaphoreHandle_t seriKilit; // Serial için mutex / mutex for Serial
6
7void IRAM_ATTR butonKesmesi() {
8 BaseType_t uyandir = pdFALSE;
9 xSemaphoreGiveFromISR(butonSemaforu, &uyandir); // ISR'de FromISR sürümü / FromISR version in ISR
10 if (uyandir == pdTRUE) {
11 portYIELD_FROM_ISR(); // bekleyen görevi hemen çalıştır / run the waiting task now
12 }
13}
14
15void guvenliYaz(const char *metin) {
16 if (xSemaphoreTake(seriKilit, pdMS_TO_TICKS(100)) == pdTRUE) {
17 Serial.println(metin);
18 xSemaphoreGive(seriKilit); // kilidi mutlaka bırak / always release the lock
19 }
20}
21
22void butonGorevi(void *parametre) {
23 uint32_t sonBasma = 0;
24 for (;;) {
25 xSemaphoreTake(butonSemaforu, portMAX_DELAY); // basılana kadar uyu / sleep until pressed
26 if (millis() - sonBasma > 200) { // 200 ms ark önleme / 200 ms debounce
27 sonBasma = millis();
28 digitalWrite(LED_PIN, !digitalRead(LED_PIN));
29 guvenliYaz("Butona basildi / Button pressed");
30 }
31 }
32}
33
34void raporGorevi(void *parametre) {
35 char satir[64];
36 for (;;) {
37 snprintf(satir, sizeof(satir), "Calisma suresi / Uptime: %lu s", (unsigned long)(millis() / 1000));
38 guvenliYaz(satir);
39 vTaskDelay(pdMS_TO_TICKS(2000));
40 }
41}
42
43void setup() {
44 Serial.begin(115200);
45 pinMode(LED_PIN, OUTPUT);
46 pinMode(BUTON_PIN, INPUT_PULLUP);
47 butonSemaforu = xSemaphoreCreateBinary();
48 seriKilit = xSemaphoreCreateMutex();
49 xTaskCreatePinnedToCore(butonGorevi, "Buton", 2048, NULL, 3, NULL, 1);
50 xTaskCreatePinnedToCore(raporGorevi, "Rapor", 2048, NULL, 1, NULL, 1);
51 attachInterrupt(digitalPinToInterrupt(BUTON_PIN), butonKesmesi, FALLING);
52}
53
54void loop() {
55 vTaskDelay(pdMS_TO_TICKS(1000));
56}¿En qué núcleo funciona el WiFi y dónde poner tus tareas?
En el núcleo Arduino, el controlador WiFi, la pila TCP/IP y el Bluetooth están fijados al núcleo 0; loop() y los eventos de Arduino corren en el núcleo 1. Por defecto, el watchdog de tareas del ESP32 vigila también la tarea inactiva del núcleo 0 (IDLE0). Si pones en el núcleo 0 una tarea con prioridad que nunca espera, IDLE0 no puede ejecutarse durante 5 segundos, el Monitor Serie muestra Task watchdog got triggered y la placa se reinicia. Esa misma tarea retrasa además el procesado de los paquetes de red. Una regla sencilla te facilita las cosas:
| Trabajo | Núcleo recomendado | ¿Por qué? |
|---|---|---|
| Control rápido y regular, muestreo de sensores, control de motores | 1 | Las interrupciones del WiFi no alteran los tiempos |
| Servidor web, MQTT, peticiones HTTP | 0 o 1, prioridad baja | La pila de red ya está en el núcleo 0; tu tarea debe esperar a menudo |
| Actualizar pantalla, registro de datos | 1, prioridad 1 | No es urgente, aprovecha el tiempo libre |
| Cálculos largos (FFT, cifrado) | 1, o 0 con prioridad baja, con vTaskDelay(1) entre medias | Para no dejar sin tiempo al watchdog ni a otras tareas |
Tamaño de pila y errores del watchdog
Cada tarea tiene su propia memoria de pila (stack); las variables locales, las llamadas a funciones y funciones de librería como printf usan ese espacio. En el ESP32 el tamaño de pila se indica en bytes; la unidad "word" de la documentación estándar de FreeRTOS no se aplica al ESP32. Para una tarea sencilla de LED bastan 2048 bytes. A las tareas que usan Serial.printf(), operaciones con String o imprimen números con decimales dales 3072–4096 bytes. Las que manejan HTTPClient, TLS (HTTPS) o JSON pueden necesitar 8192 bytes o más. Si una pila se desborda, el ESP32 muestra Stack canary watchpoint triggered o A stack overflow in task ... has been detected y se reinicia. Con uxTaskGetStackHighWaterMark() sabes cuánta pila ha quedado libre como mínimo hasta ahora; el valor va en bytes y, si baja de 500, agranda la pila. En ESP32 Brownout y Guru Meditation explicamos cómo leer los mensajes de error de los reinicios inesperados.
| Mensaje de error | Significado | Solución |
|---|---|---|
| Task watchdog got triggered ... IDLE (CPU 0) | Una tarea del núcleo 0 no esperó en 5 s | Añade vTaskDelay(1) al bucle, baja la prioridad o pasa la tarea al núcleo 1 |
| Stack canary watchpoint triggered (nombre de la tarea) | Se desbordó la pila de la tarea indicada | Aumenta el valor de pila en xTaskCreatePinnedToCore |
| Guru Meditation Error: LoadProhibited | Se leyó una dirección no válida | Comprueba si el puntero que pasas a la tarea apunta a una variable local |
| Interrupt wdt timeout on CPU1 | Una rutina de interrupción tardó demasiado o las interrupciones quedaron desactivadas | Acorta la ISR y pasa el trabajo a una tarea con un semáforo |
| FreeRTOS Task "Gorev" should not return, Aborting now! | La función de la tarea terminó con return | Usa un bucle infinito o llama a vTaskDelete(NULL) al final |
Proyecto: LED, sensor y servidor web a la vez
Ahora juntemos todo en un único proyecto. Habrá tres tareas: la tarea del sensor lee el potenciómetro cada 200 ms y escribe la media de las 8 últimas lecturas en una cola de un elemento; la tarea del LED hace parpadear el LED integrado a la velocidad que se ajusta desde la página web; y la tarea web muestra el valor actual del sensor en una página que abres desde el móvil y ofrece enlaces para cambiar la velocidad del LED. Las tareas no comparten datos con variables globales, sino con xQueueOverwrite() y xQueuePeek(). loop() imprime cada 10 segundos la pila libre de cada tarea y la RAM libre, para que veas en funcionamiento real si las pilas son suficientes. Cambia el nombre de la red WiFi y la contraseña por los tuyos.
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_ADI = "EvAgi_2G"; // Wi-Fi adı / network name
5const char* WIFI_SIFRE = "sifre1234"; // Wi-Fi şifresi / Wi-Fi password
6
7const int LED_PIN = 2; // dahili LED / onboard LED
8const int POT_PIN = 34; // ADC1, Wi-Fi ile çalışır / ADC1, works with Wi-Fi
9
10WebServer sunucu(80);
11QueueHandle_t sensorKutusu; // tek öğe: son ortalama / one item: latest average
12QueueHandle_t hizKutusu; // tek öğe: LED yarım periyodu / one item: LED half period
13TaskHandle_t ledTutamac, sensorTutamac, webTutamac;
14
15void sensorGorevi(void *p) {
16 uint16_t son[8] = {0};
17 uint8_t sira = 0;
18 TickType_t sonUyanma = xTaskGetTickCount();
19 for (;;) {
20 son[sira] = analogRead(POT_PIN);
21 sira = (sira + 1) % 8;
22 uint32_t toplam = 0;
23 for (int i = 0; i < 8; i++) toplam += son[i];
24 uint16_t ortalama = toplam / 8;
25 xQueueOverwrite(sensorKutusu, &ortalama); // eskisinin üzerine yaz / overwrite the old one
26 vTaskDelayUntil(&sonUyanma, pdMS_TO_TICKS(200));
27 }
28}
29
30void ledGorevi(void *p) {
31 pinMode(LED_PIN, OUTPUT);
32 uint32_t beklemeMs = 500;
33 for (;;) {
34 xQueuePeek(hizKutusu, &beklemeMs, 0); // yeni hız varsa al / take a new speed if any
35 digitalWrite(LED_PIN, !digitalRead(LED_PIN));
36 vTaskDelay(pdMS_TO_TICKS(beklemeMs));
37 }
38}
39
40void anaSayfa() {
41 uint16_t deger = 0;
42 uint32_t hiz = 0;
43 xQueuePeek(sensorKutusu, °er, 0); // okur ama silmez / reads without removing
44 xQueuePeek(hizKutusu, &hiz, 0);
45 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
46 "<meta http-equiv='refresh' content='2'>"
47 "<meta name='viewport' content='width=device-width'></head><body>"
48 "<h2>ESP32 FreeRTOS</h2>";
49 html += "<p>Sensor: " + String(deger) + " / 4095</p>";
50 html += "<p>LED: " + String(hiz) + " ms</p>";
51 html += "<p><a href='/hiz?ms=100'>100 ms</a> | <a href='/hiz?ms=500'>500 ms</a> | "
52 "<a href='/hiz?ms=1000'>1000 ms</a></p></body></html>";
53 sunucu.send(200, "text/html", html);
54}
55
56void hizAyarla() {
57 uint32_t ms = sunucu.arg("ms").toInt();
58 if (ms >= 50 && ms <= 5000) {
59 xQueueOverwrite(hizKutusu, &ms);
60 }
61 sunucu.sendHeader("Location", "/");
62 sunucu.send(303);
63}
64
65void webGorevi(void *p) {
66 WiFi.mode(WIFI_STA);
67 WiFi.begin(WIFI_ADI, WIFI_SIFRE);
68 while (WiFi.status() != WL_CONNECTED) {
69 vTaskDelay(pdMS_TO_TICKS(500)); // beklerken çekirdeği bırak / yield while waiting
70 }
71 Serial.print("Adres / Address: http://");
72 Serial.println(WiFi.localIP());
73 sunucu.on("/", anaSayfa);
74 sunucu.on("/hiz", hizAyarla);
75 sunucu.begin();
76 for (;;) {
77 sunucu.handleClient();
78 vTaskDelay(pdMS_TO_TICKS(2)); // IDLE görevine nefes aldır / let the idle task run
79 }
80}
81
82void setup() {
83 Serial.begin(115200);
84 sensorKutusu = xQueueCreate(1, sizeof(uint16_t));
85 hizKutusu = xQueueCreate(1, sizeof(uint32_t));
86 uint32_t ilkHiz = 500;
87 xQueueOverwrite(hizKutusu, &ilkHiz);
88
89 xTaskCreatePinnedToCore(sensorGorevi, "Sensor", 2048, NULL, 2, &sensorTutamac, 1);
90 xTaskCreatePinnedToCore(ledGorevi, "LED", 2048, NULL, 1, &ledTutamac, 1);
91 xTaskCreatePinnedToCore(webGorevi, "Web", 6144, NULL, 1, &webTutamac, 0);
92}
93
94void loop() {
95 // boş yığın (bayt) ve boş RAM / free stack (bytes) and free heap
96 Serial.printf("Bos yigin / Free stack Sensor: %u LED: %u Web: %u | Heap: %u\n",
97 (unsigned)uxTaskGetStackHighWaterMark(sensorTutamac),
98 (unsigned)uxTaskGetStackHighWaterMark(ledTutamac),
99 (unsigned)uxTaskGetStackHighWaterMark(webTutamac),
100 (unsigned)ESP.getFreeHeap());
101 vTaskDelay(pdMS_TO_TICKS(10000));
102}Después de cargar el código, abre en el móvil la dirección que aparece en el Monitor Serie. La página se recarga cada 2 segundos y el valor cambia al girar el potenciómetro. Al pulsar los enlaces, la velocidad del LED cambia al instante, pero el ritmo de lectura del sensor no se altera, porque cada trabajo corre en su propia tarea y a su propio ritmo. La tarea web está en el núcleo 0, junto a la pila de red y con prioridad baja; como espera 2 ms en cada vuelta, la tarea IDLE0 puede ejecutarse y el watchdog no salta. Las tareas del LED y del sensor están en el núcleo 1 y el tráfico WiFi no les afecta. Es fácil ampliar esta estructura: para actualizar los datos al instante sin recargar la página, añade el método WebSocket del artículo servidor web ESP32 y WebSocket, y para suavizar valores ruidosos cambia la media de la tarea del sensor por un filtro de mediana o exponencial.
Comparación con la Raspberry Pi Pico: dos núcleos en MicroPython
El RP2040 de la Raspberry Pi Pico también tiene doble núcleo, pero no hay sistema operativo: en MicroPython arrancas el segundo núcleo con el módulo _thread y solo corren dos hilos entre los dos núcleos. En el lado de Arduino, el núcleo arduino-pico ofrece las funciones setup1() y loop1() para el segundo núcleo. El código MicroPython de abajo hace parpadear el LED en el segundo núcleo mientras lee el potenciómetro en el primero; el contador compartido está protegido con un cerrojo (lock), igual que con el mutex en el ESP32. Tienes más sobre los núcleos y las unidades PIO de la Pico en el artículo PIO y dos núcleos en la Pico.
1import _thread, time
2from machine import Pin, ADC
3
4led = Pin(25, Pin.OUT) # Pico dahili LED (Pico W'da Pin("LED")) / onboard LED (Pin("LED") on Pico W)
5pot = ADC(26) # GP26 = ADC0
6kilit = _thread.allocate_lock() # ortak veri kilidi / lock for shared data
7yanma_sayisi = 0
8
9def ikinci_cekirdek():
10 global yanma_sayisi
11 while True:
12 led.toggle()
13 with kilit: # sayaç güvenle artar / counter updated safely
14 yanma_sayisi += 1
15 time.sleep_ms(300)
16
17_thread.start_new_thread(ikinci_cekirdek, ()) # çekirdek 1'de çalışır / runs on core 1
18
19while True:
20 deger = pot.read_u16() # 0-65535
21 with kilit:
22 sayac = yanma_sayisi
23 print("Pot:", deger, "LED degisimi / toggles:", sayac)
24 time.sleep(1)En la Pico este método funciona bien para dos trabajos, pero herramientas como el número de tareas, las prioridades, las colas y el planificador no son tan completas como FreeRTOS en el ESP32. Para proyectos con muchos trabajos simultáneos, conexiones de red y tiempos precisos, el ESP32 con FreeRTOS ofrece una base más cómoda. Si quieres hacer proyectos con WiFi en la Pico, echa un vistazo al artículo servidor web WiFi con Pico W.
Errores frecuentes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| La placa se reinicia nada más crear una tarea | La función de la tarea termina con return o la pila es demasiado pequeña | Añade un bucle infinito y sube la pila a 4096 bytes |
| loop() nunca se ejecuta | Una tarea de mayor prioridad en el núcleo 1 nunca espera | Añade vTaskDelay() a esa tarea o baja su prioridad a 1 |
| Error del watchdog con el WiFi encendido | Una tarea del núcleo 0 deja sin tiempo a IDLE0 | Usa vTaskDelay(1) en el bucle o pasa la tarea al núcleo 1 |
| A veces salen valores absurdos | Dos tareas leen y escriben a la vez la misma estructura global | Pasa los datos con una cola o protege el acceso con un mutex |
| Las líneas del Monitor Serie se mezclan | Dos tareas escriben a la vez en Serial | Toma un mutex antes de escribir y suéltalo después |
| La placa se cuelga al pulsar el botón | Serial.print o una función FreeRTOS normal en la rutina de interrupción | En la ISR usa solo funciones FromISR y pasa el trabajo a una tarea |
| analogRead() devuelve 4095 o 0 con el WiFi activo | El sensor está en un pin ADC2 | Usa uno de los pines ADC1, GPIO 32–39 |
| El código compila en el ESP32-C3 pero no funciona | Se pidió el núcleo 1 en un chip de un solo núcleo | Usa el núcleo 0 o tskNO_AFFINITY, o bien xTaskCreate() |
Los dos núcleos del ESP32 y FreeRTOS convierten funciones loop() complicadas y llenas de cuentas con millis() en tareas pequeñas y legibles, cada una centrada en un solo trabajo. Ahora que sabes crear tareas, dar prioridades, mover datos con colas, atender interrupciones con semáforos y medir la pila, tus proyectos con WiFi funcionarán sin atascos. Si acabas de conocer el ESP32, encontrarás lo básico en ¿Qué es el ESP32?. En la app BlueGrays también puedes explorar proyectos con ESP32 como un servidor web asíncrono, WebSocket, un reloj NTP, un registrador de temperatura y una iluminación inteligente, con esquemas paso a paso y código listo para usar.
Preguntas frecuentes
¿Qué es FreeRTOS en el ESP32?
FreeRTOS es un sistema operativo en tiempo real que funciona dentro del ESP32, y tu código Arduino también se ejecuta sobre él. Te permite dividir varios trabajos en tareas separadas, darles prioridades y repartirlas entre los dos núcleos. No hace falta instalar nada; funciones como xTaskCreate ya están disponibles en el núcleo Arduino del ESP32.
¿En qué núcleo se ejecuta loop() en el ESP32?
En el núcleo Arduino, setup() y loop() se ejecutan dentro de la tarea loopTask, en el núcleo 1 y con prioridad 1. El WiFi, el TCP/IP y el Bluetooth están en el núcleo 0. Puedes comprobarlo tú mismo imprimiendo xPortGetCoreID().
¿Qué diferencia hay entre delay() y vTaskDelay() en el ESP32?
En el núcleo Arduino del ESP32, delay() llama en realidad a vTaskDelay(), así que los dos ceden el núcleo a otras tareas mientras esperan. La espera activa que conoces del Arduino Uno se da en el ESP32 con delayMicroseconds() y con bucles while vacíos. Para trabajos a intervalo fijo, vTaskDelayUntil() es más preciso.
¿Qué tamaño de pila poner en xTaskCreatePinnedToCore?
En el ESP32 el tamaño de pila va en bytes. Un buen punto de partida es 2048 bytes para tareas sencillas de LED, 3072–4096 para tareas con Serial.printf y String, y 8192 para trabajos pesados como HTTPS y JSON. Mide la necesidad real con uxTaskGetStackHighWaterMark() y ajústala.
¿Cómo se soluciona el error "Task watchdog got triggered" del ESP32?
Este error indica que la tarea inactiva del núcleo 0 no pudo ejecutarse durante 5 segundos; casi siempre una tarea da vueltas sin esperar nunca. Añade vTaskDelay(1) dentro del bucle, baja la prioridad de la tarea o pásala al núcleo 1. También ayuda dividir los cálculos largos en partes más pequeñas.
¿Cómo se comparten datos entre tareas en el ESP32?
Lo más seguro son las colas de FreeRTOS: los datos se envían con xQueueSend() y se reciben con xQueueReceive(), y como se copian no aparecen valores leídos a medias. Si solo hace falta el último valor, se usa una cola de un elemento con xQueueOverwrite() y xQueuePeek(). Si compartes hardware o una estructura global, protege el acceso con un mutex.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)
En este proyecto, dos botones conectados al ESP32 (GPIO 5 suma, GPIO 4 resta) cambian un contador. El valor se actualiza al instante en una pantalla LCD I2C de 16x2 y, gracias al soporte WebSocket de ESPAsyncWebServer, en todos los navegadores conectados sin recargar la página. En lugar del sondeo HTTP se usa una única conexión persistente y el ESP32 envía el nuevo valor a todos con ws.textAll().

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

Control de la tira NeoPixel WS2812B con ESP32
Los LED direccionables WS2812B (NeoPixel) son LED RGB inteligentes que se encadenan y se controlan desde un solo pin de datos. Controlamos una tira WS2812B de 8 LED con la biblioteca Adafruit_NeoPixel y creamos un arcoíris fluido. La lógica de 3,3 V del ESP32 va bien con casi todos los WS2812B; si hay inestabilidad, mostramos la solución con una resistencia en serie de 470Ω y un condensador de 1000µF. La animación desplaza el tono en el espacio HSV.

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

