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 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 | Öncelik | Görevi |
|---|---|---|---|
| loopTask (setup ve loop) | 1 | 1 | Senin Arduino kodun, 8192 bayt yığın |
| Wi-Fi sürücüsü | 0 | 23 | Radyo ve Wi-Fi protokolü |
| lwIP (tcpip) | 0 | 18 | TCP/IP yığını, web ve MQTT paketleri |
| Bluetooth (BT/BLE) | 0 | Yüksek | Bluetooth denetleyicisi ve Bluedroid |
| esp_timer | 0 | 22 | Yazılım zamanlayıcıları |
| IDLE0 ve IDLE1 | 0 ve 1 | 0 | Boş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ça | ESP32 pini | Not |
|---|---|---|
| Dahili LED | GPIO 2 | Çoğu DevKit'te kart üzerinde |
| İkinci LED | GPIO 4 | 220 Ω seri direnç, kısa bacak GND'ye |
| Potansiyometre orta bacak | GPIO 34 | Yalnız giriş, ADC1; kenar bacaklar 3V3 ve GND |
| Buton | GPIO 27 | Diğer ucu GND'ye, INPUT_PULLUP ile |
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.
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ğer | Anlamı |
|---|---|---|
| pvTaskCode | ledGorevi | Görevin çalıştıracağı fonksiyon |
| pcName | "LED1" | Hata ayıklamada görünen ad, en fazla 16 karakter |
| usStackDepth | 2048 | Yığın boyutu; ESP32'de bayt cinsinden |
| pvParameters | &led1 | Göreve verilen işaretçi; global ya da static bir değişkeni göstermeli |
| uxPriority | 1 | Öncelik, 0 (en düşük) ile 24 arasında |
| pvCreatedTask | NULL | Görevi sonradan durdurmak ya da izlemek için tutamaç |
| xCoreID | 0 ya da 1 | Çalışacağı çekirdek; tskNO_AFFINITY verirsen boş olan çekirdekte çalışır |
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)) | Evet | Görevlerde bekleme; süre, işin süresine eklenir |
| vTaskDelayUntil(&son, periyot) | Evet | Sabit aralıklı örnekleme; iş süresinden bağımsız tam periyot |
| delayMicroseconds(us) | Hayır | Sensör protokollerindeki mikro saniyelik beklemeler |
| while (millis() - t < ms) {} | Hayır | FreeRTOS 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.
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.
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}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 çekirdek | Neden? |
|---|---|---|
| Hızlı ve düzenli kontrol, sensör örnekleme, motor kontrolü | 1 | Wi-Fi kesintileri zamanlamayı bozmaz |
| Web sunucu, MQTT, HTTP istekleri | 0 ya da 1, düşük öncelik | Ağ yığını zaten çekirdek 0'da; kendi görevin sık sık beklemeye geçmeli |
| Ekran güncelleme, kayıt tutma | 1, öncelik 1 | Acelesi 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çmedi | Dö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: LoadProhibited | Geçersiz bir adres okundu | Göreve verilen işaretçi yerel bir değişkeni mi gösteriyor, kontrol et |
| Interrupt wdt timeout on CPU1 | Kesme 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 bitti | Sonsuz 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.
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}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.
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
| Belirti | Olası sebep | Çözüm |
|---|---|---|
| Görev oluşturulunca kart hemen yeniden başlıyor | Görev fonksiyonu return ile bitiyor ya da yığın çok küçük | Sonsuz 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çmiyor | Gö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ıyor | Dö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ıyor | Veriyi 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ıyor | Yazmadan önce mutex al, bitince bırak |
| Butona basınca kart çöküyor | Kesme fonksiyonunda Serial.print ya da normal FreeRTOS fonksiyonu var | ISR'de yalnızca FromISR fonksiyonları kullan, işi göreve devret |
| Wi-Fi açıkken analogRead() 4095 ya da 0 veriyor | Sensör ADC2 pinine bağlı | GPIO 32–39 arasındaki ADC1 pinlerinden birini kullan |
| Kod ESP32-C3'te derleniyor ama çalışmıyor | Tek çekirdekli kartta çekirdek 1 istenmiş | Çekirdek olarak 0 ya da tskNO_AFFINITY ver, ya da xTaskCreate() kullan |
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.
Bu yazıdan sonra yapabileceğin projeler
Tüm projeleri gör
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.

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.

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.

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.

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.

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.

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.

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.
Diğer yazılar
BlueGrays uygulaması
Bu devreyi telefonunda adım adım kur
Devre şeması, kod ve parça listesi tek ekranda. 500'den fazla Arduino, ESP32 ve Pico projesi seni bekliyor.
Telefonunla tara
Kamerayı koda tut; telefonunun uygulama mağazası açılır.
ya da mağazada aç

