生产任务局部 message             队列长期持有的两个槽位            消费任务局部 received
{10,110} --send 成功复制 8 字节--> [ {10,110} | 空 ] --receive 成功复制--> {10,110}
     随后改成 {999,-1}              旧消息仍为 {10,110}                 接收后槽位释放

Consumer: 空 -> 记入接收等待信息并阻塞
Producer: send 复制 -> 队列已有数据 -> Consumer 移到就绪集合
调度规则: 在所有就绪任务中选择
Consumer 真正运行: 回到尚未完成的 receive -> 重查 -> 复制到自己的缓冲 -> 返回成功

复位/匹配的 SystemInit
  -> HSI 标称 16 MHz，HSION=1，等 HSIRDY
  -> 主 PLL 关闭，不进入倍频链；HSE 不参与
  -> SYSCLK 选择 HSI：16 MHz
  -> AHB（高速总线）分频 /1：HCLK = 16 MHz
       -> Cortex-M4 内核 = 16 MHz
       -> SysTick 使用 HCLK，端口默认 CLKSOURCE=1
            LOAD = 16000000 / 1000 - 1 = 15999
            名义内核 tick = 1000 Hz，1 tick = 1 ms
  -> APB1（外设总线 1）/1：PCLK1 = 16 MHz
  -> APB2（外设总线 2）/1：PCLK2 = 16 MHz

$work = '.state/runs/20261023-163148887-24156/teacher-work'
& ./lessons/L043-freertos-static-queue/tools/test-host.ps1 `
    -BuildDir "$work/build" -EvidenceDir "$work/host-evidence"

PASS 9 queue-model tests; not FreeRTOS or STM32 execution

Reset_Handler -> SystemInit / C 运行时初始化 -> main
  -> HAL_Init / 明确检查 HAL_InitTick
  -> SystemClock_Config：HSI / SYSCLK / AHB / APB / nominal HCLK 检查
  -> HAL 时基单向交接准备
  -> App_CreateQueueTasks
       xQueueCreateStatic -> 两个永久 context -> 两个 xTaskCreateStatic
  -> vTaskStartScheduler -> 静态 Idle -> ARM_CM4F 首次任务启动
  -> Consumer 优先级 2：空队列 receive，阻塞
  -> Producer 优先级 1：send -> 内核复制/唤醒 Consumer
  -> Consumer 按调度得到 CPU，receive 完成，检查消息，任务延时
  -> Producer 完成 send，计数并修改局部消息，任务延时

& ./lessons/L043-freertos-static-queue/tools/check-reference-syntax.ps1 `
    -CubeF4Root 'C:\Users\25108\STM32Cube\Repository\STM32Cube_FW_F4_V1.28.3' `
    -EvidenceDir '.state/runs/20261023-163148887-24156/teacher-work/reference-syntax'

model/queue_model.h, queue_model.c      原创教学机制模型，测试持有对象
tests/test_queue_model.c               手写预期、失败退出码
tools/test-host.ps1                    编译、负向/变异检查，输出指定目录
tools/check-reference-syntax.ps1       真正厂商头文件上的主机语法检查
target/app_queue.h, app_queue.c        消息声明、静态队列/任务实例与组装、两个任务使用
target/FreeRTOSConfig.h                唯一内核配置
target/stm32f4xx_hal_conf.h             HSI-only 最小 HAL 配置
target/app_fatal.h, app_fatal.c         固定宽度错误接口、停机观察点
target/interrupts.h, interrupts.c       SysTick 所有权交接包装
target/main.c                         HAL 时钟、组装顺序与启动调度器

#ifndef L043_QUEUE_MODEL_H
#define L043_QUEUE_MODEL_H
#include <stdint.h>

#define QM_CAPACITY UINT32_C(2)
#define QM_PRODUCER UINT32_C(0)
#define QM_CONSUMER UINT32_C(1)
#define QM_NONE UINT32_C(2)
#define QM_OK UINT32_C(0)
#define QM_FULL UINT32_C(1)
#define QM_EMPTY UINT32_C(2)
#define QM_BLOCKED UINT32_C(3)
#define QM_INVALID UINT32_C(4)
#define QM_READY UINT32_C(0)
#define QM_WAIT_SEND UINT32_C(1)
#define QM_WAIT_RECEIVE UINT32_C(2)

typedef struct {
    uint32_t sequence;
    int32_t value;
} QueueMessage;

typedef struct {
    uint32_t priority;
    uint32_t state;
    uint32_t operation;
    uint32_t deadline;
    uint32_t result;
    const QueueMessage *source;
    QueueMessage *destination;
} ModelTask;

typedef struct {
    QueueMessage slots[QM_CAPACITY];
    uint32_t head;
    uint32_t count;
    uint32_t tick;
    ModelTask tasks[2];
} QueueModel;

void QM_Init(QueueModel *model, uint32_t producer_priority,
             uint32_t consumer_priority);
uint32_t QM_Send(QueueModel *model, const QueueMessage *source,
                 uint32_t wait_ticks);
uint32_t QM_Receive(QueueModel *model, QueueMessage *destination,
                    uint32_t wait_ticks);
uint32_t QM_Resume(QueueModel *model, uint32_t task);
uint32_t QM_Tick(QueueModel *model, uint32_t elapsed);
uint32_t QM_Pick(const QueueModel *model);
#endif

#include <stddef.h>
#include <string.h>
#include "queue_model.h"

#define OP_NONE UINT32_C(0)
#define OP_SEND UINT32_C(1)
#define OP_RECEIVE UINT32_C(2)

static uint32_t Finish(ModelTask *task, uint32_t result)
{
    task->state = QM_READY;
    task->operation = OP_NONE;
    task->source = NULL;
    task->destination = NULL;
    task->result = result;
    return result;
}

void QM_Init(QueueModel *q, uint32_t producer_priority,
             uint32_t consumer_priority)
{
    memset(q, 0, sizeof(*q));
    q->tasks[QM_PRODUCER].priority = producer_priority;
    q->tasks[QM_CONSUMER].priority = consumer_priority;
}

uint32_t QM_Resume(QueueModel *q, uint32_t id)
{
    ModelTask *task;
    if (q == NULL || id >= QM_NONE) {
        return QM_INVALID;
    }
    task = &q->tasks[id];
    if (task->operation == OP_NONE || task->state != QM_READY) {
        return QM_INVALID;
    }
    if (task->operation == OP_SEND && q->count < QM_CAPACITY) {
        uint32_t tail = (q->head + q->count) % QM_CAPACITY;
        q->slots[tail] = *task->source;
        ++q->count;
        if (q->tasks[QM_CONSUMER].state == QM_WAIT_RECEIVE) {
            q->tasks[QM_CONSUMER].state = QM_READY;
        }
        return Finish(task, QM_OK);
    }
    if (task->operation == OP_RECEIVE && q->count > 0U) {
        *task->destination = q->slots[q->head];
        q->head = (q->head + 1U) % QM_CAPACITY;
        --q->count;
        if (q->tasks[QM_PRODUCER].state == QM_WAIT_SEND) {
            q->tasks[QM_PRODUCER].state = QM_READY;
        }
        return Finish(task, QM_OK);
    }
    if (q->tick >= task->deadline) {
        uint32_t result = task->operation == OP_SEND ? QM_FULL : QM_EMPTY;
        return Finish(task, result);
    }
    task->state = task->operation == OP_SEND ? QM_WAIT_SEND : QM_WAIT_RECEIVE;
    task->result = QM_BLOCKED;
    return QM_BLOCKED;
}

uint32_t QM_Send(QueueModel *q, const QueueMessage *source,
                 uint32_t wait_ticks)
{
    ModelTask *task;
    if (q == NULL || source == NULL || wait_ticks > UINT32_MAX - q->tick) {
        return QM_INVALID;
    }
    task = &q->tasks[QM_PRODUCER];
    if (task->operation != OP_NONE) {
        return QM_INVALID;
    }
    task->source = source;
    task->operation = OP_SEND;
    task->deadline = q->tick + wait_ticks;
    return QM_Resume(q, QM_PRODUCER);
}

uint32_t QM_Receive(QueueModel *q, QueueMessage *destination,
                    uint32_t wait_ticks)
{
    ModelTask *task;
    if (q == NULL || destination == NULL || wait_ticks > UINT32_MAX - q->tick) {
        return QM_INVALID;
    }
    task = &q->tasks[QM_CONSUMER];
    if (task->operation != OP_NONE) {
        return QM_INVALID;
    }
    task->destination = destination;
    task->operation = OP_RECEIVE;
    task->deadline = q->tick + wait_ticks;
    return QM_Resume(q, QM_CONSUMER);
}

uint32_t QM_Tick(QueueModel *q, uint32_t elapsed)
{
    uint32_t id;
    if (q == NULL || elapsed > UINT32_MAX - q->tick) {
        return QM_INVALID;
    }
    q->tick += elapsed;
    for (id = 0U; id < QM_NONE; ++id) {
        ModelTask *task = &q->tasks[id];
        if (task->state != QM_READY && q->tick >= task->deadline) {
            task->state = QM_READY;
        }
    }
    return QM_OK;
}

uint32_t QM_Pick(const QueueModel *q)
{
    uint32_t best = QM_NONE;
    uint32_t id;
    if (q == NULL) {
        return best;
    }
    for (id = 0U; id < QM_NONE; ++id) {
        if (q->tasks[id].state == QM_READY &&
            (best == QM_NONE || q->tasks[id].priority > q->tasks[best].priority)) {
            best = id;
        }
    }
    return best;
}

#include <stdio.h>
#include <string.h>
#include "queue_model.h"

#define CHECK(expr) do { if (!(expr)) { \
    fprintf(stderr, "FAIL line %d: %s\n", __LINE__, #expr); return 1; \
} } while (0)

/* Break caught: aliased storage, missing second copy, or FIFO changed to LIFO. */
static int CopyAndFifo(int wrong_expected)
{
    QueueModel q;
    QueueMessage a = {10U, 110};
    QueueMessage b = {20U, 220};
    QueueMessage out = {0U, 0};
    QM_Init(&q, 1U, 2U);
    CHECK(QM_Send(&q, &a, 0U) == QM_OK);
    a.sequence = 999U;
    a.value = -1;
    CHECK(QM_Send(&q, &b, 0U) == QM_OK);
    CHECK(QM_Receive(&q, &out, 0U) == QM_OK);
    CHECK(out.sequence == (wrong_expected ? 999U : 10U));
    CHECK(out.value == 110);
    out.value = -2;
    CHECK(QM_Receive(&q, &out, 0U) == QM_OK);
    CHECK(out.sequence == 20U && out.value == 220);
    CHECK(q.count == 0U);
    return 0;
}

/* Break caught: full queue overwrites an existing record. */
static int FullKeepsOldMessages(void)
{
    QueueModel q;
    QueueMessage a = {1U, 11}, b = {2U, 22}, c = {3U, 33}, out;
    QM_Init(&q, 1U, 2U);
    CHECK(QM_Send(&q, &a, 0U) == QM_OK);
    CHECK(QM_Send(&q, &b, 0U) == QM_OK);
    CHECK(QM_Send(&q, &c, 0U) == QM_FULL);
    CHECK(q.count == 2U);
    CHECK(QM_Receive(&q, &out, 0U) == QM_OK && out.sequence == 1U);
    CHECK(QM_Receive(&q, &out, 0U) == QM_OK && out.sequence == 2U);
    return 0;
}

/* Break caught: failure changes the receive buffer or fabricates an item. */
static int EmptyPreservesOutput(void)
{
    QueueModel q;
    QueueMessage out = {77U, -77};
    QM_Init(&q, 1U, 2U);
    CHECK(QM_Receive(&q, &out, 0U) == QM_EMPTY);
    CHECK(out.sequence == 77U && out.value == -77);
    CHECK(q.count == 0U && q.tasks[QM_CONSUMER].state == QM_READY);
    return 0;
}

/* Break caught: wake completes a receive before the task actually resumes. */
static int ReceiveWakeAndResume(void)
{
    QueueModel q;
    QueueMessage in = {7U, 70}, out = {99U, -99};
    QM_Init(&q, 1U, 2U);
    CHECK(QM_Receive(&q, &out, 8U) == QM_BLOCKED);
    CHECK(q.tasks[QM_CONSUMER].state == QM_WAIT_RECEIVE);
    CHECK(QM_Pick(&q) == QM_PRODUCER);
    CHECK(QM_Send(&q, &in, 0U) == QM_OK);
    CHECK(q.tasks[QM_CONSUMER].state == QM_READY);
    CHECK(q.tasks[QM_CONSUMER].result == QM_BLOCKED);
    CHECK(q.count == 1U && out.sequence == 99U);
    CHECK(QM_Pick(&q) == QM_CONSUMER);
    CHECK(QM_Resume(&q, QM_CONSUMER) == QM_OK);
    CHECK(out.sequence == 7U && out.value == 70 && q.count == 0U);
    return 0;
}

/* Break caught: waking a lower-priority task is treated as immediate running. */
static int LowerPriorityWakeDoesNotWin(void)
{
    QueueModel q;
    QueueMessage in = {8U, 80}, out = {0U, 0};
    QM_Init(&q, 2U, 1U);
    CHECK(QM_Receive(&q, &out, 8U) == QM_BLOCKED);
    CHECK(QM_Send(&q, &in, 0U) == QM_OK);
    CHECK(q.tasks[QM_CONSUMER].state == QM_READY);
    CHECK(QM_Pick(&q) == QM_PRODUCER);
    CHECK(out.sequence == 0U && q.count == 1U);
    return 0;
}

/* Break caught: a blocked send copies early or fails to resume after space. */
static int SendWakeAndResume(void)
{
    QueueModel q;
    QueueMessage a = {1U, 11}, b = {2U, 22}, c = {3U, 33}, out;
    QM_Init(&q, 2U, 1U);
    CHECK(QM_Send(&q, &a, 0U) == QM_OK);
    CHECK(QM_Send(&q, &b, 0U) == QM_OK);
    CHECK(QM_Send(&q, &c, 9U) == QM_BLOCKED);
    CHECK(q.tasks[QM_PRODUCER].state == QM_WAIT_SEND);
    CHECK(QM_Receive(&q, &out, 0U) == QM_OK && out.sequence == 1U);
    CHECK(q.tasks[QM_PRODUCER].state == QM_READY);
    CHECK(q.count == 1U && q.tasks[QM_PRODUCER].result == QM_BLOCKED);
    CHECK(QM_Pick(&q) == QM_PRODUCER);
    CHECK(QM_Resume(&q, QM_PRODUCER) == QM_OK && q.count == 2U);
    CHECK(QM_Receive(&q, &out, 0U) == QM_OK && out.sequence == 2U);
    CHECK(QM_Receive(&q, &out, 0U) == QM_OK && out.sequence == 3U);
    return 0;
}

/* Break caught: timeout is early/late or changes an unsuccessful output. */
static int ReceiveTimeout(void)
{
    QueueModel q;
    QueueMessage out = {55U, -55};
    QM_Init(&q, 1U, 2U);
    CHECK(QM_Tick(&q, 10U) == QM_OK);
    CHECK(QM_Receive(&q, &out, 3U) == QM_BLOCKED);
    CHECK(QM_Tick(&q, 2U) == QM_OK);
    CHECK(q.tasks[QM_CONSUMER].state == QM_WAIT_RECEIVE);
    CHECK(QM_Tick(&q, 1U) == QM_OK);
    CHECK(q.tasks[QM_CONSUMER].state == QM_READY);
    CHECK(q.tasks[QM_CONSUMER].result == QM_BLOCKED);
    CHECK(QM_Resume(&q, QM_CONSUMER) == QM_EMPTY);
    CHECK(out.sequence == 55U && out.value == -55);
    return 0;
}

/* Break caught: expired send adds a message or damages existing FIFO data. */
static int SendTimeout(void)
{
    QueueModel q;
    QueueMessage a = {1U, 11}, b = {2U, 22}, c = {3U, 33}, out;
    QM_Init(&q, 2U, 1U);
    CHECK(QM_Send(&q, &a, 0U) == QM_OK);
    CHECK(QM_Send(&q, &b, 0U) == QM_OK);
    CHECK(QM_Send(&q, &c, 4U) == QM_BLOCKED);
    CHECK(QM_Tick(&q, 4U) == QM_OK);
    CHECK(QM_Resume(&q, QM_PRODUCER) == QM_FULL && q.count == 2U);
    CHECK(QM_Receive(&q, &out, 0U) == QM_OK && out.sequence == 1U);
    CHECK(QM_Receive(&q, &out, 0U) == QM_OK && out.sequence == 2U);
    return 0;
}

/* Break caught: null input, double call, or unsupported tick wrap is accepted. */
static int RejectInvalidEvents(void)
{
    QueueModel q;
    QueueMessage out = {0U, 0};
    QM_Init(&q, 1U, 2U);
    CHECK(QM_Send(&q, NULL, 0U) == QM_INVALID);
    CHECK(QM_Receive(&q, NULL, 0U) == QM_INVALID);
    CHECK(QM_Resume(&q, QM_NONE) == QM_INVALID);
    CHECK(QM_Resume(&q, QM_CONSUMER) == QM_INVALID);
    CHECK(QM_Receive(&q, &out, 3U) == QM_BLOCKED);
    CHECK(QM_Receive(&q, &out, 3U) == QM_INVALID);
    CHECK(QM_Tick(&q, UINT32_MAX) == QM_OK);
    CHECK(QM_Tick(&q, 1U) == QM_INVALID);
    CHECK(QM_Resume(&q, QM_CONSUMER) == QM_EMPTY);
    CHECK(QM_Receive(&q, &out, 1U) == QM_INVALID);
    return 0;
}

int main(int argc, char **argv)
{
    int wrong = argc == 2 && strcmp(argv[1], "--wrong-expected") == 0;
    if (CopyAndFifo(wrong) || FullKeepsOldMessages() || EmptyPreservesOutput() ||
        ReceiveWakeAndResume() || LowerPriorityWakeDoesNotWin() ||
        SendWakeAndResume() || ReceiveTimeout() || SendTimeout() ||
        RejectInvalidEvents()) {
        return 1;
    }
    puts("PASS 9 queue-model tests; not FreeRTOS or STM32 execution");
    return 0;
}

#ifndef L043_APP_FATAL_H
#define L043_APP_FATAL_H
#include <stdint.h>

#define APP_FATAL_ASSERT UINT32_C(1)
#define APP_FATAL_HAL_INIT UINT32_C(2)
#define APP_FATAL_HAL_TICK UINT32_C(3)
#define APP_FATAL_OSC UINT32_C(4)
#define APP_FATAL_CLOCK UINT32_C(5)
#define APP_FATAL_CREATE UINT32_C(6)
#define APP_FATAL_SCHED_RETURN UINT32_C(7)
#define APP_FATAL_TASK_RETURN UINT32_C(8)
#define APP_FATAL_STACK UINT32_C(9)
#define APP_FATAL_PARAMETER UINT32_C(10)
#define APP_FATAL_MESSAGE UINT32_C(11)

extern volatile uint32_t g_error_code;
extern volatile uint32_t g_error_line;
_Noreturn void App_Fatal(uint32_t code, uint32_t line);
_Noreturn void App_TaskReturned(void);
#endif

#include "stm32f4xx.h"
#include "app_fatal.h"

volatile uint32_t g_error_code;
volatile uint32_t g_error_line;

_Noreturn void App_Fatal(uint32_t code, uint32_t line)
{
    __disable_irq();
    g_error_code = code;
    g_error_line = line;
    for (;;) {
        __NOP();
    }
}

_Noreturn void App_TaskReturned(void)
{
    App_Fatal(APP_FATAL_TASK_RETURN, (uint32_t)__LINE__);
}

#ifndef FREERTOS_CONFIG_H
#define FREERTOS_CONFIG_H
#include "stm32f4xx.h"
#include "app_fatal.h"

#define configUSE_PREEMPTION 1
#define configUSE_TIME_SLICING 1
#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1
#define configCPU_CLOCK_HZ (SystemCoreClock)
#define configTICK_RATE_HZ 1000U
#define configMAX_PRIORITIES 5U
#define configMINIMAL_STACK_SIZE 256U
#define configMAX_TASK_NAME_LEN 12U
#define configUSE_16_BIT_TICKS 0
#define configIDLE_SHOULD_YIELD 0
#define configUSE_TICKLESS_IDLE 0
#define configSUPPORT_STATIC_ALLOCATION 1
#define configSUPPORT_DYNAMIC_ALLOCATION 0
#define configUSE_TIMERS 0
#define configUSE_MUTEXES 0
#define configUSE_RECURSIVE_MUTEXES 0
#define configUSE_COUNTING_SEMAPHORES 0
#define configUSE_TASK_NOTIFICATIONS 0
#define configUSE_QUEUE_SETS 0
#define configUSE_CO_ROUTINES 0
#define configUSE_IDLE_HOOK 0
#define configUSE_TICK_HOOK 0
#define configCHECK_FOR_STACK_OVERFLOW 2
#define configUSE_MALLOC_FAILED_HOOK 0
#define configUSE_NEWLIB_REENTRANT 0
#define configUSE_TRACE_FACILITY 0
#define configGENERATE_RUN_TIME_STATS 0
#define configQUEUE_REGISTRY_SIZE 0U
#define INCLUDE_vTaskDelay 1
#define INCLUDE_vTaskDelete 0
#define INCLUDE_vTaskSuspend 0
#define INCLUDE_eTaskGetState 1
#define INCLUDE_uxTaskGetStackHighWaterMark 1
#define configPRIO_BITS __NVIC_PRIO_BITS
#define configLIBRARY_LOWEST_INTERRUPT_PRIORITY 15U
#define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY 5U
#define configKERNEL_INTERRUPT_PRIORITY \
    (configLIBRARY_LOWEST_INTERRUPT_PRIORITY << (8U - configPRIO_BITS))
#define configMAX_SYSCALL_INTERRUPT_PRIORITY \
    (configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8U - configPRIO_BITS))
#define configASSERT(expr) do { if ((expr) == 0) { \
    App_Fatal(APP_FATAL_ASSERT, (uint32_t)__LINE__); } } while (0)
#define configTASK_RETURN_ADDRESS App_TaskReturned
#define vPortSVCHandler SVC_Handler
#define xPortPendSVHandler PendSV_Handler
/* interrupts.c owns the only SysTick wrapper; do not alias it here. */
#endif

#ifndef STM32F4XX_HAL_CONF_H
#define STM32F4XX_HAL_CONF_H
#include "app_fatal.h"

#define HAL_MODULE_ENABLED
#define HAL_RCC_MODULE_ENABLED
#define HAL_CORTEX_MODULE_ENABLED
#define HAL_FLASH_MODULE_ENABLED
#define HSI_VALUE 16000000U
#define HSE_VALUE 0U /* Unused. Set from the real board before ever enabling HSE. */
#define HSE_STARTUP_TIMEOUT 100U
#define LSI_VALUE 32000U
#define LSE_VALUE 32768U
#define LSE_STARTUP_TIMEOUT 5000U
#define EXTERNAL_CLOCK_VALUE 0U
#define TICK_INT_PRIORITY 15U
#define USE_RTOS 0U /* Reserved HAL option, not the FreeRTOS enable switch. */
#define PREFETCH_ENABLE 0U
#define INSTRUCTION_CACHE_ENABLE 0U
#define DATA_CACHE_ENABLE 0U

#include "stm32f4xx_hal_rcc.h"
#include "stm32f4xx_hal_cortex.h"
#include "stm32f4xx_hal_flash.h"
#define assert_param(expr) do { if ((expr) == 0U) { \
    App_Fatal(APP_FATAL_ASSERT, (uint32_t)__LINE__); } } while (0)
#endif

#ifndef L043_APP_QUEUE_H
#define L043_APP_QUEUE_H
#include <stdint.h>

typedef struct {
    uint32_t sequence;
    int32_t value;
} SampleMessage;

uint32_t App_CreateQueueTasks(void);
#endif

#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "app_queue.h"
#include "app_fatal.h"

#define APP_QUEUE_LENGTH 2U
#define APP_STACK_WORDS 256U
#ifndef APP_PRODUCER_MS
#define APP_PRODUCER_MS 20U
#endif
#ifndef APP_CONSUMER_MS
#define APP_CONSUMER_MS 5U
#endif
#ifndef APP_SEND_WAIT_MS
#define APP_SEND_WAIT_MS 10U
#endif
#ifndef APP_RECEIVE_WAIT_MS
#define APP_RECEIVE_WAIT_MS 100U
#endif

_Static_assert(sizeof(SampleMessage) == 8U, "Check target message layout");

typedef struct {
    QueueHandle_t queue;
    TickType_t wait_ticks;
    TickType_t pause_ticks;
} QueueTaskContext;

static StaticQueue_t s_queue_control;
static uint8_t s_queue_storage[APP_QUEUE_LENGTH * sizeof(SampleMessage)];
static QueueHandle_t s_queue;
static StaticTask_t s_producer_control, s_consumer_control;
static StackType_t s_producer_stack[APP_STACK_WORDS];
static StackType_t s_consumer_stack[APP_STACK_WORDS];
static TaskHandle_t s_producer_handle, s_consumer_handle;
static QueueTaskContext s_producer_context, s_consumer_context;
static uint32_t s_create_attempted;

volatile uint32_t g_send_ok;
volatile uint32_t g_send_timeout;
volatile uint32_t g_receive_ok;
volatile uint32_t g_receive_timeout;
volatile uint32_t g_last_sequence;
volatile int32_t g_last_value;

static const QueueTaskContext *CheckedContext(void *argument)
{
    const QueueTaskContext *context = argument;
    if (context == NULL || context->queue == NULL || context->pause_ticks == 0U) {
        App_Fatal(APP_FATAL_PARAMETER, (uint32_t)__LINE__);
    }
    return context;
}

static void ProducerEntry(void *argument)
{
    const QueueTaskContext *context = CheckedContext(argument);
    uint32_t sequence = 0U;
    for (;;) {
        SampleMessage message = {sequence, (int32_t)(sequence % 1000U)};
        if (xQueueSend(context->queue, &message, context->wait_ticks) == pdPASS) {
            ++g_send_ok;
        } else {
            ++g_send_timeout;
        }
        message.sequence = UINT32_MAX;
        message.value = -1;
        ++sequence;
        vTaskDelay(context->pause_ticks);
    }
}

static void ConsumerEntry(void *argument)
{
    const QueueTaskContext *context = CheckedContext(argument);
    for (;;) {
        SampleMessage message = {0U, 0};
        if (xQueueReceive(context->queue, &message, context->wait_ticks) == pdPASS) {
            if (message.value != (int32_t)(message.sequence % 1000U)) {
                App_Fatal(APP_FATAL_MESSAGE, (uint32_t)__LINE__);
            }
            g_last_sequence = message.sequence;
            g_last_value = message.value;
            ++g_receive_ok;
        } else {
            ++g_receive_timeout;
        }
        vTaskDelay(context->pause_ticks);
    }
}

uint32_t App_CreateQueueTasks(void)
{
    if (s_create_attempted != 0U) {
        return 1U;
    }
    s_create_attempted = 1U;
    s_queue = xQueueCreateStatic(APP_QUEUE_LENGTH, sizeof(SampleMessage),
                                 s_queue_storage, &s_queue_control);
    if (s_queue == NULL) {
        return 1U;
    }
    s_producer_context.queue = s_queue;
    s_producer_context.wait_ticks = pdMS_TO_TICKS(APP_SEND_WAIT_MS);
    s_producer_context.pause_ticks = pdMS_TO_TICKS(APP_PRODUCER_MS);
    s_consumer_context.queue = s_queue;
    s_consumer_context.wait_ticks = pdMS_TO_TICKS(APP_RECEIVE_WAIT_MS);
    s_consumer_context.pause_ticks = pdMS_TO_TICKS(APP_CONSUMER_MS);
    if (s_producer_context.pause_ticks == 0U || s_consumer_context.pause_ticks == 0U) {
        return 1U;
    }
    s_producer_handle = xTaskCreateStatic(ProducerEntry, "Producer", APP_STACK_WORDS,
                                        &s_producer_context, 1U,
                                        s_producer_stack, &s_producer_control);
    s_consumer_handle = xTaskCreateStatic(ConsumerEntry, "Consumer", APP_STACK_WORDS,
                                        &s_consumer_context, 2U,
                                        s_consumer_stack, &s_consumer_control);
    return s_producer_handle == NULL || s_consumer_handle == NULL ? 1U : 0U;
}

void vApplicationGetIdleTaskMemory(StaticTask_t **control, StackType_t **stack,
                                   uint32_t *depth)
{
    static StaticTask_t idle_control;
    static StackType_t idle_stack[configMINIMAL_STACK_SIZE];
    *control = &idle_control;
    *stack = idle_stack;
    *depth = configMINIMAL_STACK_SIZE;
}

void vApplicationStackOverflowHook(TaskHandle_t task, char *name)
{
    (void)task;
    (void)name;
    App_Fatal(APP_FATAL_STACK, (uint32_t)__LINE__);
}

#ifndef L043_INTERRUPTS_H
#define L043_INTERRUPTS_H
#include <stdint.h>
extern volatile uint32_t g_kernel_owns_systick;
#endif

#include "stm32f4xx_hal.h"
#include "interrupts.h"

volatile uint32_t g_kernel_owns_systick;
extern void xPortSysTickHandler(void);

void SysTick_Handler(void)
{
    if (g_kernel_owns_systick == 0U) {
        HAL_IncTick();
    } else {
        xPortSysTickHandler();
    }
    __DSB(); /* ES0182 2.1.3: check actual silicon revision during integration. */
}
/* The GCC ARM_CM4F port supplies SVC_Handler and PendSV_Handler. */

#include "stm32f4xx_hal.h"
#include "FreeRTOS.h"
#include "task.h"
#include "app_queue.h"
#include "app_fatal.h"
#include "interrupts.h"

volatile uint32_t g_main_phase;

/* Genuine reset + matching SystemInit only; no bootloader handoff is assumed. */
static void SystemClock_Config(void)
{
    RCC_OscInitTypeDef oscillator = {0};
    RCC_ClkInitTypeDef clocks = {0};
    oscillator.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    oscillator.HSIState = RCC_HSI_ON;
    oscillator.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    oscillator.PLL.PLLState = RCC_PLL_OFF;
    if (HAL_RCC_OscConfig(&oscillator) != HAL_OK) {
        App_Fatal(APP_FATAL_OSC, (uint32_t)__LINE__);
    }
    clocks.ClockType = RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK |
                       RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
    clocks.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
    clocks.AHBCLKDivider = RCC_SYSCLK_DIV1;
    clocks.APB1CLKDivider = RCC_HCLK_DIV1;
    clocks.APB2CLKDivider = RCC_HCLK_DIV1;
    if (HAL_RCC_ClockConfig(&clocks, FLASH_LATENCY_0) != HAL_OK) {
        App_Fatal(APP_FATAL_CLOCK, (uint32_t)__LINE__);
    }
    SystemCoreClockUpdate();
    if (SystemCoreClock != UINT32_C(16000000) ||
        HAL_NVIC_GetPriorityGrouping() != NVIC_PRIORITYGROUP_4) {
        App_Fatal(APP_FATAL_CLOCK, (uint32_t)__LINE__);
    }
    /* This fixed HAL ignores the return from its nested HAL_InitTick calls. */
    if (HAL_InitTick(TICK_INT_PRIORITY) != HAL_OK) {
        App_Fatal(APP_FATAL_HAL_TICK, (uint32_t)__LINE__);
    }
}

int main(void)
{
    g_main_phase = 1U;
    if (HAL_Init() != HAL_OK) {
        App_Fatal(APP_FATAL_HAL_INIT, (uint32_t)__LINE__);
    }
    if (HAL_InitTick(TICK_INT_PRIORITY) != HAL_OK) {
        App_Fatal(APP_FATAL_HAL_TICK, (uint32_t)__LINE__);
    }
    SystemClock_Config();
    HAL_NVIC_SetPriority(SVCall_IRQn, 0U, 0U);
    g_main_phase = 2U;

    /* One-way handoff: never use timed HAL operations after this point. */
    __disable_irq();
    HAL_SuspendTick();
    SysTick->CTRL = 0U;
    SysTick->VAL = 0U;
    SCB->ICSR = SCB_ICSR_PENDSTCLR_Msk | SCB_ICSR_PENDSVCLR_Msk;
    __DSB();
    __ISB();
    if (App_CreateQueueTasks() != 0U) {
        App_Fatal(APP_FATAL_CREATE, (uint32_t)__LINE__);
    }
    g_kernel_owns_systick = 1U;
    g_main_phase = 3U;
    vTaskStartScheduler();
    App_Fatal(APP_FATAL_SCHED_RETURN, (uint32_t)__LINE__);
}

param(
    [Parameter(Mandatory=$true)][string]$BuildDir,
    [Parameter(Mandatory=$true)][string]$EvidenceDir,
    [string]$Compiler = 'gcc'
)
$ErrorActionPreference = 'Stop'
$PSNativeCommandUseErrorActionPreference = $false
$lesson = Split-Path -Parent $PSScriptRoot
$build = [IO.Path]::GetFullPath($BuildDir)
$evidence = [IO.Path]::GetFullPath($EvidenceDir)
New-Item -ItemType Directory -Force $build,$evidence | Out-Null
$compilerPath = (Get-Command $Compiler -ErrorAction Stop).Source
$version = & $compilerPath --version
if ($LASTEXITCODE -ne 0) { throw 'Compiler version command failed' }
$version | Set-Content -Encoding utf8 (Join-Path $evidence 'compiler-version.log')
$model = Join-Path $lesson 'model/queue_model.c'
$tests = Join-Path $lesson 'tests/test_queue_model.c'
$results = [Collections.Generic.List[object]]::new()

function Invoke-Case([string]$Name, [string]$Source, [string[]]$TestArgs,
                     [bool]$ShouldPass, [string]$FailureText = '') {
    $exe = Join-Path $build "$Name.exe"
    $flags = @('-std=c11','-Wall','-Wextra','-Werror','-pedantic',
               '-I',(Join-Path $lesson 'model'),$Source,$tests,'-o',$exe)
    $compileOutput = & $compilerPath @flags 2>&1
    $compileExit = $LASTEXITCODE
    $compileOutput | Set-Content -Encoding utf8 (Join-Path $evidence "$Name-compile.log")
    if ($compileExit -ne 0) { throw "$Name compilation failed: $compileOutput" }
    $output = & $exe @TestArgs 2>&1
    $testExit = $LASTEXITCODE
    $text = $output -join "`n"
    $text | Set-Content -Encoding utf8 (Join-Path $evidence "$Name-test.log")
    if (($ShouldPass -and $testExit -ne 0) -or
        (-not $ShouldPass -and ($testExit -eq 0 -or -not $text.Contains($FailureText)))) {
        throw "$Name unexpected exit/output: $testExit $text"
    }
    $results.Add([pscustomobject]@{
        name=$Name; compiler=$compilerPath; arguments=$flags; compile_exit=$compileExit
        test_arguments=$TestArgs; test_exit=$testExit; expected_pass=$ShouldPass
        source_sha256=(Get-FileHash -LiteralPath $Source).Hash.ToLowerInvariant()
        test_sha256=(Get-FileHash -LiteralPath $tests).Hash.ToLowerInvariant()
    })
    Write-Host "$Name : expected result observed (exit $testExit)"
}

Invoke-Case 'green' $model @() $true
Invoke-Case 'wrong-expected' $model @('--wrong-expected') $false 'out.sequence =='
$original = Get-Content -Raw -LiteralPath $model
$mutations = @(
    @('red-copy', 'q->slots[tail] = *task->source;',
       'q->slots[tail] = *task->source; q->slots[tail].sequence = 999U;', 'out.sequence =='),
    @('red-fifo', '*task->destination = q->slots[q->head];',
       '*task->destination = q->slots[(q->head + q->count - 1U) % QM_CAPACITY];', 'out.sequence =='),
    @('red-wake', 'q->tasks[QM_CONSUMER].state = QM_READY;',
       'q->tasks[QM_CONSUMER].state = QM_WAIT_RECEIVE;', 'q.tasks[QM_CONSUMER].state == QM_READY')
)
foreach ($mutation in $mutations) {
    if (-not $original.Contains($mutation[1])) { throw "Mutation anchor missing: $($mutation[0])" }
    $mutant = Join-Path $build "$($mutation[0]).c"
    [IO.File]::WriteAllText($mutant, $original.Replace($mutation[1],$mutation[2]))
    Invoke-Case $mutation[0] $mutant @() $false $mutation[3]
}
Invoke-Case 'final-green' $model @() $true
[pscustomobject]@{
    recorded_at=(Get-Date).ToString('o'); scope='Host teaching model only; not kernel/target execution'
    model_sha256=(Get-FileHash -LiteralPath $model).Hash.ToLowerInvariant()
    results=@($results.ToArray())
} | ConvertTo-Json -Depth 7 | Set-Content -Encoding utf8 (Join-Path $evidence 'host-results.json')

param(
    [Parameter(Mandatory=$true)][string]$CubeF4Root,
    [Parameter(Mandatory=$true)][string]$EvidenceDir,
    [string]$Compiler = 'gcc'
)
$ErrorActionPreference = 'Stop'
$PSNativeCommandUseErrorActionPreference = $false
$lesson = Split-Path -Parent $PSScriptRoot
$package = (Resolve-Path -LiteralPath $CubeF4Root).Path
$kernel = Join-Path $package 'Middlewares/Third_Party/FreeRTOS/Source'
$evidence = [IO.Path]::GetFullPath($EvidenceDir)
New-Item -ItemType Directory -Force $evidence | Out-Null
$compilerPath = (Get-Command $Compiler -ErrorAction Stop).Source
$includes = @(
    (Join-Path $lesson 'target'),
    (Join-Path $kernel 'include'),
    (Join-Path $kernel 'portable/GCC/ARM_CM4F'),
    (Join-Path $package 'Drivers/STM32F4xx_HAL_Driver/Inc'),
    (Join-Path $package 'Drivers/CMSIS/Include'),
    (Join-Path $package 'Drivers/CMSIS/Device/ST/STM32F4xx/Include')
)
$flags = @('-std=c11','-fsyntax-only','-Wall','-Wextra','-Werror',
           '-Wno-int-to-pointer-cast','-Wno-pointer-to-int-cast',
           '-DSTM32F407xx','-DUSE_HAL_DRIVER')
foreach ($include in $includes) {
    if (-not (Test-Path -LiteralPath $include -PathType Container)) { throw "Missing include: $include" }
    $flags += @('-I',$include)
}
$results = foreach ($file in Get-ChildItem -LiteralPath (Join-Path $lesson 'target') -Filter '*.c' -File) {
    $arguments = $flags + @($file.FullName)
    $output = & $compilerPath @arguments 2>&1
    $code = $LASTEXITCODE
    $output | Set-Content -Encoding utf8 (Join-Path $evidence "$($file.BaseName)-syntax.log")
    if ($code -ne 0) { throw "Host syntax check failed: $($file.Name): $output" }
    [pscustomobject]@{file=$file.Name;sha256=(Get-FileHash -LiteralPath $file.FullName).Hash.ToLowerInvariant();arguments=$arguments;exit=$code}
}
[pscustomobject]@{
    recorded_at=(Get-Date).ToString('o');compiler=$compilerPath;package=$package
    scope='Host GCC C front-end syntax only with real vendor headers; no ARM code generation, assembly, link or target execution'
    waived_warnings=@('int-to-pointer-cast','pointer-to-int-cast')
    results=@($results)
} | ConvertTo-Json -Depth 7 | Set-Content -Encoding utf8 (Join-Path $evidence 'reference-syntax.json')
Write-Host 'PASS 4 application C files: host syntax only, NOT an ARM build'