Mini RTOS

/* Vong lap chinh o Bai 50.1: moi viec phai NGAN */
for (;;) {
    cap_nhat_den(tick_ms());        /* 3 us  */
    cap_nhat_cam_bien(tick_ms());   /* 12 us */
    xu_ly_vo_lenh();                /* 40 us */
}

/* Bay gio them mot viec dai: */
for (;;) {
    cap_nhat_den(tick_ms());
    cap_nhat_cam_bien(tick_ms());
    xu_ly_vo_lenh();
    ghi_the_nho();                  /* 250 ms, cho phan cung tra loi */
}

/* Trong 250 ms do, den khong nhay, cam bien khong duoc doc,
   va vo lenh khong phan hoi. He thong nhu treo. */

#include <stdint.h>

#define NV_TOI_DA   4u
#define NGAN_XEP_TU 256u          /* 1 KB mỗi nhiệm vụ */

typedef enum { NV_TRONG, NV_SAN_SANG, NV_NGU } TrangThaiNv;

typedef struct {
    uint32_t    *sp;              /* PHẢI là trường đầu tiên, xem PendSV */
    uint32_t     thuc_day_luc;
    TrangThaiNv  trang_thai;
    void       (*ham)(void);
    uint32_t     ngan_xep[NGAN_XEP_TU];
} Nv;

static Nv       s_nv[NV_TOI_DA];
static uint8_t  s_so_nv    = 0u;
Nv             *g_nv_nay   = NULL;    /* PendSV đọc biến này */

static void nv_thoat(void)
{
    /* Nhiệm vụ không được phép trả về. Nếu tới đây là có lỗi. */
    for (;;) { }
}

int nv_tao(void (*ham)(void))
{
    if (s_so_nv >= NV_TOI_DA) return -1;

    Nv       *n    = &s_nv[s_so_nv];
    uint32_t *dinh = &n->ngan_xep[NGAN_XEP_TU];

    /* Ngăn xếp phải thẳng hàng 8 byte theo quy ước AAPCS */
    dinh = (uint32_t *)((uintptr_t)dinh & ~(uintptr_t)7);

    /* Khung phần cứng, đẩy vào theo thứ tự ngược */
    *(--dinh) = 0x01000000u;               /* xPSR, bit T bắt buộc bằng 1 */
    *(--dinh) = (uint32_t)ham;             /* PC  */
    *(--dinh) = (uint32_t)nv_thoat;        /* LR  */
    *(--dinh) = 0x12121212u;               /* R12, giá trị nhận dạng */
    *(--dinh) = 0x03030303u;               /* R3  */
    *(--dinh) = 0x02020202u;               /* R2  */
    *(--dinh) = 0x01010101u;               /* R1  */
    *(--dinh) = 0x00000000u;               /* R0, tham số của nhiệm vụ */

    /* Khung phần mềm */
    for (int i = 11; i >= 4; --i) *(--dinh) = (uint32_t)(0x11111111u * (uint32_t)i);

    n->sp           = dinh;
    n->ham          = ham;
    n->trang_thai   = NV_SAN_SANG;
    n->thuc_day_luc = 0u;

    ++s_so_nv;

    return 0;
}

#include "stm32f4xx.h"

void lich_khoi_tao(uint32_t clock_hz)
{
    /* 0xFF là mức thấp nhất trên mọi Cortex-M, dù chip cài mấy bit */
    NVIC_SetPriority(PendSV_IRQn,  0xFFu);
    NVIC_SetPriority(SysTick_IRQn, 0xFEu);   /* thấp, nhưng cao hơn PendSV */

    SysTick_Config(clock_hz / 1000u);        /* tick 1 ms */
}

/* Đặt cờ chờ cho PendSV. Ghi bit 28 của ICSR. */
static inline void yeu_cau_chuyen(void)
{
    SCB->ICSR = SCB_ICSR_PENDSVSET_Msk;
}

__attribute__((naked)) void PendSV_Handler(void)
{
    __asm volatile (
        "  mrs   r0, psp              \n"   /* r0 = ngăn xếp nhiệm vụ cũ  */
        "  isb                        \n"

        "  ldr   r3, =g_nv_nay        \n"
        "  ldr   r2, [r3]             \n"   /* r2 = con trỏ tới Nv cũ     */

        "  stmdb r0!, {r4-r11}        \n"   /* cất R4-R11, r0 lùi 32 byte */
        "  str   r0, [r2]             \n"   /* Nv.sp = r0, sp là trường đầu */

        "  stmdb sp!, {r3, lr}        \n"   /* giữ r3 và lr qua lời gọi C */
        "  bl    lap_lich             \n"   /* đổi g_nv_nay sang nhiệm vụ khác */
        "  ldmia sp!, {r3, lr}        \n"

        "  ldr   r2, [r3]             \n"   /* r2 = con trỏ tới Nv mới    */
        "  ldr   r0, [r2]             \n"   /* r0 = sp đã cất của nó      */
        "  ldmia r0!, {r4-r11}        \n"   /* khôi phục R4-R11           */

        "  msr   psp, r0              \n"   /* PSP trỏ vào khung phần cứng */
        "  isb                        \n"
        "  bx    lr                   \n"   /* lr đang giữ EXC_RETURN     */
        "  .align 4                   \n"   /* chỗ cho hằng g_nv_nay      */
    );
}

#include "stm32f4xx.h"

static volatile uint32_t s_tick = 0u;

/* Đổi g_nv_nay sang nhiệm vụ sẵn sàng kế tiếp.
   Hàm này do PendSV gọi, và nó KHÔNG được chặn hay chờ. */
void lap_lich(void)
{
    uint8_t bat_dau = (uint8_t)(g_nv_nay - s_nv);

    for (uint8_t i = 1u; i <= s_so_nv; ++i) {
        uint8_t k = (uint8_t)((bat_dau + i) % s_so_nv);

        if (s_nv[k].trang_thai == NV_SAN_SANG) {
            g_nv_nay = &s_nv[k];

            return;
        }
    }

    /* Không nhiệm vụ nào sẵn sàng: quay lại nhiệm vụ nhàn rỗi ở chỉ số 0 */
    g_nv_nay = &s_nv[0];
}

void SysTick_Handler(void)
{
    ++s_tick;

    /* Đánh thức nhiệm vụ nào đã hết giờ ngủ */
    for (uint8_t i = 0u; i < s_so_nv; ++i)
        if (s_nv[i].trang_thai == NV_NGU &&
            (int32_t)(s_tick - s_nv[i].thuc_day_luc) >= 0)
            s_nv[i].trang_thai = NV_SAN_SANG;

    SCB->ICSR = SCB_ICSR_PENDSVSET_Msk;      /* nhờ PendSV chuyển */
}

uint32_t tick_ms(void) { return s_tick; }

/* Nhường CPU cho tới khi đủ ms mili giây. */
void nv_ngu(uint32_t ms)
{
    if (ms == 0u) { SCB->ICSR = SCB_ICSR_PENDSVSET_Msk; return; }

    uint32_t truoc = __get_PRIMASK();
    __disable_irq();

    g_nv_nay->thuc_day_luc = s_tick + ms;
    g_nv_nay->trang_thai   = NV_NGU;

    __set_PRIMASK(truoc);

    SCB->ICSR = SCB_ICSR_PENDSVSET_Msk;      /* chuyển ngay, đừng đợi tick */

    /* Khi hàm này trở về, đã qua ít nhất ms mili giây */
}

void lich_chay(void)
{
    g_nv_nay = &s_nv[0];

    /* PSP trỏ vào đỉnh ngăn xếp nhiệm vụ 0 */
    __set_PSP((uint32_t)&s_nv[0].ngan_xep[NGAN_XEP_TU]);

    /* Bit 1 của CONTROL: chế độ Thread dùng PSP thay vì MSP */
    __set_CONTROL(0x02u);
    __ISB();                        /* bắt buộc sau khi đổi CONTROL */

    s_nv[0].ham();                  /* nhảy thẳng vào, không qua PendSV */

    for (;;) { }                    /* không bao giờ tới đây */
}

#include "nv.h"

static void nv_nhan_roi(void)
{
    for (;;) __WFI();               /* ngủ tới khi có ngắt, tiết kiệm điện */
}

static void nv_den(void)
{
    for (;;) {
        gpio_dao(GPIOA, 5u);
        nv_ngu(500u);
    }
}

static void nv_cam_bien(void)
{
    for (;;) {
        uint16_t raw = adc_doc(0u);

        g_nhiet_centi = nhiet_centi(raw);
        nv_ngu(100u);
    }
}

static void nv_vo_lenh(void)
{
    BoDocDong doc;

    doc_dong_khoi_tao(&doc);

    for (;;) {
        char *dong = doc_dong_cap_nhat(&doc);

        if (dong != NULL) lenh_chay(dong);
        else              nv_ngu(2u);
    }
}

int main(void)
{
    clock_khoi_tao();
    gpio_khoi_tao();
    adc_khoi_tao();
    uart_khoi_tao(84000000u, 115200u);

    lich_khoi_tao(84000000u);

    nv_tao(nv_nhan_roi);            /* PHẢI là nhiệm vụ số 0 */
    nv_tao(nv_den);
    nv_tao(nv_cam_bien);
    nv_tao(nv_vo_lenh);

    lich_chay();                    /* không bao giờ trở về */
}