ESP32 FreeRTOS: Dua Inti, Task, Antrean, dan Semaphore
ESP32 FreeRTOS: xTaskCreatePinnedToCore, prioritas, delay vs vTaskDelay, antrean, semaphore, stack, dan watchdog; jalankan LED, sensor, dan web server bersamaan.
ESP32 FreeRTOS adalah sistem operasi waktu nyata yang sudah berjalan di dalam ESP32 dan memungkinkan kamu melakukan beberapa hal sekaligus. Setiap sketch ESP32 yang kamu tulis di Arduino IDE sebenarnya berjalan di atas FreeRTOS: fungsi setup() dan loop() berjalan di dalam task bernama loopTask pada salah satu dari dua inti ESP32. Dengan membuat task sendiri, kamu bisa mengedipkan LED sambil membaca sensor dan menjawab request web server secara bersamaan, tanpa satu pun menghambat yang lain. Pola “beberapa pekerjaan sekaligus” yang kamu coba buat dengan millis() pada Arduino Uno memiliki struktur yang jauh lebih rapi pada ESP32.
Dalam panduan ini, kamu akan mempelajari pembagian kerja kedua inti ESP32 dan inti yang menjalankan Wi-Fi. Lalu kita akan membuat task dengan xTaskCreatePinnedToCore, menempatkan task pada inti tertentu, mengatur prioritas, dan melihat perbedaan antara delay() dan vTaskDelay(). Kita akan memakai antrean untuk berbagi data dengan aman antar-task, semaphore untuk membangunkan task dari interrupt tombol, dan mutex untuk melindungi Serial Monitor yang dipakai bersama. Setelah membahas ukuran stack dan error watchdog, kita akan membuat contoh lengkap yang menjalankan LED, sensor, dan web server secara bersamaan. Di bagian akhir ada perbandingan singkat dengan dua inti Raspberry Pi Pico.

Apa itu ESP32 FreeRTOS dan bagaimana kedua intinya bekerja?
Dalam FreeRTOS, setiap pekerjaan adalah sebuah task. Task adalah fungsi C biasa dengan memori stack dan prioritas sendiri, biasanya berisi perulangan tanpa akhir. Pada setiap inti, penjadwal FreeRTOS memilih task berprioritas tertinggi di antara task yang siap berjalan. Ketika sebuah task menunggu dengan vTaskDelay(), menunggu data dari antrean, atau menunggu semaphore, inti langsung diserahkan ke task lain. Task dengan prioritas yang sama bergantian pada setiap tick. Dalam core Arduino ESP32, satu tick adalah 1 ms (1000 tick per detik), sehingga vTaskDelay(100) menunggu sekitar 100 ms. ESP32 klasik memiliki dua inti: inti 0 (PRO_CPU) dan inti 1 (APP_CPU). Espressif menempatkan komunikasi nirkabel pada inti 0 dan kodemu pada inti 1, sehingga pekerjaan Wi-Fi tidak menginterupsi perulanganmu. Dengan pengaturan bawaan Arduino, inilah yang berjalan pada kedua inti:
| Task | Inti | Prioritas | Pekerjaan |
|---|---|---|---|
| loopTask (setup dan loop) | 1 | 1 | Kode Arduino-mu, stack 8192 byte |
| Driver Wi-Fi | 0 | 23 | Radio dan protokol Wi-Fi |
| lwIP (tcpip) | 0 | 18 | Stack TCP/IP, paket web dan MQTT |
| Bluetooth (BT/BLE) | 0 | Tinggi | Pengendali Bluetooth dan Bluedroid |
| esp_timer | 0 | 22 | Timer perangkat lunak |
| IDLE0 dan IDLE1 | 0 dan 1 | 0 | Task idle; memberi sinyal ke watchdog dan membebaskan memori task yang dihapus |
Ada dua pelajaran penting dari tabel ini. Pertama, task Wi-Fi dan TCP/IP memiliki prioritas sangat tinggi; jika kamu menempatkan task berat milikmu pada inti 0, keduanya akan menginterupsinya setiap kali ada lalu lintas jaringan, dan jika task-mu membebani inti itu terlalu lama, Wi-Fi terganggu. Kedua, loopTask hanya memiliki prioritas 1; jika kamu menempatkan task dengan prioritas lebih tinggi pada inti 1 yang tidak pernah menunggu, loop() tidak akan pernah berjalan. ESP32-S3 juga memiliki dua inti. ESP32-S2, ESP32-C3, dan ESP32-C6 memiliki satu inti; kamu tetap bisa membuat task pada board ini, tetapi semuanya berbagi inti yang sama.
Pengkabelan
Untuk contoh dalam artikel ini, kamu memerlukan ESP32 DevKit, dua LED, potensiometer, dan push button. LED biru pada board terhubung ke GPIO 2; hubungkan LED kedua ke GPIO 4 melalui resistor 220 Ω. Kita menghubungkan potensiometer ke GPIO 34, kanal ADC1, karena pin ADC2 tidak bisa dibaca selama Wi-Fi aktif.
| Komponen | Pin ESP32 | Catatan |
|---|---|---|
| LED bawaan | GPIO 2 | Sudah terpasang pada kebanyakan DevKit |
| LED kedua | GPIO 4 | Resistor seri 220 Ω, kaki pendek ke GND |
| Wiper potensiometer | GPIO 34 | Hanya input, ADC1; kaki luar ke 3V3 dan GND |
| Tombol | GPIO 27 | Kaki lainnya ke GND, digunakan dengan INPUT_PULLUP |
Task pertama dengan xTaskCreatePinnedToCore
Pada contoh pertama, kita mengedipkan dua LED dengan dua task terpisah, pada kecepatan berbeda dan inti berbeda. Setiap fungsi task berbentuk void function(void *parameter) dan berisi perulangan tanpa akhir. xTaskCreatePinnedToCore(), yang memulai task, juga menentukan inti tempat task berjalan. Perhatikan bahwa kita memakai fungsi task yang sama dua kali dan memberikan struktur pengaturan berbeda setiap kali; berkat parameter tersebut, satu fungsi mengendalikan dua LED secara independen.
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}Ketika kamu meng-upload kode, kedua LED berkedip secara independen, dan Serial Monitor menunjukkan bahwa loop() berjalan pada inti 1. Berikut parameter fungsi tersebut:
| Parameter | Nilai dalam contoh | Arti |
|---|---|---|
| pvTaskCode | ledGorevi | Fungsi yang dijalankan task |
| pcName | "LED1" | Nama yang ditampilkan ketika debugging, maksimal 16 karakter |
| usStackDepth | 2048 | Ukuran stack; pada ESP32 satuannya byte |
| pvParameters | &led1 | Pointer yang diberikan ke task; harus menunjuk ke variabel global atau statis |
| uxPriority | 1 | Prioritas, dari 0 (terendah) hingga 24 |
| pvCreatedTask | NULL | Handle untuk menghentikan atau memantau task nantinya |
| xCoreID | 0 atau 1 | Inti tempat task berjalan; dengan tskNO_AFFINITY, task berjalan pada inti mana pun yang kosong |
Perbandingan delay(), vTaskDelay(), dan vTaskDelayUntil()
Pada Arduino Uno, delay() membuat prosesor terus sibuk; tidak ada pekerjaan lain yang berjalan selama menunggu. Pada ESP32, situasinya berbeda: delay() dalam core Arduino sebenarnya memanggil vTaskDelay(). Jadi, ketika kamu menulis delay(100), task-mu tidur selama 100 ms dan inti dipakai task lain selama waktu itu. Karena itulah memakai delay() di dalam task juga berfungsi; meski begitu, menulis vTaskDelay(pdMS_TO_TICKS(100)) dalam kode FreeRTOS menunjukkan maksudmu dengan lebih jelas. Perbedaan sebenarnya terletak pada metode yang menunggu sambil membuat prosesor tetap sibuk: delayMicroseconds() dan perulangan kosong seperti while (millis() - t < 500) {} tidak pernah melepaskan inti. Kami membahas pola millis() pada Arduino secara terperinci dalam millis() vs delay().
| Metode | Melepaskan inti? | Kapan digunakan |
|---|---|---|
| delay(ms) | Ya (memanggil vTaskDelay pada ESP32) | Penundaan sederhana, di dalam loop() |
| vTaskDelay(pdMS_TO_TICKS(ms)) | Ya | Menunggu dalam task; penundaan ditambahkan ke waktu kerja |
| vTaskDelayUntil(&last, period) | Ya | Sampling dengan laju tetap; periode tepat tanpa dipengaruhi waktu kerja |
| delayMicroseconds(us) | Tidak | Penundaan mikrodetik dalam protokol sensor |
| while (millis() - t < ms) {} | Tidak | Jangan gunakan dalam task FreeRTOS; task lain tidak mendapat waktu berjalan |
Jika perulangan berjalan dengan vTaskDelay(100) dan pekerjaannya membutuhkan 15 ms, perulangan berulang setiap 115 ms dan galatnya terakumulasi seiring waktu. Jika kamu ingin membaca sensor tepat setiap 100 ms, gunakan vTaskDelayUntil(): fungsi ini melacak waktu bangun sebelumnya dan membangunkan task tepat satu periode kemudian setiap kali. Task sensor di bagian berikutnya memakai metode ini.
Prioritas task: task mana yang berjalan lebih dahulu?
Jika beberapa task pada satu inti siap berjalan, task dengan prioritas tertinggi selalu dijalankan. Task berprioritas lebih rendah hanya mendapat inti ketika task berprioritas lebih tinggi sedang menunggu. Ini disebut penjadwalan preemptif berbasis prioritas: begitu data yang ditunggu task berprioritas tinggi tiba, task berprioritas lebih rendah diinterupsi. Ini memungkinkan kamu memberi prioritas tinggi pada pekerjaan yang membutuhkan respons cepat, tetapi ada jebakannya: jika task berprioritas tinggi tidak pernah menunggu, task di bawahnya tidak akan pernah berjalan. Dalam praktiknya, skema berikut bekerja dengan baik:
- Prioritas 1: Pekerjaan yang tidak mendesak, seperti memperbarui layar, menulis ke Serial Monitor, atau web server. loop() juga berada pada tingkat ini.
- Prioritas 2–3: Pekerjaan yang harus dilakukan tepat waktu, seperti pembacaan sensor berkala, perulangan kendali, dan penanganan tombol.
- Prioritas 4–5: Task singkat yang dibangunkan oleh interrupt dan harus segera merespons.
- Hindari: Jangan memberi task-mu prioritas 18 atau lebih tinggi; tingkat tersebut digunakan oleh Wi-Fi, TCP/IP, dan timer sistem.
Berbagi data dengan aman antar-task melalui antrean
Ide pertama untuk memindahkan data antar-task adalah variabel global, tetapi dua task bisa mengakses variabel yang sama secara bersamaan. Jika satu task membaca struktur multibyte ketika task lain sedang menulisnya, task tersebut mendapatkan nilai yang separuh lama dan separuh baru; karena bug seperti ini jarang muncul dan kemunculannya acak, penyebabnya sangat sulit dilacak. Solusi FreeRTOS adalah antrean. Antrean adalah barisan item berukuran tetap yang memindahkan data dengan menyalinnya: task pengirim meninggalkan salinan dengan xQueueSend() dan task penerima mengambil salinan itu dengan xQueueReceive(). Jika antrean kosong, task penerima tidur dan tidak memakai waktu CPU; task tersebut bangun begitu data tiba. Pada contoh di bawah, satu task membaca potensiometer tepat setiap 100 ms dan memasukkan hasil pembacaan ke antrean bersama penanda waktu; task kedua memproses setiap hasil pembacaan yang keluar dari antrean.
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}Karena prioritas task sensor (2) lebih tinggi daripada task pemroses (1), pembacaan selalu dilakukan tepat waktu. Bahkan jika task pemroses melambat sebentar, misalnya ketika menulis ke kartu SD, tidak ada hasil pembacaan yang hilang; semuanya menunggu giliran dalam antrean berkapasitas 10 item. Jika antrean penuh, xQueueSend() mengembalikan error tanpa menunggu, sehingga kamu mengetahuinya. Jika kamu hanya memerlukan nilai terbaru, misalnya untuk menampilkan suhu terkini di layar, kamu bisa membuat antrean berkapasitas satu item, menulis ke dalamnya dengan xQueueOverwrite(), dan membaca nilai tanpa menghapusnya memakai xQueuePeek(). Kita akan memakai metode ini pada contoh terakhir.
Semaphore dan mutex: membangunkan task dari interrupt dan melindungi sumber daya bersama
Semaphore biner seperti penanda yang memungkinkan task menunggu suatu kejadian. Penggunaan paling umum adalah bersama interrupt: rutin interrupt tombol (ISR) harus sangat singkat, jadi rutin tersebut tidak melakukan pekerjaan sebenarnya, melainkan hanya memberikan semaphore; task yang menunggu semaphore itu bangun dan mengerjakan tugasnya. Kami menjelaskan dasar-dasar interrupt dalam artikel interrupt Arduino. Mutex menjamin bahwa hanya satu task pada satu waktu yang memakai sumber daya bersama, seperti port serial, bus I2C, atau layar. Jika dua task memanggil Serial.printf() pada waktu yang sama, baris keluarannya bisa bercampur; dengan mutex, setiap task mengambil kunci sebelum menulis dan melepaskannya setelah selesai. Pada kode di bawah, setiap tekanan tombol membalik keadaan nyala LED kedua, dan dua task menulis ke Serial Monitor yang sama tanpa mencampur keluarannya.
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}Pada inti mana Wi-Fi berjalan, dan di mana sebaiknya kamu menempatkan task?
Dalam core Arduino, driver Wi-Fi, stack TCP/IP, dan Bluetooth ditempatkan tetap pada inti 0; loop() dan event Arduino berjalan pada inti 1. Secara bawaan, task watchdog ESP32 juga memantau task idle pada inti 0 (IDLE0). Jika kamu menempatkan task pada inti 0 yang memiliki prioritas dan tidak pernah menunggu, IDLE0 tidak bisa berjalan selama 5 detik, Serial Monitor menampilkan Task watchdog got triggered, dan board memulai ulang. Task yang sama juga menunda pemrosesan paket jaringan. Aturan sederhana berikut mempermudah pengaturan:
| Pekerjaan | Inti yang disarankan | Alasan |
|---|---|---|
| Kendali cepat dan berkala, sampling sensor, kendali motor | 1 | Interupsi dari Wi-Fi tidak mengganggu pengaturan waktu |
| Web server, MQTT, request HTTP | 0 atau 1, prioritas rendah | Stack jaringan sudah berada pada inti 0; task-mu harus sering menunggu |
| Pembaruan layar, pencatatan log | 1, prioritas 1 | Tidak mendesak, memakai waktu yang tersisa |
| Perhitungan panjang (FFT, enkripsi) | 1, atau 0 dengan prioritas rendah, diselingi vTaskDelay(1) | Agar watchdog dan task lain tetap mendapat waktu berjalan |
Ukuran stack dan error watchdog
Setiap task memiliki memori stack sendiri; variabel lokal, pemanggilan fungsi, dan fungsi library seperti printf memakai ruang ini. Pada ESP32, ukuran stack dinyatakan dalam byte; satuan “word” yang disebut dalam dokumentasi standar FreeRTOS tidak berlaku untuk ESP32. 2048 byte cukup untuk task LED sederhana. Berikan 3072–4096 byte kepada task yang memakai Serial.printf(), operasi String, dan pencetakan bilangan floating-point. Task yang menangani HTTPClient, TLS (HTTPS), atau JSON mungkin memerlukan 8192 byte atau lebih. Jika stack meluap, ESP32 melaporkan Stack canary watchpoint triggered atau A stack overflow in task ... has been detected dan memulai ulang. Kamu bisa mengetahui jumlah minimum ruang stack task yang tetap kosong sejak mulai berjalan dengan uxTaskGetStackHighWaterMark(); nilainya dalam byte, dan jika turun di bawah 500 byte, kamu harus memperbesar stack. Kami menjelaskan cara membaca pesan error di balik restart tak terduga dalam error brownout dan Guru Meditation ESP32.
| Pesan error | Arti | Solusi |
|---|---|---|
| “Task watchdog got triggered ... IDLE (CPU 0)” | Task pada inti 0 tidak menunggu selama 5 dtk | Tambahkan vTaskDelay(1) ke perulangan, turunkan prioritas, atau pindahkan task ke inti 1 |
| “Stack canary watchpoint triggered (task name)” | Stack task yang namanya disebut meluap | Perbesar nilai stack dalam xTaskCreatePinnedToCore |
| “Guru Meditation Error: LoadProhibited” | Alamat yang tidak valid dibaca | Periksa apakah pointer yang diberikan ke task menunjuk ke variabel lokal |
| “Interrupt wdt timeout on CPU1” | Rutin interrupt terlalu lama atau interrupt tetap dinonaktifkan | Persingkat ISR dan serahkan pekerjaan ke task melalui semaphore |
| “FreeRTOS Task "Gorev" should not return, Aborting now!” | Fungsi task berakhir dengan return | Gunakan perulangan tanpa akhir atau panggil vTaskDelete(NULL) di akhir |
Proyek: LED, sensor, dan web server secara bersamaan
Sekarang mari gabungkan semua yang sudah kita pelajari dalam satu proyek. Akan ada tiga task: task sensor membaca potensiometer setiap 200 ms dan menulis rata-rata 8 pembacaan terakhir ke antrean berkapasitas satu item; task LED mengedipkan LED bawaan pada kecepatan yang diatur dari halaman web; dan task web menampilkan nilai sensor terkini pada halaman yang dibuka dari ponselmu serta menyediakan tautan untuk mengubah kecepatan LED. Task berbagi data bukan melalui variabel global, melainkan dengan xQueueOverwrite() dan xQueuePeek(). loop() mencetak ruang stack kosong setiap task dan RAM kosong setiap 10 detik, sehingga kamu bisa melihat selama perangkat benar-benar beroperasi apakah ukuran stack sudah cukup. Ganti nama jaringan Wi-Fi dan kata sandi dengan milikmu sendiri.
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}Setelah meng-upload, buka alamat yang ditampilkan di Serial Monitor pada ponselmu. Halaman diperbarui setiap 2 detik dan nilainya berubah ketika kamu memutar potensiometer. Ketika kamu mengetuk tautan, kecepatan LED langsung berubah, tetapi ritme pembacaan sensor tidak pernah terganggu, karena setiap pekerjaan berjalan dalam task sendiri dengan temponya sendiri. Task web berada pada inti 0 bersama stack jaringan dengan prioritas rendah; karena task ini menunggu 2 ms pada setiap putaran, task IDLE0 bisa berjalan dan watchdog tidak terpicu. Task LED dan sensor berada pada inti 1 dan tidak terpengaruh lalu lintas Wi-Fi. Struktur ini mudah dikembangkan: untuk memperbarui nilai secara langsung tanpa memuat ulang halaman, tambahkan metode WebSocket dari artikel web server dan WebSocket ESP32, dan untuk menghaluskan nilai sensor yang berderau, ganti perhitungan rata-rata pada task sensor dengan filter median atau eksponensial.
Perbandingan dengan Raspberry Pi Pico: dua inti dalam MicroPython
RP2040 pada Raspberry Pi Pico juga memiliki dua inti, tetapi tidak ada sistem operasi: dalam MicroPython, kamu memulai inti kedua dengan modul _thread, dan hanya dua thread yang berjalan pada kedua inti. Di sisi Arduino, core arduino-pico menyediakan fungsi setup1() dan loop1() untuk inti kedua. Kode MicroPython di bawah mengedipkan LED pada inti kedua sambil membaca potensiometer pada inti pertama; penghitung bersama dilindungi dengan kunci (lock), seperti mutex pada ESP32. Penjelasan lebih lanjut tentang inti dan unit PIO Pico tersedia dalam artikel PIO dan dua inti Pico.
1import _thread, time
2from machine import Pin, ADC
3
4led = Pin(25, Pin.OUT) # Pico dahili LED (Pico W'da Pin("LED")) / onboard LED (Pin("LED") on Pico W)
5pot = ADC(26) # GP26 = ADC0
6kilit = _thread.allocate_lock() # ortak veri kilidi / lock for shared data
7yanma_sayisi = 0
8
9def ikinci_cekirdek():
10 global yanma_sayisi
11 while True:
12 led.toggle()
13 with kilit: # sayaç güvenle artar / counter updated safely
14 yanma_sayisi += 1
15 time.sleep_ms(300)
16
17_thread.start_new_thread(ikinci_cekirdek, ()) # çekirdek 1'de çalışır / runs on core 1
18
19while True:
20 deger = pot.read_u16() # 0-65535
21 with kilit:
22 sayac = yanma_sayisi
23 print("Pot:", deger, "LED degisimi / toggles:", sayac)
24 time.sleep(1)Pada Pico, metode ini bekerja dengan baik untuk dua pekerjaan, tetapi fasilitas seperti jumlah task, prioritas, antrean, dan penjadwal tidak selengkap FreeRTOS pada ESP32. Untuk proyek dengan banyak pekerjaan bersamaan, koneksi jaringan, dan pengaturan waktu yang presisi, ESP32 dan FreeRTOS menyediakan landasan yang lebih nyaman. Jika kamu ingin membuat proyek Wi-Fi dengan Pico, lihat artikel web server Wi-Fi Pico W.
Kesalahan umum dan solusinya
| Gejala | Kemungkinan penyebab | Solusi |
|---|---|---|
| Board langsung memulai ulang begitu task dibuat | Fungsi task berakhir dengan return atau stack terlalu kecil | Tambahkan perulangan tanpa akhir dan perbesar stack menjadi 4096 byte |
| loop() tidak pernah berjalan | Task berprioritas lebih tinggi pada inti 1 tidak pernah menunggu | Tambahkan vTaskDelay() ke task tersebut atau turunkan prioritasnya menjadi 1 |
| Error watchdog ketika Wi-Fi aktif | Task pada inti 0 membuat IDLE0 tidak mendapat waktu berjalan | Gunakan vTaskDelay(1) dalam perulangan atau pindahkan task ke inti 1 |
| Nilai terkadang tidak masuk akal | Dua task membaca dan menulis struktur global yang sama secara bersamaan | Pindahkan data melalui antrean atau lindungi akses dengan mutex |
| Baris di Serial Monitor bercampur | Dua task menulis ke Serial secara bersamaan | Ambil mutex sebelum menulis dan lepaskan setelah selesai |
| Board crash ketika tombol ditekan | Ada Serial.print atau fungsi FreeRTOS biasa dalam rutin interrupt | Gunakan hanya fungsi FromISR dalam ISR dan serahkan pekerjaan ke task |
| analogRead() mengembalikan 4095 atau 0 selama Wi-Fi aktif | Sensor terhubung ke pin ADC2 | Gunakan salah satu pin ADC1 GPIO 32–39 |
| Kode berhasil dikompilasi pada ESP32-C3 tetapi tidak berjalan | Inti 1 diminta pada board dengan satu inti | Gunakan inti 0 atau tskNO_AFFINITY, atau gunakan xTaskCreate() |
Dua inti ESP32 dan FreeRTOS mengubah fungsi loop() rumit yang penuh perhitungan millis() menjadi task kecil yang mudah dibaca dan masing-masing berfokus pada satu pekerjaan. Kini setelah kamu mengetahui cara membuat task, mengatur prioritas, memindahkan data melalui antrean, menangani interrupt dengan semaphore, dan mengukur stack, proyek Wi-Fi-mu akan berjalan tanpa tersendat. Jika kamu baru mengenal ESP32, dasar-dasarnya tersedia dalam Apa Itu ESP32?. Dalam aplikasi BlueGrays, kamu juga bisa menjelajahi proyek ESP32 seperti web server asinkron, WebSocket, jam NTP, pencatat suhu, dan pencahayaan pintar, masing-masing dengan skema rangkaian langkah demi langkah dan kode siap pakai.
Pertanyaan umum
Apa itu FreeRTOS pada ESP32?
FreeRTOS adalah sistem operasi waktu nyata yang berjalan di dalam ESP32, dan kode Arduino-mu berjalan di atasnya. FreeRTOS memungkinkan kamu membagi beberapa pekerjaan menjadi task terpisah, memberi prioritas, dan membagikannya ke kedua inti. Tidak diperlukan instalasi terpisah; fungsi seperti xTaskCreate sudah siap digunakan dalam core Arduino ESP32.
Pada inti mana loop() berjalan di ESP32?
Dalam core Arduino, setup() dan loop() berjalan di dalam task bernama loopTask pada inti 1 dengan prioritas 1. Wi-Fi, TCP/IP, dan Bluetooth berada pada inti 0. Kamu bisa melihatnya sendiri dengan mencetak hasil xPortGetCoreID().
Apa perbedaan delay() dan vTaskDelay() pada ESP32?
Dalam core Arduino ESP32, delay() sebenarnya memanggil vTaskDelay(), sehingga keduanya melepaskan inti untuk task lain selama menunggu. Penantian yang membuat prosesor tetap sibuk seperti pada Arduino Uno terjadi pada ESP32 melalui delayMicroseconds() dan perulangan while kosong. Untuk pekerjaan dengan interval tetap, vTaskDelayUntil() lebih akurat.
Seberapa besar ukuran stack xTaskCreatePinnedToCore yang diperlukan?
Pada ESP32, ukuran stack dinyatakan dalam byte. Sebagai titik awal, gunakan 2048 byte untuk task LED sederhana, 3072–4096 untuk task yang memakai Serial.printf dan String, serta 8192 untuk pekerjaan berat seperti HTTPS dan JSON. Ukur kebutuhan sebenarnya dengan uxTaskGetStackHighWaterMark() lalu sesuaikan.
Bagaimana cara mengatasi error “Task watchdog got triggered” pada ESP32?
Error ini berarti task idle pada inti 0 tidak bisa berjalan selama 5 detik; biasanya ada task yang terus mengulang tanpa pernah menunggu. Tambahkan vTaskDelay(1) di dalam perulangan, turunkan prioritas task, atau pindahkan ke inti 1. Membagi perhitungan panjang menjadi bagian-bagian lebih kecil juga membantu.
Bagaimana cara berbagi data antar-task pada ESP32?
Cara paling aman adalah memakai antrean FreeRTOS: data dikirim dengan xQueueSend() dan diterima dengan xQueueReceive(), dan karena data disalin, tidak ada nilai yang hanya terbaca sebagian. Jika hanya nilai terbaru yang diperlukan, gunakan antrean berkapasitas satu item dengan xQueueOverwrite() dan xQueuePeek(). Jika kamu berbagi perangkat keras atau struktur global, lindungi akses dengan mutex.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Web Server Asinkron ESP32 (dengan Tampilan IP di LCD)
Di proyek ini, kita mengubah ESP32 menjadi web server asinkron yang bisa kamu kendalikan dari ponsel atau komputer di jaringan Wi-Fi yang sama. Berkat library ESPAsyncWebServer, server bisa memproses beberapa permintaan bersamaan (berbeda dengan WebServer.h klasik, yang memblokir pada satu permintaan). Kamu bisa membuka alamat IP ESP32 di browser dan mengklik tombol ON/OFF (rute /on dan /off) untuk menyalakan dan mematikan LED yang tersambung ke GPIO 5.

Penghitung WebSocket ESP32 (2 Tombol + LCD + Web Real-Time)
Di proyek ini, dua tombol yang tersambung ke ESP32 (GPIO 5 menghitung naik, GPIO 4 menghitung turun) mengubah sebuah penghitung. Nilainya langsung diperbarui di LCD I2C 16x2 sekaligus, lewat dukungan WebSocket ESPAsyncWebServer, di setiap browser yang tersambung tanpa memuat ulang halaman. Alih-alih polling HTTP, dipakai satu koneksi yang tetap terbuka, dan ESP32 mengirim nilai baru ke semua orang dengan ws.textAll().

Koneksi Wi-Fi STA ESP32 (dengan Layar LCD)
Di proyek ini, kita menyambungkan ESP32 ke jaringan Wi-Fi rumah dalam mode Station (STA) dengan cara yang aman dan tahan gangguan. Kita menyimpan SSID dan kata sandi di file secrets.h terpisah agar tidak bocor ke Git, menyiapkan mekanisme sambung ulang otomatis, dan menampilkan tingkat sinyal RSSI dan alamat IP di layar LCD I2C. LED bawaan bekerja sebagai indikator status. Ini adalah pengelola koneksi kelas produksi.

Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)
Di proyek ini, kita mengendalikan kecerahan LED secara analog memakai potensiometer. Pin ADC ESP32 membaca tegangan 0-3,3V dari potensiometer, lalu nilai ini diubah menjadi sinyal PWM (Pulse Width Modulation) dan dikirim ke LED. Hasilnya, ketika kamu memutar potensiometer, LED perlahan menerang dan meredup. Dengan Arduino Core 3.0+, analogWrite() bisa langsung dipakai; di ESP32-S2/S3, resolusi ADC tetap 12-bit.

Kendali Strip NeoPixel WS2812B ESP32
LED addressable WS2812B (NeoPixel) adalah LED RGB pintar yang bisa dikendalikan secara berantai lewat satu pin data. Di proyek ini, kita mengendalikan strip WS2812B 8 LED dengan library Adafruit_NeoPixel untuk membuat animasi pelangi yang halus. Meskipun level logika 3,3V ESP32 bekerja lancar dengan sebagian besar komponen WS2812B, kita menunjukkan solusi dengan resistor seri 470Ω dan kapasitor 1000µF untuk berjaga-jaga jika tidak stabil. Animasinya dibuat dengan menggeser nilai hue.

Deep Sleep ESP32: Hemat Baterai (OLED + Penghitung RTC RAM)
Mode Deep Sleep ESP32 menurunkan konsumsi arus hingga ~10 µA dengan mematikan CPU dan sebagian besar periferal, sehingga sangat penting untuk perangkat IoT bertenaga baterai. Di proyek ini, kita memakai tiga sumber bangun yang berbeda: timer (15 detik), pin eksternal (EXT0, tombol GPIO 33), dan sentuhan (T0/GPIO 4). Variabel yang ditandai RTC_DATA_ATTR dipertahankan selama deep sleep; penghitung boot, penghitung bangun karena timer, dan penghitung bangun karena tombol terus dilacak.

Pencatat Data Suhu ESP32 (DHT22 + RTC DS1307 + microSD + OLED)
Buat pencatat suhu bercap waktu dengan ESP32! Baca suhu/kelembapan DHT22 setiap menit, ambil waktu sebenarnya dari RTC DS1307, dan catat ke kartu microSD sebagai CSV. OLED menampilkan suhu langsung (font besar), kelembapan, cap waktu, dan penghitung catatan. File /temp_log.csv bisa dibuka di Excel, Google Sheets, atau Python pandas; cocok untuk rumah kaca, suhu kamar, data laboratorium, penyimpanan makanan, atau sarang lebah.

Lampu Pintar ESP32 (PIR + LDR + Relay + OLED)
Ubah lorong, kamar mandi, atau gudangmu menjadi lampu pintar dengan ESP32! Dengan sensor gerak PIR, sensor cahaya LDR, dan modul relay, kita membuat skenario klasik "lampu menyala ketika ada gerakan dalam gelap"; jika sudah terang, gerakan TIDAK menyalakan lampu, jadi energi hemat di siang hari. Lampu menyala 30 detik; jika gerakan berlanjut, timer diulang. OLED SSD1306 menampilkan status dengan font besar (NYALA / SIANG / MENUNGGU) dan hitung mundur.
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

