第21章：工程实践与系统集成

连续设计 G(s) → 离散化方法选择 → 离散控制器 G(z)
                     ↓
              [前向欧拉/后向欧拉/双线性变换]
                     ↓
              采样周期选择 (Ts)
                     ↓
              量化效应 (ADC/DAC分辨率)
                     ↓
              计算延迟 (1-2个采样周期)

症状：控制量高频抖动，执行器发热
可能原因：
├── 采样频率过高（相对于系统带宽）
├── 微分增益过大
├── 传感器噪声放大
└── 结构共振激发

诊断方法：

1. 频谱分析确定振荡频率
2. 降低控制器带宽测试
3. 增加滤波器或降低微分增益

症状：系统无法达到期望值
可能原因：
├── 积分器未启用或积分增益过小
├── 执行器死区未补偿
├── 模型静态增益错误
└── 传感器偏置

诊断方法：

1. 检查积分项累积值
2. 施加阶跃信号测试静态增益
3. 开环测试执行器特性

症状：系统响应速度远低于仿真
可能原因：
├── 计算延迟未补偿
├── 通信延迟累积
├── 执行器带宽限制
└── 保护逻辑过度限制

诊断方法：

1. 测量端到端延迟
2. 提高采样频率测试
3. 直接驱动执行器测试其响应

// 避免除零和数值溢出
float safe_divide(float num, float den) {
    const float epsilon = 1e-6f;
    if (fabs(den) < epsilon) {
        // 记录错误但继续运行
        log_warning("Division by near-zero: num=%f, den=%f", num, den);
        return (num >= 0) ? FLT_MAX : -FLT_MAX;
    }
    float result = num / den;
    // 饱和保护
    if (result > FLT_MAX/2) return FLT_MAX/2;
    if (result < -FLT_MAX/2) return -FLT_MAX/2;
    // NaN检查
    if (isnan(result)) {
        log_error("NaN detected in division");
        return 0.0f;
    }
    return result;
}

// 积分器防饱和（反windup设计）
typedef struct {
    float integral;
    float max_integral;
    float ki;
    float kb;  // 反windup增益
    float last_output;
    float last_saturated_output;
} IntegratorAntiWindup;

void update_integral(IntegratorAntiWindup* integ, float error, float dt) {
    // 计算反windup修正项
    float windup_correction = integ->kb * 
        (integ->last_saturated_output - integ->last_output);

    // 更新积分项（带反windup）
    float new_integral = integ->integral + 
        (error + windup_correction) * dt;

    // 条件积分：输出饱和时停止积分
    if (fabs(integ->last_saturated_output - integ->last_output) > 0.01f) {
        // 输出已饱和，仅在误差减小方向积分
        if (error * integ->integral < 0) {
            // 误差反向，允许积分
            integ->integral = new_integral;
        }
        // 否则保持积分值不变
    } else {
        // 正常积分
        if (fabs(new_integral * integ->ki) > integ->max_integral) {
            new_integral = integ->max_integral / integ->ki * 
                          (new_integral >= 0 ? 1 : -1);
        }
        integ->integral = new_integral;
    }

    // 更新输出历史
    integ->last_output = integ->integral * integ->ki;
}

typedef enum {
    STATE_INIT,
    STATE_STANDBY,
    STATE_ACTIVE,
    STATE_FAULT,
    STATE_EMERGENCY
} ControllerState;

typedef struct {
    ControllerState current_state;
    uint32_t state_entry_time;
    uint32_t fault_code;
} StateMachine;

void state_transition(StateMachine* sm, ControllerState new_state) {
    // 记录状态转换日志
    log_state_change(sm->current_state, new_state);

    // 检查转换合法性
    if (!is_valid_transition(sm->current_state, new_state)) {
        sm->current_state = STATE_FAULT;
        sm->fault_code = INVALID_STATE_TRANSITION;
        return;
    }

    // 执行退出动作
    execute_exit_action(sm->current_state);

    // 更新状态
    sm->current_state = new_state;
    sm->state_entry_time = get_system_time();

    // 执行进入动作
    execute_entry_action(new_state);
}

┌─────────────────┐         ┌──────────────────┐
│  真实控制器硬件  │ <-----> │   HIL仿真平台     │
│  - 嵌入式处理器 │  信号   │  - 实时仿真器    │
│  - I/O接口     │  接口   │  - 被控对象模型   │
│  - 控制算法     │         │  - 环境模型      │
└─────────────────┘         └──────────────────┘
         ↑                            ↑
         │                            │
    控制信号(u)                  传感器信号(y)

传感器模拟：

- 电压输出：0-10V, ±10V
- 电流输出：4-20mA
- 分辨率：16-bit DAC typical
- 更新率：> 10kHz

执行器接口：

- PWM输入捕获
- 模拟量输入（ADC）
- 编码器仿真

输入保护：
├── 过压保护（TVS二极管）
├── 隔离（光耦、磁隔离）
├── 滤波（EMI/EMC要求）
└── 阻抗匹配

输出驱动：
├── 电流驱动能力
├── 短路保护
├── 回读验证
└── 故障注入能力

# 测试脚本示例
def test_extreme_conditions():
    # 温度扫描
    for temp in range(-40, 125, 5):  # -40°C to 125°C
        set_environment_temp(temp)

        # 参数变化
        for param_var in [0.7, 0.85, 1.0, 1.15, 1.3]:  # ±30%
            set_model_parameters(nominal * param_var)

            # 运行测试序列
            results = run_test_sequence()

            # 验证稳定性和性能
            assert check_stability(results)
            assert check_performance(results, relaxed=True)

需求分析 ────────────────────────── 系统测试
    ↓                                    ↑
系统设计 ──────────────────────── 集成测试
    ↓                                    ↑
详细设计 ────────────────────── 模块测试
    ↓                                    ↑
编码实现 ─────────────────────────────┘

测试层级：

- MIL: 模型级验证（Simulink/Modelica）
- SIL: 代码级验证（主机环境）
- PIL: 处理器在环（目标处理器）
- HIL: 硬件在环（完整系统）

% Simulink代码生成配置
config = coder.config('lib');
config.TargetLang = 'C';
config.OptimizeReductions = 1;
config.ZeroExternalMemoryAtStartup = true;
config.InitFltsAndDblsToZero = true;

% 生成代码
codegen -config config controller_model

% 等效性测试
[sim_out, code_out] = run_equivalence_test();
assert(max(abs(sim_out - code_out)) < 1e-6);

# .gitlab-ci.yml 示例
stages:

  - build
  - test
  - deploy

model_test:
  stage: test
  script:

    - matlab -batch "run_mil_tests"
    - python check_coverage.py --min-coverage 95

code_test:
  stage: test
  script:

    - cmake . && make
    - ./run_sil_tests
    - valgrind --leak-check=full ./controller_test

static_analysis:
  stage: test
  script:

    - cppcheck --enable=all src/
    - polyspace-bug-finder -sources src/

时间不确定性来源：
├── 中断响应延迟（IRQ latency）
├── 调度延迟（Scheduling latency）
├── 缓存未命中（Cache miss）
├── 内存分页（Memory paging）
├── 优先级反转（Priority inversion）
└── 资源竞争（Resource contention）

// 1kHz 快速控制环（最高优先级）
void fast_control_task(void* params) {
    TickType_t xLastWakeTime = xTaskGetTickCount();
    const TickType_t xPeriod = pdMS_TO_TICKS(1);  // 1ms

    while(1) {
        vTaskDelayUntil(&xLastWakeTime, xPeriod);

        // 电流环/力矩控制
        motor_current_t current = read_current_sensors();
        voltage_cmd_t voltage = current_controller(current, current_ref);
        apply_voltage(voltage);

        // 更新状态估计器
        update_fast_estimator(current);
    }
}

// 100Hz 中速控制环
void medium_control_task(void* params) {
    TickType_t xLastWakeTime = xTaskGetTickCount();
    const TickType_t xPeriod = pdMS_TO_TICKS(10);  // 10ms

    while(1) {
        vTaskDelayUntil(&xLastWakeTime, xPeriod);

        // 位置/速度控制
        position_t pos = read_encoders();
        velocity_t vel = calculate_velocity(pos);
        current_ref = position_controller(pos, pos_ref) + 
                     velocity_controller(vel, vel_ref);
    }
}

// 10Hz 慢速规划任务
void planning_task(void* params) {
    TickType_t xLastWakeTime = xTaskGetTickCount();
    const TickType_t xPeriod = pdMS_TO_TICKS(100);  // 100ms

    while(1) {
        vTaskDelayUntil(&xLastWakeTime, xPeriod);

        // 轨迹规划
        trajectory_t traj = plan_trajectory(current_state, goal_state);
        update_reference_generator(traj);
    }
}

// 无锁环形缓冲实现
typedef struct {
    volatile uint32_t head;
    volatile uint32_t tail;
    uint32_t size;
    uint8_t buffer[BUFFER_SIZE];
} RingBuffer;

bool ringbuffer_write(RingBuffer* rb, const void* data, uint32_t len) {
    uint32_t head = rb->head;
    uint32_t tail = rb->tail;
    uint32_t free_space = (tail - head - 1) & (rb->size - 1);

    if (free_space < len) return false;

    // 复制数据
    for (uint32_t i = 0; i < len; i++) {
        rb->buffer[head] = ((uint8_t*)data)[i];
        head = (head + 1) & (rb->size - 1);
    }

    // 内存屏障确保数据写入完成
    __sync_synchronize();
    rb->head = head;
    return true;
}

// 使用硬件定时器获取微秒级时间戳
uint64_t get_timestamp_us(void) {
    static uint64_t overflow_count = 0;
    static uint32_t last_timer_val = 0;

    uint32_t timer_val = TIMER->CNT;

    // 检测溢出
    if (timer_val < last_timer_val) {
        overflow_count++;
    }
    last_timer_val = timer_val;

    return (overflow_count << 32) | timer_val;
}

// 时间同步（用于分布式系统）
typedef struct {
    uint64_t local_time;
    uint64_t master_time;
    int32_t offset;
    uint32_t drift_ppb;  // parts per billion
} TimeSyncState;

void sync_with_master(TimeSyncState* sync) {
    // IEEE 1588 PTP 或 自定义同步协议
    uint64_t t1 = get_timestamp_us();
    uint64_t master_time = request_master_time();
    uint64_t t2 = get_timestamp_us();

    // 假设对称延迟
    uint64_t rtt = t2 - t1;
    uint64_t estimated_master = master_time + rtt/2;

    // 更新偏移和漂移估计
    sync->offset = estimated_master - t2;
    // 使用卡尔曼滤波估计时钟漂移...
}

// 内存池设计
typedef struct {
    uint8_t memory[POOL_SIZE];
    uint32_t free_list[MAX_BLOCKS];
    uint32_t free_count;
    uint32_t block_size;
} MemoryPool;

void* pool_alloc(MemoryPool* pool) {
    if (pool->free_count == 0) return NULL;

    uint32_t block_idx = pool->free_list[--pool->free_count];
    return &pool->memory[block_idx * pool->block_size];
}

void pool_free(MemoryPool* pool, void* ptr) {
    uint32_t offset = (uint8_t*)ptr - pool->memory;
    uint32_t block_idx = offset / pool->block_size;

    pool->free_list[pool->free_count++] = block_idx;
}

// 栈使用监控
#define STACK_CANARY 0xDEADBEEF

void check_stack_usage(TaskHandle_t task) {
    uint32_t* stack_top = (uint32_t*)task->stack_base;
    uint32_t unused = 0;

    while (*stack_top++ == STACK_CANARY) {
        unused += 4;
    }

    log_debug("Task %s: %d bytes unused stack", 
             task->name, unused);
}

概念阶段
    ↓
危害分析与风险评估(HARA)
    ↓
功能安全概念
    ↓
技术安全概念
    ↓
硬件/软件开发
    ↓
集成与测试
    ↓
安全验证
    ↓
生产发布
    ↓
运行、服务与退役

typedef struct {
    float channel_a_output;
    float channel_b_output;
    bool discrepancy_flag;
    uint32_t discrepancy_count;
} DualChannelMonitor;

bool check_dual_channel(DualChannelMonitor* mon) {
    float diff = fabs(mon->channel_a_output - mon->channel_b_output);
    float threshold = 0.01f * fmax(fabs(mon->channel_a_output), 
                                   fabs(mon->channel_b_output));

    if (diff > threshold) {
        mon->discrepancy_count++;
        if (mon->discrepancy_count > 3) {
            mon->discrepancy_flag = true;
            trigger_safe_state();
            return false;
        }
    } else {
        mon->discrepancy_count = 0;
        mon->discrepancy_flag = false;
    }
    return true;
}

typedef struct {
    uint32_t window_min;
    uint32_t window_max;
    uint32_t counter;
    bool armed;
} WindowWatchdog;

void watchdog_refresh(WindowWatchdog* wd) {
    uint32_t current_time = get_system_time();

    // 窗口看门狗：太早或太晚刷新都触发复位
    if (wd->armed) {
        if (current_time < wd->window_min) {
            // 刷新太早
            system_reset("Watchdog early refresh");
        } else if (current_time > wd->window_max) {
            // 刷新太晚
            system_reset("Watchdog timeout");
        }
    }

    // 正常刷新
    wd->counter = 0;
    wd->window_min = current_time + WD_MIN_PERIOD;
    wd->window_max = current_time + WD_MAX_PERIOD;
    wd->armed = true;
}

攻击向量：
├── 物理访问
│   ├── USB/串口调试接口
│   ├── JTAG/SWD接口
│   └── 侧信道攻击
├── 网络攻击
│   ├── 中间人攻击(MITM)
│   ├── 拒绝服务(DoS)
│   ├── 重放攻击
│   └── 注入攻击
└── 供应链攻击
    ├── 恶意固件
    ├── 硬件木马
    └── 后门植入

typedef struct {
    uint8_t signature[256];  // RSA-2048签名
    uint32_t version;
    uint32_t size;
    uint8_t hash[32];        // SHA-256哈希
} FirmwareHeader;

bool verify_firmware(const uint8_t* firmware, size_t size) {
    FirmwareHeader* header = (FirmwareHeader*)firmware;

    // 验证版本防回滚
    if (header->version < get_min_firmware_version()) {
        return false;
    }

    // 验证哈希
    uint8_t calculated_hash[32];
    sha256(firmware + sizeof(FirmwareHeader), 
           header->size, calculated_hash);
    if (memcmp(calculated_hash, header->hash, 32) != 0) {
        return false;
    }

    // 验证签名
    return rsa_verify(header->hash, 32, 
                     header->signature, 256, 
                     get_public_key());
}

// 使用AES-GCM提供机密性和完整性
typedef struct {
    uint8_t key[32];      // AES-256密钥
    uint8_t iv[12];       // 初始化向量
    uint32_t counter;     // 防重放计数器
} SecureChannel;

bool secure_send(SecureChannel* ch, const uint8_t* data, 
                size_t len, uint8_t* output) {
    // 防重放：递增计数器
    ch->counter++;

    // 构造附加认证数据(AAD)
    uint8_t aad[8];
    memcpy(aad, &ch->counter, 4);
    memcpy(aad + 4, &len, 4);

    // AES-GCM加密
    uint8_t tag[16];
    aes_gcm_encrypt(ch->key, ch->iv, 
                   data, len,
                   aad, sizeof(aad),
                   output, tag);

    // 附加认证标签
    memcpy(output + len, tag, 16);
    return true;
}

class AnomalyDetector:
    def __init__(self, window_size=1000):
        self.window_size = window_size
        self.history = deque(maxlen=window_size)
        self.baseline_stats = None

    def update_baseline(self, normal_data):
        """使用正常运行数据建立基线"""
        self.baseline_stats = {
            'mean': np.mean(normal_data, axis=0),
            'std': np.std(normal_data, axis=0),
            'cov': np.cov(normal_data.T)
        }

    def detect_anomaly(self, sample):
        """马氏距离异常检测"""
        if self.baseline_stats is None:
            return False

        diff = sample - self.baseline_stats['mean']
        md = np.sqrt(diff.T @ np.linalg.inv(self.baseline_stats['cov']) @ diff)

        # 阈值基于卡方分布
        threshold = chi2.ppf(0.99, df=len(sample))
        return md > threshold

云端服务器
    ↓ (HTTPS/TLS)
车载网关(TCU)
    ↓ (车内CAN/Ethernet)
域控制器
    ├── 自动驾驶计算平台(FSD Computer)
    ├── 车身控制模块(BCM)
    ├── 动力系统控制(Powertrain)
    └── 信息娱乐系统(MCU)

typedef struct {
    uint32_t version_a;
    uint32_t version_b;
    bool active_partition;  // 0=A, 1=B
    uint32_t boot_count;
    uint32_t rollback_count;
} BootloaderConfig;

void ota_update_handler(const uint8_t* update_package) {
    BootloaderConfig* config = get_bootloader_config();

    // 写入非活动分区
    bool target_partition = !config->active_partition;
    if (write_firmware_partition(target_partition, update_package)) {
        // 验证新固件
        if (verify_partition(target_partition)) {
            // 切换到新分区
            config->active_partition = target_partition;
            config->boot_count = 0;
            system_reboot();
        } else {
            // 验证失败，保持原分区
            log_error("Firmware verification failed");
        }
    }
}

def generate_delta_update(old_version, new_version):
    """生成二进制差分更新包"""
    # 使用bsdiff算法生成差分
    delta = bsdiff(old_version, new_version)

    # 压缩差分数据
    compressed = zstd.compress(delta, level=19)

    # 添加元数据
    update_package = {
        'from_version': hash(old_version),
        'to_version': hash(new_version),
        'delta_size': len(compressed),
        'delta_data': compressed,
        'signature': sign(compressed)
    }

    return update_package

void boot_health_check(void) {
    BootloaderConfig* config = get_bootloader_config();

    // 增加启动计数
    config->boot_count++;

    // 检查启动是否成功
    if (config->boot_count > MAX_BOOT_ATTEMPTS) {
        // 启动失败次数过多，回滚
        config->active_partition = !config->active_partition;
        config->rollback_count++;
        config->boot_count = 0;

        log_critical("Rollback triggered after %d failed boots", 
                    MAX_BOOT_ATTEMPTS);
        system_reboot();
    }

    // 正常启动后清零计数器
    if (system_health_check_passed()) {
        config->boot_count = 0;
    }
}