第7章: LEDマトリクス可視化#

UNO R4 WiFi 内蔵の LED マトリクスに OS の内部状態を表示します。

この章で分かること: top やタスクマネージャの CPU % は、どう数えている？

Linux の top や Windows のタスクマネージャには、プログラムごとの CPU 使用率が出ます。この章の OS も、同じような値を自分で数えて、LED マトリクスとシェルの ps に出します。

数え方は、タイマ割り込みのたびに「そのとき走っていたタスク」に時間を足していく、というものです。Linux も基本は同じ考え方です。くわしくはコラム「top と htop」にまとめました。

LED マトリクスの配線#

96 個の LED は、11 本の線（ROW0〜ROW10）のチャーリープレクシングでつながっています。2 本の線の組ごとに向きが逆の LED が 2 個ついていて、片方を HIGH・もう片方を LOW にすると 1 個だけが光ります。下の回路図の右上にある表は、回路図上の LED 番号とマトリクス上の位置の対応です。

付属の Arduino_LED_Matrix ライブラリは、10 kHz のタイマ割り込み 1 回ごとに LED を 1 個ずつ順に点け替えています（96 個で 1 周するので、1 画面あたり約 104 Hz）。 (Arduino_LED_Matrix.h L182、 L346–L349、 ArduinoCore-renesas 1.5.1)

../_images/uno_r4_wifi_led_matrix_schematic.png — LED マトリクスの回路図。出典: Arduino, ABX00087 Schematics 2 ページ目「LED MATRIX」（Silvio Navaretti）。 CC BY-SA 4.0#

サンプルコード#

ディレクトリ: docs/os-on-arduino/code/07_led_matrix
ビルドと書き込み:

uv run pio run -d 07_led_matrix -t upload
uv run pio device monitor -b 115200

コードを見る: docs/os-on-arduino/code/07_led_matrix

ソースコード#

この章のスケッチです。ファイル名をクリックすると開きます。コードは原稿リポジトリから自動で同期されているので、ここに出ているものが常に最新です。

src/os_display.cpp — 162 行

GitHub で開く

// os_display.cpp

#include "os_display.h"
#include <Arduino.h>

// LEDマトリクスオブジェクト
static ArduinoLEDMatrix matrix;

// フレームバッファ（8行×12列）
static uint8_t frame[8][12];

// CPU負荷履歴（12サンプル）
static uint8_t cpu_history[12];
static int history_index = 0;

// タスク実行履歴（4タスク × 8サンプル）
#define TASK_HISTORY_LEN 8
static int task_history[MAX_TASKS][TASK_HISTORY_LEN];
static int task_history_index = 0;

void display_init(void)
{
    matrix.begin();

    // フレームバッファをクリア
    memset(frame, 0, sizeof(frame));
    memset(cpu_history, 0, sizeof(cpu_history));
    memset(task_history, -1, sizeof(task_history));
}

// CPU負荷をパーセントから高さ（0-4）に変換
static int cpu_to_height(int cpu_percent)
{
    if (cpu_percent >= 80) return 4;
    if (cpu_percent >= 60) return 3;
    if (cpu_percent >= 40) return 2;
    if (cpu_percent >= 20) return 1;
    return 0;
}

// フレームバッファにCPU負荷グラフを描画
static void draw_cpu_graph(void)
{
    // 上半分（行0-3）にCPU負荷を描画
    for (int col = 0; col < 12; col++) {
        int height = cpu_to_height(cpu_history[col]);

        for (int row = 0; row < 4; row++) {
            // 下から上に向かって描画（行3が底、行0が頂上）
            frame[3 - row][col] = (row < height) ? 1 : 0;
        }
    }
}

// フレームバッファにタスク実行状態を描画
static void draw_task_status(void)
{
    int task_count = os_get_task_count();

    // 最大4タスク表示（行4-7）
    int display_tasks = (task_count > 4) ? 4 : task_count;

    for (int t = 0; t < display_tasks; t++) {
        int row = 4 + t;

        // 履歴を描画
        for (int i = 0; i < TASK_HISTORY_LEN; i++) {
            int hist_idx = (task_history_index + i + 1) % TASK_HISTORY_LEN;
            int col = i;

            if (task_history[t][hist_idx] == t) {
                // このタスクが実行中だった
                frame[row][col] = 1;
            } else {
                frame[row][col] = 0;
            }
        }

        // 現在の状態を示すインジケータ（右端）
        TaskState state = os_get_task_state(t);
        switch (state) {
            case TASK_RUNNING:
                frame[row][10] = 1;
                frame[row][11] = 1;
                break;
            case TASK_READY:
                frame[row][10] = 1;
                frame[row][11] = 0;
                break;
            case TASK_BLOCKED:
                frame[row][10] = 0;
                frame[row][11] = 1;
                break;
            default:
                frame[row][10] = 0;
                frame[row][11] = 0;
                break;
        }
    }
}

// 区切り線を描画
static void draw_separator(void)
{
    // CPU負荷領域とタスク状態領域の間に区切り線
    // 列8, 9を区切りとして使用
    for (int row = 0; row < 8; row++) {
        frame[row][8] = 0;
        frame[row][9] = (row == 3) ? 1 : 0;  // 行3だけ点灯
    }
}

void display_update(void)
{
    // CPU 使用率を更新（アイドル以外の割合）。
    // os_get_cpu_usage() は呼ぶたびに基準時刻を更新するので、ここから呼ぶと
    // シェルの ps の計測窓を壊してしまう。生カウンタから自前で差分を取る。
    static uint32_t last_total = 0;
    static uint32_t last_idle  = 0;

    uint32_t total = os_get_tick();
    uint32_t idle  = os_get_task_cpu_ticks(0);
    uint32_t d_total = total - last_total;
    uint32_t d_idle  = idle  - last_idle;
    last_total = total;
    last_idle  = idle;

    int total_cpu = (d_total == 0) ? 0
                  : (int)(100u - (d_idle * 100u) / d_total);

    // 履歴に追加
    cpu_history[history_index] = total_cpu;
    history_index = (history_index + 1) % 12;

    // 現在実行中のタスクを記録
    int current = os_get_current_task();
    if (current >= 0 && current < MAX_TASKS) {
        task_history[current][task_history_index] = current;
    }
    task_history_index = (task_history_index + 1) % TASK_HISTORY_LEN;

    // フレームバッファをクリア
    memset(frame, 0, sizeof(frame));

    // 各要素を描画
    draw_cpu_graph();
    draw_task_status();

    // マトリクスに表示
    matrix.renderBitmap(frame, 8, 12);
}

// 表示更新タスク
void display_task(void)
{
    display_init();

    while (1) {
        display_update();
        os_sleep(100);  // 100msごとに更新
    }
}

src/os_fault.cpp — 170 行

GitHub で開く

/**
 * os_fault.cpp - Fault Handler Implementation
 * Chapter 6: Memory Protection
 */

#include "os_fault.h"
#include "os_kernel.h"
#include <Arduino.h>

static volatile int g_fault_occurred = 0;
static volatile const char* g_fault_reason = "";
static volatile int g_faulted_task = -1;

// Forward declarations for vector table override
extern "C" __attribute__((naked)) void HardFault_Handler(void);
extern "C" void PendSV_Handler(void);
extern "C" void SysTick_Handler(void);

void fault_init(void)
{
    // Enable divide by zero trap
    SCB->CCR |= SCB_CCR_DIV_0_TRP_Msk;

    // Do NOT enable separate UsageFault/BusFault/MemFault handlers.
    // By leaving them disabled, all faults escalate to HardFault,
    // which we handle via the VTOR override above.

    // The Arduino framework copies the vector table to RAM (VTOR points to RAM).
    // We must overwrite the HardFault entry in the RAM vector table directly.
    // Also override PendSV and SysTick entries for the OS scheduler.
    uint32_t *vtor = (uint32_t *)SCB->VTOR;
    vtor[3] = (uint32_t)HardFault_Handler;   // Vector #3 = HardFault
    vtor[14] = (uint32_t)PendSV_Handler;     // Vector #14 = PendSV
    vtor[15] = (uint32_t)SysTick_Handler;    // Vector #15 = SysTick

    g_fault_occurred = 0;
    g_fault_reason = "";
}

const char* fault_get_reason(void)
{
    return (const char*)g_fault_reason;
}

int fault_occurred(void)
{
    return g_fault_occurred;
}

void fault_clear(void)
{
    g_fault_occurred = 0;
    g_fault_reason = "";
}

static void analyze_fault(void)
{
    uint32_t cfsr = SCB->CFSR;

    // Check Usage Fault Status Register (UFSR)
    if (cfsr & SCB_CFSR_DIVBYZERO_Msk) {
        g_fault_reason = "Divide by zero";
    } else if (cfsr & SCB_CFSR_UNALIGNED_Msk) {
        g_fault_reason = "Unaligned access";
    } else if (cfsr & SCB_CFSR_UNDEFINSTR_Msk) {
        g_fault_reason = "Undefined instruction";
    } else if (cfsr & SCB_CFSR_INVSTATE_Msk) {
        g_fault_reason = "Invalid state (Thumb bit)";
    } else if (cfsr & SCB_CFSR_INVPC_Msk) {
        g_fault_reason = "Invalid PC";
    }
    // Check Bus Fault Status Register (BFSR)
    else if (cfsr & SCB_CFSR_PRECISERR_Msk) {
        g_fault_reason = "Precise data bus error";
    } else if (cfsr & SCB_CFSR_IMPRECISERR_Msk) {
        g_fault_reason = "Imprecise data bus error";
    } else if (cfsr & SCB_CFSR_IBUSERR_Msk) {
        g_fault_reason = "Instruction bus error";
    }
    // Check Memory Management Fault Status Register (MMFSR)
    else if (cfsr & SCB_CFSR_DACCVIOL_Msk) {
        g_fault_reason = "Data access violation";
    } else if (cfsr & SCB_CFSR_IACCVIOL_Msk) {
        g_fault_reason = "Instruction access violation";
    }
    else {
        g_fault_reason = "Unknown fault";
    }

    // Clear fault flags
    SCB->CFSR = cfsr;
}

// Safe landing pad for terminated tasks after fault recovery
extern "C" void _fault_task_sink(void)
{
    while (1) {
        __WFI();
    }
}

// Flag to defer fault message printing to a safe context
static volatile int g_fault_pending_print = 0;
static volatile uint32_t g_fault_pc = 0;

extern "C" void HardFault_Handler_C(FaultFrame *frame)
{
    g_fault_occurred = 1;
    g_faulted_task = g_current_task;
    g_fault_pc = frame->pc;

    analyze_fault();

    // Terminate the faulted task and redirect PC to safe sink
    if (g_faulted_task > 0) {
        os_terminate_task(g_faulted_task);

        // Rewrite the stacked PC to a safe infinite loop so that
        // returning from the fault doesn't re-execute the faulting
        // instruction. The SysTick scheduler will switch away from
        // this terminated task on the next tick.
        frame->pc = (uint32_t)_fault_task_sink;
        frame->xpsr = 0x01000000;  // Thumb bit set

        // Defer printing to next safe context
        g_fault_pending_print = 1;
        return;
    }

    // If idle task or no task crashed, halt
    while (1) { }
}

// Call this from a task (e.g., shell) to print deferred fault info
void fault_print_pending(void)
{
    if (!g_fault_pending_print) return;
    g_fault_pending_print = 0;

    Serial.println();
    Serial.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    Serial.println("!!!       FAULT DETECTED      !!!");
    Serial.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
    Serial.println();
    Serial.print("Task ");
    Serial.print(g_faulted_task);
    Serial.print(" (");
    Serial.print(os_get_task_name(g_faulted_task));
    Serial.println(") crashed!");
    Serial.print("Reason: ");
    Serial.println((const char*)g_fault_reason);
    Serial.print("PC at fault: 0x");
    Serial.println(g_fault_pc, HEX);
    Serial.println("Task terminated. Other tasks continue.");
    Serial.println();
}

extern "C" __attribute__((naked)) void HardFault_Handler(void)
{
    __asm volatile (
        "   TST     LR, #4              \n"  // Check which stack was used
        "   ITE     EQ                  \n"
        "   MRSEQ   R0, MSP             \n"  // MSP if LR bit 2 is 0
        "   MRSNE   R0, PSP             \n"  // PSP if LR bit 2 is 1
        "   PUSH    {LR}                \n"  // Save EXC_RETURN
        "   BL      HardFault_Handler_C \n"  // Call C handler (preserves LR on stack)
        "   POP     {LR}                \n"  // Restore EXC_RETURN
        "   BX      LR                  \n"  // Return from exception properly
    );
}

src/os_kernel.cpp — 241 行

GitHub で開く

/**
 * os_kernel.cpp - Mini OS Kernel Implementation
 * Chapter 6: Memory Protection
 */

#include "os_kernel.h"
#include <Arduino.h>
#include <string.h>

TCB g_tasks[MAX_TASKS];
volatile int g_task_count = 0;
volatile int g_current_task = -1;
volatile int g_next_task = -1;
volatile uint32_t g_system_ticks = 0;

const uint32_t g_tcb_size = sizeof(TCB);

static uint32_t g_stack_pool[STACK_POOL_SIZE / 4];
static uint32_t g_stack_used;   // 切り出し済みのワード数

static void idle_task(void) { while (1) __WFI(); }

// タスク関数が return したときの受け皿。例外フレームの LR スロットは
// ここを指す (第3章 3.4)。EXC_RETURN を置く場所ではない。
static void task_exit(void)
{
    g_tasks[g_current_task].state = TASK_TERMINATED;
    os_yield();
    while (1) { }  // ここには到達しない
}

static uint32_t* init_task_stack(uint32_t *stack_top, void (*entry)(void))
{
    uint32_t *sp = stack_top;
    *(--sp) = 0x01000000;
    *(--sp) = (uint32_t)entry;
    *(--sp) = (uint32_t)task_exit;  // LR: タスクが return したときの戻り先
    *(--sp) = 0; *(--sp) = 0; *(--sp) = 0; *(--sp) = 0; *(--sp) = 0;
    // FPU を使ったタスクは例外フレームが拡張される（FP レジスタ込み）。
    // どちらのフレームで中断したかは EXC_RETURN の値に現れるため、
    // タスクごとに EXC_RETURN も保存する。初期値は「PSP・基本フレーム」。
    *(--sp) = 0xFFFFFFFD;
    *(--sp) = 0; *(--sp) = 0; *(--sp) = 0; *(--sp) = 0;
    *(--sp) = 0; *(--sp) = 0; *(--sp) = 0; *(--sp) = 0;
    return sp;
}

void os_init(void)
{
    memset(g_tasks, 0, sizeof(g_tasks));
    g_task_count = 0;
    g_current_task = -1;
    g_next_task = -1;
    g_system_ticks = 0;
    os_create_task(idle_task, "idle", IDLE_STACK_SIZE);
}

int os_create_task(void (*entry)(void), const char *name, uint32_t stack_size)
{
    if (g_task_count >= MAX_TASKS) return -1;
    int id = g_task_count;
    TCB *task = &g_tasks[id];
    task->id = id;
    task->state = TASK_READY;
    task->priority = id;
    task->entry = entry;
    task->wake_tick = 0;
    task->cpu_ticks = 0;
    strncpy(task->name, name, sizeof(task->name) - 1);
    if (stack_size == 0) {
        stack_size = DEFAULT_STACK_SIZE;
    }
    uint32_t words = (stack_size + 3) / 4;
    if (g_stack_used + words > STACK_POOL_SIZE / 4) {
        return -1;          // プールが尽きた。黙って縮めず、失敗として返す
    }
    g_stack_used += words;
    task->stack_size = stack_size;
    task->stack_base = &g_stack_pool[g_stack_used];   // スタックは上端から下へ伸びる
    task->sp = init_task_stack(task->stack_base, entry);
    g_task_count++;
    return id;
}

void os_schedule(void)
{
    for (int i = 0; i < g_task_count; i++) {
        if (g_tasks[i].state == TASK_BLOCKED && g_system_ticks >= g_tasks[i].wake_tick) {
            g_tasks[i].state = TASK_READY;
        }
    }

    int next = g_current_task;
    do {
        next = (next + 1) % g_task_count;
        if (g_tasks[next].state == TASK_READY || g_tasks[next].state == TASK_RUNNING) break;
    } while (next != g_current_task);

    if (next != g_current_task || g_current_task < 0) {
        if (g_current_task >= 0 && g_tasks[g_current_task].state == TASK_RUNNING) {
            g_tasks[g_current_task].state = TASK_READY;
        }
        g_tasks[next].state = TASK_RUNNING;
        g_next_task = next;
        SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;
    }
}

void os_yield(void) { os_schedule(); }
void os_sleep(uint32_t ms) {
    if (g_current_task > 0) {
        g_tasks[g_current_task].state = TASK_BLOCKED;
        g_tasks[g_current_task].wake_tick = g_system_ticks + ms;
        os_schedule();
    }
}
void os_suspend_task(int id) {
    if (id > 0 && id < g_task_count) {
        g_tasks[id].state = TASK_SUSPENDED;
        if (id == g_current_task) os_schedule();
    }
}
void os_resume_task(int id) {
    if (id > 0 && id < g_task_count && g_tasks[id].state == TASK_SUSPENDED) {
        g_tasks[id].state = TASK_READY;
    }
}
void os_terminate_task(int id) {
    if (id > 0 && id < g_task_count) {
        g_tasks[id].state = TASK_TERMINATED;
        if (id == g_current_task) os_schedule();
    }
}

uint32_t os_get_tick(void) { return g_system_ticks; }
int os_get_task_count(void) { return g_task_count; }
const char* os_get_task_name(int id) { return (id >= 0 && id < g_task_count) ? g_tasks[id].name : ""; }
TaskState os_get_task_state(int id) { return (id >= 0 && id < g_task_count) ? g_tasks[id].state : TASK_TERMINATED; }
int os_get_current_task(void) { return g_current_task; }

void os_start(void)
{
    NVIC_SetPriority(PendSV_IRQn, 0xFF);
    SysTick_Config(SystemCoreClock / 1000 * TIME_SLICE_MS);
    g_current_task = -1;
    g_next_task = 0;
    // Do NOT switch CONTROL to PSP here — PSP is not yet initialized.
    // PendSV returns with EXC_RETURN=0xFFFFFFFD, which automatically
    // switches thread mode to PSP after loading the first task's context.
    SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;
    while (1) { }
}

extern "C" void SysTick_Handler(void) {
    // 実際に経過した時間を、いま走っていたタスクの取り分として計上する。
    // os_schedule() 側で数えると os_yield() の回数まで混ざってしまう。
    if (g_current_task >= 0) {
        g_tasks[g_current_task].cpu_ticks += TIME_SLICE_MS;
    }
    g_system_ticks += TIME_SLICE_MS;
    os_schedule();
}

extern "C" __attribute__((naked)) void PendSV_Handler(void)
{
    __asm volatile (
        "   MRS     R0, PSP              \n"
        "   LDR     R1, =g_current_task  \n"
        "   LDR     R2, [R1]             \n"
        "   CMP     R2, #0               \n"
        "   BLT     _skip_save           \n"
        // FPU を使って中断したタスク（EXC_RETURN の bit4 が 0）は、
        // ハードウェアが積まない S16-S31 もここで退避する
        "   TST     LR, #0x10            \n"
        "   IT      EQ                   \n"
        "   VSTMDBEQ R0!, {S16-S31}      \n"
        // R4-R11 と EXC_RETURN(LR) を保存する
        "   STMDB   R0!, {R4-R11, LR}    \n"
        "   LDR     R3, =g_tasks         \n"
        "   LDR     R4, =g_tcb_size      \n"
        "   LDR     R4, [R4]             \n"
        "   MUL     R2, R2, R4           \n"
        "   ADD     R3, R3, R2           \n"
        "   STR     R0, [R3]             \n"
        "_skip_save:                     \n"
        "   LDR     R1, =g_next_task     \n"
        "   LDR     R2, [R1]             \n"
        "   LDR     R1, =g_current_task  \n"
        "   STR     R2, [R1]             \n"
        "   LDR     R3, =g_tasks         \n"
        "   LDR     R4, =g_tcb_size      \n"
        "   LDR     R4, [R4]             \n"
        "   MUL     R2, R2, R4           \n"
        "   ADD     R3, R3, R2           \n"
        "   LDR     R0, [R3]             \n"
        "   LDMIA   R0!, {R4-R11, LR}    \n"
        // FPU を使って中断していたタスクなら S16-S31 も復元する
        "   TST     LR, #0x10            \n"
        "   IT      EQ                   \n"
        "   VLDMIAEQ R0!, {S16-S31}      \n"
        "   MSR     PSP, R0              \n"
        "   BX      LR                   \n"
    );
}

// CPU使用率を取得（パーセント）
// 直前にこの関数を呼んだ時点からの差分で計算する。
// ps のようにタスクごとにループで呼ぶため、基準時刻もタスクごとに持つ。
// CPU 使用カウンタの生値。os_get_cpu_usage() と違って状態を持たないので、
// 何度呼んでも他の呼び手の計測窓を壊さない (第4章 4.7)。
uint32_t os_get_task_cpu_ticks(int task_id)
{
    if (task_id < 0 || task_id >= g_task_count) {
        return 0;
    }
    return g_tasks[task_id].cpu_ticks;
}

int os_get_cpu_usage(int task_id)
{
    if (task_id < 0 || task_id >= g_task_count) {
        return -1;
    }

    static uint32_t last_total[MAX_TASKS] = {0};
    static uint32_t last_task_ticks[MAX_TASKS] = {0};

    uint32_t total = g_system_ticks;
    uint32_t delta_total = total - last_total[task_id];

    if (delta_total == 0) {
        return 0;
    }

    uint32_t delta_task = g_tasks[task_id].cpu_ticks - last_task_ticks[task_id];

    last_total[task_id] = total;
    last_task_ticks[task_id] = g_tasks[task_id].cpu_ticks;

    return (delta_task * 100) / delta_total;
}

src/shell.cpp — 190 行

GitHub で開く

/**
 * shell.cpp - Interactive Shell Implementation
 * Chapter 5: Interactive Shell
 */

#include "shell.h"
#include "os_kernel.h"
#include "os_fault.h"
#include <Arduino.h>
#include <string.h>

#define CMD_BUF_SIZE 64

static char cmd_buf[CMD_BUF_SIZE];
static int cmd_pos = 0;

static const char* state_to_str(TaskState state)
{
    switch (state) {
        case TASK_READY:      return "READY";
        case TASK_RUNNING:    return "RUNNING";
        case TASK_BLOCKED:    return "BLOCKED";
        case TASK_SUSPENDED:  return "SUSPEND";
        case TASK_TERMINATED: return "TERM";
        default:              return "?";
    }
}

static void cmd_help(void)
{
    Serial.println("Available commands:");
    Serial.println("  ps      - List all tasks");
    Serial.println("  kill N  - Suspend task N");
    Serial.println("  exec N  - Resume task N");
    Serial.println("  info    - System information");
    Serial.println("  reboot  - Reboot system");
    Serial.println("  help    - Show this help");
}

static void cmd_ps(void)
{
    Serial.println();
    Serial.println("ID  NAME           STATE      CPU%");
    Serial.println("--  ----           -----      ----");

    for (int i = 0; i < os_get_task_count(); i++) {
        Serial.print(i);
        Serial.print("   ");

        const char *name = os_get_task_name(i);
        Serial.print(name);
        for (int j = strlen(name); j < 15; j++) Serial.print(" ");

        Serial.print(state_to_str(os_get_task_state(i)));
        for (int j = strlen(state_to_str(os_get_task_state(i))); j < 10; j++) Serial.print(" ");

        Serial.print(os_get_cpu_usage(i));
        Serial.println("%");
    }
    Serial.println();
}

static void cmd_kill(int id)
{
    if (id <= 0) {
        Serial.println("Error: Cannot kill idle task (ID 0)");
        return;
    }
    if (id >= os_get_task_count()) {
        Serial.println("Error: Invalid task ID");
        return;
    }

    os_suspend_task(id);
    Serial.print("Task ");
    Serial.print(id);
    Serial.print(" (");
    Serial.print(os_get_task_name(id));
    Serial.println(") suspended.");
}

static void cmd_exec(int id)
{
    if (id <= 0 || id >= os_get_task_count()) {
        Serial.println("Error: Invalid task ID");
        return;
    }

    os_resume_task(id);
    Serial.print("Task ");
    Serial.print(id);
    Serial.print(" (");
    Serial.print(os_get_task_name(id));
    Serial.println(") resumed.");
}

static void cmd_info(void)
{
    Serial.println();
    Serial.println("=== System Information ===");
    Serial.print("System Ticks:  ");
    Serial.println(os_get_tick());
    Serial.print("Uptime:        ");
    Serial.print(os_get_tick() / 1000);
    Serial.println(" s");
    Serial.print("Task Count:    ");
    Serial.println(os_get_task_count());
    Serial.print("Time Slice:    ");
    Serial.print(TIME_SLICE_MS);
    Serial.println(" ms");
    Serial.println();
}

static void cmd_reboot(void)
{
    Serial.println("Rebooting...");
    delay(100);
    NVIC_SystemReset();
}

void shell_process_command(char *cmd)
{
    // Trim whitespace
    while (*cmd == ' ') cmd++;
    char *end = cmd + strlen(cmd) - 1;
    while (end > cmd && *end == ' ') *end-- = '\0';

    if (strlen(cmd) == 0) return;

    // Parse command
    if (strcmp(cmd, "help") == 0 || strcmp(cmd, "?") == 0) {
        cmd_help();
    } else if (strcmp(cmd, "ps") == 0) {
        cmd_ps();
    } else if (strncmp(cmd, "kill ", 5) == 0) {
        int id = atoi(cmd + 5);
        cmd_kill(id);
    } else if (strncmp(cmd, "exec ", 5) == 0) {
        int id = atoi(cmd + 5);
        cmd_exec(id);
    } else if (strcmp(cmd, "info") == 0) {
        cmd_info();
    } else if (strcmp(cmd, "reboot") == 0) {
        cmd_reboot();
    } else {
        Serial.print("Unknown command: ");
        Serial.println(cmd);
        Serial.println("Type 'help' for available commands.");
    }
}

void shell_task(void)
{
    Serial.println();
    Serial.println("Mini OS Shell");
    Serial.println("Type 'help' for commands.");

    while (1) {
        // 保留中のフォルト情報をタスク文脈で表示する (第6章 6.3)
        fault_print_pending();

        Serial.print("> ");

        cmd_pos = 0;
        memset(cmd_buf, 0, CMD_BUF_SIZE);

        while (1) {
            if (Serial.available()) {
                char ch = Serial.read();

                if (ch == '\r' || ch == '\n') {
                    Serial.println();
                    break;
                } else if (ch == '\b' || ch == 127) {
                    if (cmd_pos > 0) {
                        cmd_pos--;
                        cmd_buf[cmd_pos] = '\0';
                        Serial.print("\b \b");
                    }
                } else if (cmd_pos < CMD_BUF_SIZE - 1) {
                    cmd_buf[cmd_pos++] = ch;
                    Serial.print(ch);
                }
            }
            os_sleep(10);
        }

        shell_process_command(cmd_buf);
    }
}

実機での出力#

Arduino UNO R4 WiFi の実機で実際に取得した出力です（macOS / Windows の両方で同じ結果を確認しています）。手元の出力と見比べてください。

ps

ID  NAME           STATE      CPU%
--  ----           -----      ----
0   idle           READY     50%
1   LED            BLOCKED   0%
2   Light          BLOCKED   0%
3   Heavy          READY     49%
4   Shell          RUNNING   0%
5   Display        READY     0%

> 

Heavy は眠らないのに 49% しかありません。本書のスケジューラは idle（ID 0）も普通のタスクと同じ順番で回すので、ほかのタスクが眠っている間は idle と Heavy が交互に走り、 CPU を半分ずつ分け合うためです。

実機のマトリクスはこう動きます。

../_images/ch07_kill.gif — 実機の LED マトリクス。上半分が直近 1.2 秒の CPU 負荷で、0.1 秒ごとに左から順に 1 列ずつ書き換わります。下半分の右端 2 列はタスク 0〜3 の状態です。`kill 3` で `Heavy` を止めるとグラフが下がり、`exec 3` でまた上がります。（UNO R4 WiFi を Web カメラで撮影）#

シミュレータで見る#

実機が無くても、同じファームウェアをシミュレータで動かすとこう見えます。

../_images/sim_ch07_kill.gif — マトリクスの上半分が直近 1.2 秒の CPU 負荷（0.1 秒ごとに左から順に 1 列ずつ書き換わる）、下半分の右端 2 列がタスク 0〜3 の状態です。`kill 3` で重い計算の `Heavy` を止めるとグラフが消えていき、`exec 3` でまた上がります。（シミュレータで撮影）#

改良版: `07_led_matrix_v2`（書籍未掲載）#

本書のコードの表示は、上半分の負荷の履歴が時間の順に並んでいないことと、下半分がほとんど光らないことから、何を表しているのか読み取りにくいところがあります。そこで表示を Linux の htop（CPU の負荷を横棒で、プロセスごとの CPU 使用率を一覧で出すツール。下のコラム参照）のような「いまの値」の横棒にした改良版を code/07_led_matrix_v2 に置きました。カーネルは本書と同じで、変えたのは表示・シェル・タスクの中身だけです。

書籍のリポジトリ（learning-os-from-arduino）には入っていないので、このサイトのリポジトリから取ってきて書き込みます。

git clone https://github.com/iory/build-your-own-arduino-rtos.git
cd build-your-own-arduino-rtos/code
uv sync
uv run pio run -d 07_led_matrix_v2 -t upload
uv run pio device monitor -b 115200

行	中身（どれも 12 個で 100%、0.5 秒ごとに更新）
0–1	CPU 全体の負荷（idle 以外）
2	空き
3–7	LED / Light / Heavy / Shell / Display の CPU 使用率

シェルに足した top と打つと、マトリクスと同じ数字が 0.5 秒ごとに端末へ描き直されます（もう一度 top で止まる。表示中も kill 3 などを打てます）。 Heavy 以外に Light も CPU を使うようにしてあるので、行ごとの棒を足すと CPU 全体の棒になるのが見えます。

実機（UNO R4 WiFi）の top の値は次のとおりです。

操作	CPU 全体	目に見えること
起動直後	約 60%	Light（16%）と Heavy（40%）の行に棒
`kill 3`	約 24%	Heavy の棒が消え、全体の棒が縮む
`kill 2`	約 4%	残るのは `top` を描いている Shell だけ
`exec 2` / `exec 3`	元に戻る

注釈

Heavy は眠らずに回り続けても 40〜50% しか取れません。本書のスケジューラは idle も普通のタスクと同じ順番で回すので、idle と CPU を分け合うためです。

コラム: top と htop

Linux には、動いているプロセスごとの CPU 使用率を一覧する top（procps-ng）と、それを見やすくした htop があります。v2 のマトリクスとシェルの top は、この 2 つを真似たものです。

見ているもの。 htop の画面上部の CPU メーターは、CPU 時間を種類（nice・user・system など）ごとに色分けして積み上げた横棒です（htop(1) の METERS）。その下の一覧の %CPU は、「前回画面を描いてから今回までの経過時間のうち、そのプロセスが使った割合」です（top(1) の %CPU）。v2 では行 0–1 が CPU メーター、行 3–7 が一覧にあたります。

更新の間隔。 htop は既定で 1.5 秒ごとに描き直します（-d は 0.1 秒単位で、既定値は 15。Settings.h）。procps-ng の top も既定は 1.5 秒で、元の設定でビルドした場合は 3 秒です（top.h）。v2 は 0.5 秒です。

CPU 時間の数え方。 Linux は基本的に、タイマ割り込み（tick）のたびに「そのとき走っていたタスク」へ 1 tick ぶんの CPU 時間を足していきます（account_process_tick()）。その合計が /proc/stat （proc_stat(5)）などに出ていて、top は 2 回読んだ差分から割合を出します。本書の OS も、SysTick 割り込みのたびに走っていたタスクへ 10 ms を足していて（os_kernel.cpp の SysTick_Handler）、考え方は同じです。 v2 はこの値を 0.5 秒ごとに 2 回読んで差を取っています。

tick で数える方式は、tick と tick の間に終わってしまう短い仕事を取りこぼします。 LED タスクが 0% に見えるのはこのためです（Linux でも、設定によっては tick 以外の方法で数えます）。

止める。 top では k、htop では F9 か k で、選んだプロセスにシグナルを送って止めます（top(1)、htop(1)）。本書のシェルの kill N はタスクを一時停止（suspend）するだけなので、exec N で再開できます。

壊してみる#

ここでは、上の改良版 07_led_matrix_v2 を使います。カーネルは本書のコードと同じで、マトリクスの横棒と top で CPU% の変化が目で見えるからです。

予想してから答えを開いてください。1 つめはコードを変えずに、ブラウザ版の改良版でそのまま試せます。2 つめはコードを変えてビルドし、firmware.elf をブラウザ版にドロップします。v2 はこのサイトのリポジトリにあるので、上の「改良版」の手順で clone した code/ の中で作業します。

uv run pio run -d 07_led_matrix_v2
# できた 07_led_matrix_v2/.pio/build/uno_r4_wifi/firmware.elf をブラウザ版にドロップ
# 元に戻すとき: git checkout -- 07_led_matrix_v2

注釈

答えに載せた出力は、ブラウザ版と同じ QEMU で実際に動かして取ったものです。実機ではまだ確かめていません。ブラウザ版は重い計算が実機より遅いので、 CPU% の値は少し違って見えることがあります。

1. シェルが自分を止める#

kill 0 は Error: Cannot kill idle task (ID 0) で断られます。では、kill 4 はどうでしょう。ID 4 は、いまコマンドを受け付けているシェル自身です。

予想: kill 4 のあと、exec 4 で元に戻せるでしょうか。

2. idle を順番から外す#

ps を打つと、眠らずに回り続ける Heavy の CPU% が 41% しかありません（QEMU で idle 41%・Light 16%・Heavy 41%）。本書のスケジューラが、idle も普通のタスクと同じ順番で回していて、Heavy と idle が CPU を分け合うからです。

そこで、src/os_kernel.cpp の os_schedule() を変えて、idle はほかに走れるタスクが無いときだけ選ぶようにします。

     int next = g_current_task;
     do {
         next = (next + 1) % g_task_count;
-        if (g_tasks[next].state == TASK_READY || g_tasks[next].state == TASK_RUNNING) break;
+        if (next != 0 && (g_tasks[next].state == TASK_READY || g_tasks[next].state == TASK_RUNNING)) break;
     } while (next != g_current_task);
+    if (g_tasks[next].state != TASK_READY && g_tasks[next].state != TASK_RUNNING) next = 0;

予想: マトリクスの Heavy の行と、いちばん上の全体の棒はどうなるでしょう。

つまずきやすいポイント#

（読者からの質問に応じて随時追記します。質問は GitHub Issues へどうぞ）

第7章: LEDマトリクス可視化#

LED マトリクスの配線#

サンプルコード#

ソースコード#

実機での出力#

シミュレータで見る#

改良版: 07_led_matrix_v2（書籍未掲載）#

壊してみる#

1. シェルが自分を止める#

2. idle を順番から外す#

つまずきやすいポイント#

改良版: `07_led_matrix_v2`（書籍未掲載）#