🎓 Danh sách khóa học Thầy Lê Chí Tuyền

// Bài 1 – Vì sao cần RTOS? Mô phỏng chương trình "siêu vòng lặp" (super loop) kiểu Arduino
// KHÔNG dùng FreeRTOS: mỗi việc dùng delay() chặn -> nút nhấn bị bỏ lỡ.
#include <cstdio>

unsigned long thoiGian = 0;                       // đồng hồ giả lập (ms)
void delayMs(unsigned long ms) { thoiGian += ms; } // delay(): CPU đứng chờ, không làm gì khác được

// Nút được nhấn tại các thời điểm này (mỗi lần nhấn giữ 50 ms)
const unsigned long LAN_NHAN[] = {120, 950, 1430, 2210};
bool nutDangNhan() {
    for (unsigned long t : LAN_NHAN)
        if (thoiGian >= t && thoiGian < t + 50) return true;
    return false;
}

int main() {
    int phatHien = 0;
    std::printf("== Siêu vòng lặp với delay() ==\n");
    while (thoiGian < 2500) {                     // loop()
        if (nutDangNhan()) { phatHien++; std::printf("[%4lu ms] phát hiện nút nhấn\n", thoiGian); }
        std::printf("[%4lu ms] đọc cảm biến DHT22 (mất 250 ms)\n", thoiGian);
        delayMs(250);
        std::printf("[%4lu ms] cập nhật màn hình LCD (mất 200 ms)\n", thoiGian);
        delayMs(200);
    }
    std::printf("Nhấn 4 lần, chỉ phát hiện %d lần -> bỏ lỡ %d lần!\n", phatHien, 4 - phatHien);
    std::printf("RTOS giải quyết: mỗi việc là một TASK, task đọc nút có ưu tiên cao được chạy ngay.\n");
}

// Bài 2 – Task đầu tiên: tạo 2 task nháy 2 "LED" với chu kỳ khác nhau, chạy song song
#include "sim.h"

void taskLedDo(void* thamSo) {
    (void)thamSo;
    for (int i = 0; i < 4; i++) {                 // trên board thật là for (;;) – task không bao giờ return
        LOG("LED đỏ   %s", i % 2 ? "TẮT" : "BẬT");
        vTaskDelay(pdMS_TO_TICKS(500));           // nhường CPU 500 ms (KHÔNG chặn task khác như delay())
    }
    vTaskDelete(nullptr);                         // task tự xoá khi xong việc
}

void taskLedXanh(void* thamSo) {
    int chuKy = *static_cast<int*>(thamSo);       // nhận tham số qua con trỏ void*
    for (int i = 0; i < 6; i++) {
        LOG("LED xanh %s", i % 2 ? "TẮT" : "BẬT");
        vTaskDelay(pdMS_TO_TICKS(chuKy));
    }
    LOG("Hai task đã chạy song song xong");
    ket_thuc();
}

int main() {
    static int chuKyXanh = 300;                   // static: phải còn sống khi task chạy
    PRINT("Tạo task...");
    xTaskCreate(taskLedDo,   "LedDo",   configMINIMAL_STACK_SIZE, nullptr,    1, nullptr);
    xTaskCreate(taskLedXanh, "LedXanh", configMINIMAL_STACK_SIZE, &chuKyXanh, 1, nullptr);
    PRINT("Khởi động scheduler – từ đây FreeRTOS điều khiển CPU");
    vTaskStartScheduler();                        // không bao giờ trả về nếu đủ bộ nhớ
    PRINT("Không đủ heap để tạo idle task!");
}

// Bài 2 – Task: một hàm dùng cho nhiều task (tham số khác nhau), task tạo tĩnh, handle, trạng thái, stack
#include "sim.h"

struct CauHinhCamBien {
    const char* ten;
    int chuKyMs;
    int giaTriGoc;
};

void taskCamBien(void* p) {
    const CauHinhCamBien* cfg = static_cast<const CauHinhCamBien*>(p);
    for (int i = 0; i < 3; i++) {
        LOG("%-8s đọc được %d", cfg->ten, cfg->giaTriGoc + i);
        vTaskDelay(pdMS_TO_TICKS(cfg->chuKyMs));
    }
    LOG("%-8s xong, stack còn trống ít nhất %u word", cfg->ten, (unsigned)uxTaskGetStackHighWaterMark(nullptr));
    vTaskDelete(nullptr);
}

// ===== Task tạo TĨNH: bộ nhớ stack và TCB do ta cấp, không dùng heap =====
StackType_t stackTinh[256];
StaticTask_t tcbTinh;
void taskBaoThuc(void*) {
    for (;;) {
        LOG("BaoThuc  bíp! (task tĩnh)");
        vTaskDelay(pdMS_TO_TICKS(400));
    }
}

const char* tenTrangThai(eTaskState s) {
    switch (s) {
        case eRunning:   return "Running";
        case eReady:     return "Ready";
        case eBlocked:   return "Blocked";
        case eSuspended: return "Suspended";
        case eDeleted:   return "Deleted";
        default:         return "?";
    }
}

TaskHandle_t hBaoThuc = nullptr;

void taskQuanLy(void*) {
    vTaskDelay(pdMS_TO_TICKS(50));
    LOG("QuanLy   trạng thái BaoThuc: %s", tenTrangThai(eTaskGetState(hBaoThuc)));
    vTaskDelay(pdMS_TO_TICKS(900));
    LOG("QuanLy   số task đang tồn tại: %u", (unsigned)uxTaskGetNumberOfTasks());
    LOG("QuanLy   xoá task BaoThuc");
    vTaskDelete(hBaoThuc);
    vTaskDelay(pdMS_TO_TICKS(500));
    LOG("QuanLy   số task còn lại: %u (gồm IDLE và Tmr Svc)", (unsigned)uxTaskGetNumberOfTasks());
    ket_thuc();
}

int main() {
    static const CauHinhCamBien nhiet{"Nhiet", 300, 28};
    static const CauHinhCamBien doAm{"DoAm", 450, 60};
    xTaskCreate(taskCamBien, "Nhiet", 512, (void*)&nhiet, 1, nullptr);   // cùng hàm,
    xTaskCreate(taskCamBien, "DoAm",  512, (void*)&doAm,  1, nullptr);   // khác tham số
    hBaoThuc = xTaskCreateStatic(taskBaoThuc, "BaoThuc", 256, nullptr, 1, stackTinh, &tcbTinh);
    xTaskCreate(taskQuanLy, "QuanLy", 512, nullptr, 2, nullptr);
    vTaskStartScheduler();
}

// Bài 3 – Ưu tiên và chiếm quyền (preemption): task ưu tiên cao chen ngang ngay khi sẵn sàng.
// Phần 2: task ưu tiên cao KHÔNG nhường CPU -> task thấp bị "đói" (starvation).
#include "sim.h"

void taskNen(void*) {                        // ưu tiên 1: việc nền nặng
    for (int i = 1; i <= 10; i++) {
        banTinhToan(100);                    // tính toán liên tục 100 ms, không nhường CPU
        LOG("  Nen      xong khối việc %d", i);
    }
    vTaskDelete(nullptr);
}

void taskKhanCap(void*) {                    // ưu tiên 3: phải phản hồi đúng hạn
    TickType_t moc = xTaskGetTickCount();
    for (int i = 0; i < 3; i++) {
        vTaskDelayUntil(&moc, pdMS_TO_TICKS(170));
        LOG("KhanCap  đọc cảm biến khí gas (chen ngang task nền)");
    }
    vTaskDelete(nullptr);
}

void taskThamLam(void*) {                    // ưu tiên 2: chạy liên tục 300 ms không nghỉ
    vTaskDelay(pdMS_TO_TICKS(700));
    LOG("ThamLam  bắt đầu chiếm CPU 300 ms (không gọi vTaskDelay)");
    banTinhToan(300);
    LOG("ThamLam  xong – trong 300 ms đó task Nen (ưu tiên 1) không chạy được");
    vTaskDelay(pdMS_TO_TICKS(350));
    ket_thuc();
}

int main() {
    xTaskCreate(taskNen,     "Nen",     512, nullptr, 1, nullptr);
    xTaskCreate(taskKhanCap, "KhanCap", 512, nullptr, 3, nullptr);
    xTaskCreate(taskThamLam, "ThamLam", 512, nullptr, 2, nullptr);
    vTaskStartScheduler();
}

// Bài 3 – vTaskDelay vs vTaskDelayUntil (chu kỳ chính xác), vTaskSuspend/Resume, đổi ưu tiên lúc chạy
#include "sim.h"

void taskLayMau(void*) {
    LOG("== Cách 1: vTaskDelay(100) sau khi xử lý 30 ms ==");
    for (int i = 0; i < 4; i++) {
        LOG("vTaskDelay      lấy mẫu lần %d", i);
        banTinhToan(30);                             // xử lý mất 30 ms
        vTaskDelay(pdMS_TO_TICKS(100));              // nghỉ 100 ms TÍNH TỪ BÂY GIỜ -> chu kỳ thực 130 ms (trôi dần)
    }
    LOG("== Cách 2: vTaskDelayUntil(&moc, 100) ==");
    TickType_t moc = xTaskGetTickCount();
    for (int i = 0; i < 4; i++) {
        LOG("vTaskDelayUntil lấy mẫu lần %d", i);
        banTinhToan(30);
        vTaskDelayUntil(&moc, pdMS_TO_TICKS(100));   // đánh thức đúng moc + 100 -> chu kỳ đúng 100 ms
    }
    vTaskDelete(nullptr);
}

TaskHandle_t hNhay = nullptr;
void taskNhayLed(void*) {
    vTaskDelay(pdMS_TO_TICKS(1000));
    for (;;) {
        LOG("  NhayLed  nháy (ưu tiên %u)", (unsigned)uxTaskPriorityGet(nullptr));
        vTaskDelay(pdMS_TO_TICKS(150));
    }
}

void taskDieuKhien(void*) {
    vTaskDelay(pdMS_TO_TICKS(1320));
    LOG("DieuKhien  -> vTaskSuspend(NhayLed): tạm dừng");
    vTaskSuspend(hNhay);
    vTaskDelay(pdMS_TO_TICKS(400));
    LOG("DieuKhien  -> vTaskResume(NhayLed) và nâng ưu tiên lên 3");
    vTaskPrioritySet(hNhay, 3);
    vTaskResume(hNhay);
    vTaskDelay(pdMS_TO_TICKS(320));
    ket_thuc();
}

int main() {
    xTaskCreate(taskLayMau,    "LayMau",    512, nullptr, 2, nullptr);
    xTaskCreate(taskNhayLed,   "NhayLed",   512, nullptr, 1, &hNhay);
    xTaskCreate(taskDieuKhien, "DieuKhien", 512, nullptr, 4, nullptr);
    vTaskStartScheduler();
}

// Bài 4 – Idle task, idle hook (đo tải CPU), vùng găng, tạm dừng scheduler, liệt kê task
#include "sim.h"

volatile uint32_t demIdle = 0;

// Idle hook: được gọi liên tục khi KHÔNG có task nào khác sẵn sàng.
// Không được chặn (không vTaskDelay). Thường dùng để: đo CPU rảnh, cho chip vào chế độ ngủ.
extern "C" void vApplicationIdleHook(void) {
    static TickType_t lanCuoi = 0;
    TickType_t now = xTaskGetTickCount();
    if (now != lanCuoi) { lanCuoi = now; demIdle++; }   // đếm số tick CPU rảnh
}

void taskBan(void*) {
    for (int i = 0; i < 3; i++) {
        banTinhToan(60);                 // bận 60 ms
        vTaskDelay(pdMS_TO_TICKS(140));  // nghỉ 140 ms -> tải CPU ~30%
    }
    vTaskDelete(nullptr);
}

volatile int biengChung = 0;
void taskBaoCao(void*) {
    vTaskDelay(pdMS_TO_TICKS(20));
    char bang[512];
    vTaskList(bang);                     // bảng: Tên  Trạng thái  Ưu tiên  Stack trống  Số thứ tự
    PRINT("Tên            \tTT\tƯT\tStack\tSTT\n%s", bang);
    PRINT("(TT: X=đang chạy, R=sẵn sàng, B=bị chặn, S=tạm dừng, D=đã xoá)\n");

    // Vùng găng (critical section): tắt ngắt/không chuyển task – phải thật NGẮN
    taskENTER_CRITICAL();
    biengChung++;
    taskEXIT_CRITICAL();

    // Tạm dừng scheduler: các task khác không chạy nhưng ngắt vẫn hoạt động
    vTaskSuspendAll();
    biengChung++;
    xTaskResumeAll();
    LOG("BaoCao   biengChung = %d (sửa an toàn 2 lần)", biengChung);

    TickType_t batDau = xTaskGetTickCount();
    uint32_t idleBatDau = demIdle;
    vTaskDelay(pdMS_TO_TICKS(600));
    uint32_t tong = xTaskGetTickCount() - batDau, ranh = demIdle - idleBatDau;
    LOG("BaoCao   trong %lu ms: CPU rảnh ~%lu ms -> tải CPU ~%lu%%", (unsigned long)tong, (unsigned long)ranh,
        (unsigned long)(100 - ranh * 100 / tong));
    LOG("BaoCao   tên task hiện tại: %s, idle task: %s", pcTaskGetName(nullptr), pcTaskGetName(xTaskGetIdleTaskHandle()));
    ket_thuc();
}

int main() {
    xTaskCreate(taskBan,     "Ban",     512,  nullptr, 1, nullptr);
    xTaskCreate(taskBaoCao,  "BaoCao",  2048, nullptr, 2, nullptr);
    vTaskStartScheduler();
}

// Bài 5 – Queue cơ bản: task sản xuất gửi dữ liệu, task tiêu thụ chờ (bị chặn) cho tới khi có dữ liệu.
// Phần 2: hàng đợi đầy khi bên gửi nhanh hơn bên nhận.
#include "sim.h"
#include "queue.h"

QueueHandle_t qNhietDo;

void taskDocCamBien(void*) {                          // producer
    for (int i = 0; i < 4; i++) {
        int t = 280 + i * 3;                          // nhiệt độ x10
        LOG("DocCamBien gửi %d", t);
        xQueueSend(qNhietDo, &t, portMAX_DELAY);      // sao chép giá trị vào hàng đợi
        vTaskDelay(pdMS_TO_TICKS(200));
    }
    vTaskDelete(nullptr);
}

void taskHienThi(void*) {                             // consumer
    int t;
    for (int i = 0; i < 4; i++) {
        xQueueReceive(qNhietDo, &t, portMAX_DELAY);   // ngủ (Blocked) tới khi có dữ liệu – không tốn CPU
        LOG("  HienThi  nhận %d -> LCD: %d.%d°C", t, t / 10, t % 10);
    }
    vTaskDelete(nullptr);
}

QueueHandle_t qNho;
void taskGuiNhanh(void*) {
    vTaskDelay(pdMS_TO_TICKS(1000));
    LOG("== Phần 2: hàng đợi 3 phần tử, gửi mỗi 50 ms, nhận mỗi 200 ms ==");
    for (int i = 1; i <= 8; i++) {
        BaseType_t ok = xQueueSend(qNho, &i, 0);      // timeout 0: không chờ nếu đầy
        LOG("GuiNhanh  gửi %d -> %s (đang chờ %u)", i, ok == pdPASS ? "OK" : "ĐẦY, bỏ mất", (unsigned)uxQueueMessagesWaiting(qNho));
        vTaskDelay(pdMS_TO_TICKS(50));
    }
    vTaskDelete(nullptr);
}

void taskNhanCham(void*) {
    vTaskDelay(pdMS_TO_TICKS(1000));
    int v;
    while (xQueueReceive(qNho, &v, pdMS_TO_TICKS(500)) == pdPASS) {   // chờ tối đa 500 ms
        LOG("  NhanCham nhận %d", v);
        vTaskDelay(pdMS_TO_TICKS(200));
    }
    LOG("  NhanCham hết 500 ms không có dữ liệu -> kết thúc");
    ket_thuc();
}

int main() {
    qNhietDo = xQueueCreate(5, sizeof(int));          // 5 phần tử, mỗi phần tử sizeof(int) byte
    qNho = xQueueCreate(3, sizeof(int));
    xTaskCreate(taskDocCamBien, "DocCamBien", 512, nullptr, 2, nullptr);
    xTaskCreate(taskHienThi,    "HienThi",    512, nullptr, 1, nullptr);
    xTaskCreate(taskGuiNhanh,   "GuiNhanh",   512, nullptr, 2, nullptr);
    xTaskCreate(taskNhanCham,   "NhanCham",   512, nullptr, 1, nullptr);
    vTaskStartScheduler();
}

// Bài 5 – Queue chứa struct: nhiều task nguồn gửi về một task ghi log; tin khẩn gửi lên ĐẦU hàng đợi;
// xQueuePeek xem mà không lấy; gửi từ ngắt bằng xQueueSendFromISR.
#include "sim.h"
#include "queue.h"

enum Nguon : uint8_t { NHIET, DO_AM, KHOI, NUT };
const char* TEN_NGUON[] = {"Nhiệt độ", "Độ ẩm", "Khói", "Nút nhấn"};

struct BanTin {
    Nguon nguon;
    int16_t giaTri;
    bool khanCap;
};

QueueHandle_t qLog;

void taskNhiet(void*) {
    for (int i = 0; i < 3; i++) {
        BanTin b{NHIET, int16_t(28 + i), false};
        xQueueSend(qLog, &b, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(150));
    }
    vTaskDelete(nullptr);
}

void taskDoAm(void*) {
    for (int i = 0; i < 3; i++) {
        BanTin b{DO_AM, int16_t(60 - i), false};
        xQueueSend(qLog, &b, portMAX_DELAY);
        vTaskDelay(pdMS_TO_TICKS(150));
    }
    vTaskDelete(nullptr);
}

void taskKhoi(void*) {
    vTaskDelay(pdMS_TO_TICKS(140));
    BanTin b{KHOI, 850, true};
    xQueueSendToFront(qLog, &b, portMAX_DELAY);     // chen lên ĐẦU hàng đợi
    vTaskDelete(nullptr);
}

// ISR nút nhấn: dùng phiên bản ...FromISR, không bao giờ chờ
uint32_t isrNut() {
    BaseType_t canChuyen = pdFALSE;
    BanTin b{NUT, 1, false};
    xQueueSendFromISR(qLog, &b, &canChuyen);
    return canChuyen;                                // pdTRUE nếu task đang chờ có ưu tiên cao hơn task bị ngắt
}

void taskPhanCung(void*) {                           // giả lập: người dùng nhấn nút lúc 300 ms
    vTaskDelay(pdMS_TO_TICKS(300));
    phatNgat(3);
    vTaskDelete(nullptr);
}

void taskGhiLog(void*) {
    vTaskDelay(pdMS_TO_TICKS(100));                  // ghi log chậm: để bản tin dồn lại trong hàng đợi
    BanTin b;
    while (xQueuePeek(qLog, &b, pdMS_TO_TICKS(400)) == pdPASS) {
        if (b.khanCap) LOG("GhiLog   (peek) thấy tin khẩn ở đầu hàng đợi!");
        xQueueReceive(qLog, &b, 0);
        LOG("GhiLog   %s = %d%s", TEN_NGUON[b.nguon], b.giaTri, b.khanCap ? "   <<< KHẨN" : "");
        vTaskDelay(pdMS_TO_TICKS(40));
    }
    LOG("GhiLog   hàng đợi trống, kết thúc. sizeof(BanTin) = %u byte", (unsigned)sizeof(BanTin));
    ket_thuc();
}

int main() {
    qLog = xQueueCreate(10, sizeof(BanTin));
    dangKyNgat(3, isrNut);
    xTaskCreate(taskNhiet,    "Nhiet",    512, nullptr, 2, nullptr);
    xTaskCreate(taskDoAm,     "DoAm",     512, nullptr, 2, nullptr);
    xTaskCreate(taskKhoi,     "Khoi",     512, nullptr, 3, nullptr);
    xTaskCreate(taskPhanCung, "PhanCung", 512, nullptr, 4, nullptr);
    xTaskCreate(taskGhiLog,   "GhiLog",   1024, nullptr, 1, nullptr);
    vTaskStartScheduler();
}

// Bài 6 – Binary semaphore: "xử lý ngắt trì hoãn" (deferred interrupt processing).
// ISR chỉ báo hiệu (give) rồi thoát ngay; task xử lý (ưu tiên cao) làm phần việc nặng.
#include "sim.h"
#include "semphr.h"

SemaphoreHandle_t semNut;
volatile uint32_t soLanNgat = 0;

uint32_t isrNutNhan() {                              // ISR: thật ngắn, không in, không chờ
    soLanNgat++;
    BaseType_t canChuyen = pdFALSE;
    xSemaphoreGiveFromISR(semNut, &canChuyen);
    return canChuyen;                                // = portYIELD_FROM_ISR(canChuyen) trên board thật
}

void taskXuLyNut(void*) {
    for (;;) {
        if (xSemaphoreTake(semNut, pdMS_TO_TICKS(450)) == pdTRUE) {    // ngủ tới khi ISR give (tối đa 450 ms)
            LOG("XuLyNut  được đánh thức -> đọc chống dội, đổi chế độ quạt (việc nặng ở đây)");
        } else {
            LOG("XuLyNut  450 ms không có ai nhấn nút -> kết thúc ví dụ");
            ket_thuc();
        }
    }
}

void taskNen(void*) {
    for (;;) {
        banTinhToan(100);                            // task nền bận liên tục
        LOG("  Nen    đang tính toán...");
    }
}

void taskPhanCung(void*) {                           // giả lập người dùng nhấn nút
    const uint32_t thoiDiem[] = {250, 520, 900};
    TickType_t truoc = 0;
    for (uint32_t t : thoiDiem) {
        vTaskDelay(pdMS_TO_TICKS(t - truoc));
        truoc = t;
        LOG("[phần cứng] nút được nhấn -> phát ngắt");
        phatNgat(3);
    }
    vTaskDelete(nullptr);
}

int main() {
    semNut = xSemaphoreCreateBinary();               // tạo ra ở trạng thái "trống" (đã bị take)
    dangKyNgat(3, isrNutNhan);
    xTaskCreate(taskXuLyNut,  "XuLyNut",  512, nullptr, 3, nullptr);
    xTaskCreate(taskNen,      "Nen",      512, nullptr, 1, nullptr);
    xTaskCreate(taskPhanCung, "PhanCung", 512, nullptr, 4, nullptr);
    vTaskStartScheduler();
}

// Bài 6 – Counting semaphore: quản lý một NHÓM tài nguyên giống nhau (ở đây: 2 kênh DMA / 2 chỗ sạc)
// và đếm sự kiện (nhiều ngắt dồn lại không bị mất).
#include "sim.h"
#include "semphr.h"

SemaphoreHandle_t semKenh;                            // 2 kênh truyền dữ liệu dùng chung

void taskGuiDuLieu(void* p) {
    const char* ten = static_cast<const char*>(p);
    LOG("%s xin một kênh (còn %u kênh rảnh)", ten, (unsigned)uxSemaphoreGetCount(semKenh));
    xSemaphoreTake(semKenh, portMAX_DELAY);           // giảm bộ đếm; nếu = 0 thì chờ
    LOG("%s ĐƯỢC cấp kênh, gửi dữ liệu 300 ms", ten);
    vTaskDelay(pdMS_TO_TICKS(300));
    LOG("%s trả kênh", ten);
    xSemaphoreGive(semKenh);                          // tăng bộ đếm
    vTaskDelete(nullptr);
}

// ===== Đếm sự kiện: encoder phát nhiều xung liên tiếp =====
SemaphoreHandle_t semXung;
uint32_t isrEncoder() {
    BaseType_t c = pdFALSE;
    xSemaphoreGiveFromISR(semXung, &c);
    return c;
}

void taskDemXung(void*) {
    vTaskDelay(pdMS_TO_TICKS(800));
    LOG("== Phần 2: 5 xung encoder tới dồn dập trong lúc task đang bận ==");
    for (int i = 0; i < 5; i++) phatNgat(3);
    vTaskDelay(pdMS_TO_TICKS(10));
    int dem = 0;
    while (xSemaphoreTake(semXung, 0) == pdTRUE) dem++;
    LOG("DemXung  xử lý được %d/5 xung (counting semaphore không làm mất xung)", dem);
    ket_thuc();
}

int main() {
    semKenh = xSemaphoreCreateCounting(2, 2);          // tối đa 2, ban đầu 2 (cả hai kênh rảnh)
    semXung = xSemaphoreCreateCounting(10, 0);         // đếm sự kiện: ban đầu 0
    dangKyNgat(3, isrEncoder);
    static const char* ten[] = {"Task A", "Task B", "Task C", "Task D"};
    for (int i = 0; i < 4; i++) xTaskCreate(taskGuiDuLieu, ten[i], 512, (void*)ten[i], 2, nullptr);
    xTaskCreate(taskDemXung, "DemXung", 512, nullptr, 1, nullptr);
    vTaskStartScheduler();
}

// Bài 7 – Mutex bảo vệ tài nguyên dùng chung (màn hình LCD).
// Ghi một dòng lên LCD gồm nhiều bước; nếu task khác chen vào giữa -> màn hình bị lẫn chữ.
#include <cstring>
#include "sim.h"
#include "semphr.h"

char lcd[2][17];                                      // màn hình 2 dòng x 16 ký tự (tài nguyên dùng chung)
SemaphoreHandle_t mutexLcd;
bool dungMutex = false;

void lcdVietDong(int dong, const char* s) {           // ghi từng ký tự, mỗi ký tự mất 1 ms (giống LCD thật)
    for (int i = 0; i < 16; i++) {
        lcd[dong][i] = s[i] ? s[i] : ' ';
        vTaskDelay(1);                                // tạo cơ hội cho task khác chen vào
        if (!s[i]) { for (int k = i + 1; k < 16; k++) lcd[dong][k] = ' '; break; }
    }
}

void hienThi(const char* d0, const char* d1) {
    if (dungMutex) xSemaphoreTake(mutexLcd, portMAX_DELAY);   // vào vùng găng
    lcdVietDong(0, d0);
    lcdVietDong(1, d1);
    if (dungMutex) xSemaphoreGive(mutexLcd);                  // ra vùng găng – CHÍNH task đã take phải give
}

void taskNhietDo(void*) { for (;;) { hienThi("Nhiet do: 28.5C", "Do am   : 61%"); vTaskDelay(5); } }
void taskCanhBao(void*) { for (;;) { hienThi("!! CANH BAO !!", "Khoi vuot nguong"); vTaskDelay(7); } }

void chup(const char* tieuDe) {
    vTaskSuspendAll();                                // chụp nội dung LCD khi không ai đang ghi dở
    PRINT("%s\n  +----------------+\n  |%.16s|\n  |%.16s|\n  +----------------+", tieuDe, lcd[0], lcd[1]);
    xTaskResumeAll();
}

void taskKiemTra(void*) {
    vTaskDelay(pdMS_TO_TICKS(53));
    chup("KHÔNG có mutex – hai task ghi xen kẽ:");
    dungMutex = true;
    vTaskDelay(pdMS_TO_TICKS(200));
    xSemaphoreTake(mutexLcd, portMAX_DELAY);          // chờ tới lúc không ai đang ghi
    chup("CÓ mutex – mỗi lần chỉ một task ghi trọn vẹn:");
    xSemaphoreGive(mutexLcd);
    ket_thuc();
}

int main() {
    std::memset(lcd, ' ', sizeof(lcd));
    lcd[0][16] = lcd[1][16] = 0;
    mutexLcd = xSemaphoreCreateMutex();
    xTaskCreate(taskNhietDo, "NhietDo", 512, nullptr, 1, nullptr);
    xTaskCreate(taskCanhBao, "CanhBao", 512, nullptr, 1, nullptr);
    xTaskCreate(taskKiemTra, "KiemTra", 1024, nullptr, 2, nullptr);
    vTaskStartScheduler();
}

// Bài 7 – Đảo ưu tiên (priority inversion) và kế thừa ưu tiên (priority inheritance).
// Thap (1) giữ khoá -> Cao (3) phải chờ khoá -> Vua (2) chen ngang Thap, làm Cao chờ lâu vô lý.
// Binary semaphore: KHÔNG kế thừa ưu tiên.  Mutex: Thap được tạm nâng lên ưu tiên 3.
#include "sim.h"
#include "semphr.h"

SemaphoreHandle_t khoa;
TickType_t batDau;

void taskThap(void*) {
    xSemaphoreTake(khoa, portMAX_DELAY);
    LOG("  Thap  (ƯT 1) lấy khoá, ghi thẻ SD 100 ms");
    for (int i = 0; i < 100; i++) {
        banTinhToan(1);
        if (i == 50) LOG("  Thap  đang giữ khoá, ưu tiên hiện tại = %u", (unsigned)uxTaskPriorityGet(nullptr));
    }
    LOG("  Thap  trả khoá");
    xSemaphoreGive(khoa);
    vTaskDelete(nullptr);
}

void taskCao(void*) {
    vTaskDelay(pdMS_TO_TICKS(10));
    LOG("Cao     (ƯT 3) cần khoá -> phải chờ Thap");
    xSemaphoreTake(khoa, portMAX_DELAY);
    LOG("Cao     có khoá sau khi chờ %lu ms", (unsigned long)(xTaskGetTickCount() - batDau - 10));
    xSemaphoreGive(khoa);
    vTaskDelete(nullptr);
}

void taskVua(void*) {
    vTaskDelay(pdMS_TO_TICKS(20));
    LOG(" Vua    (ƯT 2) không cần khoá, chạy 200 ms");
    banTinhToan(200);
    LOG(" Vua    xong");
    vTaskDelete(nullptr);
}

void chayThuNghiem(void* p) {
    for (int lan = 0; lan < 2; lan++) {
        bool dungMutex = (lan == 1);
        khoa = dungMutex ? xSemaphoreCreateMutex() : xSemaphoreCreateBinary();
        if (!dungMutex) xSemaphoreGive(khoa);       // binary tạo ra ở trạng thái rỗng
        LOG("========== Dùng %s ==========", dungMutex ? "MUTEX (có kế thừa ưu tiên)" : "BINARY SEMAPHORE (không kế thừa)");
        batDau = xTaskGetTickCount();
        xTaskCreate(taskThap, "Thap", 512, nullptr, 1, nullptr);
        xTaskCreate(taskCao,  "Cao",  512, nullptr, 3, nullptr);
        xTaskCreate(taskVua,  "Vua",  512, nullptr, 2, nullptr);
        vTaskDelay(pdMS_TO_TICKS(450));
        vSemaphoreDelete(khoa);
    }
    (void)p;
    ket_thuc();
}

int main() {
    xTaskCreate(chayThuNghiem, "DieuPhoi", 1024, nullptr, 4, nullptr);
    vTaskStartScheduler();
}

// Bài 7 – Mutex đệ quy (recursive mutex): một task lấy CÙNG một khoá nhiều lần (hàm gọi lồng nhau).
// Với mutex thường, lần lấy thứ hai sẽ tự khoá chính mình (deadlock).
#include "sim.h"
#include "semphr.h"

SemaphoreHandle_t mutexThuong, mutexDeQuy;

void ghiByte(uint8_t b) {                            // hàm cấp thấp: tự khoá bus I2C
    xSemaphoreTakeRecursive(mutexDeQuy, portMAX_DELAY);
    LOG("    ghiByte(0x%02X) – đang giữ khoá", b);
    xSemaphoreGiveRecursive(mutexDeQuy);
}

void ghiGoiTin(const uint8_t* d, int n) {            // hàm cấp cao: khoá cả gói, rồi gọi hàm cấp thấp (cũng khoá)
    xSemaphoreTakeRecursive(mutexDeQuy, portMAX_DELAY);
    LOG("  ghiGoiTin: lấy khoá lần 1");
    for (int i = 0; i < n; i++) ghiByte(d[i]);       // lấy khoá lần 2, 3, ... trong cùng task – hợp lệ
    xSemaphoreGiveRecursive(mutexDeQuy);             // số lần give phải bằng số lần take
    LOG("  ghiGoiTin: trả khoá – task khác giờ mới lấy được");
}

void taskChinh(void*) {
    LOG("== Recursive mutex ==");
    const uint8_t goi[] = {0x3C, 0xA5, 0x01};
    ghiGoiTin(goi, 3);

    LOG("== Mutex thường bị lấy 2 lần trong cùng task ==");
    xSemaphoreTake(mutexThuong, portMAX_DELAY);
    LOG("  lấy lần 1: OK");
    BaseType_t ok = xSemaphoreTake(mutexThuong, pdMS_TO_TICKS(200));   // chờ chính mình -> không bao giờ được
    LOG("  lấy lần 2 (chờ tối đa 200 ms): %s", ok ? "OK" : "THẤT BẠI – nếu chờ portMAX_DELAY sẽ treo vĩnh viễn (deadlock)");
    xSemaphoreGive(mutexThuong);
    ket_thuc();
}

int main() {
    mutexThuong = xSemaphoreCreateMutex();
    mutexDeQuy = xSemaphoreCreateRecursiveMutex();
    xTaskCreate(taskChinh, "Chinh", 1024, nullptr, 1, nullptr);
    vTaskStartScheduler();
}

// Bài 8 – Direct-to-task notification dùng như binary semaphore và counting semaphore.
// Mỗi task có sẵn một "hộp thư" 32 bit: không cần tạo đối tượng, nhanh hơn và tốn ít RAM hơn semaphore.
#include "sim.h"
#include "semphr.h"

TaskHandle_t hXuLy = nullptr;

uint32_t isrAdcXong() {                              // ngắt "ADC chuyển đổi xong"
    BaseType_t c = pdFALSE;
    vTaskNotifyGiveFromISR(hXuLy, &c);               // tăng giá trị notification của task lên 1
    return c;
}

void taskXuLy(void*) {
    LOG("== Như BINARY semaphore: ulTaskNotifyTake(pdTRUE, ...) xoá về 0 sau khi nhận ==");
    for (int i = 0; i < 2; i++) {
        uint32_t n = ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        LOG("XuLy  thức dậy, giá trị notification = %lu -> đọc ADC", (unsigned long)n);
    }
    LOG("== Như COUNTING semaphore: ulTaskNotifyTake(pdFALSE, ...) giảm đi 1 mỗi lần ==");
    vTaskDelay(pdMS_TO_TICKS(200));                  // trong lúc ngủ, 3 ngắt dồn lại
    for (int i = 0; i < 3; i++) {
        uint32_t n = ulTaskNotifyTake(pdFALSE, 0);
        LOG("XuLy  xử lý 1 sự kiện (còn lại %lu)", (unsigned long)(n - 1));
    }
    LOG("Kích thước: một binary semaphore ~%u byte RAM; notification: 0 byte thêm (nằm sẵn trong TCB)",
        (unsigned)sizeof(StaticSemaphore_t));
    ket_thuc();
}

void taskPhanCung(void*) {
    vTaskDelay(pdMS_TO_TICKS(100)); LOG("[ngắt] ADC xong"); phatNgat(3);
    vTaskDelay(pdMS_TO_TICKS(100)); LOG("[ngắt] ADC xong"); phatNgat(3);
    vTaskDelay(pdMS_TO_TICKS(100));
    for (int i = 0; i < 3; i++) { LOG("[ngắt] ADC xong (dồn)"); phatNgat(3); vTaskDelay(pdMS_TO_TICKS(20)); }
    vTaskDelete(nullptr);
}

int main() {
    dangKyNgat(3, isrAdcXong);
    xTaskCreate(taskXuLy,     "XuLy",     1024, nullptr, 2, &hXuLy);
    xTaskCreate(taskPhanCung, "PhanCung", 512,  nullptr, 3, nullptr);
    vTaskStartScheduler();
}

// Bài 8 – Task notification dùng như EVENT GROUP (từng bit là một sự kiện) và như MAILBOX (ghi đè giá trị mới nhất)
#include "sim.h"

constexpr uint32_t BIT_WIFI = 1u << 0, BIT_NUT = 1u << 1, BIT_PIN_YEU = 1u << 2;
TaskHandle_t hQuanLy = nullptr, hHienThi = nullptr;

void taskQuanLy(void*) {
    for (int i = 0; i < 3; i++) {
        uint32_t bits = 0;
        // Chờ bất kỳ bit nào; khi thoát xoá hết các bit (0xFFFFFFFF)
        xTaskNotifyWait(0, 0xFFFFFFFF, &bits, portMAX_DELAY);
        LOG("QuanLy   nhận bits = 0x%lX:%s%s%s", (unsigned long)bits,
            (bits & BIT_WIFI) ? " [WiFi đã kết nối]" : "", (bits & BIT_NUT) ? " [Nút nhấn]" : "",
            (bits & BIT_PIN_YEU) ? " [Pin yếu]" : "");
    }
    vTaskDelete(nullptr);
}

void taskWifi(void*) { vTaskDelay(pdMS_TO_TICKS(100)); xTaskNotify(hQuanLy, BIT_WIFI, eSetBits); vTaskDelete(nullptr); }
void taskNut(void*)  {
    vTaskDelay(pdMS_TO_TICKS(250));
    xTaskNotify(hQuanLy, BIT_NUT, eSetBits);
    xTaskNotify(hQuanLy, BIT_PIN_YEU, eSetBits);          // hai sự kiện gần như cùng lúc -> gộp trong một lần nhận
    vTaskDelay(pdMS_TO_TICKS(100));
    xTaskNotify(hQuanLy, BIT_NUT, eSetBits);
    vTaskDelete(nullptr);
}

// ===== Mailbox: chỉ cần giá trị MỚI NHẤT, giá trị cũ chưa đọc thì ghi đè =====
void taskCamBien(void*) {
    vTaskDelay(pdMS_TO_TICKS(500));
    for (int t = 280; t <= 300; t += 4) {
        xTaskNotify(hHienThi, t, eSetValueWithOverwrite);
        LOG("CamBien  ghi %d vào mailbox", t);
        vTaskDelay(pdMS_TO_TICKS(50));
    }
    vTaskDelete(nullptr);
}

void taskHienThi(void*) {
    vTaskDelay(pdMS_TO_TICKS(500));
    for (int i = 0; i < 3; i++) {
        uint32_t v;
        xTaskNotifyWait(0, 0, &v, portMAX_DELAY);
        LOG("  HienThi  LCD cập nhật chậm (120 ms/lần), đọc giá trị mới nhất: %lu", (unsigned long)v);
        vTaskDelay(pdMS_TO_TICKS(120));
    }
    ket_thuc();
}

int main() {
    xTaskCreate(taskQuanLy,  "QuanLy",  512, nullptr, 3, &hQuanLy);
    xTaskCreate(taskWifi,    "Wifi",    512, nullptr, 2, nullptr);
    xTaskCreate(taskNut,     "Nut",     512, nullptr, 4, nullptr);   // ưu tiên cao hơn QuanLy: gửi xong cả 2 bit rồi QuanLy mới chạy
    xTaskCreate(taskHienThi, "HienThi", 512, nullptr, 1, &hHienThi);
    xTaskCreate(taskCamBien, "CamBien", 512, nullptr, 2, nullptr);
    vTaskStartScheduler();
}

// Bài 9 – Event group: chờ NHIỀU sự kiện (AND / OR) và đồng bộ nhiều task tại một điểm (rendezvous)
#include <initializer_list>
#include "sim.h"
#include "event_groups.h"

EventGroupHandle_t egKhoiDong, egDongBo;
constexpr EventBits_t BIT_WIFI = 1 << 0, BIT_SD = 1 << 1, BIT_CAM_BIEN = 1 << 2, BIT_LOI = 1 << 3;
constexpr EventBits_t TAT_CA = BIT_WIFI | BIT_SD | BIT_CAM_BIEN;

void taskKhoiTao(void* p) {
    auto bit = static_cast<EventBits_t>(reinterpret_cast<uintptr_t>(p));
    const char* ten = bit == BIT_WIFI ? "WiFi" : bit == BIT_SD ? "Thẻ SD" : "Cảm biến";
    uint32_t thoiGian = bit == BIT_WIFI ? 300 : bit == BIT_SD ? 120 : 200;
    vTaskDelay(pdMS_TO_TICKS(thoiGian));
    LOG("  %s sẵn sàng -> đặt bit 0x%lX", ten, (unsigned long)bit);
    xEventGroupSetBits(egKhoiDong, bit);
    vTaskDelete(nullptr);
}

void taskUngDung(void*) {
    LOG("UngDung  chờ TẤT CẢ: WiFi + SD + cảm biến (xWaitForAllBits = pdTRUE)");
    EventBits_t b = xEventGroupWaitBits(egKhoiDong, TAT_CA, pdFALSE, pdTRUE, portMAX_DELAY);
    LOG("UngDung  bits = 0x%lX -> hệ thống sẵn sàng, bắt đầu ghi log", (unsigned long)b);

    LOG("UngDung  chờ BẤT KỲ: lỗi hoặc ... (xWaitForAllBits = pdFALSE), tối đa 200 ms");
    b = xEventGroupWaitBits(egKhoiDong, BIT_LOI, pdTRUE, pdFALSE, pdMS_TO_TICKS(200));
    LOG("UngDung  hết giờ, bit lỗi = %s", (b & BIT_LOI) ? "CÓ" : "không");
    vTaskDelete(nullptr);
}

// ===== Rendezvous: 3 task (3 động cơ) phải cùng tới vạch xuất phát rồi mới chạy =====
constexpr EventBits_t DC1 = 1 << 0, DC2 = 1 << 1, DC3 = 1 << 2;
void taskDongCo(void* p) {
    int so = (int)reinterpret_cast<uintptr_t>(p);
    EventBits_t bitCuaToi = 1 << (so - 1);
    vTaskDelay(pdMS_TO_TICKS(800 + so * 70));                // mỗi động cơ hiệu chỉnh mất thời gian khác nhau
    LOG("  Động cơ %d hiệu chỉnh xong, chờ các động cơ khác", so);
    xEventGroupSync(egDongBo, bitCuaToi, DC1 | DC2 | DC3, portMAX_DELAY);
    LOG("  Động cơ %d XUẤT PHÁT", so);
    if (so == 3) { vTaskDelay(pdMS_TO_TICKS(10)); ket_thuc(); }
    vTaskDelete(nullptr);
}

int main() {
    egKhoiDong = xEventGroupCreate();
    egDongBo = xEventGroupCreate();
    xTaskCreate(taskUngDung, "UngDung", 512, nullptr, 3, nullptr);
    for (EventBits_t b : {BIT_WIFI, BIT_SD, BIT_CAM_BIEN})
        xTaskCreate(taskKhoiTao, "KhoiTao", 512, reinterpret_cast<void*>(uintptr_t(b)), 2, nullptr);
    for (int i = 1; i <= 3; i++) xTaskCreate(taskDongCo, "DongCo", 512, reinterpret_cast<void*>(uintptr_t(i)), 2, nullptr);
    vTaskStartScheduler();
}

// Bài 10 – Stream buffer: chuyển luồng BYTE từ ngắt (UART nhận dữ liệu GPS) sang task.
// Một bên ghi – một bên đọc, không cần mutex. Task được đánh thức khi đủ "trigger level" byte.
#include <cstring>
#include "sim.h"
#include "stream_buffer.h"

StreamBufferHandle_t sbUart;
const char DU_LIEU_GPS[] = "$GPGGA,21.0285N,105.8542E*4A\n$GPGGA,21.0290N,105.8551E*47\n";
volatile size_t viTriPhat = 0;

uint32_t isrUartRx() {                                 // mỗi ngắt "nhận" 4 byte từ module GPS
    BaseType_t c = pdFALSE;
    size_t con = std::strlen(DU_LIEU_GPS) - viTriPhat;
    size_t n = con < 4 ? con : 4;
    xStreamBufferSendFromISR(sbUart, DU_LIEU_GPS + viTriPhat, n, &c);
    viTriPhat += n;
    return c;
}

void taskPhanCung(void*) {                             // UART tạo ngắt mỗi 10 ms
    while (viTriPhat < std::strlen(DU_LIEU_GPS)) {
        phatNgat(3);
        vTaskDelay(pdMS_TO_TICKS(10));
    }
    vTaskDelete(nullptr);
}

void taskDocGps(void*) {
    char dong[64];
    size_t len = 0;
    for (;;) {
        char buf[16];
        size_t n = xStreamBufferReceive(sbUart, buf, sizeof(buf), pdMS_TO_TICKS(200));  // nhận tối đa 16 byte
        if (n == 0) { LOG("DocGps  không còn dữ liệu"); ket_thuc(); }
        LOG("DocGps  nhận khối %2u byte", (unsigned)n);
        for (size_t i = 0; i < n; i++) {
            if (buf[i] == '\n') { dong[len] = 0; LOG("DocGps  >>> câu NMEA hoàn chỉnh: %s", dong); len = 0; }
            else if (len < sizeof(dong) - 1) dong[len++] = buf[i];
        }
    }
}

int main() {
    sbUart = xStreamBufferCreate(128, 12);              // dung lượng 128 byte, đánh thức task khi có >= 12 byte
    dangKyNgat(3, isrUartRx);
    xTaskCreate(taskDocGps,   "DocGps",   1024, nullptr, 2, nullptr);
    xTaskCreate(taskPhanCung, "PhanCung", 512,  nullptr, 3, nullptr);
    vTaskStartScheduler();
}

// Bài 10 – Message buffer: gửi các THÔNG ĐIỆP có độ dài thay đổi; bên nhận luôn nhận trọn từng thông điệp.
// Đây cũng là cơ chế FreeRTOS gợi ý để trao đổi dữ liệu giữa 2 nhân (core-to-core) trên chip đa nhân.
#include <cstring>
#include "sim.h"
#include "message_buffer.h"

MessageBufferHandle_t mbLenh;

void taskBluetooth(void*) {                             // "nhân 0": nhận lệnh từ điện thoại
    const char* lenh[] = {"LED ON", "SERVO 90", "PLAY_MELODY twinkle_twinkle_little_star", "STOP"};
    for (const char* l : lenh) {
        size_t n = xMessageBufferSend(mbLenh, l, std::strlen(l), portMAX_DELAY);
        LOG("Bluetooth gửi thông điệp %2u byte: \"%s\"", (unsigned)n, l);
        vTaskDelay(pdMS_TO_TICKS(30));
    }
    vTaskDelete(nullptr);
}

void taskThucThi(void*) {                               // "nhân 1": thực thi lệnh
    vTaskDelay(pdMS_TO_TICKS(100));                     // bận lúc đầu -> các thông điệp dồn lại
    LOG("ThucThi  còn trống %u byte trong buffer", (unsigned)xMessageBufferSpacesAvailable(mbLenh));
    char buf[64];
    size_t n;
    while ((n = xMessageBufferReceive(mbLenh, buf, sizeof(buf) - 1, pdMS_TO_TICKS(200))) > 0) {
        buf[n] = 0;
        LOG("ThucThi  nhận nguyên vẹn %2u byte: \"%s\"", (unsigned)n, buf);
    }
    LOG("ThucThi  hết thông điệp (mỗi thông điệp tốn thêm %u byte lưu độ dài)", (unsigned)sizeof(size_t));
    ket_thuc();
}

int main() {
    mbLenh = xMessageBufferCreate(200);
    xTaskCreate(taskBluetooth, "Bluetooth", 512, nullptr, 2, nullptr);
    xTaskCreate(taskThucThi,   "ThucThi",   1024, nullptr, 1, nullptr);
    vTaskStartScheduler();
}

// Bài 11 – Software timer: one-shot và auto-reload, timer ID, đổi chu kỳ, dừng timer.
// Callback chạy trong task "Tmr Svc" (timer daemon) – KHÔNG được chặn (không vTaskDelay, không chờ lâu).
#include "sim.h"
#include "timers.h"

TimerHandle_t tmrNhay, tmrTatBom, tmrDemNguoc;

void cbNhayLed(TimerHandle_t t) {                       // auto-reload: gọi lặp lại
    static bool led = false;
    led = !led;
    LOG("  [timer NhayLed] LED %s (chạy trong task: %s)", led ? "BẬT" : "TẮT", pcTaskGetName(nullptr));
    (void)t;
}

void cbTatBom(TimerHandle_t) {                          // one-shot: chỉ gọi một lần
    LOG("  [timer TatBom] ĐÃ TƯỚI ĐỦ 500 ms -> tắt bơm");
}

void cbDemNguoc(TimerHandle_t t) {                      // dùng timer ID để lưu bộ đếm riêng của timer
    uintptr_t con = reinterpret_cast<uintptr_t>(pvTimerGetTimerID(t));
    LOG("  [timer DemNguoc] còn %u", (unsigned)con);
    if (con == 0) { xTimerStop(t, 0); LOG("  [timer DemNguoc] dừng timer"); return; }
    vTimerSetTimerID(t, reinterpret_cast<void*>(con - 1));
}

void taskChinh(void*) {
    LOG("Chinh  bật bơm, khởi động các timer");
    xTimerStart(tmrNhay, 0);
    xTimerStart(tmrTatBom, 0);
    vTaskDelay(pdMS_TO_TICKS(700));
    LOG("Chinh  đổi chu kỳ nháy LED 200 ms -> 80 ms");
    xTimerChangePeriod(tmrNhay, pdMS_TO_TICKS(80), 0);
    vTaskDelay(pdMS_TO_TICKS(300));
    xTimerStop(tmrNhay, 0);
    LOG("Chinh  dừng timer nháy; timer TatBom còn hoạt động? %s", xTimerIsTimerActive(tmrTatBom) ? "có" : "không");
    xTimerStart(tmrDemNguoc, 0);
    vTaskDelay(pdMS_TO_TICKS(450));
    ket_thuc();
}

int main() {
    // xTimerCreate(tên, chu kỳ, auto-reload?, ID, callback)
    tmrNhay     = xTimerCreate("NhayLed",  pdMS_TO_TICKS(200), pdTRUE,  nullptr, cbNhayLed);
    tmrTatBom   = xTimerCreate("TatBom",   pdMS_TO_TICKS(500), pdFALSE, nullptr, cbTatBom);
    tmrDemNguoc = xTimerCreate("DemNguoc", pdMS_TO_TICKS(100), pdTRUE,  reinterpret_cast<void*>(3), cbDemNguoc);
    xTaskCreate(taskChinh, "Chinh", 1024, nullptr, 1, nullptr);
    vTaskStartScheduler();
}

// Bài 11 – Reset timer: tự tắt đèn nền LCD sau 1 giây KHÔNG có thao tác. Mỗi lần nhấn nút -> đếm lại từ đầu.
// Đây là cách làm "timeout không hoạt động" chuẩn trên thiết bị nhúng (màn hình, chế độ ngủ, watchdog mềm).
#include "sim.h"
#include "timers.h"

TimerHandle_t tmrDenNen;
bool denNenBat = false;

void cbTatDenNen(TimerHandle_t) {
    denNenBat = false;
    LOG("  [timer] 1000 ms không thao tác -> TẮT đèn nền LCD");
}

uint32_t isrNut() {                                     // nhấn nút: bật đèn nền + reset timer (bản FromISR)
    BaseType_t c = pdFALSE;
    denNenBat = true;
    xTimerResetFromISR(tmrDenNen, &c);                  // nếu timer đang dừng thì khởi động, đang chạy thì đếm lại
    return c;
}

void taskNguoiDung(void*) {
    const uint32_t lanNhan[] = {100, 600, 1100, 1500, 3200};
    TickType_t truoc = 0;
    for (uint32_t t : lanNhan) {
        vTaskDelay(pdMS_TO_TICKS(t - truoc));
        truoc = t;
        LOG("Nhấn nút -> bật đèn nền, đếm lại 1000 ms");
        phatNgat(3);
    }
    vTaskDelay(pdMS_TO_TICKS(1200));
    ket_thuc();
}

int main() {
    tmrDenNen = xTimerCreate("DenNen", pdMS_TO_TICKS(1000), pdFALSE, nullptr, cbTatDenNen);
    dangKyNgat(3, isrNut);
    xTaskCreate(taskNguoiDung, "NguoiDung", 512, nullptr, 1, nullptr);
    vTaskStartScheduler();
}

// Bài 12 – Queue set: một task chờ đồng thời trên NHIỀU queue/semaphore, xử lý cái nào có dữ liệu trước.
#include <initializer_list>
#include "sim.h"
#include "queue.h"
#include "semphr.h"

QueueHandle_t qNhiet, qLenh;
SemaphoreHandle_t semKhanCap;
QueueSetHandle_t tapHop;

void taskNguonNhiet(void*) {
    for (int t : {280, 285, 291}) { xQueueSend(qNhiet, &t, 0); vTaskDelay(pdMS_TO_TICKS(120)); }
    vTaskDelete(nullptr);
}
void taskNguonLenh(void*) {
    vTaskDelay(pdMS_TO_TICKS(60));
    char c = 'F'; xQueueSend(qLenh, &c, 0);
    vTaskDelay(pdMS_TO_TICKS(150));
    c = 'S'; xQueueSend(qLenh, &c, 0);
    vTaskDelay(pdMS_TO_TICKS(50));
    xSemaphoreGive(semKhanCap);
    vTaskDelete(nullptr);
}

void taskXuLy(void*) {
    for (;;) {
        QueueSetMemberHandle_t ai = xQueueSelectFromSet(tapHop, pdMS_TO_TICKS(300));   // chờ BẤT KỲ thành viên nào
        if (ai == qNhiet) {
            int t; xQueueReceive(qNhiet, &t, 0);
            LOG("XuLy  từ qNhiet: %d.%d°C", t / 10, t % 10);
        } else if (ai == qLenh) {
            char c; xQueueReceive(qLenh, &c, 0);
            LOG("XuLy  từ qLenh : lệnh '%c'", c);
        } else if (ai == semKhanCap) {
            xSemaphoreTake(semKhanCap, 0);
            LOG("XuLy  từ semKhanCap: DỪNG KHẨN CẤP");
        } else {
            LOG("XuLy  300 ms không có gì -> kết thúc");
            ket_thuc();
        }
    }
}

int main() {
    qNhiet = xQueueCreate(4, sizeof(int));
    qLenh = xQueueCreate(4, sizeof(char));
    semKhanCap = xSemaphoreCreateBinary();
    tapHop = xQueueCreateSet(4 + 4 + 1);                 // tổng sức chứa của các thành viên
    xQueueAddToSet(qNhiet, tapHop);
    xQueueAddToSet(qLenh, tapHop);
    xQueueAddToSet(semKhanCap, tapHop);
    xTaskCreate(taskXuLy,       "XuLy",       1024, nullptr, 3, nullptr);
    xTaskCreate(taskNguonNhiet, "NguonNhiet", 512,  nullptr, 2, nullptr);
    xTaskCreate(taskNguonLenh,  "NguonLenh",  512,  nullptr, 2, nullptr);
    vTaskStartScheduler();
}

// Bài 12 – DỰ ÁN TỔNG HỢP: firmware trạm thời tiết đa nhiệm
//   TaskCamBien (ưu tiên 3, chu kỳ 200 ms, vTaskDelayUntil) --queue--> TaskXuLy (2)
//   TaskXuLy: lọc trung bình, cập nhật LCD (mutex), báo động qua event group
//   TaskCanhBao (4): chờ bit báo động           ISR nút nhấn --notification--> TaskGiaoDien (2): đổi chế độ hiển thị
//   Software timer 500 ms: nhịp tim (heartbeat LED)       Timer one-shot: kết thúc mô phỏng sau 2,5 giây
#include <cstdio>
#include "sim.h"
#include "queue.h"
#include "semphr.h"
#include "event_groups.h"
#include "timers.h"

struct MauDo { uint32_t thoiDiem; int16_t nhietX10; uint8_t doAm; };

QueueHandle_t qMau;
SemaphoreHandle_t mtxLcd;
EventGroupHandle_t egBaoDong;
TaskHandle_t hGiaoDien;
constexpr EventBits_t BIT_QUA_NHIET = 1 << 0;
volatile int cheDo = 0;                                   // 0: nhiệt độ, 1: độ ẩm
uint32_t soMau = 0, soLanCanhBao = 0;

void lcdIn(const char* s) {
    xSemaphoreTake(mtxLcd, portMAX_DELAY);
    LOG("    LCD | %-20s |", s);
    xSemaphoreGive(mtxLcd);
}

void taskCamBien(void*) {
    TickType_t moc = xTaskGetTickCount();
    const int16_t nhiet[] = {285, 287, 290, 295, 302, 311, 318, 322, 316, 305, 298, 291};
    for (int i = 0;; i = (i + 1) % 12) {
        MauDo m{xTaskGetTickCount(), nhiet[i], uint8_t(60 - i)};
        xQueueSend(qMau, &m, 0);
        vTaskDelayUntil(&moc, pdMS_TO_TICKS(200));
    }
}

void taskXuLy(void*) {
    int16_t lichSu[3] = {0};
    int dem = 0;
    MauDo m;
    for (;;) {
        xQueueReceive(qMau, &m, portMAX_DELAY);
        soMau++;
        lichSu[dem++ % 3] = m.nhietX10;
        int n = dem < 3 ? dem : 3, tong = 0;
        for (int i = 0; i < n; i++) tong += lichSu[i];
        int tb = tong / n;
        char s[32];
        if (cheDo == 0) std::snprintf(s, sizeof(s), "T = %d.%d C (TB3)", tb / 10, tb % 10);
        else            std::snprintf(s, sizeof(s), "H = %u %%", m.doAm);
        lcdIn(s);
        if (tb >= 310) xEventGroupSetBits(egBaoDong, BIT_QUA_NHIET);
        else           xEventGroupClearBits(egBaoDong, BIT_QUA_NHIET);
    }
}

void taskCanhBao(void*) {
    for (;;) {
        xEventGroupWaitBits(egBaoDong, BIT_QUA_NHIET, pdFALSE, pdTRUE, portMAX_DELAY);
        soLanCanhBao++;
        LOG("!! CanhBao  nhiệt độ TB >= 31.0 C -> bật còi, gửi SMS");
        vTaskDelay(pdMS_TO_TICKS(400));                     // nhắc lại mỗi 400 ms khi còn quá nhiệt
    }
}

uint32_t isrNutMode() {
    BaseType_t c = pdFALSE;
    vTaskNotifyGiveFromISR(hGiaoDien, &c);
    return c;
}

void taskGiaoDien(void*) {
    for (;;) {
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        cheDo = 1 - cheDo;
        LOG("GiaoDien  nút MODE -> hiển thị %s", cheDo ? "ĐỘ ẨM" : "NHIỆT ĐỘ");
    }
}

void cbNhipTim(TimerHandle_t) { static bool b; b = !b; LOG("  (heartbeat LED %s)", b ? "●" : "○"); }

void cbKetThuc(TimerHandle_t) {
    char bang[512];
    vTaskList(bang);
    PRINT("\n===== Tổng kết sau 2,5 giây =====\nSố mẫu đã xử lý: %lu, số lần cảnh báo: %lu\nTên            \tTT\tƯT\tStack\tSTT\n%s",
          (unsigned long)soMau, (unsigned long)soLanCanhBao, bang);
    ket_thuc();
}

void taskNguoiDung(void*) {                                   // giả lập nhấn nút MODE lúc 700 ms và 1300 ms
    vTaskDelay(pdMS_TO_TICKS(700));  phatNgat(3);
    vTaskDelay(pdMS_TO_TICKS(600));  phatNgat(3);
    vTaskDelete(nullptr);
}

int main() {
    qMau = xQueueCreate(8, sizeof(MauDo));
    mtxLcd = xSemaphoreCreateMutex();
    egBaoDong = xEventGroupCreate();
    dangKyNgat(3, isrNutMode);
    xTaskCreate(taskCamBien,   "CamBien",   512,  nullptr, 3, nullptr);
    xTaskCreate(taskXuLy,      "XuLy",      1024, nullptr, 2, nullptr);
    xTaskCreate(taskCanhBao,   "CanhBao",   512,  nullptr, 4, nullptr);
    xTaskCreate(taskGiaoDien,  "GiaoDien",  512,  nullptr, 2, &hGiaoDien);
    xTaskCreate(taskNguoiDung, "NguoiDung", 512,  nullptr, 1, nullptr);
    xTimerStart(xTimerCreate("NhipTim", pdMS_TO_TICKS(500), pdTRUE, nullptr, cbNhipTim), 0);
    xTimerStart(xTimerCreate("KetThuc", pdMS_TO_TICKS(2500), pdFALSE, nullptr, cbKetThuc), 0);
    vTaskStartScheduler();
}