Rehberler · 10 dk okuma

ESP32 FreeRTOS: Çift Çekirdek, Görevler, Kuyruk ve Semafor

ESP32 FreeRTOS: xTaskCreatePinnedToCore, görev öncelikleri, delay ve vTaskDelay farkı, kuyruk, semafor, yığın ve watchdog; LED, sensör ve web sunucu birlikte.

ESP32 FreeRTOS, ESP32'nin içinde zaten çalışan ve birden fazla işi aynı anda yürütmeni sağlayan gerçek zamanlı işletim sistemidir. Arduino IDE'de yazdığın her ESP32 kodu aslında FreeRTOS'un üzerinde çalışır: setup() ve loop() fonksiyonların loopTask adlı bir görevin içinde, ESP32'nin iki çekirdeğinden birinde döner. Sen de kendi görevlerini oluşturarak bir LED'i yanıp söndürürken sensör okuyabilir, aynı anda web sunucusuna gelen istekleri cevaplayabilir ve bunların hiçbiri diğerini bekletmez. Arduino Uno'da millis() ile kurmaya çalıştığın "aynı anda birkaç iş" düzeni, ESP32'de çok daha temiz bir yapıya kavuşur.

Bu rehberde ESP32'nin iki çekirdeğinin nasıl paylaşıldığını ve Wi-Fi'nin hangi çekirdekte çalıştığını öğreneceksin. Ardından xTaskCreatePinnedToCore ile görev oluşturacak, görevleri belirli bir çekirdeğe sabitleyecek, öncelikleri ayarlayacak ve delay() ile vTaskDelay() arasındaki farkı göreceğiz. Görevler arasında güvenli veri paylaşımı için kuyruk (queue), butondan gelen kesmeyle görev uyandırmak için semafor, ortak Seri Monitör'ü korumak için mutex kullanacağız. Yığın boyutu ve watchdog hatalarını da ele aldıktan sonra LED, sensör ve web sunucuyu aynı anda çalıştıran tam bir örnek kuracağız. Sonda Raspberry Pi Pico'nun iki çekirdeğiyle kısa bir karşılaştırma da var.

ESP32 geliştirme kartı
Klasik ESP32 iki Xtensa LX6 çekirdeği taşır ve FreeRTOS ile her iki çekirdekte ayrı görevler çalıştırabilir.

ESP32 FreeRTOS nedir, çift çekirdek nasıl çalışır?

FreeRTOS'ta her iş bir görevdir (task). Görev, kendi yığın belleği ve önceliği olan, genellikle sonsuz bir döngü içeren sıradan bir C fonksiyonudur. FreeRTOS'un zamanlayıcısı (scheduler) her çekirdekte, çalışmaya hazır görevler arasından en yüksek öncelikliyi seçer. Bir görev vTaskDelay() ile beklemeye geçtiğinde, bir kuyruktan veri beklediğinde ya da bir semafor beklediğinde çekirdek hemen başka bir göreve verilir. Aynı öncelikteki görevler ise her tick'te sırayla çalışır. ESP32 Arduino çekirdeğinde tick süresi 1 ms'dir (saniyede 1000 tick), yani vTaskDelay(100) yaklaşık 100 ms bekler. Klasik ESP32'de iki çekirdek vardır: çekirdek 0 (PRO_CPU) ve çekirdek 1 (APP_CPU). Espressif, kablosuz haberleşmeyi çekirdek 0'a, senin kodunu çekirdek 1'e yerleştirir. Böylece Wi-Fi işlemleri senin döngünü bölmez. Varsayılan Arduino ayarlarıyla çekirdeklerin üzerinde şunlar çalışır:

GörevÇekirdekÖncelikGörevi
loopTask (setup ve loop)11Senin Arduino kodun, 8192 bayt yığın
Wi-Fi sürücüsü023Radyo ve Wi-Fi protokolü
lwIP (tcpip)018TCP/IP yığını, web ve MQTT paketleri
Bluetooth (BT/BLE)0YüksekBluetooth denetleyicisi ve Bluedroid
esp_timer022Yazılım zamanlayıcıları
IDLE0 ve IDLE10 ve 10Boşta görevleri; watchdog'u besler, silinen görevlerin belleğini temizler

Bu tabloda iki önemli ders var. Birincisi, Wi-Fi ve TCP/IP görevleri çok yüksek önceliklidir; çekirdek 0'a kendi ağır görevini koyarsan ağ trafiği geldiğinde bu görevler seninkini keser, sen de onları uzun süre meşgul edersen Wi-Fi aksar. İkincisi, loopTask'in önceliği yalnızca 1'dir; çekirdek 1'e daha yüksek öncelikli bir görev koyup hiç beklemeye geçmezsen loop() hiç çalışmaz. ESP32-S3 de çift çekirdeklidir. ESP32-S2, ESP32-C3 ve ESP32-C6 ise tek çekirdeklidir; bu kartlarda görevleri yine oluşturabilirsin ama hepsi aynı çekirdeği paylaşır.

Bağlantı şeması

Bu yazıdaki örnekler için bir ESP32 DevKit, iki LED, bir potansiyometre ve bir buton yeterli. Kart üzerindeki mavi LED GPIO 2'dedir; ikinci LED'i 220 Ω dirençle GPIO 4'e bağla. Potansiyometreyi ADC1 kanalındaki GPIO 34'e bağlıyoruz, çünkü ADC2 pinleri Wi-Fi açıkken okunamaz.

ParçaESP32 piniNot
Dahili LEDGPIO 2Çoğu DevKit'te kart üzerinde
İkinci LEDGPIO 4220 Ω seri direnç, kısa bacak GND'ye
Potansiyometre orta bacakGPIO 34Yalnız giriş, ADC1; kenar bacaklar 3V3 ve GND
ButonGPIO 27Diğer ucu GND'ye, INPUT_PULLUP ile
Potansiyometrenin kenar bacağını 5V'a değil 3V3'e bağla. ESP32'nin pinleri 3,3 V ile çalışır ve 5 V'a dayanıklı değildir. Wi-Fi kullanan projelerde analog sensörleri GPIO 32–39 arasındaki ADC1 pinlerine bağla; ADC2 pinleri (GPIO 0, 2, 4, 12–15, 25–27) Wi-Fi açıkken analogRead() ile okunamaz. Pin seçimini Pinout aracında kontrol edebilirsin.

xTaskCreatePinnedToCore ile ilk görevler

İlk örnekte iki LED'i iki ayrı görevle, farklı hızlarda ve farklı çekirdeklerde yakıp söndürüyoruz. Her görev fonksiyonu void fonksiyon(void *parametre) biçimindedir ve içinde bir sonsuz döngü bulunur. Görevi başlatan xTaskCreatePinnedToCore(), ona hangi çekirdekte çalışacağını da söyler. Aynı görev fonksiyonunu iki kez kullanıp her seferinde farklı bir ayar yapısı verdiğimize dikkat et; parametre sayesinde tek fonksiyon iki LED'i bağımsız olarak yönetir.

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}

Kodu yüklediğinde iki LED birbirinden bağımsız yanıp söner, Seri Monitör'de de loop()'un 1 numaralı çekirdekte çalıştığını görürsün. Fonksiyonun parametreleri şunlardır:

ParametreÖrnekteki değerAnlamı
pvTaskCodeledGoreviGörevin çalıştıracağı fonksiyon
pcName"LED1"Hata ayıklamada görünen ad, en fazla 16 karakter
usStackDepth2048Yığın boyutu; ESP32'de bayt cinsinden
pvParameters&led1Göreve verilen işaretçi; global ya da static bir değişkeni göstermeli
uxPriority1Öncelik, 0 (en düşük) ile 24 arasında
pvCreatedTaskNULLGörevi sonradan durdurmak ya da izlemek için tutamaç
xCoreID0 ya da 1Çalışacağı çekirdek; tskNO_AFFINITY verirsen boş olan çekirdekte çalışır
Görev fonksiyonu asla return ile bitmemelidir; biterse ESP32 hata verip yeniden başlar. Görevin işi bittiyse son satırda vTaskDelete(NULL) çağırarak kendini sil. Göreve parametre olarak setup() içindeki yerel bir değişkenin adresini de verme: setup() bittiğinde o değişken yok olur ve görev bozuk bir adresi okur. Tek çekirdekli ESP32-C3, S2 ve C6'da çekirdek numarası olarak yalnızca 0 ya da tskNO_AFFINITY verilebilir; en taşınabilir yol çekirdek seçmeyen xTaskCreate() fonksiyonudur.

delay(), vTaskDelay() ve vTaskDelayUntil() farkı

Arduino Uno'da delay() işlemciyi tamamen meşgul eder; beklerken başka hiçbir kod çalışmaz. ESP32'de ise durum farklıdır: Arduino çekirdeğindeki delay() aslında vTaskDelay()'i çağırır. Yani delay(100) yazdığında görevin 100 ms uyur ve çekirdek bu sürede diğer görevlere verilir. Bu yüzden görevlerin içinde delay() kullanmak da çalışır; yine de FreeRTOS kodlarında vTaskDelay(pdMS_TO_TICKS(100)) yazmak niyetini daha açık gösterir. Gerçek fark, işlemciyi meşgul ederek bekleyen yöntemlerdedir: delayMicroseconds() ve while (millis() - t < 500) {} gibi boş döngüler çekirdeği hiç bırakmaz. Arduino'daki millis() düzenini millis() ve delay() farkı yazısında ayrıntılı anlattık.

YöntemÇekirdeği bırakır mı?Ne zaman kullanılır?
delay(ms)Evet (ESP32'de vTaskDelay çağırır)Basit beklemeler, loop() içinde
vTaskDelay(pdMS_TO_TICKS(ms))EvetGörevlerde bekleme; süre, işin süresine eklenir
vTaskDelayUntil(&son, periyot)EvetSabit aralıklı örnekleme; iş süresinden bağımsız tam periyot
delayMicroseconds(us)HayırSensör protokollerindeki mikro saniyelik beklemeler
while (millis() - t < ms) {}HayırFreeRTOS görevlerinde kullanma; diğer görevleri aç bırakır

vTaskDelay(100) ile çalışan bir döngüde iş 15 ms sürüyorsa döngü 115 ms'de bir döner ve hata zamanla birikir. Sensörü tam 100 ms'de bir okumak istiyorsan vTaskDelayUntil() kullan: fonksiyon, bir önceki uyanma zamanını tutar ve görevi her seferinde tam bir periyot sonra uyandırır. Sonraki bölümdeki sensör görevi bu yöntemi kullanıyor.

Görev öncelikleri: hangi görev önce çalışır?

Bir çekirdekte aynı anda birden fazla görev çalışmaya hazırsa her zaman önceliği en yüksek olan çalışır. Daha düşük öncelikli bir görev ancak yüksek öncelikliler beklemeye geçtiğinde çekirdeğe kavuşur. Buna önceliğe dayalı kesintili (preemptive) zamanlama denir: yüksek öncelikli bir görevin beklediği veri geldiği anda düşük öncelikli görev yarıda kesilir. Bu, hızlı tepki gerektiren işleri yüksek öncelikli yapmanı sağlar, ama bir tuzağı vardır: yüksek öncelikli bir görev hiç beklemeye geçmezse altındaki görevler hiç çalışamaz. Pratikte şu düzen iyi çalışır:

  • Öncelik 1: Ekran güncelleme, Seri Monitör'e yazma, web sunucu gibi acelesi olmayan işler. loop() da bu seviyededir.
  • Öncelik 2–3: Düzenli sensör okuma, kontrol döngüleri, buton işleme gibi zamanında yapılması gereken işler.
  • Öncelik 4–5: Kesmeyle uyandırılan ve hemen tepki vermesi gereken kısa görevler.
  • Kaçın: Kendi görevlerine 18 ve üzeri öncelik verme; bu seviyeler Wi-Fi, TCP/IP ve sistem zamanlayıcılarına aittir.

Kuyruk (queue) ile görevler arasında güvenli veri paylaşımı

Görevler arasında veri taşımanın ilk akla gelen yolu global bir değişkendir, ama iki görev aynı değişkene aynı anda erişebilir. Bir görev çok baytlı bir yapıyı yazarken diğeri okursa yarısı eski, yarısı yeni bir değer elde eder; bu hatalar nadiren ve rastgele çıktığı için bulunması çok zordur. FreeRTOS'un çözümü kuyruktur. Kuyruk, sabit boyutlu öğelerden oluşan bir sıradır ve veriyi kopyalayarak taşır: gönderen görev xQueueSend() ile bir kopya bırakır, alan görev xQueueReceive() ile o kopyayı alır. Kuyruk boşsa alan görev uyur ve hiç işlemci harcamaz; veri gelince hemen uyanır. Aşağıdaki örnekte bir görev potansiyometreyi tam 100 ms'de bir okur, ölçümü zaman damgasıyla birlikte kuyruğa koyar; ikinci görev de kuyruktan gelen her ölçümü işler.

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}

Sensör görevinin önceliği (2) işleyicininkinden (1) yüksek olduğu için ölçümler her zaman zamanında alınır. İşleyici görev bir an yavaşlasa bile, örneğin bir SD karta yazarken, ölçümler kaybolmaz; 10 öğelik kuyrukta sırasını bekler. Kuyruk dolarsa xQueueSend() beklemeden hata döndürür ve sen de bunu fark edersin. Yalnızca en son değere ihtiyacın varsa, örneğin bir ekranda anlık sıcaklığı gösteriyorsan, tek öğelik bir kuyruk oluşturup xQueueOverwrite() ile yazabilir, xQueuePeek() ile değeri silmeden okuyabilirsin. Son örnekte bu yöntemi kullanacağız.

Semafor ve mutex: kesmeden görev uyandırmak ve ortak kaynağı korumak

İkili semafor (binary semaphore), bir görevin bir olayı beklemesini sağlayan bir bayrak gibidir. En sık kullanımı kesmelerdir: buton kesme fonksiyonu (ISR) çok kısa olmalıdır, bu yüzden asıl işi yapmaz, yalnızca semaforu verir; o semaforu bekleyen görev uyanır ve işi yapar. Kesmelerin temelini Arduino interrupt yazısında anlattık. Mutex ise ortak bir kaynağı, örneğin Seri port, I2C hattı ya da bir ekranı, aynı anda tek bir görevin kullanmasını garanti eder. İki görev aynı anda Serial.printf() çağırırsa satırlar birbirine karışabilir; mutex ile her görev yazmadan önce kilidi alır ve bitince bırakır. Aşağıdaki kodda butona her basışta ikinci LED'in durumu değişir ve iki görev aynı Seri Monitör'e karışmadan yazar.

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}
Kesme fonksiyonunun içinde yalnızca adı FromISR ile biten FreeRTOS fonksiyonlarını kullan (xSemaphoreGiveFromISR, xQueueSendFromISR gibi). Kesmede Serial.print(), delay() ya da bekleme yapan bir fonksiyon çağırmak ESP32'yi çökertir. Kesme fonksiyonunun başına IRAM_ATTR yaz; bu, fonksiyonu flaş bellek yerine hızlı RAM'e koyar. Mutex'i aldıktan sonra her yoldan mutlaka geri ver: bir hata dalında xSemaphoreGive() unutulursa o kaynağı bekleyen bütün görevler sonsuza kadar kilitlenir.

Wi-Fi hangi çekirdekte çalışır, görevleri nereye koymalısın?

Arduino çekirdeğinde Wi-Fi sürücüsü, TCP/IP yığını ve Bluetooth çekirdek 0'a sabitlenmiştir; loop() ve Arduino olayları çekirdek 1'de çalışır. ESP32'nin görev watchdog'u da varsayılan olarak çekirdek 0'daki boşta görevini (IDLE0) izler. Çekirdek 0'a öncelikli ve hiç beklemeye geçmeyen bir görev koyarsan IDLE0 5 saniye boyunca çalışamaz ve Seri Monitör'de Task watchdog got triggered hatasıyla birlikte kart yeniden başlar. Aynı görev ağ paketlerinin işlenmesini de geciktirir. Basit bir kural işini kolaylaştırır:

İşÖnerilen çekirdekNeden?
Hızlı ve düzenli kontrol, sensör örnekleme, motor kontrolü1Wi-Fi kesintileri zamanlamayı bozmaz
Web sunucu, MQTT, HTTP istekleri0 ya da 1, düşük öncelikAğ yığını zaten çekirdek 0'da; kendi görevin sık sık beklemeye geçmeli
Ekran güncelleme, kayıt tutma1, öncelik 1Acelesi yok, kalan zamanı kullanır
Uzun hesaplar (FFT, şifreleme)1 ya da 0'da düşük öncelik, arada vTaskDelay(1)Watchdog'u ve diğer görevleri aç bırakmamak için

Yığın boyutu ve watchdog hataları

Her görevin kendi yığın (stack) belleği vardır; yerel değişkenler, fonksiyon çağrıları ve printf gibi kütüphane fonksiyonları bu alanı kullanır. ESP32'de yığın boyutu bayt cinsinden verilir; standart FreeRTOS belgelerinde geçen "word" birimi ESP32 için geçerli değildir. Basit bir LED görevi için 2048 bayt yeter. Serial.printf(), String işlemleri ve kayan noktalı sayı yazdırma kullanan görevlere 3072–4096 bayt ver. HTTPClient, TLS (HTTPS) ya da JSON işleyen görevler 8192 bayt ve üzerini isteyebilir. Yığın taşarsa ESP32 Stack canary watchpoint triggered ya da A stack overflow in task ... has been detected hatası verip yeniden başlar. Bir görevin şimdiye kadar yığınının en az ne kadarının boş kaldığını uxTaskGetStackHighWaterMark() ile öğrenebilirsin; değer bayt cinsindendir ve 500 baytın altına iniyorsa yığını büyüt. Kartın beklenmedik yeniden başlamalarındaki hata mesajlarını okumayı ESP32 Brownout ve Guru Meditation yazısında anlattık.

Hata mesajıAnlamıÇözüm
Task watchdog got triggered ... IDLE (CPU 0)Çekirdek 0'da bir görev 5 sn boyunca hiç beklemeye geçmediDöngüye vTaskDelay(1) ekle, önceliği düşür ya da görevi çekirdek 1'e taşı
Stack canary watchpoint triggered (Gorev adi)Adı yazan görevin yığını taştıxTaskCreatePinnedToCore'daki yığın değerini artır
Guru Meditation Error: LoadProhibitedGeçersiz bir adres okunduGöreve verilen işaretçi yerel bir değişkeni mi gösteriyor, kontrol et
Interrupt wdt timeout on CPU1Kesme fonksiyonu çok uzun sürdü ya da kesmeler kapalı kaldıISR'yi kısalt, işi semaforla bir göreve devret
FreeRTOS Task "Gorev" should not return, Aborting now!Görev fonksiyonu return ile bittiSonsuz döngü kur ya da sonda vTaskDelete(NULL) çağır

Uygulama: LED, sensör ve web sunucu aynı anda

Şimdi öğrendiklerimizi tek bir projede birleştirelim. Üç görev olacak: sensör görevi potansiyometreyi 200 ms'de bir okuyup son 8 ölçümün ortalamasını tek öğelik bir kuyruğa yazar; LED görevi dahili LED'i web sayfasından ayarlanan hızda yakıp söndürür; web görevi de telefondan açılan sayfaya anlık sensör değerini gösterir ve LED hızını değiştiren bağlantılar sunar. Görevler veriyi global değişkenlerle değil, xQueueOverwrite() ve xQueuePeek() ile paylaşır. loop() ise her 10 saniyede bir görevlerin boş yığın miktarını ve boş RAM'i yazar; böylece yığınların yeterli olup olmadığını gerçek çalışmada görürsün. Wi-Fi ağ adını ve şifreni kendi bilgilerinle değiştir.

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}

Kodu yükledikten sonra Seri Monitör'de görünen adresi telefonda aç. Sayfa 2 saniyede bir yenilenir ve potansiyometreyi çevirdikçe değer değişir. Bağlantılara dokunduğunda LED'in hızı anında değişir, ama sensör okuma ritmi hiç bozulmaz, çünkü her iş kendi görevinde, kendi temposunda çalışır. Web görevi çekirdek 0'da ağ yığınının yanında ve düşük öncelikte durur; her döngüde 2 ms beklemeye geçtiği için IDLE0 görevi çalışabilir ve watchdog tetiklenmez. LED ve sensör görevleri ise çekirdek 1'dedir ve Wi-Fi trafiğinden etkilenmez. Bu yapıyı genişletmek kolaydır: sayfayı yenilemeden anlık güncellemek için ESP32 web sunucu ve WebSocket yazısındaki WebSocket yöntemini, gürültülü sensör değerlerini yumuşatmak için de sensör görevindeki ortalamayı medyan ya da üstel filtreyle değiştirebilirsin.

Raspberry Pi Pico ile karşılaştırma: iki çekirdek MicroPython'da

Raspberry Pi Pico'daki RP2040 de çift çekirdeklidir, ama işletim sistemi yoktur: MicroPython'da ikinci çekirdeği _thread modülüyle başlatırsın ve iki çekirdek arasında yalnızca iki iş parçacığı çalışır. Arduino tarafında arduino-pico çekirdeği ise ikinci çekirdek için setup1() ve loop1() fonksiyonlarını sunar. Aşağıdaki MicroPython kodu ikinci çekirdekte LED'i yakıp söndürürken birinci çekirdekte potansiyometreyi okur; ortak sayaç bir kilit (lock) ile korunur, tıpkı ESP32'deki mutex gibi. Pico'nun çekirdekleri ve PIO birimleri hakkında daha fazlası Pico PIO ve iki çekirdek yazısında.

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)

Pico'da bu yöntem iki iş için iyi çalışır, ama görev sayısı, öncelik, kuyruk ve zamanlayıcı gibi araçlar ESP32'deki FreeRTOS kadar zengin değildir. Çok sayıda eş zamanlı iş, ağ bağlantısı ve kesin zamanlama gereken projelerde ESP32 ve FreeRTOS daha rahat bir zemin sunar. Pico ile Wi-Fi'li projeler yapmak istersen Pico W Wi-Fi web sunucu yazısına göz atabilirsin.

Sık hatalar ve çözümleri

BelirtiOlası sebepÇözüm
Görev oluşturulunca kart hemen yeniden başlıyorGörev fonksiyonu return ile bitiyor ya da yığın çok küçükSonsuz döngü ekle, yığını 4096 bayta çıkar
loop() hiç çalışmıyorÇekirdek 1'de daha yüksek öncelikli bir görev hiç beklemeye geçmiyorGöreve vTaskDelay() ekle ya da önceliğini 1'e indir
Wi-Fi açılınca watchdog hatasıÇekirdek 0'daki görev IDLE0'ı aç bırakıyorDöngüde vTaskDelay(1) kullan ya da görevi çekirdek 1'e taşı
Değerler ara sıra saçma çıkıyorİki görev aynı global yapıyı aynı anda okuyup yazıyorVeriyi kuyrukla taşı ya da erişimi mutex ile koru
Seri Monitör'de satırlar birbirine karışıyorİki görev aynı anda Serial'a yazıyorYazmadan önce mutex al, bitince bırak
Butona basınca kart çöküyorKesme fonksiyonunda Serial.print ya da normal FreeRTOS fonksiyonu varISR'de yalnızca FromISR fonksiyonları kullan, işi göreve devret
Wi-Fi açıkken analogRead() 4095 ya da 0 veriyorSensör ADC2 pinine bağlıGPIO 32–39 arasındaki ADC1 pinlerinden birini kullan
Kod ESP32-C3'te derleniyor ama çalışmıyorTek çekirdekli kartta çekirdek 1 istenmişÇekirdek olarak 0 ya da tskNO_AFFINITY ver, ya da xTaskCreate() kullan
FreeRTOS'a geçerken her şeyi bir anda göreve bölme. Önce çalışan kodundaki en zamana duyarlı işi, örneğin sensör örneklemeyi, kendi görevine taşı ve geri kalanı loop()'ta bırak. Her yeni görevden sonra uxTaskGetStackHighWaterMark() ile yığına bak. Görevlerin arasındaki her veri alışverişini kuyrukla, her ortak donanımı mutex ile yaparsan "bazen bozuluyor" türünden hataların büyük kısmından baştan kurtulursun.

ESP32'nin iki çekirdeği ve FreeRTOS, millis() hesaplarıyla dolu karmaşık loop() fonksiyonlarını her biri tek bir işe odaklanan küçük ve okunaklı görevlere dönüştürür. Görev oluşturmayı, öncelik vermeyi, kuyrukla veri taşımayı, semaforla kesme işlemeyi ve yığını ölçmeyi öğrendiğine göre Wi-Fi'li projelerin artık takılmadan çalışacak. ESP32'yi yeni tanıyorsan temelleri ESP32 Nedir? yazısında bulabilirsin. BlueGrays uygulamasında da ESP32 ile async web sunucu, WebSocket, NTP saati, sıcaklık kaydedici ve akıllı aydınlatma gibi projeleri adım adım devre şemaları ve hazır kodlarıyla inceleyebilirsin.

Sıkça sorulan sorular

ESP32'de FreeRTOS nedir?

FreeRTOS, ESP32'nin içinde çalışan gerçek zamanlı bir işletim sistemidir ve Arduino kodun da onun üzerinde çalışır. Birden fazla işi ayrı görevlere bölmeni, bunlara öncelik vermeni ve iki çekirdeğe dağıtmanı sağlar. Ayrı bir kurulum gerekmez; xTaskCreate gibi fonksiyonlar ESP32 Arduino çekirdeğinde hazırdır.

ESP32'de loop() hangi çekirdekte çalışır?

Arduino çekirdeğinde setup() ve loop(), loopTask adlı görevin içinde çekirdek 1'de ve öncelik 1 ile çalışır. Wi-Fi, TCP/IP ve Bluetooth ise çekirdek 0'dadır. Bunu xPortGetCoreID() fonksiyonunu yazdırarak kendin de görebilirsin.

ESP32'de delay() ile vTaskDelay() arasındaki fark nedir?

ESP32 Arduino çekirdeğinde delay() aslında vTaskDelay()'i çağırır, yani ikisi de beklerken çekirdeği diğer görevlere bırakır. Arduino Uno'daki gibi işlemciyi meşgul eden bekleme ESP32'de delayMicroseconds() ve boş while döngüleridir. Sabit aralıklı işler için vTaskDelayUntil() daha doğrudur.

xTaskCreatePinnedToCore yığın boyutu ne kadar olmalı?

ESP32'de yığın boyutu bayt cinsindendir. Basit LED görevleri için 2048, Serial.printf ve String kullanan görevler için 3072–4096, HTTPS ve JSON gibi ağır işler için 8192 bayt iyi bir başlangıçtır. Gerçek ihtiyacı uxTaskGetStackHighWaterMark() ile ölçüp ayarlamalısın.

ESP32 Task watchdog got triggered hatası nasıl çözülür?

Bu hata, çekirdek 0'daki boşta görevinin 5 saniye boyunca çalışamadığını gösterir; çoğu zaman bir görev hiç beklemeye geçmeden dönüyordur. Döngünün içine vTaskDelay(1) ekle, görevin önceliğini düşür ya da görevi çekirdek 1'e taşı. Uzun hesapları küçük parçalara bölmek de işe yarar.

ESP32'de görevler arasında veri nasıl paylaşılır?

En güvenli yol FreeRTOS kuyruklarıdır: xQueueSend() ile veri gönderilir, xQueueReceive() ile alınır ve kopyalama sayesinde yarım okunmuş değer oluşmaz. Yalnızca son değer gerekiyorsa tek öğelik kuyrukla xQueueOverwrite() ve xQueuePeek() kullanılır. Ortak bir donanımı ya da global yapıyı paylaşıyorsan erişimi mutex ile korumalısın.

Tüm projeleri gör
ESP32 Async Web Server (LCD'de IP Göstergeli)
ES-27İleri

ESP32 Async Web Server (LCD'de IP Göstergeli)

Bu projede ESP32'yi aynı Wi-Fi ağındaki telefonunuzdan veya bilgisayarınızdan kontrol edebileceğiniz asenkron bir web sunucusuna dönüştürüyoruz. ESPAsyncWebServer kütüphanesi sayesinde sunucu birden fazla isteği aynı anda işleyebiliyor (klasik WebServer.h gibi tek istekte bloklamıyor). Tarayıcıdan ESP32'nin IP adresine bağlanıp ON/OFF butonlarına basarak (/on ve /off adresleri) GPIO 5'e bağlı LED'i açıp kapatabileceksiniz.

4.8(16)
26
ESP32 WebSocket Sayaç (2 Buton + LCD + Web Realtime)
ES-28İleri
Premium

ESP32 WebSocket Sayaç (2 Buton + LCD + Web Realtime)

Bu projede ESP32'ye bağlı iki butonla (GPIO 5 artırır, GPIO 4 azaltır) bir sayaç değiştirilir. Değer hem 16x2 I2C LCD'de hem de ESPAsyncWebServer'ın WebSocket desteğiyle bağlı tüm tarayıcılarda anında güncellenir; sayfayı yenilemek gerekmez. HTTP polling yerine tek bir kalıcı bağlantı kullanılır ve ESP32 yeni değeri ws.textAll() ile herkese gönderir.

4.5(14)
23
ESP32 Wi-Fi STA Bağlantısı (LCD Ekranlı)
ES-25İleri

ESP32 Wi-Fi STA Bağlantısı (LCD Ekranlı)

Bu projede ESP32'yi Station (STA) modunda evdeki Wi-Fi ağına güvenli ve hata toleranslı şekilde bağlıyoruz. SSID/şifreyi secrets.h dosyasına ayırarak Git'e sızmasını önlüyor, otomatik yeniden bağlanma mekanizması kuruyor, RSSI sinyal seviyesini ve IP adresini I2C LCD ekranda gösteriyoruz. Dahili LED durum göstergesi olarak çalışır. Üretim seviyesi bir bağlantı yöneticisidir.

4.4(21)
38
ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)
ES-13Orta
Premium

ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)

Bu projede bir potansiyometre ile LED parlaklığını analog olarak kontrol ediyoruz. ESP32'nin ADC pini potansiyometreden gelen 0-3.3V gerilimi okur, ardından bu değer PWM (Pulse Width Modulation) sinyaline çevrilerek LED'e gönderilir. Böylece potansiyometreyi çevirdikçe LED kademeli olarak parlar ve söner. Arduino Core 3.0+ ile analogWrite() doğrudan kullanılabilir; ESP32-S2/S3'te ADC çözünürlüğü 12-bit'e sabitlenir.

4.5(19)
32
ESP32 WS2812B NeoPixel Şerit Kontrolü
ES-24Orta
Premium

ESP32 WS2812B NeoPixel Şerit Kontrolü

WS2812B (NeoPixel) adreslenebilir LED'ler, tek bir veri pini üzerinden zincirleme kontrol edilebilen akıllı RGB LED'lerdir. Bu projede 8 LED'lik bir WS2812B şeridi Adafruit_NeoPixel kütüphanesi ile kontrol edip akıcı bir gökkuşağı animasyonu üreteceğiz. ESP32'nin 3.3V mantık seviyesi çoğu WS2812B partisinde sorunsuz çalışsa da, kararsızlık durumunda 470Ω seri direnç ve 1000µF kondansatör çözümünü göstereceğiz. Animasyon, HSV renk uzayında ton (hue) değerini kaydırarak elde edilir.

4.9(19)
30
ESP32 Deep Sleep — Pil Tasarrufu (OLED + RTC RAM Sayaç)
ES-33İleri
Premium

ESP32 Deep Sleep — Pil Tasarrufu (OLED + RTC RAM Sayaç)

ESP32'nin Deep Sleep modu, CPU'yu ve çoğu çevre birimini kapatarak akım tüketimini yaklaşık 10µA seviyesine düşürür; pille çalışan IoT cihazları için kritik öneme sahiptir. Bu projede üç uyandırma kaynağı kullanıyoruz: zamanlayıcı (15 sn), harici pin (EXT0, GPIO 33'teki buton) ve dokunmatik pin (T0/GPIO 4). RTC_DATA_ATTR ile işaretlenen sayaçlar deep sleep boyunca korunur.

4.3(10)
16
ESP32 Sıcaklık Loglayıcı (DHT22 + DS1307 RTC + microSD + OLED)
ES-40İleri
Premium

ESP32 Sıcaklık Loglayıcı (DHT22 + DS1307 RTC + microSD + OLED)

ESP32 ile zamanlı sıcaklık ve nem kayıt sistemi kur! Bu projede DHT22 sensörüyle dakikada bir sıcaklık ve nem okuyup DS1307 RTC modülünden aldığın gerçek zaman etiketiyle microSD karta CSV formatında kaydediyoruz. OLED ekranda büyük yazıyla son sıcaklık değeri, nem yüzdesi, zaman damgası ve toplam kayıt sayısı canlı gösterilir.

4.7(7)
12
ESP32 Akıllı Aydınlatma (PIR + LDR + Röle + OLED)
ES-37İleri
Premium

ESP32 Akıllı Aydınlatma (PIR + LDR + Röle + OLED)

ESP32, PIR hareket sensörü, LDR ışık sensörü ve röle modülüyle evinin koridorunu, tuvaletini veya kilerini akıllı aydınlatmaya dönüştürüyoruz. Ortam aydınlıksa hareket olsa bile ışık yanmaz; böylece gündüz boşa enerji harcanmaz. Işık 30 saniye açık kalır; hareket sürerse süre otomatik olarak uzar.

4.3(6)
11