Running --调用 vTaskDelay(N>0)--> Blocked
Blocked --到期条件满足---------> Ready
Ready   --调度选择并恢复上下文--> Running
Running --被更合适任务替代-----> Ready

HighEntry
  → vTaskDelay(3)
  → tasks.c 将当前任务从就绪链移到延时链
  → API 请求 PendSV
  → 端口保存现场 → vTaskSwitchContext 选 Low → 端口恢复 Low

SysTick 硬件到零
  → 向量表中的唯一 SysTick_Handler
  → xPortSysTickHandler → xTaskIncrementTick
  → tick 增加，High 到期：延时链 → 就绪链
  → 满足配置/优先级条件：设置 SCB.ICSR.PENDSVSET
  → PendSV_Handler（端口）保存现场
  → vTaskSwitchContext 选择最高优先级候选
  → 端口恢复任务栈和现场 → 异常返回 → High 从延时之后继续

芯片真复位 / 匹配 SystemInit 与 C 运行时
  → 内部 HSI RC 振荡源，标称 16 MHz，确认 HSIRDY
  → PLL 关闭，未参与频率生成；HSE 未选用
  → SYSCLK 选择 HSI：16 MHz（标称）
  → AHB /1：HCLK = 16 MHz（处理器/总线时钟）
     ├─ APB1 /1：PCLK1 = 16 MHz
     ├─ APB2 /1：PCLK2 = 16 MHz
     └─ SysTick 选处理器时钟，CLKSOURCE=1：16 MHz
         → LOAD = (16000000 / 1000) - 1 = 15999
         → 每 16000 个源时钟周期产生一次节拍请求
         → 标称 tick 频率 1000 Hz，标称周期 1 ms

& ./lessons/L042-freertos-scheduler/host/run-tests.ps1 `
  -EvidenceDirectory '.state/runs/20261022-162304649-8840/teacher-work/host-evidence' `
  -BuildDirectory '.state/runs/20261022-162304649-8840/teacher-work/build'

green                    build=0 test=0
wrong-expected           build=0 test=1  (expected failure)
red-reversed-priority    build=0 test=1  (expected failure)
red-equal-unblock-strict build=0 test=1  (expected failure)
final-green              build=0 test=0
PASS 9 scheduling-model tests; not FreeRTOS or target execution

model/scheduler_model.h, scheduler_model.c   有限调度预测模型
host/test_scheduler.c, run-tests.ps1         独立预期与正/负验证
target/FreeRTOSConfig.h                     唯一内核配置
target/stm32f4xx_hal_conf.h                  最小 HAL 配置
target/app_tasks.h, app_tasks.c             静态任务对象与入口
target/interrupts.h, interrupts.c           唯一 SysTick 包装
target/main.c                              时钟、交接与内核启动
target/app_fatal.h, app_fatal.c              可观察且不返回的错误出口
target/BUILDING.md                          参考构建/下载/观察检查单

#ifndef L042_SCHEDULER_MODEL_H
#define L042_SCHEDULER_MODEL_H

#include <stdint.h>

#define MODEL_CAPACITY UINT32_C(3)
#define MODEL_NONE UINT32_MAX
#define MODEL_READY UINT32_C(1)
#define MODEL_RUNNING UINT32_C(2)
#define MODEL_BLOCKED UINT32_C(3)
#define MODEL_OK UINT32_C(0)
#define MODEL_BAD_ARGUMENT UINT32_C(1)
#define MODEL_NO_CURRENT UINT32_C(2)
#define MODEL_RANGE UINT32_C(3)

typedef struct {
    uint32_t priority;
    uint32_t state;
    uint32_t wake_tick;
} ModelTask;

typedef struct {
    ModelTask tasks[MODEL_CAPACITY];
    uint32_t count;
    uint32_t current;
    uint32_t tick;
    uint32_t preemption;
    uint32_t time_slicing;
} SchedulerModel;

uint32_t Model_Init(SchedulerModel *model, const uint32_t *priorities,
                    uint32_t count, uint32_t preemption, uint32_t time_slicing);
uint32_t Model_Yield(SchedulerModel *model);
uint32_t Model_Delay(SchedulerModel *model, uint32_t ticks);
uint32_t Model_Tick(SchedulerModel *model);

#endif

#include "scheduler_model.h"
#include <stddef.h>

/* Bounded teaching model: no kernel lists, interrupts, tick wrap, or Idle task. */
static void SelectNext(SchedulerModel *m)
{
    uint32_t i;
    uint32_t best = MODEL_NONE;
    uint32_t start = m->current == MODEL_NONE ? 0U : (m->current + 1U) % m->count;
    if (m->current != MODEL_NONE) {
        m->tasks[m->current].state = MODEL_READY;
    }
    for (i = 0U; i < m->count; ++i) {
        uint32_t candidate = (start + i) % m->count;
        if (m->tasks[candidate].state == MODEL_READY &&
            (best == MODEL_NONE ||
             m->tasks[candidate].priority > m->tasks[best].priority)) {
            best = candidate;
        }
    }
    m->current = best;
    if (best != MODEL_NONE) {
        m->tasks[best].state = MODEL_RUNNING;
    }
}

uint32_t Model_Init(SchedulerModel *m, const uint32_t *priorities,
                    uint32_t count, uint32_t preemption, uint32_t time_slicing)
{
    uint32_t i;
    if (m == NULL || priorities == NULL || count == 0U ||
        count > MODEL_CAPACITY || preemption > 1U || time_slicing > 1U) {
        return MODEL_BAD_ARGUMENT;
    }
    for (i = 0U; i < count; ++i) {
        if (priorities[i] >= 5U) {
            return MODEL_BAD_ARGUMENT;
        }
    }
    *m = (SchedulerModel){0};
    m->count = count;
    m->current = MODEL_NONE;
    m->preemption = preemption;
    m->time_slicing = time_slicing;
    for (i = 0U; i < count; ++i) {
        m->tasks[i].priority = priorities[i];
        m->tasks[i].state = MODEL_READY;
    }
    SelectNext(m);
    return MODEL_OK;
}

uint32_t Model_Yield(SchedulerModel *m)
{
    if (m == NULL) {
        return MODEL_BAD_ARGUMENT;
    }
    if (m->current == MODEL_NONE) {
        return MODEL_NO_CURRENT;
    }
    SelectNext(m);
    return MODEL_OK;
}

uint32_t Model_Delay(SchedulerModel *m, uint32_t ticks)
{
    uint32_t old;
    if (m == NULL) {
        return MODEL_BAD_ARGUMENT;
    }
    if (m->current == MODEL_NONE) {
        return MODEL_NO_CURRENT;
    }
    if (ticks == 0U) {
        return Model_Yield(m);
    }
    if (ticks > UINT32_MAX - m->tick) {
        return MODEL_RANGE;
    }
    old = m->current;
    m->tasks[old].state = MODEL_BLOCKED;
    m->tasks[old].wake_tick = m->tick + ticks;
    m->current = MODEL_NONE;
    SelectNext(m);
    return MODEL_OK;
}

uint32_t Model_Tick(SchedulerModel *m)
{
    uint32_t i;
    uint32_t request = 0U;
    uint32_t peers = 0U;
    if (m == NULL) {
        return MODEL_BAD_ARGUMENT;
    }
    if (m->tick == UINT32_MAX) {
        return MODEL_RANGE;
    }
    ++m->tick;
    for (i = 0U; i < m->count; ++i) {
        if (m->tasks[i].state == MODEL_BLOCKED && m->tasks[i].wake_tick <= m->tick) {
            m->tasks[i].state = MODEL_READY;
            /* Characterizes the inspected CubeF4 V10.3.1 tick-unblock path. */
            if (m->current != MODEL_NONE && m->preemption != 0U &&
                m->tasks[i].priority >= m->tasks[m->current].priority) {
                request = 1U;
            }
        }
        if (m->current != MODEL_NONE && m->tasks[i].state != MODEL_BLOCKED &&
            m->tasks[i].priority == m->tasks[m->current].priority) {
            ++peers;
        }
    }
    if (m->preemption != 0U && m->time_slicing != 0U && peers > 1U) {
        request = 1U;
    }
    if (request != 0U || m->current == MODEL_NONE) {
        SelectNext(m);
    }
    return MODEL_OK;
}

#include "scheduler_model.h"
#include <stddef.h>
#include <stdio.h>
#include <string.h>

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

static int Invariant(const SchedulerModel *m)
{
    uint32_t running = 0U;
    uint32_t i;
    for (i = 0U; i < m->count; ++i) {
        if (m->tasks[i].state == MODEL_RUNNING) {
            ++running;
            CHECK(m->current == i);
        }
        if (m->tasks[i].state == MODEL_BLOCKED) {
            CHECK(m->current != i);
        }
    }
    CHECK(running == (m->current == MODEL_NONE ? 0U : 1U));
    return 0;
}

static int Test_BlockWakePreempt(void)
{
    SchedulerModel m;
    const uint32_t p[] = {2U, 1U};
    const uint32_t want[] = {1U, 1U, 0U};
    uint32_t i;
    CHECK(Model_Init(&m, p, 2U, 1U, 1U) == MODEL_OK);
    CHECK(m.current == 0U);
    CHECK(Model_Delay(&m, 3U) == MODEL_OK);
    CHECK(m.current == 1U && m.tasks[0].state == MODEL_BLOCKED);
    for (i = 0U; i < 3U; ++i) {
        CHECK(Model_Tick(&m) == MODEL_OK);
        CHECK(m.current == want[i]);
        CHECK(Invariant(&m) == 0);
    }
    CHECK(m.tasks[1].state == MODEL_READY);
    puts("TRACE block/wake: 0 -> 1 -> 1 -> 1 -> 0");
    return 0;
}

static int Test_EqualSliceOn(void)
{
    SchedulerModel m;
    const uint32_t p[] = {1U, 1U};
    const uint32_t want[] = {1U, 0U, 1U, 0U};
    uint32_t i;
    CHECK(Model_Init(&m, p, 2U, 1U, 1U) == MODEL_OK);
    CHECK(m.current == 0U);
    for (i = 0U; i < 4U; ++i) {
        CHECK(Model_Tick(&m) == MODEL_OK);
        CHECK(m.current == want[i]);
        CHECK(Invariant(&m) == 0);
    }
    puts("TRACE equal slice on: 0 -> 1 -> 0 -> 1 -> 0");
    return 0;
}

static int Test_EqualSliceOffYield(void)
{
    SchedulerModel m;
    const uint32_t p[] = {1U, 1U};
    CHECK(Model_Init(&m, p, 2U, 1U, 0U) == MODEL_OK);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == 0U);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == 0U);
    CHECK(Model_Yield(&m) == MODEL_OK && m.current == 1U);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == 1U);
    CHECK(Model_Delay(&m, 0U) == MODEL_OK && m.current == 0U);
    CHECK(m.tasks[1].state == MODEL_READY);
    CHECK(Invariant(&m) == 0);
    puts("TRACE equal slice off + yield/delay0: 0 -> 0 -> 0 -> 1 -> 1 -> 0");
    return 0;
}

static int Test_CooperativeReadyNotRunning(void)
{
    SchedulerModel m;
    const uint32_t p[] = {2U, 1U};
    CHECK(Model_Init(&m, p, 2U, 0U, 1U) == MODEL_OK);
    CHECK(Model_Delay(&m, 2U) == MODEL_OK && m.current == 1U);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == 1U);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == 1U);
    CHECK(m.tasks[0].state == MODEL_READY);
    CHECK(Model_Yield(&m) == MODEL_OK && m.current == 0U);
    CHECK(Invariant(&m) == 0);
    puts("TRACE cooperative: 0 -> 1 -> 1 -> 1(0 Ready) -> 0(yield)");
    return 0;
}

static int Test_EqualWakeSliceOffPackagedBoundary(void)
{
    SchedulerModel m;
    const uint32_t p[] = {1U, 1U};
    CHECK(Model_Init(&m, p, 2U, 1U, 0U) == MODEL_OK);
    CHECK(Model_Delay(&m, 2U) == MODEL_OK && m.current == 1U);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == 1U);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == 0U);
    CHECK(Invariant(&m) == 0);
    puts("TRACE packaged >= unblock, slice off: 0 -> 1 -> 1 -> 0");
    return 0;
}

static int Test_HigherReadyStarvesLowerEvenOnYield(void)
{
    SchedulerModel m;
    const uint32_t p[] = {2U, 1U};
    uint32_t i;
    CHECK(Model_Init(&m, p, 2U, 1U, 1U) == MODEL_OK);
    for (i = 0U; i < 8U; ++i) {
        CHECK(Model_Tick(&m) == MODEL_OK && m.current == 0U);
        CHECK(Model_Yield(&m) == MODEL_OK && m.current == 0U);
    }
    CHECK(m.tasks[1].state == MODEL_READY);
    CHECK(Invariant(&m) == 0);
    puts("TRACE starvation: 8 ticks + 8 yields, only task 0 selected");
    return 0;
}

static int Test_LowerWakeCannotPreempt(void)
{
    SchedulerModel m;
    const uint32_t p[] = {2U, 1U};
    CHECK(Model_Init(&m, p, 2U, 1U, 1U) == MODEL_OK);
    CHECK(Model_Delay(&m, 1U) == MODEL_OK && m.current == 1U);
    CHECK(Model_Delay(&m, 2U) == MODEL_OK && m.current == MODEL_NONE);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == 0U);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == 0U);
    CHECK(m.tasks[1].state == MODEL_READY);
    CHECK(Invariant(&m) == 0);
    return 0;
}

static int Test_OnlyBlockedMeansNoApplicationCandidate(void)
{
    SchedulerModel m;
    const uint32_t p[] = {1U};
    CHECK(Model_Init(&m, p, 1U, 1U, 1U) == MODEL_OK);
    CHECK(Model_Delay(&m, 2U) == MODEL_OK && m.current == MODEL_NONE);
    CHECK(Model_Delay(&m, 1U) == MODEL_NO_CURRENT);
    CHECK(Model_Yield(&m) == MODEL_NO_CURRENT);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == MODEL_NONE);
    CHECK(Model_Tick(&m) == MODEL_OK && m.current == 0U);
    CHECK(Invariant(&m) == 0);
    return 0;
}

static int Test_InputAndRangeErrors(void)
{
    SchedulerModel m;
    const uint32_t p[] = {2U, 1U, 0U};
    const uint32_t bad[] = {5U};
    CHECK(Model_Init(NULL, p, 2U, 1U, 1U) == MODEL_BAD_ARGUMENT);
    CHECK(Model_Init(&m, NULL, 2U, 1U, 1U) == MODEL_BAD_ARGUMENT);
    CHECK(Model_Init(&m, p, 0U, 1U, 1U) == MODEL_BAD_ARGUMENT);
    CHECK(Model_Init(&m, p, 4U, 1U, 1U) == MODEL_BAD_ARGUMENT);
    CHECK(Model_Init(&m, p, 2U, 2U, 1U) == MODEL_BAD_ARGUMENT);
    CHECK(Model_Init(&m, p, 2U, 1U, 2U) == MODEL_BAD_ARGUMENT);
    CHECK(Model_Init(&m, bad, 1U, 1U, 1U) == MODEL_BAD_ARGUMENT);
    CHECK(Model_Tick(NULL) == MODEL_BAD_ARGUMENT);
    CHECK(Model_Yield(NULL) == MODEL_BAD_ARGUMENT);
    CHECK(Model_Delay(NULL, 1U) == MODEL_BAD_ARGUMENT);
    CHECK(Model_Init(&m, p, 3U, 1U, 1U) == MODEL_OK);
    m.tick = UINT32_MAX - 1U;
    CHECK(Model_Delay(&m, 2U) == MODEL_RANGE);
    CHECK(m.current == 0U && m.tasks[0].state == MODEL_RUNNING);
    CHECK(Model_Tick(&m) == MODEL_OK);
    CHECK(Model_Tick(&m) == MODEL_RANGE && m.tick == UINT32_MAX);
    CHECK(Invariant(&m) == 0);
    return 0;
}

int main(int argc, char **argv)
{
    if (argc == 2 && strcmp(argv[1], "--wrong-expected") == 0) {
        SchedulerModel m;
        const uint32_t p[] = {2U, 1U};
        CHECK(Model_Init(&m, p, 2U, 1U, 1U) == MODEL_OK);
        CHECK(m.current == 1U); /* Deliberately false: a test of the test gate. */
        return 0;
    }
    CHECK(argc == 1);
    RUN(Test_BlockWakePreempt);
    RUN(Test_EqualSliceOn);
    RUN(Test_EqualSliceOffYield);
    RUN(Test_CooperativeReadyNotRunning);
    RUN(Test_EqualWakeSliceOffPackagedBoundary);
    RUN(Test_HigherReadyStarvesLowerEvenOnYield);
    RUN(Test_LowerWakeCannotPreempt);
    RUN(Test_OnlyBlockedMeansNoApplicationCandidate);
    RUN(Test_InputAndRangeErrors);
    puts("PASS 9 scheduling-model tests; not FreeRTOS or target execution");
    return 0;
}

param(
    [Parameter(Mandatory=$true)][string]$EvidenceDirectory,
    [Parameter(Mandatory=$true)][string]$BuildDirectory
)
$ErrorActionPreference = 'Stop'
$PSNativeCommandUseErrorActionPreference = $false
$lesson = Split-Path -Parent $PSScriptRoot
New-Item -ItemType Directory -Force -Path $EvidenceDirectory,$BuildDirectory | Out-Null
$evidence = (Resolve-Path -LiteralPath $EvidenceDirectory).Path
$build = (Resolve-Path -LiteralPath $BuildDirectory).Path
$source = Join-Path $lesson 'model/scheduler_model.c'
$test = Join-Path $PSScriptRoot 'test_scheduler.c'
$include = Join-Path $lesson 'model'
$records = [Collections.Generic.List[object]]::new()
& gcc --version 2>&1 | Set-Content -LiteralPath (Join-Path $evidence 'compiler-version.log')
if ($LASTEXITCODE -ne 0) { throw 'gcc unavailable' }

function Invoke-Case([string]$Name, [string]$ModelSource, [string[]]$RunArguments,
                     [bool]$ExpectPass, [string]$Failure = '') {
    $binary = Join-Path $build "$Name.exe"
    $arguments = @('-std=c11','-Wall','-Wextra','-Werror','-pedantic',
                   '-I',$include,$ModelSource,$test,'-o',$binary)
    & gcc @arguments 2>&1 | Set-Content -LiteralPath (Join-Path $evidence "$Name-build.log")
    $buildExit = $LASTEXITCODE
    if ($buildExit -ne 0) { throw "$Name build failed: $buildExit" }
    $output = @(& $binary @RunArguments 2>&1 | ForEach-Object { $_.ToString() })
    $testExit = $LASTEXITCODE
    $output | Set-Content -LiteralPath (Join-Path $evidence "$Name-test.log")
    $met = if ($ExpectPass) { $testExit -eq 0 } else {
        $testExit -ne 0 -and ($output -join "`n").Contains($Failure)
    }
    $records.Add([pscustomobject]@{
        name=$Name; compiler='gcc'; arguments=$arguments; run_arguments=$RunArguments
        model_source=$ModelSource; model_sha256=(Get-FileHash -LiteralPath $ModelSource).Hash.ToLowerInvariant()
        build_exit=$buildExit; test_exit=$testExit; expected_pass=$ExpectPass
        expected_failure=$Failure; expectation_met=$met; output=$output
    })
    Write-Output "$Name build=$buildExit test=$testExit expectation_met=$met"
    if (-not $met) { throw "Unexpected result: $Name" }
}

Invoke-Case 'green' $source @() $true
Invoke-Case 'wrong-expected' $source @('--wrong-expected') $false 'm.current == 1U'
$original = Get-Content -Raw -LiteralPath $source
$mutations = @(
    @{Name='red-reversed-priority'; Old='m->tasks[candidate].priority > m->tasks[best].priority';
      New='m->tasks[candidate].priority < m->tasks[best].priority'; Failure='m.current == 0U'},
    @{Name='red-equal-unblock-strict'; Old='m->tasks[i].priority >= m->tasks[m->current].priority';
      New='m->tasks[i].priority > m->tasks[m->current].priority';
      Failure='Model_Tick(&m) == MODEL_OK && m.current == 0U'}
)
foreach ($mutation in $mutations) {
    if (-not $original.Contains($mutation.Old)) { throw "Mutation anchor missing: $($mutation.Name)" }
    $path = Join-Path $build "$($mutation.Name).c"
    $original.Replace($mutation.Old, $mutation.New) | Set-Content -LiteralPath $path -Encoding utf8
    Invoke-Case $mutation.Name $path @() $false $mutation.Failure
}
Invoke-Case 'final-green' $source @() $true
[pscustomobject]@{
    recorded_at=(Get-Date -Format o)
    scope='Bounded C11 scheduling-model logic only; not tasks.c, Cortex-M exceptions, timing, or hardware'
    model_sha256=(Get-FileHash -LiteralPath $source).Hash.ToLowerInvariant()
    tests_sha256=(Get-FileHash -LiteralPath $test).Hash.ToLowerInvariant()
    records=$records
} | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath (Join-Path $evidence 'host-results.json') -Encoding utf8

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

#ifndef APP_USE_PREEMPTION
#define APP_USE_PREEMPTION 1
#endif
#ifndef APP_USE_TIME_SLICING
#define APP_USE_TIME_SLICING 1
#endif
#define configUSE_PREEMPTION APP_USE_PREEMPTION
#define configUSE_TIME_SLICING APP_USE_TIME_SLICING
#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_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
/* No xPortSysTickHandler alias: interrupts.c supplies the unique wrapper. */
#endif

#ifndef STM32F4XX_HAL_CONF_H
#define STM32F4XX_HAL_CONF_H

#define HAL_MODULE_ENABLED
#define HAL_RCC_MODULE_ENABLED
#define HAL_CORTEX_MODULE_ENABLED
#define HAL_FLASH_MODULE_ENABLED
#define HAL_PWR_MODULE_ENABLED
#define HSI_VALUE 16000000U
/* External clocks are intentionally not selected in this reference. */
#define HSE_VALUE 0U
#define HSE_STARTUP_TIMEOUT 100U
#define LSI_VALUE 32000U
#define LSE_VALUE 0U
#define LSE_STARTUP_TIMEOUT 5000U
#define EXTERNAL_CLOCK_VALUE 0U
#define TICK_INT_PRIORITY 15U
#define USE_RTOS 0U
#define PREFETCH_ENABLE 0U
#define INSTRUCTION_CACHE_ENABLE 1U
#define DATA_CACHE_ENABLE 1U

#include "stm32f4xx_hal_rcc.h"
#include "stm32f4xx_hal_cortex.h"
#include "stm32f4xx_hal_flash.h"
#include "stm32f4xx_hal_pwr.h"
#define assert_param(expr) ((void)0U)
#endif

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

#ifndef APP_EQUAL_PRIORITIES
#define APP_EQUAL_PRIORITIES 0
#endif
#ifndef APP_HIGH_ALWAYS_READY
#define APP_HIGH_ALWAYS_READY 0
#endif
#ifndef APP_HIGH_DO_YIELD
#define APP_HIGH_DO_YIELD 0
#endif
#ifndef APP_LOW_DO_YIELD
#define APP_LOW_DO_YIELD 0
#endif

extern volatile uint32_t g_high_passes;
extern volatile uint32_t g_low_iterations;
extern volatile uint32_t g_high_last_tick;
extern volatile uint32_t g_low_last_tick;
extern volatile uint32_t g_high_state_from_low;
extern volatile uint32_t g_high_stack_free_words;
extern volatile uint32_t g_low_stack_free_words;
uint32_t App_CreateTasks(void);
#endif

#include "FreeRTOS.h"
#include "task.h"
#include "app_tasks.h"
#include "app_fatal.h"
#include <stddef.h>

#define APP_STACK_WORDS UINT32_C(256)
#define APP_HIGH_PRIORITY ((UBaseType_t)(APP_EQUAL_PRIORITIES ? 1U : 2U))

static StackType_t s_high_stack[APP_STACK_WORDS];
static StackType_t s_low_stack[APP_STACK_WORDS];
static StaticTask_t s_high_tcb;
static StaticTask_t s_low_tcb;
static TaskHandle_t s_high_handle;
static TaskHandle_t s_low_handle;
static const uint32_t s_high_delay_ticks = 3U;
static uint32_t s_create_attempted;

volatile uint32_t g_high_passes;
volatile uint32_t g_low_iterations;
volatile uint32_t g_high_last_tick;
volatile uint32_t g_low_last_tick;
volatile uint32_t g_high_state_from_low;
volatile uint32_t g_high_stack_free_words;
volatile uint32_t g_low_stack_free_words;

static void HighEntry(void *argument)
{
    const uint32_t *delay = (const uint32_t *)argument;
    if (delay == NULL || *delay == 0U) {
        App_Fatal(APP_FATAL_PARAMETER, (uint32_t)__LINE__);
    }
    for (;;) {
        ++g_high_passes;
        g_high_last_tick = (uint32_t)xTaskGetTickCount();
        g_high_stack_free_words = (uint32_t)uxTaskGetStackHighWaterMark(NULL);
#if APP_HIGH_ALWAYS_READY
#if APP_HIGH_DO_YIELD
        taskYIELD();
#endif
#else
        vTaskDelay((TickType_t)*delay);
#endif
    }
}

static void LowEntry(void *argument)
{
    (void)argument;
    for (;;) {
        ++g_low_iterations;
        g_low_last_tick = (uint32_t)xTaskGetTickCount();
        g_high_state_from_low = (uint32_t)eTaskGetState(s_high_handle);
        g_low_stack_free_words = (uint32_t)uxTaskGetStackHighWaterMark(NULL);
#if APP_LOW_DO_YIELD
        taskYIELD();
#endif
    }
}

uint32_t App_CreateTasks(void)
{
    if (s_create_attempted != 0U) {
        return 1U;
    }
    s_create_attempted = 1U;
    s_high_handle = xTaskCreateStatic(HighEntry, "High", APP_STACK_WORDS,
                                    (void *)&s_high_delay_ticks, APP_HIGH_PRIORITY,
                                    s_high_stack, &s_high_tcb);
    if (s_high_handle == NULL) {
        return 1U;
    }
    s_low_handle = xTaskCreateStatic(LowEntry, "Low", APP_STACK_WORDS,
                                   NULL, (UBaseType_t)1U,
                                   s_low_stack, &s_low_tcb);
    return s_low_handle == NULL ? 1U : 0U;
}

void vApplicationGetIdleTaskMemory(StaticTask_t **tcb, StackType_t **stack,
                                   uint32_t *depth)
{
    static StaticTask_t idle_tcb;
    static StackType_t idle_stack[configMINIMAL_STACK_SIZE];
    *tcb = &idle_tcb;
    *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 L042_INTERRUPTS_H
#define L042_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(); /* Review ES0182 section 2.1.3 with the actual target revision. */
}
/* SVC/PendSV are supplied by the selected port, not empty application stubs. */

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

volatile uint32_t g_main_phase;

/* Assumes a genuine reset and matching SystemInit, not a bootloader handoff. */
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 HAL version ignores its nested HAL_InitTick return value. */
    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 HAL-to-kernel handoff: no timed HAL calls 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_CreateTasks() != 0U) {
        App_Fatal(APP_FATAL_TASK_CREATE, (uint32_t)__LINE__);
    }
    g_kernel_owns_systick = 1U;
    g_main_phase = 3U;
    vTaskStartScheduler(); /* This port enables interrupts on first-task entry. */
    App_Fatal(APP_FATAL_SCHED_RETURN, (uint32_t)__LINE__);
}

#ifndef L042_APP_FATAL_H
#define L042_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_TASK_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)

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__);
}