ESP32 FreeRTOS: dual core, task, code, semafori e watchdog
ESP32 FreeRTOS: xTaskCreatePinnedToCore, priorità, delay o vTaskDelay, code, semafori, stack e watchdog; LED, sensore e web server che girano insieme.
ESP32 FreeRTOS è il sistema operativo in tempo reale che gira già dentro l'ESP32 e che ti permette di fare più cose contemporaneamente. Ogni sketch per ESP32 che scrivi nell'Arduino IDE in realtà gira sopra FreeRTOS: le tue funzioni setup() e loop() vengono eseguite in un task chiamato loopTask, su uno dei due core dell'ESP32. Creando task tuoi puoi far lampeggiare un LED mentre leggi un sensore e rispondere nello stesso momento alle richieste di un web server, senza che nessuno blocchi gli altri. Lo schema "più cose insieme" che costruisci con millis() su un Arduino Uno diventa molto più pulito sull'ESP32.
In questa guida scoprirai come vengono divisi i due core dell'ESP32 e su quale gira il Wi-Fi. Poi creeremo task con xTaskCreatePinnedToCore, li vincoleremo a un core preciso, imposteremo le priorità e vedremo la differenza tra delay() e vTaskDelay(). Useremo una coda (queue) per condividere dati in sicurezza tra i task, un semaforo per svegliare un task dall'interrupt di un pulsante e un mutex per proteggere il Monitor seriale condiviso. Dopo aver affrontato dimensione dello stack ed errori del watchdog, costruiremo un esempio completo in cui un LED, un sensore e un web server girano insieme. Alla fine c'è un breve confronto con i due core del Raspberry Pi Pico.

Che cos'è ESP32 FreeRTOS e come funzionano i due core?
In FreeRTOS ogni lavoro è un task. Un task è una normale funzione C con il proprio stack e la propria priorità, che di solito contiene un ciclo infinito. Su ogni core lo scheduler di FreeRTOS sceglie, tra i task pronti, quello con la priorità più alta. Quando un task attende con vTaskDelay(), aspetta dati da una coda o un semaforo, il core passa subito a un altro task. I task con la stessa priorità si alternano a ogni tick. Nel core Arduino dell'ESP32 un tick dura 1 ms (1000 tick al secondo), quindi vTaskDelay(100) attende circa 100 ms. L'ESP32 classico ha due core: il core 0 (PRO_CPU) e il core 1 (APP_CPU). Espressif mette le comunicazioni wireless sul core 0 e il tuo codice sul core 1, così il Wi-Fi non interrompe il tuo ciclo. Con le impostazioni predefinite di Arduino, sui core gira questo:
| Task | Core | Priorità | Compito |
|---|---|---|---|
| loopTask (setup e loop) | 1 | 1 | Il tuo codice Arduino, stack di 8192 byte |
| Driver Wi-Fi | 0 | 23 | Radio e protocollo Wi-Fi |
| lwIP (tcpip) | 0 | 18 | Stack TCP/IP, pacchetti web e MQTT |
| Bluetooth (BT/BLE) | 0 | Alta | Controller Bluetooth e Bluedroid |
| esp_timer | 0 | 22 | Timer software |
| IDLE0 e IDLE1 | 0 e 1 | 0 | Task di inattività; alimentano il watchdog e liberano la memoria dei task eliminati |
Questa tabella contiene due lezioni importanti. Primo: i task Wi-Fi e TCP/IP hanno una priorità molto alta; se metti un tuo task pesante sul core 0, lo interromperanno a ogni arrivo di traffico di rete, e se li tieni occupati a lungo il Wi-Fi ne risente. Secondo: loopTask ha priorità 1; se metti sul core 1 un task con priorità più alta che non attende mai, loop() non verrà più eseguito. Anche l'ESP32-S3 è dual core. ESP32-S2, ESP32-C3 ed ESP32-C6 invece sono single core; puoi comunque creare task su queste schede, ma condividono tutti lo stesso core.
Schema di collegamento
Per gli esempi di questo articolo bastano un ESP32 DevKit, due LED, un potenziometro e un pulsante. Il LED blu della scheda è sul GPIO 2; collega il secondo LED al GPIO 4 con una resistenza da 220 Ω. Il potenziometro va sul GPIO 34, un canale dell'ADC1, perché i pin dell'ADC2 non si possono leggere con il Wi-Fi attivo.
| Componente | Pin ESP32 | Nota |
|---|---|---|
| LED integrato | GPIO 2 | Presente sulla maggior parte dei DevKit |
| Secondo LED | GPIO 4 | Resistenza in serie da 220 Ω, gamba corta a GND |
| Cursore del potenziometro | GPIO 34 | Solo ingresso, ADC1; gambe esterne a 3V3 e GND |
| Pulsante | GPIO 27 | L'altro capo a GND, con INPUT_PULLUP |
I primi task con xTaskCreatePinnedToCore
Nel primo esempio facciamo lampeggiare due LED con due task separati, a velocità diverse e su core diversi. Ogni funzione task ha la forma void funzione(void *parametro) e contiene un ciclo infinito. xTaskCreatePinnedToCore(), che avvia il task, gli dice anche su quale core girare. Nota che usiamo due volte la stessa funzione task passando ogni volta una struttura di impostazioni diversa; grazie al parametro, una sola funzione gestisce due LED in modo indipendente.
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}Dopo il caricamento i due LED lampeggiano in modo indipendente e il Monitor seriale mostra che loop() gira sul core 1. Questi sono i parametri della funzione:
| Parametro | Valore nell'esempio | Significato |
|---|---|---|
| pvTaskCode | ledGorevi | La funzione eseguita dal task |
| pcName | "LED1" | Nome visibile nel debug, al massimo 16 caratteri |
| usStackDepth | 2048 | Dimensione dello stack; sull'ESP32 è in byte |
| pvParameters | &led1 | Puntatore passato al task; deve puntare a una variabile globale o static |
| uxPriority | 1 | Priorità, da 0 (la più bassa) a 24 |
| pvCreatedTask | NULL | Handle per fermare o monitorare il task in seguito |
| xCoreID | 0 o 1 | Core su cui gira; con tskNO_AFFINITY gira sul core libero |
delay(), vTaskDelay() e vTaskDelayUntil(): le differenze
Su un Arduino Uno delay() tiene il processore completamente occupato; durante l'attesa non gira nient'altro. Sull'ESP32 è diverso: delay() del core Arduino in realtà chiama vTaskDelay(). Quindi quando scrivi delay(100) il tuo task dorme 100 ms e nel frattempo il core passa agli altri task. Per questo delay() funziona anche dentro i task; comunque scrivere vTaskDelay(pdMS_TO_TICKS(100)) nel codice FreeRTOS rende più chiara la tua intenzione. La vera differenza riguarda i metodi che attendono tenendo occupato il processore: delayMicroseconds() e i cicli vuoti come while (millis() - t < 500) {} non liberano mai il core. Spieghiamo in dettaglio lo schema con millis() su Arduino in millis() e delay() a confronto.
| Metodo | Libera il core? | Quando usarlo |
|---|---|---|
| delay(ms) | Sì (sull'ESP32 chiama vTaskDelay) | Attese semplici dentro loop() |
| vTaskDelay(pdMS_TO_TICKS(ms)) | Sì | Attese nei task; il ritardo si somma al tempo di lavoro |
| vTaskDelayUntil(&ultimo, periodo) | Sì | Campionamento a intervallo fisso; periodo esatto indipendente dal tempo di lavoro |
| delayMicroseconds(us) | No | Attese in microsecondi nei protocolli dei sensori |
| while (millis() - t < ms) {} | No | Da evitare nei task FreeRTOS; lascia a secco gli altri task |
Se un ciclo gira con vTaskDelay(100) e il lavoro dura 15 ms, il ciclo si ripete ogni 115 ms e l'errore si accumula nel tempo. Se vuoi leggere un sensore esattamente ogni 100 ms, usa vTaskDelayUntil(): la funzione ricorda l'istante dell'ultimo risveglio e sveglia il task esattamente un periodo dopo ogni volta. Il task del sensore nella prossima sezione usa questo metodo.
Priorità dei task: quale gira per primo?
Se su un core ci sono più task pronti, gira sempre quello con la priorità più alta. Un task con priorità più bassa ottiene il core solo quando quelli più prioritari sono in attesa. Si chiama scheduling preemptive a priorità: appena arrivano i dati che un task ad alta priorità sta aspettando, quello a priorità più bassa viene interrotto. Così puoi dare alta priorità ai lavori che devono reagire in fretta, ma c'è una trappola: se un task ad alta priorità non attende mai, quelli sotto di lui non girano mai. In pratica funziona bene questo schema:
- Priorità 1: Lavori senza fretta, come aggiornare un display, scrivere sul Monitor seriale o un web server. Anche loop() è a questo livello.
- Priorità 2–3: Lavori da fare puntualmente, come la lettura periodica dei sensori, i cicli di controllo e la gestione dei pulsanti.
- Priorità 4–5: Task brevi svegliati da un interrupt che devono reagire subito.
- Da evitare: Non dare ai tuoi task priorità 18 o superiore; quei livelli appartengono a Wi-Fi, TCP/IP e timer di sistema.
Condividere dati tra task in sicurezza con una coda
La prima idea per passare dati tra task è una variabile globale, ma due task possono accedervi nello stesso momento. Se un task legge una struttura di più byte mentre un altro la scrive, ottiene un valore metà vecchio e metà nuovo; poiché questi errori compaiono di rado e a caso, sono difficilissimi da trovare. La soluzione di FreeRTOS è la coda. Una coda è una fila di elementi di dimensione fissa che trasporta i dati copiandoli: il task che invia lascia una copia con xQueueSend() e quello che riceve la preleva con xQueueReceive(). Se la coda è vuota, il task ricevente dorme e non consuma CPU; appena arrivano dati si sveglia. Nell'esempio qui sotto un task legge il potenziometro esattamente ogni 100 ms e mette la misura in coda insieme a un timestamp; un secondo task elabora ogni misura che esce dalla coda.
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}Poiché la priorità del task del sensore (2) è più alta di quella del task che elabora (1), le misure vengono sempre prese in orario. Anche se il task che elabora rallenta per un attimo, per esempio mentre scrive su una scheda SD, nessuna misura va persa: aspettano il loro turno nella coda da 10 elementi. Se la coda si riempie, xQueueSend() restituisce un errore senza attendere e te ne accorgi. Se ti serve solo l'ultimo valore, per esempio per mostrare la temperatura attuale su un display, puoi creare una coda da un solo elemento, scriverci con xQueueOverwrite() e leggere il valore senza toglierlo con xQueuePeek(). Useremo questo metodo nell'ultimo esempio.
Semaforo e mutex: svegliare un task da un interrupt e proteggere una risorsa condivisa
Un semaforo binario è come una bandierina che permette a un task di attendere un evento. L'uso più comune riguarda gli interrupt: la routine di interrupt (ISR) di un pulsante deve essere brevissima, quindi non fa il lavoro vero, si limita a dare il semaforo; il task che lo attende si sveglia e svolge il lavoro. Spieghiamo le basi degli interrupt nell'articolo interrupt su Arduino. Un mutex garantisce che una risorsa condivisa, come la porta seriale, il bus I2C o un display, sia usata da un solo task alla volta. Se due task chiamano Serial.printf() nello stesso momento, le loro righe possono mescolarsi; con un mutex ogni task prende il lucchetto prima di scrivere e lo rilascia alla fine. Nel codice qui sotto ogni pressione del pulsante cambia lo stato del secondo LED, e due task scrivono sullo stesso Monitor seriale senza mescolare i messaggi.
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}Su quale core gira il Wi-Fi e dove mettere i tuoi task?
Nel core Arduino il driver Wi-Fi, lo stack TCP/IP e il Bluetooth sono vincolati al core 0; loop() e gli eventi Arduino girano sul core 1. Per impostazione predefinita il watchdog dei task dell'ESP32 controlla anche il task di inattività del core 0 (IDLE0). Se metti sul core 0 un task prioritario che non attende mai, IDLE0 non può girare per 5 secondi, il Monitor seriale mostra Task watchdog got triggered e la scheda si riavvia. Lo stesso task ritarda anche l'elaborazione dei pacchetti di rete. Una regola semplice ti aiuta:
| Lavoro | Core consigliato | Perché? |
|---|---|---|
| Controllo rapido e regolare, campionamento sensori, controllo motori | 1 | Le interruzioni del Wi-Fi non disturbano i tempi |
| Web server, MQTT, richieste HTTP | 0 o 1, priorità bassa | Lo stack di rete è già sul core 0; il tuo task deve attendere spesso |
| Aggiornamento display, registrazione dati | 1, priorità 1 | Non urgente, usa il tempo libero |
| Calcoli lunghi (FFT, cifratura) | 1, oppure 0 a bassa priorità, con vTaskDelay(1) nel mezzo | Per non lasciare a secco il watchdog e gli altri task |
Dimensione dello stack ed errori del watchdog
Ogni task ha la propria memoria di stack; variabili locali, chiamate di funzione e funzioni di libreria come printf usano questo spazio. Sull'ESP32 la dimensione dello stack si indica in byte; l'unità "word" della documentazione standard di FreeRTOS non vale per l'ESP32. Per un semplice task LED bastano 2048 byte. Ai task che usano Serial.printf(), operazioni con String o stampano numeri decimali dai 3072–4096 byte. I task che gestiscono HTTPClient, TLS (HTTPS) o JSON possono richiedere 8192 byte o più. Se uno stack trabocca, l'ESP32 segnala Stack canary watchpoint triggered o A stack overflow in task ... has been detected e si riavvia. Con uxTaskGetStackHighWaterMark() sai quanto stack è rimasto libero come minimo fino a quel momento; il valore è in byte e, se scende sotto 500, ingrandisci lo stack. Spieghiamo come leggere i messaggi di errore dei riavvii imprevisti in ESP32 Brownout e Guru Meditation.
| Messaggio di errore | Significato | Soluzione |
|---|---|---|
| Task watchdog got triggered ... IDLE (CPU 0) | Un task sul core 0 non ha atteso per 5 s | Aggiungi vTaskDelay(1) nel ciclo, abbassa la priorità o sposta il task sul core 1 |
| Stack canary watchpoint triggered (nome del task) | Lo stack del task indicato è traboccato | Aumenta il valore dello stack in xTaskCreatePinnedToCore |
| Guru Meditation Error: LoadProhibited | È stato letto un indirizzo non valido | Controlla se il puntatore passato al task punta a una variabile locale |
| Interrupt wdt timeout on CPU1 | Una routine di interrupt è durata troppo o gli interrupt sono rimasti disattivati | Accorcia la ISR e passa il lavoro a un task con un semaforo |
| FreeRTOS Task "Gorev" should not return, Aborting now! | La funzione task è terminata con return | Usa un ciclo infinito o chiama vTaskDelete(NULL) alla fine |
Progetto: LED, sensore e web server insieme
Ora mettiamo insieme tutto in un unico progetto. Ci saranno tre task: il task del sensore legge il potenziometro ogni 200 ms e scrive la media delle ultime 8 letture in una coda da un elemento; il task del LED fa lampeggiare il LED integrato alla velocità impostata dalla pagina web; il task web mostra il valore attuale del sensore su una pagina aperta dallo smartphone e offre link per cambiare la velocità del LED. I task non condividono i dati con variabili globali ma con xQueueOverwrite() e xQueuePeek(). loop() stampa ogni 10 secondi lo stack libero di ogni task e la RAM libera, così vedi nel funzionamento reale se gli stack bastano. Sostituisci nome della rete Wi-Fi e password con i tuoi.
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}Dopo il caricamento apri sullo smartphone l'indirizzo che compare nel Monitor seriale. La pagina si ricarica ogni 2 secondi e il valore cambia quando giri il potenziometro. Toccando i link la velocità del LED cambia subito, ma il ritmo di lettura del sensore non viene mai disturbato, perché ogni lavoro gira nel proprio task e al proprio ritmo. Il task web sta sul core 0 accanto allo stack di rete, a bassa priorità; poiché attende 2 ms a ogni giro, il task IDLE0 può girare e il watchdog non scatta. I task del LED e del sensore sono sul core 1 e non risentono del traffico Wi-Fi. La struttura è facile da ampliare: per aggiornare i dati all'istante senza ricaricare la pagina aggiungi il metodo WebSocket dell'articolo web server ESP32 e WebSocket, e per smussare valori rumorosi sostituisci la media del task del sensore con un filtro mediano o esponenziale.
Confronto con il Raspberry Pi Pico: due core in MicroPython
Anche l'RP2040 del Raspberry Pi Pico è dual core, ma non c'è un sistema operativo: in MicroPython avvii il secondo core con il modulo _thread e sui due core girano solo due thread. Lato Arduino, il core arduino-pico offre le funzioni setup1() e loop1() per il secondo core. Il codice MicroPython qui sotto fa lampeggiare il LED sul secondo core mentre legge il potenziometro sul primo; il contatore condiviso è protetto da un lock, proprio come il mutex sull'ESP32. Trovi altro sui core e sulle unità PIO del Pico nell'articolo PIO e due core del 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)Sul Pico questo metodo funziona bene per due lavori, ma strumenti come numero di task, priorità, code e scheduler non sono ricchi quanto FreeRTOS sull'ESP32. Per progetti con molti lavori simultanei, connessioni di rete e tempi precisi, ESP32 e FreeRTOS offrono una base più comoda. Se vuoi realizzare progetti Wi-Fi con il Pico, dai un'occhiata all'articolo web server Wi-Fi con Pico W.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| La scheda si riavvia appena viene creato un task | La funzione task termina con return o lo stack è troppo piccolo | Aggiungi un ciclo infinito e porta lo stack a 4096 byte |
| loop() non gira mai | Un task con priorità più alta sul core 1 non attende mai | Aggiungi vTaskDelay() a quel task o abbassa la sua priorità a 1 |
| Errore del watchdog con il Wi-Fi attivo | Un task sul core 0 lascia a secco IDLE0 | Usa vTaskDelay(1) nel ciclo o sposta il task sul core 1 |
| A volte escono valori assurdi | Due task leggono e scrivono insieme la stessa struttura globale | Passa i dati con una coda o proteggi l'accesso con un mutex |
| Le righe del Monitor seriale si mescolano | Due task scrivono su Serial nello stesso momento | Prendi un mutex prima di scrivere e rilascialo dopo |
| La scheda va in crash alla pressione del pulsante | Serial.print o una funzione FreeRTOS normale nella routine di interrupt | Nella ISR usa solo funzioni FromISR e passa il lavoro a un task |
| analogRead() restituisce 4095 o 0 con il Wi-Fi attivo | Il sensore è su un pin ADC2 | Usa uno dei pin ADC1, GPIO 32–39 |
| Il codice compila sull'ESP32-C3 ma non funziona | È stato richiesto il core 1 su un chip single core | Usa il core 0 o tskNO_AFFINITY, oppure xTaskCreate() |
I due core dell'ESP32 e FreeRTOS trasformano funzioni loop() complicate e piene di conti con millis() in task piccoli e leggibili, ognuno concentrato su un solo lavoro. Ora che sai creare task, assegnare priorità, spostare dati con le code, gestire interrupt con i semafori e misurare lo stack, i tuoi progetti Wi-Fi gireranno senza blocchi. Se hai appena conosciuto l'ESP32, trovi le basi in Che cos'è l'ESP32?. Nell'app BlueGrays puoi anche esplorare progetti ESP32 come web server asincrono, WebSocket, orologio NTP, registratore di temperatura e illuminazione intelligente, con schemi passo passo e codice pronto all'uso.
Domande frequenti
Che cos'è FreeRTOS sull'ESP32?
FreeRTOS è un sistema operativo in tempo reale che gira dentro l'ESP32, e anche il tuo codice Arduino gira sopra di esso. Ti permette di dividere più lavori in task separati, dar loro priorità e distribuirli sui due core. Non serve installare nulla; funzioni come xTaskCreate sono già disponibili nel core Arduino dell'ESP32.
Su quale core gira loop() nell'ESP32?
Nel core Arduino, setup() e loop() girano dentro il task loopTask sul core 1 con priorità 1. Wi-Fi, TCP/IP e Bluetooth sono sul core 0. Puoi verificarlo tu stesso stampando xPortGetCoreID().
Che differenza c'è tra delay() e vTaskDelay() sull'ESP32?
Nel core Arduino dell'ESP32, delay() in realtà chiama vTaskDelay(), quindi entrambi cedono il core agli altri task durante l'attesa. L'attesa attiva che conosci dall'Arduino Uno sull'ESP32 avviene con delayMicroseconds() e con i cicli while vuoti. Per i lavori a intervallo fisso vTaskDelayUntil() è più preciso.
Quanto deve essere grande lo stack in xTaskCreatePinnedToCore?
Sull'ESP32 la dimensione dello stack è in byte. Un buon punto di partenza è 2048 byte per i task LED semplici, 3072–4096 per i task con Serial.printf e String e 8192 per i lavori pesanti come HTTPS e JSON. Misura il fabbisogno reale con uxTaskGetStackHighWaterMark() e regola di conseguenza.
Come si risolve l'errore "Task watchdog got triggered" dell'ESP32?
L'errore indica che il task di inattività del core 0 non ha potuto girare per 5 secondi; quasi sempre un task cicla senza mai attendere. Aggiungi vTaskDelay(1) nel ciclo, abbassa la priorità del task o spostalo sul core 1. Aiuta anche dividere i calcoli lunghi in pezzi più piccoli.
Come si condividono i dati tra task sull'ESP32?
Il modo più sicuro sono le code di FreeRTOS: i dati si inviano con xQueueSend() e si ricevono con xQueueReceive(), e poiché vengono copiati non nascono valori letti a metà. Se serve solo l'ultimo valore si usa una coda da un elemento con xQueueOverwrite() e xQueuePeek(). Se condividi hardware o una struttura globale, proteggi l'accesso con un mutex.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)
In questo progetto due pulsanti collegati all'ESP32 (GPIO 5 incrementa, GPIO 4 decrementa) modificano un contatore. Il valore si aggiorna all'istante su un display LCD I2C 16x2 e, grazie al supporto WebSocket di ESPAsyncWebServer, in tutti i browser collegati senza ricaricare la pagina. Al posto del polling HTTP si usa un'unica connessione persistente e l'ESP32 invia il nuovo valore a tutti con ws.textAll().

Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.

Controllo della striscia LED NeoPixel WS2812B con ESP32
I LED indirizzabili WS2812B (NeoPixel) sono LED RGB intelligenti collegabili in catena e controllati da un solo pin dati. Pilotiamo una striscia WS2812B da 8 LED con la libreria Adafruit_NeoPixel e creiamo un arcobaleno fluido. La logica a 3,3 V dell'ESP32 va bene con quasi tutti i WS2812B; in caso di instabilità mostriamo la soluzione con una resistenza in serie da 470Ω e un condensatore da 1000µF. L'animazione sposta la tonalità nello spazio HSV.

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

