┌─────────────────────────────────────────────────────────────┐
│                    应用层（控制算法、诊断）                    │
├─────────────────────────────────────────────────────────────┤
│  状态同步漂移补偿层  ◄── 核心创新点                           │
│  ├─ 时间戳对齐 + 卡尔曼预测 + 增量校验                        │
│  └─ 输出：漂移修正后的“虚拟当前状态”                          │
├─────────────────────────────────────────────────────────────┤
│  确定性通信层（TTCAN / TSN / EtherCAT DC）                    │
│  ├─ 静态时隙调度、抖动 < 1 μs                                 │
│  └─ 支持“单帧多主”热备组播                                    │
├─────────────────────────────────────────────────────────────┤
│  零拷贝内存映射层（MPU 区域 + DMA 双缓冲）                    │
│  └─ 物理内存共享，切换仅需修改 MPU 属性 + 翻转 DMA 指针       │
└─────────────────────────────────────────────────────────────┘

/* 状态向量定义：[位置, 速度, 电流, 温度, 故障标志] */
typedef struct { q31_t pos, vel, cur, tmp; uint16_t flt; } StateVec_t;

/* 卡尔曼定点数上下文（离线配置 Q, R, P0） */
typedef struct {
    arm_matrix_instance_q31 A, B, H, Q, R, P, K;
    StateVec_t x_hat;          // 后验估计
} KF_Ctx_t;

/* 单周期补偿入口：在通讯中断 ISR 尾部调用 */
void DriftCompensate_Update(const StateVec_t *master_raw,
                            uint32_t master_ts,   // 主节点硬件时间戳
                            uint32_t local_ts)    // 本地捕获时间戳
{
    /* S1: 时间戳对齐 → 线性插值得到 t_aligned 处的状态 */
    StateVec_t aligned = LinearInterp_State(master_raw, master_ts, local_ts);

    /* S2: 卡尔曼预测 Δ = 1 个控制周期（如 100 μs） */
    StateVec_t predicted;
    KF_Predict_Q31(&kf_ctx, &aligned, &predicted);  // CMSIS-DSP 定点版

    /* S3: 增量校验 */
    q63_t diff_norm = Vec_Dist_Q31(&predicted, &local_state);
    if (diff_norm > DRIFT_THRESHOLD_Q31) {
        Diag_Report(DRIFT_WARN, diff_norm);
        /* 策略：加权融合而非硬覆盖，避免阶跃 */
        local_state = Weighted_Fuse(&local_state, &predicted, 0.7f);
    } else {
        local_state = predicted;  // 正常采纳
    }
}

物理地址 0x2000_0000 ~ 0x2000_FFFF (64 KB 共享池)
   │
   ├─ 别名 A (0x6000_0000) → 主节点独占 RW，备用节点 RO
   └─ 别名 B (0x6001_0000) → 备用节点独占 RW，主节点 RO

/* 共享池布局 */
typedef struct {
    StateVec_t  buf[2];      // 双缓冲
    volatile uint8_t active; // 0/1 指示当前生效缓冲
    uint32_t    seq;         // 单调递增序列号，防 ABA
} SharedPool_t;

__attribute__((section(".shared_ram"))) SharedPool_t g_pool;

/* 主节点写入路径（周期性任务） */
void Master_WriteState(const StateVec_t *src)
{
    uint8_t nxt = g_pool.active ^ 1;
    memcpy(&g_pool.buf[nxt], src, sizeof(StateVec_t));
    __DMB();                    // 确保写完成
    g_pool.seq++;
    g_pool.active = nxt;        // 原子翻转（单指令）
}

/* 备用节点读取路径（零拷贝） */
const StateVec_t* Backup_ReadState(uint32_t *out_seq)
{
    uint8_t cur = g_pool.active;
    *out_seq = g_pool.seq;
    return &g_pool.buf[cur];    // 直接返回指针，无 memcpy
}

/* 1. M4 监控 M7 硬件看门狗 (HWWDG) - 窗口模式 */
HAL_WWDG_Init(&hwwdg);                    // 窗口值 0x5F, 计数器 0x7F → 约 1.2 ms 窗口
__HAL_WWDG_ENABLE_IT(&hwwdg, WWDG_IT_EWI); // 早期唤醒中断 → M4 介入决策

/* 2. M7 监控 M4 生命信号 - 通过 HSEM 信号量 + GPIO 翻转 */
void M7_Monitor_M4_Task(void) {
    if (HAL_HSEM_Take(SEM_M4_ALIVE, 0) == HAL_OK) {
        uint32_t tick = HAL_GetTick();
        if (tick - g_m4_last_tick > M4_HEARTBEAT_TIMEOUT_MS) {
            Trigger_Failover_To_Backup(); // 直接写备用核 GPIO 引脚
        }
        g_m4_last_tick = tick;
        HAL_HSEM_Release(SEM_M4_ALIVE, 0);
    }
}

/* 3. 双核共享 ECC RAM 错误注入测试 - 必须在 CI 跑通 */
SCB->ICIALLU = 0;  // 清指令缓存
__DSB(); __ISB();
RAM_ECC->CR |= RAM_ECC_CR_ECCIE;  // 使能 ECC 中断
NVIC_EnableIRQ(RAM_ECC_IRQn);     // 中断里直接判单/双比特错，双比特错硬复位

/* 从节点本地安全状态机（裸机/RTOS 均适用） */
typedef enum { S_INIT, S_SYNC_OK, S_COMM_LOST, S_LOCAL_SAFE, S_WAIT_RECOVER } SlaveState_t;

void Comm_Watchdog_ISR(void) {  // 由硬件定时器触发，周期 = 2 * TTCAN 周期
    if (g_comm_lost_cnt++ > 3) {  // 连续 3 个周期无 SYNC 帧
        g_slave_state = S_COMM_LOST;
        Motor_FOC_SetTorque(0);   // 硬件级 PWM 死区插入，0 转矩
        GPIO_WritePin(SAFE_STATE_LED, SET);
    }
}

void TTCAN_Sync_RX_Callback(void) {
    g_comm_lost_cnt = 0;
    if (g_slave_state == S_COMM_LOST) g_slave_state = S_WAIT_RECOVER;
}

/* 主循环处理恢复逻辑 */
void Slave_MainLoop(void) {
    if (g_slave_state == S_WAIT_RECOVER) {
        if (Validate_Master_State_Integrity()) { // 校验主控下发的状态 CRC + 序列号
            Motor_FOC_Restore_State(g_master_state); // 平滑恢复电流环积分项
            g_slave_state = S_SYNC_OK;
        }
    }
}

/* 定义在 .noinit 段，复位不清零 */
typedef struct {
    uint64_t timestamp;      // 64-bit 全局时间基 (PTP 同步)
    StateVec_t state;        // 切换瞬间完整状态
    uint32_t decision_flag;  // BIT0:漂移超阈 BIT1:心跳丢失 BIT2:ECC双比特错
    uint16_t seq;            // 单调递增
    uint16_t crc16;          // 自校验
} DiagEvent_t;

__attribute__((section(".diag_ram.noinit"))) 
DiagEvent_t g_diag_ring[DIAG_RING_DEPTH]; // DIAG_RING_DEPTH = 1024 (2的幂)
__attribute__((section(".diag_ram.noinit"))) 
volatile uint32_t g_diag_head = 0;        // 仅 ISR 写，主循环读

/* ISR 中调用，耗时 < 20 cycles */
void Diag_RecordEvent(uint32_t flag, const StateVec_t *st) {
    uint32_t idx = atomic_fetch_add_explicit(&g_diag_head, 1, memory_order_relaxed) & (DIAG_RING_DEPTH - 1);
    DiagEvent_t *e = &g_diag_ring[idx];
    e->timestamp = PTP_GetTime64();
    e->state = *st;
    e->decision_flag = flag;
    e->seq = g_global_seq++;
    e->crc16 = CRC16_CCITT((uint8_t*)e, offsetof(DiagEvent_t, crc16));
}

/* 上电自检：打印最近 10 条事件 */
void Diag_DumpRecent(uint32_t count) {
    uint32_t head = atomic_load_explicit(&g_diag_head, memory_order_relaxed);
    for (int i = 0; i < count && i < DIAG_RING_DEPTH; i++) {
        uint32_t idx = (head - 1 - i) & (DIAG_RING_DEPTH - 1);
        if (g_diag_ring[idx].crc16 == CRC16_CCITT(...)) {
            Log_Printf("[%llu] Flag=0x%X Seq=%u Pos=%d Vel=%dn", ...);
        }
    }
}

# .gitlab-ci.yml 片段
stages:
  - static_analysis
  - unit_test
  - hil_nightly

hil_fault_injection:
  stage: hil_nightly
  tags: [hil-lab-01]
  variables:
    TARGET: "STM32H747_DUAL"
    TEST_SUITE: "failover_iso26262"
  script:
    - python -m pytest hil/tests/test_failover.py --junitxml=report.xml 
        --html=report.html --self-contained-html 
        --fault-matrix=config/fault_matrix_asild.csv
    - python tools/parse_hil_report.py report.xml --threshold=PASS_RATE=100
  artifacts:
    when: always
    reports:
      junit: report.xml
    expire_in: 30 days
  rules:
    - if: $CI_PIPELINE_SOURCE == "schedule"  # 每晚 02:00 自动跑