【STM32連載 第9回】割り込み設計アンチパターン集 ― やってはいけないISRの書き方を「わざと」壊して学ぶ ―

/* ❌ 最もよくある致命的ミス */
void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;
    g_tim2_tick++;

    printf("tick = %lu\r\n", g_tim2_tick);   /* ← これが地雷 */
}

/* 壊れるコード：ISR内でprintf */
void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;
    g_tim2_tick++;
    printf("tick=%lu\r\n", g_tim2_tick);
}

/* main内で1秒後のtick値を確認 */
HAL_Delay(1000);
/* ← HAL_Delay が正常に動かないため、ここに到達しない or 大幅に遅延 */
printf("1sec tick = %lu\r\n", g_tim2_tick);
/* 本来 1000 になるはずが、はるかに小さい値になる */

/* ✅ ISRではフラグだけ立て、出力はmainでやる */
volatile uint32_t g_tim2_tick = 0;
volatile uint8_t  g_debug_flag = 0;

void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;
    g_tim2_tick++;
    g_debug_flag = 1;   /* mainへの通知だけ */
}

/* main側 */
while (1)
{
    if (g_debug_flag)
    {
        g_debug_flag = 0;
        printf("tick=%lu\r\n", g_tim2_tick);   /* ← mainで出力 */
    }
}

/* ❌ volatileなし */
uint32_t g_tim2_tick = 0;   /* volatile がない！ */

void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;
    g_tim2_tick++;
}

int main(void)
{
    /* TIM2初期化・スタート（省略）*/

    /* 1000カウント待つつもりのコード */
    while (g_tim2_tick < 1000)
    {
        /* 何もしない */
    }
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);   /* ← 永遠に到達しない */
}

/* 実験：-O0と-O2で動作の違いを確認 */

/* ① -O0でビルド → 正常に動く（LEDが点灯する）*/
/* ② -O2でビルド → while()から抜けられずLEDが点灯しない */

/* ✅ ISRと共有する変数には必ずvolatileを付ける */
volatile uint32_t g_tim2_tick = 0;

void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;
    g_tim2_tick++;
}

int main(void)
{
    while (g_tim2_tick < 1000)   /* volatileがあれば毎回RAMから読む */
    {
        /* 何もしない */
    }
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);   /* 正常に到達 */
}

/* ❌ ISR内でI2C読み取りと演算をやる（printfがなくても壊れる）*/
void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;

    /* センサーをI2C経由で読む（数百µs〜数ms かかる） */
    int16_t raw = read_sensor_i2c();

    /* 移動平均フィルタ（配列操作、数µs〜数十µs） */
    float filtered = moving_average(raw, filter_buf, FILTER_SIZE);

    g_sensor_val = (uint32_t)filtered;
}

/* ✅ ISRは「今やること」を知らせるだけ。仕事はmainに任せる */
volatile uint8_t g_sensor_read_request = 0;

void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;
    g_sensor_read_request = 1;   /* フラグを立てるだけ */
}

int main(void)
{
    while (1)
    {
        if (g_sensor_read_request)
        {
            g_sensor_read_request = 0;

            /* 重い処理はすべてmain側で */
            int16_t raw = read_sensor_i2c();
            float filtered = moving_average(raw, filter_buf, FILTER_SIZE);
            printf("sensor=%.2f\r\n", filtered);
        }
    }
}

volatile uint32_t g_isr_max_cycles = 0;

void TIM2_IRQHandler(void)
{
    uint32_t t0 = DWT->CYCCNT;
    TIM2->SR &= ~TIM_SR_UIF;

    /* ... ISRの処理 ... */

    uint32_t cycles = DWT->CYCCNT - t0;
    if (cycles > g_isr_max_cycles)
        g_isr_max_cycles = cycles;   /* 最大値を記録 */
}

/* ❌ タイムスタンプ付きセンサー値を非アトミックに更新 */
volatile uint32_t g_timestamp = 0;
volatile uint32_t g_sensor_val = 0;

void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;
    g_timestamp  = HAL_GetTick();
    g_sensor_val = read_sensor();
}

/* main側：2変数をセットで読もうとしている */
uint32_t ts  = g_timestamp;
uint32_t val = g_sensor_val;
/* ts と val が「対応していない」ペアになる可能性がある */

/* ✅ 複数変数の更新をクリティカルセクションで保護 */
volatile uint32_t g_timestamp = 0;
volatile uint32_t g_sensor_val = 0;

void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;

    uint32_t ts  = HAL_GetTick();
    uint32_t val = read_sensor();

    /* 割り込みを一時禁止して「まとめて」書く */
    __disable_irq();
    g_timestamp  = ts;
    g_sensor_val = val;
    __enable_irq();
}

/* main側も同様に保護して読む */
uint32_t ts, val;
__disable_irq();
ts  = g_timestamp;
val = g_sensor_val;
__enable_irq();

/* ✅ ダブルバッファによる無ロック読み書き */
typedef struct {
    uint32_t timestamp;
    uint32_t sensor_val;
} SensorData;

volatile SensorData g_buf[2];
volatile uint8_t    g_write_idx = 0;   /* ISRが書くバッファのインデックス */

void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;

    uint8_t w = g_write_idx;
    g_buf[w].timestamp  = HAL_GetTick();
    g_buf[w].sensor_val = read_sensor();
    g_write_idx ^= 1;   /* 書き込みバッファを切り替え */
}

/* main側：読み取りバッファは書き込みバッファの反対側 */
uint8_t r = g_write_idx ^ 1;   /* 今ISRが書いていない方を読む */
uint32_t ts  = g_buf[r].timestamp;
uint32_t val = g_buf[r].sensor_val;

/* ❌ フラグクリアなし */
void TIM2_IRQHandler(void)
{
    /* TIM2->SR &= ~TIM_SR_UIF; ← これを忘れた！ */
    g_tim2_tick++;
}

/* ✅ ISRの最初に必ずフラグをクリアする */
void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;   /* ← 最初にクリア（理由は第8回参照）*/
    g_tim2_tick++;
}

/* ❌ 不必要に長いクリティカルセクション */
__disable_irq();

/* センサー読み取り（数百µs） */
int16_t raw = read_sensor_i2c();

/* フィルタ処理（数µs〜数十µs） */
float filtered = moving_average(raw, filter_buf, FILTER_SIZE);

/* 変数更新 */
g_sensor_val = (uint32_t)filtered;

__enable_irq();

/* ✅ 変数コピーの瞬間だけ保護する */
int16_t raw = read_sensor_i2c();       /* クリティカルセクション外 */
float filtered = moving_average(raw, filter_buf, FILTER_SIZE);  /* 外 */

/* 書き込みの瞬間だけ保護（数サイクル）*/
__disable_irq();
g_sensor_val = (uint32_t)filtered;
__enable_irq();

/* ISRとmainの役割分担の基本形 */

/* 共有変数（すべてvolatile）*/
volatile uint8_t  g_flag_1ms  = 0;
volatile uint8_t  g_flag_10ms = 0;
volatile uint32_t g_tick      = 0;

void TIM2_IRQHandler(void)
{
    TIM2->SR &= ~TIM_SR_UIF;   /* フラグクリア（最初に！）*/
    g_tick++;

    /* 周期フラグを立てる */
    g_flag_1ms = 1;
    if (g_tick % 10 == 0) g_flag_10ms = 1;
}

int main(void)
{
    /* ... 初期化 ... */

    while (1)
    {
        /* 1ms タスク */
        if (g_flag_1ms)
        {
            g_flag_1ms = 0;
            task_1ms();   /* 軽い処理 */
        }

        /* 10ms タスク */
        if (g_flag_10ms)
        {
            g_flag_10ms = 0;
            task_10ms();  /* 少し重い処理（I2Cなど）*/
        }

        /* バックグラウンドタスク */
        task_background();   /* いつでもよい処理 */
    }
}

/* リングバッファ */
#define RING_BUF_SIZE 64

typedef struct {
    uint8_t  buf[RING_BUF_SIZE];
    uint16_t head;   /* ISRが書く */
    uint16_t tail;   /* mainが読む */
} RingBuf;

volatile RingBuf g_uart_rx;

/* UART受信ISR */
void USART2_IRQHandler(void)
{
    if (USART2->SR & USART_SR_RXNE)
    {
        uint8_t data = USART2->DR;
        uint16_t next = (g_uart_rx.head + 1) % RING_BUF_SIZE;
        if (next != g_uart_rx.tail)   /* バッファが満杯でなければ */
        {
            g_uart_rx.buf[g_uart_rx.head] = data;
            g_uart_rx.head = next;
        }
    }
}

/* main側：データを1バイト取り出す */
uint8_t ring_read(RingBuf *rb, uint8_t *out)
{
    if (rb->head == rb->tail) return 0;   /* 空 */
    *out = rb->buf[rb->tail];
    rb->tail = (rb->tail + 1) % RING_BUF_SIZE;
    return 1;
}

/* ❌ ネストに弱いクリティカルセクション */
void some_function(void)
{
    __disable_irq();   /* 既に禁止状態かもしれない */
    /* ... */
    __enable_irq();    /* 元の状態に関わらず無条件に許可してしまう！ */
}

/* ✅ 元の割り込み状態を保存して復元する */
void some_function(void)
{
    uint32_t primask = __get_PRIMASK();   /* 現在のPRIMASK状態を保存 */
    __disable_irq();

    /* ... クリティカルセクション ... */

    __set_PRIMASK(primask);   /* 元の状態に戻す（既に禁止なら禁止のまま）*/
}