Guide · 13 min di lettura

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.

Scheda di sviluppo ESP32
L'ESP32 classico ha due core Xtensa LX6 e, con FreeRTOS, può eseguire task diversi su ciascuno.

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:

TaskCorePrioritàCompito
loopTask (setup e loop)11Il tuo codice Arduino, stack di 8192 byte
Driver Wi-Fi023Radio e protocollo Wi-Fi
lwIP (tcpip)018Stack TCP/IP, pacchetti web e MQTT
Bluetooth (BT/BLE)0AltaController Bluetooth e Bluedroid
esp_timer022Timer software
IDLE0 e IDLE10 e 10Task 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.

ComponentePin ESP32Nota
LED integratoGPIO 2Presente sulla maggior parte dei DevKit
Secondo LEDGPIO 4Resistenza in serie da 220 Ω, gamba corta a GND
Cursore del potenziometroGPIO 34Solo ingresso, ADC1; gambe esterne a 3V3 e GND
PulsanteGPIO 27L'altro capo a GND, con INPUT_PULLUP
Collega la gamba esterna del potenziometro a 3V3, non a 5V. I pin dell'ESP32 lavorano a 3,3 V e non tollerano i 5 V. Nei progetti con Wi-Fi collega i sensori analogici ai pin ADC1, GPIO 32–39; i pin ADC2 (GPIO 0, 2, 4, 12–15, 25–27) non si possono leggere con analogRead() quando il Wi-Fi è attivo. Puoi verificare la scelta dei pin con lo strumento Pinout.

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.

C++ (Arduino IDE)
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:

ParametroValore nell'esempioSignificato
pvTaskCodeledGoreviLa funzione eseguita dal task
pcName"LED1"Nome visibile nel debug, al massimo 16 caratteri
usStackDepth2048Dimensione dello stack; sull'ESP32 è in byte
pvParameters&led1Puntatore passato al task; deve puntare a una variabile globale o static
uxPriority1Priorità, da 0 (la più bassa) a 24
pvCreatedTaskNULLHandle per fermare o monitorare il task in seguito
xCoreID0 o 1Core su cui gira; con tskNO_AFFINITY gira sul core libero
Una funzione task non deve mai terminare con return; se lo fa, l'ESP32 segnala un errore e si riavvia. Se il task ha finito il suo lavoro, eliminalo chiamando vTaskDelete(NULL) nell'ultima riga. Non passare nemmeno come parametro l'indirizzo di una variabile locale di setup(): quando setup() termina, quella variabile sparisce e il task legge un indirizzo non valido. Sugli ESP32-C3, S2 e C6 single core come numero di core si possono usare solo 0 o tskNO_AFFINITY; la soluzione più portabile è xTaskCreate(), che non sceglie il core.

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.

MetodoLibera 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)NoAttese in microsecondi nei protocolli dei sensori
while (millis() - t < ms) {}NoDa 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
Dentro una routine di interrupt usa solo le funzioni FreeRTOS il cui nome termina con FromISR (come xSemaphoreGiveFromISR o xQueueSendFromISR). Chiamare Serial.print(), delay() o una funzione che attende dentro un interrupt fa andare in crash l'ESP32. Metti IRAM_ATTR davanti alla funzione di interrupt; così viene messa nella RAM veloce invece che nella flash. Quando prendi un mutex, restituiscilo sempre su ogni percorso: se dimentichi xSemaphoreGive() in un ramo di errore, tutti i task che attendono quella risorsa restano bloccati per sempre.

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:

LavoroCore consigliatoPerché?
Controllo rapido e regolare, campionamento sensori, controllo motori1Le interruzioni del Wi-Fi non disturbano i tempi
Web server, MQTT, richieste HTTP0 o 1, priorità bassaLo stack di rete è già sul core 0; il tuo task deve attendere spesso
Aggiornamento display, registrazione dati1, priorità 1Non urgente, usa il tempo libero
Calcoli lunghi (FFT, cifratura)1, oppure 0 a bassa priorità, con vTaskDelay(1) nel mezzoPer 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 erroreSignificatoSoluzione
Task watchdog got triggered ... IDLE (CPU 0)Un task sul core 0 non ha atteso per 5 sAggiungi 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 è traboccatoAumenta il valore dello stack in xTaskCreatePinnedToCore
Guru Meditation Error: LoadProhibitedÈ stato letto un indirizzo non validoControlla se il puntatore passato al task punta a una variabile locale
Interrupt wdt timeout on CPU1Una routine di interrupt è durata troppo o gli interrupt sono rimasti disattivatiAccorcia 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 returnUsa 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.

C++ (Arduino IDE)
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, &deger, 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.

MicroPython
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

SintomoCausa probabileSoluzione
La scheda si riavvia appena viene creato un taskLa funzione task termina con return o lo stack è troppo piccoloAggiungi un ciclo infinito e porta lo stack a 4096 byte
loop() non gira maiUn task con priorità più alta sul core 1 non attende maiAggiungi vTaskDelay() a quel task o abbassa la sua priorità a 1
Errore del watchdog con il Wi-Fi attivoUn task sul core 0 lascia a secco IDLE0Usa vTaskDelay(1) nel ciclo o sposta il task sul core 1
A volte escono valori assurdiDue task leggono e scrivono insieme la stessa struttura globalePassa i dati con una coda o proteggi l'accesso con un mutex
Le righe del Monitor seriale si mescolanoDue task scrivono su Serial nello stesso momentoPrendi un mutex prima di scrivere e rilascialo dopo
La scheda va in crash alla pressione del pulsanteSerial.print o una funzione FreeRTOS normale nella routine di interruptNella ISR usa solo funzioni FromISR e passa il lavoro a un task
analogRead() restituisce 4095 o 0 con il Wi-Fi attivoIl sensore è su un pin ADC2Usa 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 coreUsa il core 0 o tskNO_AFFINITY, oppure xTaskCreate()
Passando a FreeRTOS non dividere tutto in task in un colpo solo. Sposta prima nel suo task il lavoro più sensibile ai tempi del tuo codice funzionante, come il campionamento del sensore, e lascia il resto in loop(). Controlla lo stack con uxTaskGetStackHighWaterMark() dopo ogni nuovo task. Se ogni scambio di dati tra task passa per le code e ogni hardware condiviso per un mutex, eviti fin dall'inizio la maggior parte degli errori del tipo "ogni tanto si rompe".

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.

Vedi tutti i progetti
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

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).

4.8(16)
26
Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)
ES-28Avanzato
Premium

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().

4.5(14)
23
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

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.

4.4(21)
38
Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
ES-13Intermedio
Premium

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.

4.5(19)
32
Controllo della striscia LED NeoPixel WS2812B con ESP32
ES-24Intermedio
Premium

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.

4.9(19)
30
ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
ES-33Avanzato
Premium

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.

4.3(10)
16
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

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.

4.7(7)
12
Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
ES-37Avanzato
Premium

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.

4.3(6)
11