第12章: ハードウェア制御の深層 — PWM生成とA/D変換#

PWM 生成と A/D 変換をレジスタレベルで理解します。

サンプルコード#

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

uv run pio run -d 12_hardware -t upload
uv run pio device monitor -b 115200

コードを見る: docs/os-on-arduino/code/12_hardware

ソースコード#

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

src/main.cpp — 122 行

GitHub で開く

/**
 * Chapter 12: Hardware PWM and ADC
 *
 * 本書 12.4「OS との統合」の After 版をそのまま動かすデモ。
 *
 * - task_servo   : GPT のハードウェア PWM でサーボを駆動（レジスタ書き込みのみ）
 * - task_sensor  : ADC14 を直接叩いて 14bit で読む
 * - task_heavy   : わざと CPU を占有し、それでもサーボが揺れないことを見る
 * - shell        : ps / kill / exec でタスクを触る
 *
 * 配線:
 *   D9 -- サーボ信号線（サーボの電源は別系統から取ること）
 *   A0 -- ポテンショメータのワイパ
 *   D2 -- LED（ハートビート）
 */

#include <Arduino.h>
#include "os_kernel.h"
#include "os_fault.h"
#include "shell.h"
#include "hardware_pwm.h"
#include "raw_adc.h"

#define LED_PIN    2
#define SERVO_PIN  9
#define POT_CH     9   // A0 = P014 = AN009 (ch0 は A1)

// タスク間共有データ（本書 9.2「タスク間共有データ」を参照）
volatile uint16_t g_pot_raw = 0;   // 14bit 生値
volatile int      g_pot_10bit = 0; // 10bit 換算

static HardwarePWM servo1;

// ハートビート: OS が生きていることを示す
void task_led(void)
{
    pinMode(LED_PIN, OUTPUT);
    while (1) {
        digitalWrite(LED_PIN, !digitalRead(LED_PIN));
        os_sleep(500);
    }
}

// センサ: ADC14 を直接読む（12.3）
void task_sensor(void)
{
    raw_adc_init();
    while (1) {
        g_pot_raw   = raw_analog_read(POT_CH);
        g_pot_10bit = raw_analog_read_10bit(POT_CH);
        os_sleep(50);
    }
}

// サーボ: ハードウェア PWM で駆動（12.2）
// write() はレジスタに書くだけなので CPU を占有しない。
// refresh() も不要で、波形は GPT が自動で出し続ける。
void task_servo(void)
{
    if (!servo1.attach(SERVO_PIN)) {
        Serial.println(F("[Error] servo attach failed"));
        while (1) os_sleep(1000);
    }
    while (1) {
        int angle = map(g_pot_10bit, 0, 1023, 0, 180);
        servo1.write(angle);
        os_sleep(20);
    }
}

// 重い計算: CPU を食い続ける。
// ソフトウェア PWM ならここでサーボが暴れるが、GPT なら影響を受けない。
void task_heavy(void)
{
    while (1) {
        volatile long sum = 0;
        for (long i = 0; i < 200000; i++) {
            sum += i;
        }
        os_sleep(1);
    }
}

// 状態表示
void task_status(void)
{
    while (1) {
        Serial.print(F("pot(14bit)="));
        Serial.print(g_pot_raw);
        Serial.print(F("  pot(10bit)="));
        Serial.print(g_pot_10bit);
        Serial.print(F("  servo="));
        Serial.print(servo1.read());
        Serial.println(F("deg"));
        os_sleep(1000);
    }
}

void setup()
{
    Serial.begin(115200);
    while (!Serial) { }

    Serial.println(F("=== Chapter 12: Hardware PWM / ADC ==="));
    Serial.println(F("Turn the pot on A0. The servo on D9 should follow"));
    Serial.println(F("smoothly even while 'Heavy' is hogging the CPU."));
    Serial.println(F("Try 'kill 4' to stop Heavy and compare.\n"));

    os_init();
    fault_init();

    os_create_task(task_led,    "LED",    512);
    os_create_task(task_sensor, "Sensor", 512);
    os_create_task(task_servo,  "Servo",  512);
    os_create_task(task_heavy,  "Heavy",  512);
    os_create_task(task_status, "Status", 512);
    os_create_task(shell_task,  "Shell",  1024);

    os_start();
}

void loop() { }

include/hardware_pwm.h — 159 行

GitHub で開く

// hardware_pwm.h
// GPTタイマによるハードウェアPWM（サーボ制御用）

#ifndef HARDWARE_PWM_H
#define HARDWARE_PWM_H

#include <Arduino.h>

// RA4M1 GPTレジスタ定義
// Renesas FSP ヘッダから利用可能
#include <Arduino.h>   // R_GPT0 / R_ADC0 などのレジスタ定義はここから来る

class HardwarePWM {
private:
    R_GPT0_Type *gpt;    // GPTチャネルのレジスタブロックへのポインタ
    int pin;
    int ch_num;          // GPTチャネル番号 (0〜7)
    int channel;         // 0 = GTIOCA 出力, 1 = GTIOCB 出力
    bool active;

public:
    HardwarePWM() : gpt(nullptr), pin(-1), ch_num(-1), channel(-1), active(false) {}

    /**
     * GPTチャネルを使ってPWM出力を開始する
     *
     * Arduino UNO R4 WiFi のGPTピン対応:
     *   D3  → GPT1 (GTIOC1A)
     *   D5  → GPT0 (GTIOC0A)
     *   D6  → GPT3 (GTIOC3A)
     *   D9  → GPT7 (GTIOC7B)
     *   D10 → GPT2 (GTIOC2A)
     *   D11 → GPT6 (GTIOC6A)
     */
    bool attach(int p) {
        pin = p;

        // ピン番号からGPTチャネルを決定
        switch (pin) {
            case 3:  gpt = R_GPT1; ch_num = 1; channel = 0; break;  // GTIOC1A
            case 5:  gpt = R_GPT0; ch_num = 0; channel = 0; break;  // GTIOC0A
            case 6:  gpt = R_GPT3; ch_num = 3; channel = 0; break;  // GTIOC3A
            case 9:  gpt = R_GPT7; ch_num = 7; channel = 1; break;  // GTIOC7B
            case 10: gpt = R_GPT2; ch_num = 2; channel = 0; break;  // GTIOC2A
            case 11: gpt = R_GPT6; ch_num = 6; channel = 0; break;  // GTIOC6A
            default:
                Serial.println("[PWM] Error: unsupported pin");
                return false;
        }

        // ---- GPT モジュールの電源ON ----
        // AVRと違いARMの周辺モジュールはデフォルトで電源OFFの場合がある
        // Module Stop Control Register でGPTモジュールを有効化
        // RA4M1 は ch0〜1 (GPT320/321) が MSTPD5、ch2〜7 (GPT162〜167) が MSTPD6
        if (ch_num <= 1) {
            R_MSTP->MSTPCRD_b.MSTPD5 = 0;
        } else {
            R_MSTP->MSTPCRD_b.MSTPD6 = 0;
        }

        // ---- ピンのマルチプレクサ設定 ----
        // AVRではピンの多機能割り当ては限られていたが、
        // ARMでは PFS (Pin Function Select) レジスタで明示的に設定する
        // ここではArduinoコアの pinPeripheral() でピンを GPT 出力へ切り替える
        // (実際のレジスタは R_PFS->PORT[port].PIN[pin].PmnPFS)
        pinPeripheral((uint32_t)pin,
                      (uint32_t)(IOPORT_CFG_PERIPHERAL_PIN | IOPORT_PERIPHERAL_GPT1));

        // ---- GPTタイマの設定 ----
        // Step 1: タイマ停止
        // GTSTP/GTSTR は全チャネル共有のビットマップ。自分のビットだけ立てる
        gpt->GTSTP = (1u << ch_num);

        // Step 2: 動作モード設定
        // Saw-wave (片斜面) PWMモード
        // プリスケーラ: PCLKD/64 → 48MHz / 64 = 750kHz
        gpt->GTCR = (0x0 << 16)    // MD[2:0] = 000 : ノコギリ波PWMモード
                   | (0x3 << 24);   // TPCS[2:0] = 011 : PCLKD/64

        // Step 3: 周期設定
        // 50Hz (20ms) のPWM周期
        // 750kHz × 20ms = 15000 カウント
        // → AVRで「プリスケーラ1024、OCR0A = 155」としていたのと同じ考え方
        gpt->GTPR = 15000 - 1;     // 周期 = (GTPR + 1) / 750kHz = 20ms

        // Step 4: 出力制御
        // 周期先頭でHigh、比較一致でLowに設定
        if (channel == 0) {
            // GTIOCA: 周期先頭でHigh、比較一致でLow (初期値はLow)
            gpt->GTIOR_b.GTIOA = 0x09;
            gpt->GTIOR_b.OAE = 1;       // GTIOCA出力有効
        } else {
            // GTIOCB: 同様
            gpt->GTIOR_b.GTIOB = 0x09;
            gpt->GTIOR_b.OBE = 1;       // GTIOCB出力有効
        }

        active = true;

        // Step 5: 初期デューティ比（90° = 中央）
        writeMicroseconds(1500);

        // Step 6: カウンタクリア & タイマ開始
        gpt->GTCNT = 0;
        gpt->GTSSR_b.CSTRT = 1;       // ソフトウェアスタートを起動要因として許可
        gpt->GTSTR = (1u << ch_num);  // カウント開始

        return true;
    }

    void detach() {
        if (gpt) {
            gpt->GTSTP = (1u << ch_num);  // タイマ停止
        }
        active = false;
    }

    /**
     * パルス幅をマイクロ秒で指定
     * 750kHz → 1カウント = 1.333μs
     * us マイクロ秒 → us × 750000 / 1000000 = us × 0.75 カウント
     */
    void writeMicroseconds(int us) {
        if (!active) return;
        uint32_t counts = (uint32_t)us * 3 / 4;  // μs → カウント変換

        if (channel == 0) {
            gpt->GTCCR[0] = counts;  // GTCCRA更新 → デューティ比変更
        } else {
            gpt->GTCCR[1] = counts;  // GTCCRB更新
        }
        // ★ ここがポイント: レジスタに値を書くだけ
        // CPUはすぐ次の処理に進める
        // 波形生成はハードウェアが自動で行う
    }

    /**
     * 角度（0〜180°）で指定
     */
    void write(int angle) {
        angle = constrain(angle, 0, 180);
        int us = map(angle, 0, 180, 500, 2500);
        writeMicroseconds(us);
    }

    int read() {
        if (!active) return 0;
        uint32_t counts;
        if (channel == 0) {
            counts = gpt->GTCCR[0];
        } else {
            counts = gpt->GTCCR[1];
        }
        int us = counts * 4 / 3;
        return map(us, 500, 2500, 0, 180);
    }
};

#endif // HARDWARE_PWM_H

include/raw_adc.h — 75 行

GitHub で開く

// raw_adc.h
// レジスタ操作によるA/D変換

#ifndef RAW_ADC_H
#define RAW_ADC_H

#include <Arduino.h>
#include <Arduino.h>   // R_GPT0 / R_ADC0 などのレジスタ定義はここから来る

/**
 * ADCの初期化
 * AVRでの ADCSRA = _BV(ADEN) | _BV(ADPS2) | _BV(ADPS1) | _BV(ADPS0);
 * に相当する処理
 */
void raw_adc_init(void) {
    // ---- ADCモジュールの電源ON ----
    R_MSTP->MSTPCRD_b.MSTPD16 = 0;  // ADC140 モジュールストップ解除

    // ---- ADC設定 ----
    // Step 1: ADCを停止（設定変更前に必要）
    R_ADC0->ADCSR = 0;

    // Step 2: 変換精度の設定
    // ADPRC (ADCER のビット2:1) = 11 → 14ビット分解能
    // (RA4M1 で有効なのは 00=12bit と 11=14bit のみ)
    // AVRでは固定10ビットだったが、RA4M1では選択可能
    R_ADC0->ADCER = 0x0006;  // ADPRC=11: 14bit, 右詰め

    // Step 3: サンプリング時間の設定
    // AVRのプリスケーラ（ADPS）に相当する概念
    // サンプリングステート数を設定
    for (int i = 0; i < 16; i++) {
        R_ADC0->ADSSTR[i] = 0x0D;  // 13ステート（デフォルト）
    }
}

/**
 * 指定チャネルのA/D変換を実行（ポーリング方式）
 *
 * AVRでの以下のコードに相当:
 *   ADMUX = (ADMUX & 0xF0) | channel;
 *   ADCSRA |= _BV(ADSC);
 *   loop_until_bit_is_clear(ADCSRA, ADSC);
 *   return ADC;
 */
uint16_t raw_analog_read(uint8_t channel) {
    // Step 1: チャネル選択
    // AVR: ADMUX = (ADMUX & 0xF0) | channel;
    R_ADC0->ADANSA[0] = (1 << channel);  // 指定チャネルのみ有効

    // Step 2: 変換開始
    // AVR: ADCSRA |= _BV(ADSC);
    R_ADC0->ADCSR |= R_ADC0_ADCSR_ADST_Msk;  // ADST = 1 で変換開始

    // Step 3: 変換完了を待機（ポーリング）
    // AVR: loop_until_bit_is_clear(ADCSRA, ADSC);
    while (R_ADC0->ADCSR & R_ADC0_ADCSR_ADST_Msk) {
        // ADSTが自動クリアされるまで待機
        // AVRの ADSC と同じ動作
    }

    // Step 4: 結果を読む
    // AVR: return ADC;  (ADCH:ADCLの16bit結合値)
    return R_ADC0->ADDR[channel];  // 14ビット値（0〜16383）
}

/**
 * 14ビット値を10ビット値（0〜1023）に変換
 * Arduino標準のanalogRead()と同じ範囲にする
 */
uint16_t raw_analog_read_10bit(uint8_t channel) {
    return raw_analog_read(channel) >> 4;  // 14bit → 10bit
}

#endif // RAW_ADC_H

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 — 231 行

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 のようにタスクごとにループで呼ぶため、基準時刻もタスクごとに持つ。
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 の両方で同じ結果を確認しています）。手元の出力と見比べてください。

A0 に可変抵抗をつなぐと値が動きます。servo は角度（度）です。

pot(14bit)=3233  pot(10bit)=201  servo=34deg
pot(14bit)=3252  pot(10bit)=202  servo=34deg
pot(14bit)=3243  pot(10bit)=201  servo=34deg
pot(14bit)=3254  pot(10bit)=202  servo=34deg
pot(14bit)=3239  pot(10bit)=201  servo=34deg
pot(14bit)=3221  pot(10bit)=200  servo=34deg
pot(14bit)=3238  pot(10bit)=201  servo=34deg
pot(14bit)=3222  pot(10bit)=200  servo=34deg
...

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

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