ISO 26262-6 软件级开发：编写安全的代码

应用层（Application Layer）
    ├── 制动控制模块
    │   ├── 压力控制算法
    │   ├── 车轮速度控制
    │   └── 车辆稳定性控制
    │
    ├── 故障诊断模块
    │   ├── 传感器故障诊断
    │   ├── 执行器故障诊断
    │   └── 系统故障诊断
    │
    ├── 安全管理模块
    │   ├── 故障处理逻辑
    │   ├── 安全状态管理
    │   └── 故障记录
    │
    └── 通信模块
        ├── CAN 通信
        └── 诊断服务
    │
中间件层（Middleware Layer）
    ├── 操作系统抽象层（OSAL）
    │   ├── 任务调度
    │   ├── 事件管理
    │   └── 定时器管理
    │
    ├── 通信层（Communication Layer）
    │   ├── CAN 驱动
    │   ├── SPI 驱动
    │   └── LIN 驱动
    │
    └── 存储层（Storage Layer）
        ├── EEPROM 驱动
        └── Flash 驱动
    │
硬件抽象层（HAL）
    ├── ADC 驱动
    ├── GPIO 驱动
    ├── PWM 驱动
    ├── 定时器驱动
    └── 看门狗驱动
    │
硬件层（Hardware Layer）
    ├── MCU
    ├── 传感器
    ├── 执行器
    └── 电源管理

// 制动控制模块接口
typedef struct {
    float pedal_position;      // 制动踏板位置（0-1）
    float vehicle_speed;       // 车辆速度（km/h）
    float wheel_speeds[4];     // 车轮速度（km/h）
} BrakingControlInput;

typedef struct {
    float target_pressure;     // 目标制动压力（bar）
    float valve_command[4];     // 阀门控制指令（0-1）
} BrakingControlOutput;

// 函数原型
void BrakingControl_Init(void);
void BrakingControl_Run(const BrakingControlInput* input, BrakingControlOutput* output);

// 故障诊断模块接口
typedef enum {
    FAULT_NONE = 0,
    FAULT_SENSOR_OPEN,
    FAULT_SENSOR_SHORT,
    FAULT_SENSOR_DRIFT,
    FAULT_ACTUATOR_STUCK,
    FAULT_WATCHDOG_TIMEOUT
} FaultType;

typedef struct {
    FaultType fault_type;
    uint8_t component_id;
    uint32_t timestamp;
} FaultEvent;

// 函数原型
void FaultDiagnosis_Init(void);
void FaultDiagnosis_Run(void);
bool FaultDiagnosis_GetFault(FaultEvent* event);

// 定义常量
#define MAX_PRESSURE 100.0f
#define MIN_PRESSURE 0.0f
#define SAMPLING_PERIOD_MS 10U

// 函数原型
static bool ValidatePressure(float pressure);
static void UpdateWatchdog(void);

// 主控制函数
void BrakingControl_Run(const BrakingControlInput* input, BrakingControlOutput* output)
{
    float target_pressure = 0.0f;
    float pedal_position = 0.0f;

    // 输入检查
    if (input == NULL || output == NULL)
    {
        return;
    }

    // 读取踏板位置
    pedal_position = input->pedal_position;

    // 限制踏板位置范围
    if (pedal_position < 0.0f)
    {
        pedal_position = 0.0f;
    }
    else if (pedal_position > 1.0f)
    {
        pedal_position = 1.0f;
    }

    // 计算目标压力
    target_pressure = pedal_position * MAX_PRESSURE;

    // 验证压力
    if (ValidatePressure(target_pressure) == false)
    {
        target_pressure = 0.0f;
    }

    // 设置输出
    output->target_pressure = target_pressure;

    // 更新看门狗
    UpdateWatchdog();
}

// 验证压力
static bool ValidatePressure(float pressure)
{
    bool is_valid = false;

    if ((pressure >= MIN_PRESSURE) && (pressure <= MAX_PRESSURE))
    {
        is_valid = true;
    }

    return is_valid;
}

// 更新看门狗
static void UpdateWatchdog(void)
{
    // 喂狗
    FeedWatchdog();
}

#include <unity.h>
#include "BrakingControl.h"

void setUp(void)
{
    // 初始化
    BrakingControl_Init();
}

void tearDown(void)
{
    // 清理
}

// 测试用例 1：正常输入
void test_BrakingControl_NormalInput(void)
{
    BrakingControlInput input = {0};
    BrakingControlOutput output = {0};

    input.pedal_position = 0.5f;

    BrakingControl_Run(&input, &output);

    TEST_ASSERT_EQUAL_FLOAT(50.0f, output.target_pressure);
}

// 测试用例 2：踏板位置超出上限
void test_BrakingControl_PedalPositionExceedsMaximum(void)
{
    BrakingControlInput input = {0};
    BrakingControlOutput output = {0};

    input.pedal_position = 1.5f;

    BrakingControl_Run(&input, &output);

    TEST_ASSERT_EQUAL_FLOAT(100.0f, output.target_pressure);
}

// 测试用例 3：踏板位置超出下限
void test_BrakingControl_PedalPositionExceedsMinimum(void)
{
    BrakingControlInput input = {0};
    BrakingControlOutput output = {0};

    input.pedal_position = -0.5f;

    BrakingControl_Run(&input, &output);

    TEST_ASSERT_EQUAL_FLOAT(0.0f, output.target_pressure);
}

// 测试用例 4：NULL 输入
void test_BrakingControl_NullInput(void)
{
    BrakingControlOutput output = {0};

    BrakingControl_Run(NULL, &output);

    TEST_ASSERT_EQUAL_FLOAT(0.0f, output.target_pressure);
}

应用层
    ├── 传感器融合模块
    │   ├── EKF 算法
    │   ├── 数据融合
    │   └── 状态估计
    │
    ├── 碰撞检测模块
    │   ├── TTC 计算
    │   ├── 风险评估
    │   └── 决策逻辑
    │
    ├── 制动控制模块
    │   ├── 制动策略
    │   ├── 压力控制
    │   └── 阀门控制
    │
    └── 故障诊断模块
        ├── 传感器故障诊断
        ├── 执行器故障诊断
        └── 系统故障诊断
    │
中间件层
    ├── 操作系统抽象层（OSAL）
    ├── 通信层（Communication Layer）
    └── 存储层（Storage Layer）
    │
硬件抽象层（HAL）
    ├── 摄像头驱动
    ├── 雷达驱动
    ├── 超声波驱动
    └── 制动执行器驱动
    │
硬件层
    ├── 摄像头
    ├── 雷达
    ├── 超声波传感器
    └── 制动执行器

// 定义常量
#define MAX_TTC 5.0f
#define MIN_DISTANCE 5.0f

// 数据结构
typedef struct {
    float distance;          // 距离（m）
    float relative_speed;     // 相对速度（km/h）
    float ttc;                // 碰撞时间（s）
} CollisionRisk;

// 函数原型
static float CalculateTTC(float distance, float relative_speed);
static bool AssessCollisionRisk(const CollisionRisk* risk);

// 主函数
void CollisionDetection_Run(void)
{
    CollisionRisk risk = {0};
    float distance = 0.0f;
    float relative_speed = 0.0f;

    // 读取传感器数据
    SensorFusion_GetData(&distance, &relative_speed);

    // 计算 TTC
    risk.ttc = CalculateTTC(distance, relative_speed);

    // 评估碰撞风险
    if (AssessCollisionRisk(&risk) == true)
    {
        // 触发制动
        BrakingControl_Trigger();
    }
}

// 计算 TTC
static float CalculateTTC(float distance, float relative_speed)
{
    float ttc = MAX_TTC;

    if (relative_speed > 0.0f)
    {
        ttc = distance / (relative_speed / 3.6f);  // km/h 转换为 m/s

        // 限制 TTC 范围
        if (ttc > MAX_TTC)
        {
            ttc = MAX_TTC;
        }
    }

    return ttc;
}

// 评估碰撞风险
static bool AssessCollisionRisk(const CollisionRisk* risk)
{
    bool is_collision = false;

    if (risk->distance < MIN_DISTANCE)
    {
        is_collision = true;
    }
    else if (risk->ttc < 2.0f)
    {
        is_collision = true;
    }

    return is_collision;
}

#include <unity.h>
#include "CollisionDetection.h"

void setUp(void)
{
    // 初始化
    CollisionDetection_Init();
}

void tearDown(void)
{
    // 清理
}

// 测试用例 1：正常情况，无碰撞风险
void test_CollisionDetection_NoCollision(void)
{
    CollisionRisk risk = {0};

    risk.distance = 50.0f;
    risk.relative_speed = 10.0f;
    risk.ttc = 18.0f;

    bool is_collision = AssessCollisionRisk(&risk);

    TEST_ASSERT_FALSE(is_collision);
}

// 测试用例 2：距离小于最小距离
void test_CollisionDetection_DistanceTooSmall(void)
{
    CollisionRisk risk = {0};

    risk.distance = 3.0f;
    risk.relative_speed = 10.0f;
    risk.ttc = 1.08f;

    bool is_collision = AssessCollisionRisk(&risk);

    TEST_ASSERT_TRUE(is_collision);
}

// 测试用例 3：TTC 小于阈值
void test_CollisionDetection_TTCTooSmall(void)
{
    CollisionRisk risk = {0};

    risk.distance = 10.0f;
    risk.relative_speed = 30.0f;
    risk.ttc = 1.2f;

    bool is_collision = AssessCollisionRisk(&risk);

    TEST_ASSERT_TRUE(is_collision);
}

cov-build --dir cov-int make
cov-analyze --dir cov-int --enable-concurrency-fb
cov-format-errors --dir cov-int

// 修复空指针解引用
static bool AssessCollisionRisk(const CollisionRisk* risk)
{
    bool is_collision = false;

    // 添加空指针检查
    if (risk == NULL)
    {
        return false;
    }

    if (risk->distance < MIN_DISTANCE)
    {
        is_collision = true;
    }
    else if (risk->ttc < 2.0f)
    {
        is_collision = true;
    }

    return is_collision;
}