引言
在汽车电子系统中，功能安全是至关重要的。随着汽车智能化程度的提高，ECU需要满足ISO 26262等功能安全标准的要求。YTM32B1ME0x集成了丰富的安全特性，包括硬件安全模块、故障检测与诊断、内存保护、时钟监控等功能，为汽车应用提供了全面的安全保障。
功能安全概述
ISO 26262标准要求
YTM32B1ME0x的安全特性设计遵循ISO 26262标准：
| 安全等级 | ASIL等级 | 故障率要求 | 主要应用 |
|---|---|---|---|
| QM | 无安全要求 | - | 信息娱乐系统 |
| ASIL A | 低安全要求 | <10^-6/h | 尾灯控制 |
| ASIL B | 中等安全要求 | <10^-7/h | 仪表显示 |
| ASIL C | 高安全要求 | <10^-8/h | 安全气囊 |
| ASIL D | 最高安全要求 | <10^-9/h | 制动系统 |
安全架构设计
┌─────────────────────────────────────┐ │ 安全监控系统 │ │ Safety Monitor & Diagnostics │ └─────────────────┬───────────────────┘ │ ┌─────────────────────────────┼─────────────────────────────┐ │ │ │ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ 硬件 │ │ 内存 │ │ 时钟 │ │ 安全 │ │ 保护 │ │ 监控 │ │ 模块 │ │ 单元 │ │ 系统 │ └─────────┘ └─────────┘ └─────────┘ │ │ │ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ ECC │ │ MPU │ │ WDT │ │ 错误 │ │ 访问 │ │ 看门狗 │ │ 检测 │ │ 控制 │ │ 定时器 │ └─────────┘ └─────────┘ └─────────┘ │ │ │ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ CRC │ │ 堆栈 │ │ 电压 │ │ 校验 │ │ 监控 │ │ 监控 │ │ 单元 │ │ 器 │ │ 器 │ └─────────┘ └─────────┘ └─────────┘
硬件安全模块（HSM）
HSM核心功能
YTM32B1ME0x集成的硬件安全模块提供以下功能：
安全特性：
-
真随机数生成器: 硬件TRNG
-
加密引擎: AES-128/256, DES/3DES
-
哈希算法: SHA-1, SHA-256
-
密钥管理: 安全密钥存储和管理
-
安全启动: 验证固件完整性
-
防篡改检测: 物理攻击检测
HSM配置与使用
// HSM配置结构
typedef struct {
bool trng_enable; // 真随机数生成器使能
bool aes_enable; // AES加密使能
bool sha_enable; // SHA哈希使能
bool secure_boot_enable; // 安全启动使能
bool tamper_detection_enable; // 防篡改检测使能
uint32_t key_slots; // 密钥槽配置
} hsm_config_t;
// HSM初始化
void hsm_init(HSM_Type *hsm, hsm_config_t *config) {
// 使能HSM时钟
enable_hsm_clock();
// 配置TRNG
if (config->trng_enable) {
hsm->TRNG_CR |= HSM_TRNG_CR_RNGEN;
// 等待TRNG就绪
while (!(hsm->TRNG_SR & HSM_TRNG_SR_DRDY));
}
// 配置AES引擎
if (config->aes_enable) {
hsm->AES_CR |= HSM_AES_CR_EN;
}
// 配置SHA引擎
if (config->sha_enable) {
hsm->SHA_CR |= HSM_SHA_CR_EN;
}
// 配置安全启动
if (config->secure_boot_enable) {
hsm->BOOT_CR |= HSM_BOOT_CR_SECURE_EN;
}
// 配置防篡改检测
if (config->tamper_detection_enable) {
hsm->TAMPER_CR |= HSM_TAMPER_CR_TAMP1E | HSM_TAMPER_CR_TAMP2E;
// 使能防篡改中断
hsm->TAMPER_IER |= HSM_TAMPER_IER_TAMP1IE | HSM_TAMPER_IER_TAMP2IE;
NVIC_EnableIRQ(TAMPER_IRQn);
}
// 配置密钥槽
configure_key_slots(hsm, config->key_slots);
}
// 真随机数生成
uint32_t hsm_generate_random(HSM_Type *hsm) {
// 等待随机数就绪
while (!(hsm->TRNG_SR & HSM_TRNG_SR_DRDY));
// 检查错误
if (hsm->TRNG_SR & (HSM_TRNG_SR_SECS | HSM_TRNG_SR_CECS)) {
// 清除错误标志
hsm->TRNG_SR |= HSM_TRNG_SR_SECS | HSM_TRNG_SR_CECS;
return 0; // 错误返回
}
return hsm->TRNG_DR;
}
// AES加密
hsm_status_t hsm_aes_encrypt(HSM_Type *hsm, const uint8_t *key,
const uint8_t *plaintext, uint8_t *ciphertext,
uint32_t length, aes_mode_t mode) {
// 配置AES模式
hsm->AES_CR = (hsm->AES_CR & ~HSM_AES_CR_MODE_MASK) |
HSM_AES_CR_MODE(mode);
// 配置密钥长度
hsm->AES_CR = (hsm->AES_CR & ~HSM_AES_CR_KEYSIZE_MASK) |
HSM_AES_CR_KEYSIZE_128;
// 加载密钥
for (int i = 0; i < 4; i++) {
hsm->AES_KEYR[i] = ((uint32_t*)key)[i];
}
// 使能AES
hsm->AES_CR |= HSM_AES_CR_EN;
// 处理数据块
uint32_t blocks = length / 16;
for (uint32_t i = 0; i < blocks; i++) {
// 输入数据
for (int j = 0; j < 4; j++) {
hsm->AES_DINR = ((uint32_t*)plaintext)[i * 4 + j];
}
// 等待处理完成
while (!(hsm->AES_SR & HSM_AES_SR_CCF));
// 读取输出
for (int j = 0; j < 4; j++) {
((uint32_t*)ciphertext)[i * 4 + j] = hsm->AES_DOUTR;
}
// 清除完成标志
hsm->AES_CR |= HSM_AES_CR_CCFC;
}
// 禁用AES
hsm->AES_CR &= ~HSM_AES_CR_EN;
return HSM_STATUS_OK;
}
// SHA哈希计算
hsm_status_t hsm_sha256_compute(HSM_Type *hsm, const uint8_t *data,
uint32_t length, uint8_t *hash) {
// 配置SHA-256模式
hsm->SHA_CR = (hsm->SHA_CR & ~HSM_SHA_CR_ALGO_MASK) |
HSM_SHA_CR_ALGO_SHA256;
// 使能SHA
hsm->SHA_CR |= HSM_SHA_CR_EN;
// 初始化
hsm->SHA_CR |= HSM_SHA_CR_INIT;
// 处理数据
uint32_t remaining = length;
const uint8_t *ptr = data;
while (remaining > 0) {
uint32_t chunk_size = (remaining >= 64) ? 64 : remaining;
// 输入数据
for (uint32_t i = 0; i < chunk_size; i += 4) {
uint32_t word = 0;
for (int j = 0; j < 4 && (i + j) < chunk_size; j++) {
word |= (ptr[i + j] << (j * 8));
}
hsm->SHA_DIN = word;
}
// 如果是最后一块，设置最终标志
if (remaining <= 64) {
hsm->SHA_CR |= HSM_SHA_CR_DCAL;
}
// 等待处理完成
while (!(hsm->SHA_SR & HSM_SHA_SR_DCIS));
ptr += chunk_size;
remaining -= chunk_size;
}
// 等待哈希计算完成
while (!(hsm->SHA_SR & HSM_SHA_SR_DCIS));
// 读取哈希值
for (int i = 0; i < 8; i++) {
((uint32_t*)hash)[i] = hsm->SHA_HR[i];
}
// 禁用SHA
hsm->SHA_CR &= ~HSM_SHA_CR_EN;
return HSM_STATUS_OK;
}
安全启动实现
// 安全启动配置
typedef struct {
uint8_t root_key[32]; // 根密钥
uint8_t firmware_hash[32]; // 固件哈希
uint32_t firmware_size; // 固件大小
uint32_t firmware_version; // 固件版本
bool rollback_protection; // 回滚保护
} secure_boot_config_t;
// 固件签名结构
typedef struct {
uint8_t signature[256]; // RSA-2048签名
uint8_t hash[32]; // SHA-256哈希
uint32_t size; // 固件大小
uint32_t version; // 版本号
uint32_t timestamp; // 时间戳
uint32_t crc32; // CRC32校验
} firmware_signature_t;
// 安全启动验证
boot_status_t secure_boot_verify(HSM_Type *hsm, const uint8_t *firmware,
uint32_t firmware_size,
const firmware_signature_t *signature) {
uint8_t calculated_hash[32];
// 计算固件哈希
if (hsm_sha256_compute(hsm, firmware, firmware_size, calculated_hash) != HSM_STATUS_OK) {
return BOOT_STATUS_HASH_ERROR;
}
// 验证哈希
if (memcmp(calculated_hash, signature->hash, 32) != 0) {
return BOOT_STATUS_HASH_MISMATCH;
}
// 验证大小
if (firmware_size != signature->size) {
return BOOT_STATUS_SIZE_MISMATCH;
}
// 验证版本（防回滚）
uint32_t stored_version = get_stored_firmware_version();
if (signature->version < stored_version) {
return BOOT_STATUS_ROLLBACK_DETECTED;
}
// 验证CRC32
uint32_t calculated_crc = calculate_crc32(firmware, firmware_size);
if (calculated_crc != signature->crc32) {
return BOOT_STATUS_CRC_ERROR;
}
// 验证RSA签名（简化实现）
if (!verify_rsa_signature(signature->signature, calculated_hash)) {
return BOOT_STATUS_SIGNATURE_INVALID;
}
// 更新存储的版本号
store_firmware_version(signature->version);
return BOOT_STATUS_OK;
}
// 防篡改检测中断处理
void TAMPER_IRQHandler(void) {
HSM_Type *hsm = HSM;
if (hsm->TAMPER_ISR & HSM_TAMPER_ISR_TAMP1F) {
// 检测到篡改1
hsm->TAMPER_ICR |= HSM_TAMPER_ICR_TAMP1CF;
// 执行安全响应
handle_tamper_event(TAMPER_EVENT_1);
}
if (hsm->TAMPER_ISR & HSM_TAMPER_ISR_TAMP2F) {
// 检测到篡改2
hsm->TAMPER_ICR |= HSM_TAMPER_ICR_TAMP2CF;
// 执行安全响应
handle_tamper_event(TAMPER_EVENT_2);
}
}
// 篡改事件处理
void handle_tamper_event(tamper_event_t event) {
// 清除敏感数据
clear_sensitive_data();
// 禁用关键功能
disable_critical_functions();
// 记录安全事件
log_security_event(event, get_system_time());
// 进入安全模式
enter_safe_mode();
// 可选：重启系统
if (get_security_policy() == SECURITY_POLICY_RESTART) {
system_reset();
}
}
内存保护单元（MPU）
MPU配置与管理
// MPU区域配置
typedef struct {
uint32_t base_address; // 基地址
uint32_t size; // 区域大小
uint32_t access_permission; // 访问权限
uint32_t attributes; // 内存属性
bool enable; // 区域使能
} mpu_region_config_t;
// MPU初始化
void mpu_init(void) {
// 禁用MPU
MPU->CTRL = 0;
// 配置背景区域
MPU->RNR = 0; // 选择区域0
MPU->RBAR = 0x00000000; // 基地址
MPU->RASR = MPU_RASR_ENABLE |
MPU_RASR_SIZE_4GB |
MPU_RASR_AP_NO_ACCESS; // 默认无访问权限
// 配置Flash区域（只读）
configure_mpu_region(1, 0x08000000, MPU_REGION_SIZE_1MB,
MPU_REGION_PRIV_RO_URO, MPU_TEX_NORMAL);
// 配置SRAM区域（读写）
configure_mpu_region(2, 0x20000000, MPU_REGION_SIZE_128KB,
MPU_REGION_FULL_ACCESS, MPU_TEX_NORMAL);
// 配置外设区域
configure_mpu_region(3, 0x40000000, MPU_REGION_SIZE_512MB,
MPU_REGION_FULL_ACCESS, MPU_TEX_DEVICE);
// 配置堆栈保护区域
configure_stack_guard();
// 使能MPU
MPU->CTRL = MPU_CTRL_ENABLE |
MPU_CTRL_HFNMIENA | // 硬故障和NMI使能
MPU_CTRL_PRIVDEFENA; // 特权默认内存映射使能
// 内存屏障
__DSB();
__ISB();
}
// 配置MPU区域
void configure_mpu_region(uint32_t region, uint32_t base_addr, uint32_t size,
uint32_t access_perm, uint32_t attributes) {
// 选择区域
MPU->RNR = region;
// 配置基地址
MPU->RBAR = base_addr;
// 配置属性和权限
MPU->RASR = MPU_RASR_ENABLE |
size |
access_perm |
attributes;
}
// 堆栈保护配置
void configure_stack_guard(void) {
extern uint32_t _stack_guard_start;
extern uint32_t _stack_guard_size;
// 配置堆栈保护区域（无访问权限）
configure_mpu_region(4, (uint32_t)&_stack_guard_start,
(uint32_t)&_stack_guard_size,
MPU_REGION_NO_ACCESS, MPU_TEX_NORMAL);
}
// 动态权限管理
void mpu_set_region_permission(uint32_t region, uint32_t permission) {
// 禁用MPU
MPU->CTRL &= ~MPU_CTRL_ENABLE;
// 选择区域
MPU->RNR = region;
// 修改权限
uint32_t rasr = MPU->RASR;
rasr = (rasr & ~MPU_RASR_AP_MASK) | permission;
MPU->RASR = rasr;
// 重新使能MPU
MPU->CTRL |= MPU_CTRL_ENABLE;
// 内存屏障
__DSB();
__ISB();
}
// MPU故障处理
void MemManage_Handler(void) {
uint32_t cfsr = SCB->CFSR;
uint32_t mmfar = SCB->MMFAR;
// 记录故障信息
mpu_fault_info_t fault_info = {
.fault_address = mmfar,
.fault_status = cfsr & 0xFF,
.timestamp = get_system_time(),
.task_id = get_current_task_id()
};
// 分析故障类型
if (cfsr & SCB_CFSR_IACCVIOL_Msk) {
// 指令访问违规
fault_info.fault_type = MPU_FAULT_INSTRUCTION_ACCESS;
} else if (cfsr & SCB_CFSR_DACCVIOL_Msk) {
// 数据访问违规
fault_info.fault_type = MPU_FAULT_DATA_ACCESS;
} else if (cfsr & SCB_CFSR_MUNSTKERR_Msk) {
// 出栈错误
fault_info.fault_type = MPU_FAULT_UNSTACKING;
} else if (cfsr & SCB_CFSR_MSTKERR_Msk) {
// 入栈错误
fault_info.fault_type = MPU_FAULT_STACKING;
}
// 记录故障
log_mpu_fault(&fault_info);
// 清除故障标志
SCB->CFSR |= (cfsr & 0xFF);
// 执行故障恢复策略
handle_mpu_fault(&fault_info);
}
// MPU故障恢复
void handle_mpu_fault(mpu_fault_info_t *fault_info) {
switch (fault_info->fault_type) {
case MPU_FAULT_INSTRUCTION_ACCESS:
// 指令访问故障，可能是代码损坏
if (is_critical_code_area(fault_info->fault_address)) {
// 关键代码区域，执行系统重启
system_reset();
} else {
// 非关键区域，终止当前任务
terminate_current_task();
}
break;
case MPU_FAULT_DATA_ACCESS:
// 数据访问故障，可能是缓冲区溢出
if (is_stack_overflow(fault_info->fault_address)) {
// 堆栈溢出，重置任务堆栈
reset_task_stack(fault_info->task_id);
} else {
// 其他数据访问错误
handle_data_access_error(fault_info);
}
break;
default:
// 其他类型故障，进入安全模式
enter_safe_mode();
break;
}
}
错误检测与纠正（ECC）
ECC内存保护
// ECC配置结构
typedef struct {
bool sram_ecc_enable; // SRAM ECC使能
bool flash_ecc_enable; // Flash ECC使能
bool register_ecc_enable; // 寄存器ECC使能
ecc_error_callback_t error_callback; // 错误回调
} ecc_config_t;
// ECC错误信息
typedef struct {
uint32_t error_address; // 错误地址
ecc_error_type_t error_type; // 错误类型
uint32_t error_syndrome; // 错误综合征
uint32_t timestamp; // 时间戳
bool correctable; // 是否可纠正
} ecc_error_info_t;
// ECC初始化
void ecc_init(ecc_config_t *config) {
// 使能ECC时钟
RCC->AHB1ENR |= RCC_AHB1ENR_ECCEN;
// 配置SRAM ECC
if (config->sram_ecc_enable) {
ECC->SRAM_CR |= ECC_SRAM_CR_ECCEN;
// 使能单比特和双比特错误中断
ECC->SRAM_IER |= ECC_SRAM_IER_SEIE | ECC_SRAM_IER_DEIE;
}
// 配置Flash ECC
if (config->flash_ecc_enable) {
ECC->FLASH_CR |= ECC_FLASH_CR_ECCEN;
// 使能Flash ECC中断
ECC->FLASH_IER |= ECC_FLASH_IER_SEIE | ECC_FLASH_IER_DEIE;
}
// 配置寄存器ECC
if (config->register_ecc_enable) {
ECC->REG_CR |= ECC_REG_CR_ECCEN;
// 使能寄存器ECC中断
ECC->REG_IER |= ECC_REG_IER_SEIE | ECC_REG_IER_DEIE;
}
// 使能ECC中断
NVIC_EnableIRQ(ECC_IRQn);
// 设置错误回调
set_ecc_error_callback(config->error_callback);
}
// ECC中断处理
void ECC_IRQHandler(void) {
ecc_error_info_t error_info;
// 检查SRAM ECC错误
if (ECC->SRAM_ISR & ECC_SRAM_ISR_SEF) {
// 单比特错误（可纠正）
error_info.error_address = ECC->SRAM_FEAR;
error_info.error_type = ECC_ERROR_SINGLE_BIT;
error_info.error_syndrome = ECC->SRAM_SYNDROME;
error_info.correctable = true;
error_info.timestamp = get_system_time();
// 清除中断标志
ECC->SRAM_ICR |= ECC_SRAM_ICR_SECF;
// 处理单比特错误
handle_ecc_error(&error_info);
}
if (ECC->SRAM_ISR & ECC_SRAM_ISR_DEF) {
// 双比特错误（不可纠正）
error_info.error_address = ECC->SRAM_FEAR;
error_info.error_type = ECC_ERROR_DOUBLE_BIT;
error_info.error_syndrome = ECC->SRAM_SYNDROME;
error_info.correctable = false;
error_info.timestamp = get_system_time();
// 清除中断标志
ECC->SRAM_ICR |= ECC_SRAM_ICR_DECF;
// 处理双比特错误
handle_ecc_error(&error_info);
}
// 检查Flash ECC错误
if (ECC->FLASH_ISR & (ECC_FLASH_ISR_SEF | ECC_FLASH_ISR_DEF)) {
handle_flash_ecc_error();
}
// 检查寄存器ECC错误
if (ECC->REG_ISR & (ECC_REG_ISR_SEF | ECC_REG_ISR_DEF)) {
handle_register_ecc_error();
}
}
// ECC错误处理
void handle_ecc_error(ecc_error_info_t *error_info) {
// 记录错误信息
log_ecc_error(error_info);
// 更新错误统计
update_ecc_statistics(error_info);
if (error_info->correctable) {
// 单比特错误处理
handle_correctable_error(error_info);
} else {
// 双比特错误处理
handle_uncorrectable_error(error_info);
}
// 调用用户回调
if (ecc_error_callback) {
ecc_error_callback(error_info);
}
}
// 可纠正错误处理
void handle_correctable_error(ecc_error_info_t *error_info) {
static uint32_t correctable_error_count = 0;
correctable_error_count++;
// 如果可纠正错误过多，可能存在硬件问题
if (correctable_error_count > ECC_CORRECTABLE_ERROR_THRESHOLD) {
// 触发预防性维护
trigger_preventive_maintenance();
// 重置计数器
correctable_error_count = 0;
}
// 尝试刷新内存区域
refresh_memory_region(error_info->error_address);
}
// 不可纠正错误处理
void handle_uncorrectable_error(ecc_error_info_t *error_info) {
// 标记内存区域为不可用
mark_memory_region_faulty(error_info->error_address);
// 如果是关键内存区域
if (is_critical_memory_region(error_info->error_address)) {
// 执行紧急关机程序
emergency_shutdown();
} else {
// 尝试隔离故障区域
isolate_faulty_memory(error_info->error_address);
// 重新分配内存
reallocate_memory_resources();
}
}
// 内存刷新
void refresh_memory_region(uint32_t address) {
// 计算内存块边界
uint32_t block_start = address & ~(MEMORY_BLOCK_SIZE - 1);
uint32_t block_end = block_start + MEMORY_BLOCK_SIZE;
// 临时保存数据
uint8_t temp_buffer[MEMORY_BLOCK_SIZE];
memcpy(temp_buffer, (void*)block_start, MEMORY_BLOCK_SIZE);
// 清零内存块
memset((void*)block_start, 0, MEMORY_BLOCK_SIZE);
// 恢复数据
memcpy((void*)block_start, temp_buffer, MEMORY_BLOCK_SIZE);
}
看门狗系统
多级看门狗保护
// 看门狗配置
typedef struct {
bool iwdg_enable; // 独立看门狗使能
bool wwdg_enable; // 窗口看门狗使能
uint32_t iwdg_timeout; // 独立看门狗超时时间
uint32_t wwdg_window; // 窗口看门狗窗口时间
uint32_t wwdg_timeout; // 窗口看门狗超时时间
wdg_callback_t timeout_callback; // 超时回调
} watchdog_config_t;
// 看门狗管理器
typedef struct {
bool iwdg_active;
bool wwdg_active;
uint32_t iwdg_last_refresh;
uint32_t wwdg_last_refresh;
uint32_t timeout_count;
watchdog_task_t tasks[MAX_WDG_TASKS];
uint32_t task_count;
} watchdog_manager_t;
// 看门狗任务
typedef struct {
uint32_t task_id;
uint32_t timeout_ms;
uint32_t last_checkin;
bool active;
wdg_task_callback_t callback;
} watchdog_task_t;
// 看门狗初始化
void watchdog_init(watchdog_config_t *config) {
watchdog_manager_t *wdg_mgr = get_watchdog_manager();
// 初始化独立看门狗
if (config->iwdg_enable) {
// 使能写访问
IWDG->KR = 0x5555;
// 配置预分频器
IWDG->PR = IWDG_PR_PR_2; // 分频64
// 配置重载值
uint32_t reload_value = (config->iwdg_timeout * 32) / 1000; // 32kHz LSI
IWDG->RLR = reload_value & 0xFFF;
// 启动看门狗
IWDG->KR = 0xCCCC;
wdg_mgr->iwdg_active = true;
}
// 初始化窗口看门狗
if (config->wwdg_enable) {
// 使能WWDG时钟
RCC->APB1ENR |= RCC_APB1ENR_WWDGEN;
// 配置预分频器
WWDG->CFR = WWDG_CFR_WDGTB_1; // 分频4
// 配置窗口值
uint32_t window_value = 0x80 - (config->wwdg_window * 4096) / 1000000;
WWDG->CFR |= window_value & 0x7F;
// 配置计数器值
uint32_t counter_value = 0x80 - (config->wwdg_timeout * 4096) / 1000000;
WWDG->CR = WWDG_CR_WDGA | (counter_value & 0x7F);
// 使能早期唤醒中断
WWDG->CFR |= WWDG_CFR_EWI;
NVIC_EnableIRQ(WWDG_IRQn);
wdg_mgr->wwdg_active = true;
}
// 初始化管理器
wdg_mgr->timeout_count = 0;
wdg_mgr->task_count = 0;
// 设置超时回调
set_watchdog_callback(config->timeout_callback);
}
// 独立看门狗喂狗
void iwdg_refresh(void) {
watchdog_manager_t *wdg_mgr = get_watchdog_manager();
if (wdg_mgr->iwdg_active) {
IWDG->KR = 0xAAAA;
wdg_mgr->iwdg_last_refresh = get_system_time();
}
}
// 窗口看门狗喂狗
void wwdg_refresh(void) {
watchdog_manager_t *wdg_mgr = get_watchdog_manager();
if (wdg_mgr->wwdg_active) {
// 检查是否在窗口期内
uint32_t current_counter = WWDG->CR & 0x7F;
uint32_t window_value = WWDG->CFR & 0x7F;
if (current_counter > window_value) {
WWDG->CR = (WWDG->CR & ~0x7F) | 0x7F; // 重载计数器
wdg_mgr->wwdg_last_refresh = get_system_time();
}
}
}
// 窗口看门狗中断处理
void WWDG_IRQHandler(void) {
// 清除早期唤醒标志
WWDG->SR = 0;
// 执行紧急保存操作
emergency_save_critical_data();
// 记录看门狗超时事件
log_watchdog_timeout(WATCHDOG_TYPE_WINDOW);
// 刷新看门狗（给系统最后机会）
wwdg_refresh();
}
// 注册看门狗任务
uint32_t watchdog_register_task(uint32_t timeout_ms, wdg_task_callback_t callback) {
watchdog_manager_t *wdg_mgr = get_watchdog_manager();
if (wdg_mgr->task_count >= MAX_WDG_TASKS) {
return 0; // 任务已满
}
uint32_t task_id = wdg_mgr->task_count + 1;
watchdog_task_t *task = &wdg_mgr->tasks[wdg_mgr->task_count];
task->task_id = task_id;
task->timeout_ms = timeout_ms;
task->last_checkin = get_system_time();
task->active = true;
task->callback = callback;
wdg_mgr->task_count++;
return task_id;
}
// 任务签到
void watchdog_task_checkin(uint32_t task_id) {
watchdog_manager_t *wdg_mgr = get_watchdog_manager();
for (uint32_t i = 0; i < wdg_mgr->task_count; i++) {
if (wdg_mgr->tasks[i].task_id == task_id) {
wdg_mgr->tasks[i].last_checkin = get_system_time();
break;
}
}
}
// 看门狗监控任务
void watchdog_monitor_task(void *param) {
watchdog_manager_t *wdg_mgr = get_watchdog_manager();
uint32_t current_time;
while (1) {
current_time = get_system_time();
// 检查所有注册的任务
for (uint32_t i = 0; i < wdg_mgr->task_count; i++) {
watchdog_task_t *task = &wdg_mgr->tasks[i];
if (task->active) {
uint32_t elapsed = current_time - task->last_checkin;
if (elapsed > task->timeout_ms) {
// 任务超时
if (task->callback) {
task->callback(task->task_id, elapsed);
}
// 记录超时事件
log_task_timeout(task->task_id, elapsed);
// 可选：禁用超时任务
task->active = false;
}
}
}
// 定期刷新硬件看门狗
iwdg_refresh();
wwdg_refresh();
vTaskDelay(pdMS_TO_TICKS(100)); // 100ms监控周期
}
}
```#
# 时钟监控系统
### 时钟安全监控
```c
// 时钟监控配置
typedef struct {
bool hse_monitor_enable; // HSE监控使能
bool lse_monitor_enable; // LSE监控使能
bool pll_monitor_enable; // PLL监控使能
uint32_t hse_timeout_ms; // HSE超时时间
uint32_t lse_timeout_ms; // LSE超时时间
clock_fail_callback_t fail_callback; // 时钟失效回调
} clock_monitor_config_t;
// 时钟监控状态
typedef struct {
bool hse_failed;
bool lse_failed;
bool pll_failed;
uint32_t hse_fail_count;
uint32_t lse_fail_count;
uint32_t pll_fail_count;
uint32_t last_hse_check;
uint32_t last_lse_check;
} clock_monitor_status_t;
// 时钟监控初始化
void clock_monitor_init(clock_monitor_config_t *config) {
// 使能时钟安全系统
RCC->CR |= RCC_CR_CSSON;
// 配置HSE监控
if (config->hse_monitor_enable) {
// 使能HSE时钟检测
RCC->CR |= RCC_CR_HSEBYP; // 如果使用外部时钟源
// 使能时钟安全系统中断
RCC->CIR |= RCC_CIR_CSSC;
NVIC_EnableIRQ(RCC_IRQn);
}
// 配置LSE监控
if (config->lse_monitor_enable) {
// 使能LSE时钟检测
RCC->BDCR |= RCC_BDCR_LSECSSON;
}
// 配置PLL监控
if (config->pll_monitor_enable) {
// 使能PLL就绪中断
RCC->CIR |= RCC_CIR_PLLRDYIE;
}
// 设置失效回调
set_clock_fail_callback(config->fail_callback);
// 初始化监控状态
clock_monitor_status_t *status = get_clock_monitor_status();
memset(status, 0, sizeof(clock_monitor_status_t));
}
// RCC中断处理
void RCC_IRQHandler(void) {
clock_monitor_status_t *status = get_clock_monitor_status();
// 检查时钟安全系统中断
if (RCC->CIR & RCC_CIR_CSSF) {
// HSE时钟失效
RCC->CIR |= RCC_CIR_CSSC; // 清除中断标志
status->hse_failed = true;
status->hse_fail_count++;
// 处理HSE失效
handle_hse_failure();
}
// 检查PLL就绪中断
if (RCC->CIR & RCC_CIR_PLLRDYF) {
RCC->CIR |= RCC_CIR_PLLRDYC; // 清除中断标志
// PLL就绪处理
handle_pll_ready();
}
// 检查LSE中断
if (RCC->CIR & RCC_CIR_LSERDYF) {
RCC->CIR |= RCC_CIR_LSERDYC; // 清除中断标志
// LSE就绪处理
handle_lse_ready();
}
}
// HSE失效处理
void handle_hse_failure(void) {
// 自动切换到HSI
RCC->CR |= RCC_CR_HSION;
while (!(RCC->CR & RCC_CR_HSIRDY));
// 切换系统时钟到HSI
RCC->CFGR = (RCC->CFGR & ~RCC_CFGR_SW) | RCC_CFGR_SW_HSI;
while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_HSI);
// 禁用PLL
RCC->CR &= ~RCC_CR_PLLON;
// 记录时钟失效事件
log_clock_failure(CLOCK_TYPE_HSE, get_system_time());
// 调用用户回调
clock_fail_callback_t callback = get_clock_fail_callback();
if (callback) {
callback(CLOCK_TYPE_HSE);
}
// 尝试恢复HSE
schedule_hse_recovery();
}
// 时钟恢复任务
void clock_recovery_task(void *param) {
clock_monitor_status_t *status = get_clock_monitor_status();
while (1) {
// 检查HSE恢复
if (status->hse_failed) {
if (attempt_hse_recovery()) {
status->hse_failed = false;
// 恢复PLL和系统时钟
restore_system_clock();
}
}
// 检查LSE恢复
if (status->lse_failed) {
if (attempt_lse_recovery()) {
status->lse_failed = false;
// 恢复RTC时钟
restore_rtc_clock();
}
}
vTaskDelay(pdMS_TO_TICKS(1000)); // 1秒检查周期
}
}
// HSE恢复尝试
bool attempt_hse_recovery(void) {
// 禁用HSE
RCC->CR &= ~RCC_CR_HSEON;
delay_ms(10);
// 重新使能HSE
RCC->CR |= RCC_CR_HSEON;
// 等待HSE就绪（带超时）
uint32_t timeout = 1000; // 1秒超时
while (!(RCC->CR & RCC_CR_HSERDY) && timeout--) {
delay_ms(1);
}
return (RCC->CR & RCC_CR_HSERDY) != 0;
}
// 系统时钟恢复
void restore_system_clock(void) {
// 配置PLL
RCC->CFGR = (RCC->CFGR & ~RCC_CFGR_PLLSRC) | RCC_CFGR_PLLSRC_HSE;
RCC->CFGR = (RCC->CFGR & ~RCC_CFGR_PLLMUL) | RCC_CFGR_PLLMUL10; // 10倍频
// 使能PLL
RCC->CR |= RCC_CR_PLLON;
while (!(RCC->CR & RCC_CR_PLLRDY));
// 切换系统时钟到PLL
RCC->CFGR = (RCC->CFGR & ~RCC_CFGR_SW) | RCC_CFGR_SW_PLL;
while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);
// 更新系统时钟频率
SystemCoreClockUpdate();
// 记录时钟恢复事件
log_clock_recovery(CLOCK_TYPE_HSE, get_system_time());
}
电压监控系统
电源电压监控
// 电压监控配置
typedef struct {
bool pvd_enable; // 电源电压检测使能
uint32_t pvd_level; // PVD阈值电平
bool bor_enable; // 掉电复位使能
uint32_t bor_level; // BOR阈值电平
voltage_callback_t pvd_callback; // PVD回调
} voltage_monitor_config_t;
// 电压监控状态
typedef struct {
bool voltage_low; // 电压过低标志
bool brownout_detected; // 掉电检测标志
uint32_t pvd_event_count; // PVD事件计数
uint32_t bor_event_count; // BOR事件计数
float current_voltage; // 当前电压
float min_voltage; // 最低电压
} voltage_monitor_status_t;
// 电压监控初始化
void voltage_monitor_init(voltage_monitor_config_t *config) {
// 使能PWR时钟
RCC->APB1ENR |= RCC_APB1ENR_PWREN;
// 配置PVD
if (config->pvd_enable) {
// 设置PVD阈值
PWR->CR = (PWR->CR & ~PWR_CR_PLS) | config->pvd_level;
// 使能PVD
PWR->CR |= PWR_CR_PVDE;
// 配置PVD中断
EXTI->IMR |= EXTI_IMR_MR16; // PVD连接到EXTI线16
EXTI->RTSR |= EXTI_RTSR_TR16; // 上升沿触发
EXTI->FTSR |= EXTI_FTSR_TR16; // 下降沿触发
NVIC_EnableIRQ(PVD_IRQn);
}
// 配置BOR
if (config->bor_enable) {
// BOR配置通常在选项字节中设置
configure_bor_level(config->bor_level);
}
// 设置回调函数
set_voltage_callback(config->pvd_callback);
// 初始化监控状态
voltage_monitor_status_t *status = get_voltage_monitor_status();
memset(status, 0, sizeof(voltage_monitor_status_t));
status->min_voltage = 5.0; // 初始化为高值
}
// PVD中断处理
void PVD_IRQHandler(void) {
voltage_monitor_status_t *status = get_voltage_monitor_status();
// 清除EXTI中断标志
EXTI->PR |= EXTI_PR_PR16;
// 检查PVD输出状态
if (PWR->CSR & PWR_CSR_PVDO) {
// 电压低于阈值
status->voltage_low = true;
status->pvd_event_count++;
// 执行低电压处理
handle_low_voltage_event();
} else {
// 电压恢复正常
status->voltage_low = false;
// 执行电压恢复处理
handle_voltage_recovery_event();
}
// 调用用户回调
voltage_callback_t callback = get_voltage_callback();
if (callback) {
callback(status->voltage_low);
}
}
// 低电压事件处理
void handle_low_voltage_event(void) {
// 降低系统性能
reduce_system_performance();
// 关闭非必要外设
disable_non_essential_peripherals();
// 保存关键数据
save_critical_data_to_backup();
// 进入低功耗模式
prepare_for_low_power_mode();
// 记录低电压事件
log_voltage_event(VOLTAGE_EVENT_LOW, get_system_time());
}
// 电压恢复事件处理
void handle_voltage_recovery_event(void) {
// 恢复系统性能
restore_system_performance();
// 重新使能外设
enable_peripherals();
// 退出低功耗模式
exit_low_power_mode();
// 记录电压恢复事件
log_voltage_event(VOLTAGE_EVENT_RECOVERY, get_system_time());
}
// 电压监控任务
void voltage_monitor_task(void *param) {
voltage_monitor_status_t *status = get_voltage_monitor_status();
while (1) {
// 通过ADC读取实际电压值
float voltage = read_supply_voltage_adc();
status->current_voltage = voltage;
// 更新最低电压记录
if (voltage < status->min_voltage) {
status->min_voltage = voltage;
}
// 检查掉电条件
if (voltage < BROWNOUT_THRESHOLD) {
if (!status->brownout_detected) {
status->brownout_detected = true;
status->bor_event_count++;
// 执行掉电处理
handle_brownout_event();
}
} else {
status->brownout_detected = false;
}
vTaskDelay(pdMS_TO_TICKS(100)); // 100ms监控周期
}
}
// 掉电事件处理
void handle_brownout_event(void) {
// 立即保存关键数据
emergency_save_critical_data();
// 关闭所有外设
shutdown_all_peripherals();
// 进入最低功耗模式
enter_emergency_low_power_mode();
// 记录掉电事件
log_voltage_event(VOLTAGE_EVENT_BROWNOUT, get_system_time());
}
故障诊断系统
综合故障诊断
// 故障类型定义
typedef enum {
FAULT_TYPE_MEMORY, // 内存故障
FAULT_TYPE_CLOCK, // 时钟故障
FAULT_TYPE_VOLTAGE, // 电压故障
FAULT_TYPE_TEMPERATURE, // 温度故障
FAULT_TYPE_COMMUNICATION, // 通信故障
FAULT_TYPE_PERIPHERAL, // 外设故障
FAULT_TYPE_SOFTWARE, // 软件故障
FAULT_TYPE_UNKNOWN // 未知故障
} fault_type_t;
// 故障信息结构
typedef struct {
fault_type_t type; // 故障类型
uint32_t code; // 故障代码
uint32_t address; // 故障地址
uint32_t timestamp; // 时间戳
uint32_t task_id; // 任务ID
char description[64]; // 故障描述
bool critical; // 是否关键故障
bool resolved; // 是否已解决
} fault_info_t;
// 故障诊断系统
typedef struct {
fault_info_t fault_log[MAX_FAULT_RECORDS];
uint32_t fault_count;
uint32_t fault_index;
// 故障统计
uint32_t fault_stats[FAULT_TYPE_UNKNOWN + 1];
uint32_t critical_fault_count;
uint32_t resolved_fault_count;
// 诊断配置
bool auto_recovery_enable;
bool fault_logging_enable;
fault_callback_t fault_callback;
} fault_diagnostic_system_t;
// 故障诊断初始化
void fault_diagnostic_init(void) {
fault_diagnostic_system_t *fds = get_fault_diagnostic_system();
// 初始化故障记录
memset(fds->fault_log, 0, sizeof(fds->fault_log));
fds->fault_count = 0;
fds->fault_index = 0;
// 初始化统计信息
memset(fds->fault_stats, 0, sizeof(fds->fault_stats));
fds->critical_fault_count = 0;
fds->resolved_fault_count = 0;
// 默认配置
fds->auto_recovery_enable = true;
fds->fault_logging_enable = true;
fds->fault_callback = NULL;
// 注册各种故障处理器
register_fault_handlers();
}
// 记录故障
void log_fault(fault_type_t type, uint32_t code, uint32_t address,
const char *description, bool critical) {
fault_diagnostic_system_t *fds = get_fault_diagnostic_system();
if (!fds->fault_logging_enable) {
return;
}
// 获取故障记录槽位
fault_info_t *fault = &fds->fault_log[fds->fault_index];
// 填充故障信息
fault->type = type;
fault->code = code;
fault->address = address;
fault->timestamp = get_system_time();
fault->task_id = get_current_task_id();
fault->critical = critical;
fault->resolved = false;
strncpy(fault->description, description, sizeof(fault->description) - 1);
fault->description[sizeof(fault->description) - 1] = '\0';
// 更新索引和计数
fds->fault_index = (fds->fault_index + 1) % MAX_FAULT_RECORDS;
if (fds->fault_count < MAX_FAULT_RECORDS) {
fds->fault_count++;
}
// 更新统计
fds->fault_stats[type]++;
if (critical) {
fds->critical_fault_count++;
}
// 调用故障回调
if (fds->fault_callback) {
fds->fault_callback(fault);
}
// 自动恢复处理
if (fds->auto_recovery_enable) {
attempt_fault_recovery(fault);
}
// 关键故障处理
if (critical) {
handle_critical_fault(fault);
}
}
// 故障恢复尝试
void attempt_fault_recovery(fault_info_t *fault) {
bool recovery_success = false;
switch (fault->type) {
case FAULT_TYPE_MEMORY:
recovery_success = recover_memory_fault(fault);
break;
case FAULT_TYPE_CLOCK:
recovery_success = recover_clock_fault(fault);
break;
case FAULT_TYPE_VOLTAGE:
recovery_success = recover_voltage_fault(fault);
break;
case FAULT_TYPE_COMMUNICATION:
recovery_success = recover_communication_fault(fault);
break;
case FAULT_TYPE_PERIPHERAL:
recovery_success = recover_peripheral_fault(fault);
break;
default:
recovery_success = false;
break;
}
if (recovery_success) {
fault->resolved = true;
get_fault_diagnostic_system()->resolved_fault_count++;
// 记录恢复成功
log_fault_recovery(fault);
}
}
// 内存故障恢复
bool recover_memory_fault(fault_info_t *fault) {
switch (fault->code) {
case MEMORY_FAULT_ECC_SINGLE:
// 单比特ECC错误，已自动纠正
return true;
case MEMORY_FAULT_ECC_DOUBLE:
// 双比特ECC错误，尝试重新映射
return remap_faulty_memory(fault->address);
case MEMORY_FAULT_MPU_VIOLATION:
// MPU违规，重置任务
return reset_violating_task(fault->task_id);
case MEMORY_FAULT_STACK_OVERFLOW:
// 堆栈溢出，增加堆栈大小
return increase_task_stack(fault->task_id);
default:
return false;
}
}
// 时钟故障恢复
bool recover_clock_fault(fault_info_t *fault) {
switch (fault->code) {
case CLOCK_FAULT_HSE_FAILURE:
// HSE失效，切换到HSI
return switch_to_hsi_clock();
case CLOCK_FAULT_PLL_UNLOCK:
// PLL失锁，重新配置PLL
return reconfigure_pll();
case CLOCK_FAULT_LSE_FAILURE:
// LSE失效，切换到LSI
return switch_to_lsi_clock();
default:
return false;
}
}
// 关键故障处理
void handle_critical_fault(fault_info_t *fault) {
// 保存关键数据
save_critical_system_state();
// 记录关键故障
log_critical_fault(fault);
// 根据故障类型决定处理策略
switch (fault->type) {
case FAULT_TYPE_MEMORY:
if (fault->code == MEMORY_FAULT_ECC_DOUBLE) {
// 双比特ECC错误，可能需要重启
if (is_critical_memory_region(fault->address)) {
schedule_system_restart();
}
}
break;
case FAULT_TYPE_VOLTAGE:
if (fault->code == VOLTAGE_FAULT_BROWNOUT) {
// 掉电，立即进入紧急模式
enter_emergency_mode();
}
break;
case FAULT_TYPE_TEMPERATURE:
if (fault->code == TEMPERATURE_FAULT_OVERTEMP) {
// 过温，降低性能或关机
handle_overtemperature_emergency();
}
break;
default:
// 其他关键故障，进入安全模式
enter_safe_mode();
break;
}
}
// 故障诊断报告
void generate_fault_report(char *report_buffer, uint32_t buffer_size) {
fault_diagnostic_system_t *fds = get_fault_diagnostic_system();
uint32_t offset = 0;
// 报告头
offset += snprintf(report_buffer + offset, buffer_size - offset,
"=== Fault Diagnostic Report ===\n");
offset += snprintf(report_buffer + offset, buffer_size - offset,
"Total Faults: %lu\n", fds->fault_count);
offset += snprintf(report_buffer + offset, buffer_size - offset,
"Critical Faults: %lu\n", fds->critical_fault_count);
offset += snprintf(report_buffer + offset, buffer_size - offset,
"Resolved Faults: %lu\n", fds->resolved_fault_count);
// 故障统计
offset += snprintf(report_buffer + offset, buffer_size - offset,
"\n=== Fault Statistics ===\n");
const char *fault_type_names[] = {
"Memory", "Clock", "Voltage", "Temperature",
"Communication", "Peripheral", "Software", "Unknown"
};
for (int i = 0; i <= FAULT_TYPE_UNKNOWN; i++) {
if (fds->fault_stats[i] > 0) {
offset += snprintf(report_buffer + offset, buffer_size - offset,
"%s: %lu\n", fault_type_names[i], fds->fault_stats[i]);
}
}
// 最近故障记录
offset += snprintf(report_buffer + offset, buffer_size - offset,
"\n=== Recent Faults ===\n");
uint32_t recent_count = MIN(fds->fault_count, 10); // 显示最近10个故障
for (uint32_t i = 0; i < recent_count; i++) {
uint32_t index = (fds->fault_index - 1 - i + MAX_FAULT_RECORDS) % MAX_FAULT_RECORDS;
fault_info_t *fault = &fds->fault_log[index];
offset += snprintf(report_buffer + offset, buffer_size - offset,
"[%lu] %s: %s %s\n",
fault->timestamp,
fault_type_names[fault->type],
fault->description,
fault->resolved ? "(Resolved)" : "");
}
}
// 故障诊断任务
void fault_diagnostic_task(void *param) {
while (1) {
// 执行周期性诊断
perform_periodic_diagnostics();
// 检查故障趋势
analyze_fault_trends();
// 清理已解决的旧故障
cleanup_resolved_faults();
vTaskDelay(pdMS_TO_TICKS(5000)); // 5秒诊断周期
}
}
// 周期性诊断
void perform_periodic_diagnostics(void) {
// 内存诊断
if (!perform_memory_test()) {
log_fault(FAULT_TYPE_MEMORY, MEMORY_FAULT_TEST_FAILED, 0,
"Memory test failed", false);
}
// 时钟诊断
if (!verify_clock_stability()) {
log_fault(FAULT_TYPE_CLOCK, CLOCK_FAULT_INSTABILITY, 0,
"Clock instability detected", false);
}
// 外设诊断
diagnose_peripheral_health();
// 软件诊断
check_software_integrity();
}
功能安全应用实例
汽车制动系统安全
// 制动系统安全监控
typedef struct {
// 传感器冗余
struct {
float brake_pedal_pos_1; // 制动踏板位置传感器1
float brake_pedal_pos_2; // 制动踏板位置传感器2
float wheel_speed[4]; // 车轮速度传感器
float brake_pressure[4]; // 制动压力传感器
} sensors;
// 执行器状态
struct {
bool brake_valve[4]; // 制动阀状态
bool abs_active; // ABS激活状态
bool esp_active; // ESP激活状态
} actuators;
// 安全状态
struct {
bool sensor_fault[10]; // 传感器故障标志
bool actuator_fault[6]; // 执行器故障标志
bool system_degraded; // 系统降级标志
bool emergency_brake; // 紧急制动标志
safety_state_t safety_state; // 安全状态
} safety;
// 诊断计数器
struct {
uint32_t sensor_error_count[10];
uint32_t actuator_error_count[6];
uint32_t total_error_count;
} diagnostics;
} brake_safety_system_t;
// 制动系统安全初始化
void brake_safety_init(brake_safety_system_t *brake_sys) {
// 初始化传感器
init_brake_sensors();
// 初始化执行器
init_brake_actuators();
// 配置安全监控
configure_safety_monitoring();
// 初始化诊断系统
memset(&brake_sys->diagnostics, 0, sizeof(brake_sys->diagnostics));
// 设置初始安全状态
brake_sys->safety.safety_state = SAFETY_STATE_NORMAL;
brake_sys->safety.system_degraded = false;
brake_sys->safety.emergency_brake = false;
}
// 制动系统安全任务
void brake_safety_task(void *param) {
brake_safety_system_t *brake_sys = (brake_safety_system_t*)param;
while (1) {
// 读取传感器数据
read_brake_sensors(brake_sys);
// 传感器数据验证
validate_sensor_data(brake_sys);
// 执行器状态检查
check_actuator_status(brake_sys);
// 安全逻辑处理
process_safety_logic(brake_sys);
// 故障诊断
perform_brake_diagnostics(brake_sys);
// 安全响应
execute_safety_response(brake_sys);
vTaskDelay(pdMS_TO_TICKS(10)); // 10ms安全任务周期
}
}
// 传感器数据验证
void validate_sensor_data(brake_safety_system_t *brake_sys) {
// 制动踏板位置传感器冗余检查
float pos_diff = fabs(brake_sys->sensors.brake_pedal_pos_1 -
brake_sys->sensors.brake_pedal_pos_2);
if (pos_diff > BRAKE_PEDAL_TOLERANCE) {
// 传感器不一致
brake_sys->safety.sensor_fault[0] = true;
brake_sys->diagnostics.sensor_error_count[0]++;
log_fault(FAULT_TYPE_PERIPHERAL, SENSOR_FAULT_INCONSISTENT,
0, "Brake pedal sensor mismatch", true);
} else {
brake_sys->safety.sensor_fault[0] = false;
}
// 车轮速度传感器合理性检查
for (int i = 0; i < 4; i++) {
if (brake_sys->sensors.wheel_speed[i] < 0 ||
brake_sys->sensors.wheel_speed[i] > MAX_WHEEL_SPEED) {
brake_sys->safety.sensor_fault[i + 1] = true;
brake_sys->diagnostics.sensor_error_count[i + 1]++;
log_fault(FAULT_TYPE_PERIPHERAL, SENSOR_FAULT_OUT_OF_RANGE,
i, "Wheel speed sensor out of range", false);
}
}
// 制动压力传感器检查
for (int i = 0; i < 4; i++) {
if (brake_sys->sensors.brake_pressure[i] < 0 ||
brake_sys->sensors.brake_pressure[i] > MAX_BRAKE_PRESSURE) {
brake_sys->safety.sensor_fault[i + 5] = true;
brake_sys->diagnostics.sensor_error_count[i + 5]++;
log_fault(FAULT_TYPE_PERIPHERAL, SENSOR_FAULT_OUT_OF_RANGE,
i + 4, "Brake pressure sensor out of range", true);
}
}
}
// 安全逻辑处理
void process_safety_logic(brake_safety_system_t *brake_sys) {
uint32_t active_faults = 0;
uint32_t critical_faults = 0;
// 统计故障数量
for (int i = 0; i < 10; i++) {
if (brake_sys->safety.sensor_fault[i]) {
active_faults++;
if (i == 0 || i >= 5) { // 踏板位置和压力传感器为关键
critical_faults++;
}
}
}
for (int i = 0; i < 6; i++) {
if (brake_sys->safety.actuator_fault[i]) {
active_faults++;
critical_faults++; // 所有执行器故障都是关键的
}
}
// 根据故障情况确定安全状态
if (critical_faults > 0) {
brake_sys->safety.safety_state = SAFETY_STATE_CRITICAL;
} else if (active_faults > 2) {
brake_sys->safety.safety_state = SAFETY_STATE_DEGRADED;
brake_sys->safety.system_degraded = true;
} else if (active_faults > 0) {
brake_sys->safety.safety_state = SAFETY_STATE_WARNING;
} else {
brake_sys->safety.safety_state = SAFETY_STATE_NORMAL;
brake_sys->safety.system_degraded = false;
}
}
// 安全响应执行
void execute_safety_response(brake_safety_system_t *brake_sys) {
switch (brake_sys->safety.safety_state) {
case SAFETY_STATE_NORMAL:
// 正常操作
enable_all_brake_functions();
break;
case SAFETY_STATE_WARNING:
// 警告状态，记录但继续操作
log_safety_warning("Brake system warning");
break;
case SAFETY_STATE_DEGRADED:
// 降级操作
disable_advanced_brake_features();
activate_backup_brake_system();
notify_driver_degraded_mode();
break;
case SAFETY_STATE_CRITICAL:
// 关键故障，紧急制动
brake_sys->safety.emergency_brake = true;
activate_emergency_brake();
notify_driver_critical_fault();
// 记录关键安全事件
log_fault(FAULT_TYPE_PERIPHERAL, BRAKE_FAULT_CRITICAL,
0, "Critical brake system fault", true);
break;
}
}
// 紧急制动激活
void activate_emergency_brake(void) {
// 激活所有制动器
for (int i = 0; i < 4; i++) {
set_brake_valve(i, true);
set_brake_pressure(i, MAX_EMERGENCY_PRESSURE);
}
// 激活危险警告灯
activate_hazard_lights();
// 发送紧急制动信号到其他ECU
send_emergency_brake_signal();
// 记录紧急制动事件
log_emergency_event("Emergency brake activated");
}
总结
YTM32B1ME0x的安全特性与功能安全系统为汽车电子应用提供了全面的安全保障。通过硬件安全模块、内存保护、错误检测纠正、看门狗监控、时钟监控、电压监控和综合故障诊断等多层安全机制，确保系统能够满足ISO 26262等功能安全标准的要求。
关键安全特性总结：
-
硬件安全模块: 提供加密、哈希、随机数生成和安全启动功能
-
内存保护单元: 防止非法内存访问，提供堆栈保护
-
ECC错误检测: 自动检测和纠正内存错误
-
多级看门狗: 独立看门狗和窗口看门狗双重保护
-
时钟监控: 检测时钟失效并自动切换备用时钟
-
电压监控: 监控供电电压，处理掉电和低电压情况
-
故障诊断: 综合故障检测、记录和恢复机制
-
功能安全应用: 支持ASIL等级的汽车安全应用
故障注入测试
故障注入框架
// 故障注入类型
typedef enum {
FAULT_INJECT_MEMORY_CORRUPTION, // 内存损坏
FAULT_INJECT_CLOCK_GLITCH, // 时钟毛刺
FAULT_INJECT_VOLTAGE_DROP, // 电压跌落
FAULT_INJECT_INSTRUCTION_SKIP, // 指令跳过
FAULT_INJECT_DATA_CORRUPTION, // 数据损坏
FAULT_INJECT_PERIPHERAL_ERROR // 外设错误
} fault_inject_type_t;
// 故障注入配置
typedef struct {
fault_inject_type_t type; // 故障类型
uint32_t target_address; // 目标地址
uint32_t fault_duration; // 故障持续时间
uint32_t fault_probability; // 故障概率
bool continuous_mode; // 连续模式
fault_callback_t callback; // 故障回调
} fault_inject_config_t;
// 故障注入系统
typedef struct {
bool active; // 注入活跃标志
fault_inject_config_t configs[MAX_FAULT_CONFIGS];
uint32_t config_count;
uint32_t injection_count; // 注入计数
uint32_t detection_count; // 检测计数
uint32_t recovery_count; // 恢复计数
} fault_injection_system_t;
// 故障注入初始化
void fault_injection_init(fault_injection_system_t *fi_system) {
fi_system->active = false;
fi_system->config_count = 0;
fi_system->injection_count = 0;
fi_system->detection_count = 0;
fi_system->recovery_count = 0;
// 配置故障注入定时器
configure_fault_injection_timer();
// 使能故障检测机制
enable_fault_detection_mechanisms();
}
// 内存故障注入
void inject_memory_fault(uint32_t address, uint32_t fault_mask) {
// 保存原始值
uint32_t original_value = *(volatile uint32_t*)address;
// 注入故障
*(volatile uint32_t*)address = original_value ^ fault_mask;
// 记录故障注入
log_fault_injection(FAULT_INJECT_MEMORY_CORRUPTION, address, fault_mask);
// 等待故障检测
delay_us(100);
// 检查是否被检测到
if (check_fault_detection(address)) {
increment_detection_count();
}
}
// 时钟故障注入
void inject_clock_fault(uint32_t duration_us) {
// 临时修改时钟配置
uint32_t original_cfgr = RCC->CFGR;
// 注入时钟故障（降低频率）
RCC->CFGR = (original_cfgr & ~RCC_CFGR_SW) | RCC_CFGR_SW_HSI;
// 等待故障持续时间
delay_us(duration_us);
// 恢复原始时钟配置
RCC->CFGR = original_cfgr;
// 记录故障注入
log_fault_injection(FAULT_INJECT_CLOCK_GLITCH, 0, duration_us);
}
// 故障检测验证
bool verify_fault_detection_coverage(void) {
fault_injection_system_t *fi_system = get_fault_injection_system();
// 计算故障检测覆盖率
float detection_rate = (float)fi_system->detection_count / fi_system->injection_count;
// 检查是否满足安全要求
if (detection_rate >= REQUIRED_DETECTION_RATE) {
return true;
}
// 分析未检测到的故障
analyze_undetected_faults();
return false;
}
安全状态机
// 安全状态定义
typedef enum {
SAFETY_STATE_NORMAL, // 正常状态
SAFETY_STATE_DEGRADED, // 降级状态
SAFETY_STATE_FAIL_SAFE, // 故障安全状态
SAFETY_STATE_FAIL_SILENT, // 故障静默状态
SAFETY_STATE_EMERGENCY_STOP // 紧急停止状态
} safety_state_t;
// 安全事件类型
typedef enum {
SAFETY_EVENT_NONE,
SAFETY_EVENT_SINGLE_FAULT, // 单点故障
SAFETY_EVENT_MULTIPLE_FAULT, // 多点故障
SAFETY_EVENT_LATENT_FAULT, // 潜在故障
SAFETY_EVENT_SYSTEMATIC_FAULT, // 系统性故障
SAFETY_EVENT_EXTERNAL_FAULT // 外部故障
} safety_event_t;
// 安全状态机
typedef struct {
safety_state_t current_state; // 当前状态
safety_state_t previous_state; // 前一状态
safety_event_t last_event; // 最后事件
uint32_t state_entry_time; // 状态进入时间
uint32_t fault_count; // 故障计数
uint32_t recovery_attempts; // 恢复尝试次数
bool emergency_shutdown_active; // 紧急关机激活
} safety_state_machine_t;
// 安全状态机初始化
void safety_state_machine_init(safety_state_machine_t *sm) {
sm->current_state = SAFETY_STATE_NORMAL;
sm->previous_state = SAFETY_STATE_NORMAL;
sm->last_event = SAFETY_EVENT_NONE;
sm->state_entry_time = get_system_time();
sm->fault_count = 0;
sm->recovery_attempts = 0;
sm->emergency_shutdown_active = false;
}
// 安全状态转换
void safety_state_transition(safety_state_machine_t *sm, safety_event_t event) {
safety_state_t new_state = sm->current_state;
switch (sm->current_state) {
case SAFETY_STATE_NORMAL:
switch (event) {
case SAFETY_EVENT_SINGLE_FAULT:
new_state = SAFETY_STATE_DEGRADED;
break;
case SAFETY_EVENT_MULTIPLE_FAULT:
new_state = SAFETY_STATE_FAIL_SAFE;
break;
case SAFETY_EVENT_SYSTEMATIC_FAULT:
new_state = SAFETY_STATE_EMERGENCY_STOP;
break;
}
break;
case SAFETY_STATE_DEGRADED:
switch (event) {
case SAFETY_EVENT_SINGLE_FAULT:
if (sm->fault_count > MAX_DEGRADED_FAULTS) {
new_state = SAFETY_STATE_FAIL_SAFE;
}
break;
case SAFETY_EVENT_MULTIPLE_FAULT:
new_state = SAFETY_STATE_FAIL_SAFE;
break;
}
break;
case SAFETY_STATE_FAIL_SAFE:
switch (event) {
case SAFETY_EVENT_SYSTEMATIC_FAULT:
new_state = SAFETY_STATE_EMERGENCY_STOP;
break;
}
break;
case SAFETY_STATE_FAIL_SILENT:
// 静默状态只能通过重启恢复
break;
case SAFETY_STATE_EMERGENCY_STOP:
// 紧急停止状态不可逆转
break;
}
// 执行状态转换
if (new_state != sm->current_state) {
execute_state_transition(sm, new_state, event);
}
}
// 执行状态转换
void execute_state_transition(safety_state_machine_t *sm, safety_state_t new_state,
safety_event_t event) {
// 记录状态转换
log_safety_state_transition(sm->current_state, new_state, event);
// 退出当前状态
exit_safety_state(sm->current_state);
// 更新状态机
sm->previous_state = sm->current_state;
sm->current_state = new_state;
sm->last_event = event;
sm->state_entry_time = get_system_time();
// 进入新状态
enter_safety_state(new_state);
// 更新故障计数
if (event != SAFETY_EVENT_NONE) {
sm->fault_count++;
}
}
// 进入安全状态
void enter_safety_state(safety_state_t state) {
switch (state) {
case SAFETY_STATE_NORMAL:
// 恢复正常操作
restore_normal_operation();
break;
case SAFETY_STATE_DEGRADED:
// 降级操作
enter_degraded_mode();
break;
case SAFETY_STATE_FAIL_SAFE:
// 故障安全操作
enter_fail_safe_mode();
break;
case SAFETY_STATE_FAIL_SILENT:
// 静默模式
enter_fail_silent_mode();
break;
case SAFETY_STATE_EMERGENCY_STOP:
// 紧急停止
execute_emergency_stop();
break;
}
}
// 降级模式
void enter_degraded_mode(void) {
// 降低系统性能
reduce_system_performance();
// 禁用非关键功能
disable_non_critical_functions();
// 增加监控频率
increase_monitoring_frequency();
// 启动故障恢复机制
start_fault_recovery_mechanisms();
}
// 故障安全模式
void enter_fail_safe_mode(void) {
// 停止所有非安全关键操作
stop_non_safety_critical_operations();
// 激活安全输出状态
activate_safe_output_states();
// 启动安全通信
start_safety_communication();
// 记录故障信息
record_fault_information();
}
// 紧急停止
void execute_emergency_stop(void) {
// 立即停止所有操作
immediate_stop_all_operations();
// 激活紧急输出
activate_emergency_outputs();
// 发送紧急信号
send_emergency_signals();
// 进入无限循环等待重启
while (1) {
// 保持紧急状态
maintain_emergency_state();
delay_ms(100);
}
}
功能安全应用实例
// 汽车制动系统安全应用
typedef struct {
// 传感器输入
struct {
float brake_pedal_position; // 制动踏板位置
float wheel_speed[4]; // 车轮速度
float brake_pressure; // 制动压力
bool brake_light_switch; // 制动灯开关
} sensors;
// 执行器输出
struct {
float brake_force[4]; // 制动力
bool brake_lights; // 制动灯
bool abs_active; // ABS激活
bool esp_active; // ESP激活
} actuators;
// 安全监控
struct {
safety_state_machine_t state_machine;
uint32_t sensor_fault_mask; // 传感器故障掩码
uint32_t actuator_fault_mask; // 执行器故障掩码
bool plausibility_check_failed; // 合理性检查失败
uint32_t safety_violation_count; // 安全违规计数
} safety;
// 诊断信息
struct {
uint32_t diagnostic_trouble_codes[16];
uint32_t dtc_count;
bool diagnostic_session_active;
} diagnostics;
} brake_system_t;
// 制动系统初始化
void brake_system_init(brake_system_t *brake_sys) {
// 初始化传感器
init_brake_sensors(&brake_sys->sensors);
// 初始化执行器
init_brake_actuators(&brake_sys->actuators);
// 初始化安全状态机
safety_state_machine_init(&brake_sys->safety.state_machine);
// 初始化诊断系统
init_brake_diagnostics(&brake_sys->diagnostics);
// 启动安全监控任务
start_brake_safety_monitoring(brake_sys);
}
// 制动系统主控制循环
void brake_system_control_loop(brake_system_t *brake_sys) {
// 读取传感器数据
read_brake_sensors(&brake_sys->sensors);
// 执行安全检查
safety_event_t safety_event = perform_brake_safety_checks(brake_sys);
// 更新安全状态机
if (safety_event != SAFETY_EVENT_NONE) {
safety_state_transition(&brake_sys->safety.state_machine, safety_event);
}
// 根据安全状态执行控制
switch (brake_sys->safety.state_machine.current_state) {
case SAFETY_STATE_NORMAL:
execute_normal_brake_control(brake_sys);
break;
case SAFETY_STATE_DEGRADED:
execute_degraded_brake_control(brake_sys);
break;
case SAFETY_STATE_FAIL_SAFE:
execute_fail_safe_brake_control(brake_sys);
break;
case SAFETY_STATE_EMERGENCY_STOP:
execute_emergency_brake_stop(brake_sys);
break;
}
// 输出执行器控制信号
output_brake_actuator_signals(&brake_sys->actuators);
// 更新诊断信息
update_brake_diagnostics(brake_sys);
}
// 制动系统安全检查
safety_event_t perform_brake_safety_checks(brake_system_t *brake_sys) {
safety_event_t event = SAFETY_EVENT_NONE;
// 传感器合理性检查
if (!check_brake_sensor_plausibility(&brake_sys->sensors)) {
brake_sys->safety.plausibility_check_failed = true;
event = SAFETY_EVENT_SINGLE_FAULT;
// 记录故障代码
add_diagnostic_trouble_code(&brake_sys->diagnostics, DTC_SENSOR_PLAUSIBILITY);
}
// 执行器响应检查
if (!check_brake_actuator_response(&brake_sys->actuators)) {
brake_sys->safety.actuator_fault_mask |= ACTUATOR_FAULT_NO_RESPONSE;
event = SAFETY_EVENT_SINGLE_FAULT;
// 记录故障代码
add_diagnostic_trouble_code(&brake_sys->diagnostics, DTC_ACTUATOR_FAULT);
}
// 系统响应时间检查
if (!check_brake_response_time(brake_sys)) {
event = SAFETY_EVENT_SYSTEMATIC_FAULT;
// 记录故障代码
add_diagnostic_trouble_code(&brake_sys->diagnostics, DTC_RESPONSE_TIME);
}
// 多重故障检查
uint32_t total_faults = __builtin_popcount(brake_sys->safety.sensor_fault_mask) +
__builtin_popcount(brake_sys->safety.actuator_fault_mask);
if (total_faults >= 2) {
event = SAFETY_EVENT_MULTIPLE_FAULT;
}
return event;
}
// 故障安全制动控制
void execute_fail_safe_brake_control(brake_system_t *brake_sys) {
// 激活最大制动力
for (int i = 0; i < 4; i++) {
brake_sys->actuators.brake_force[i] = MAX_SAFE_BRAKE_FORCE;
}
// 激活制动灯
brake_sys->actuators.brake_lights = true;
// 禁用ABS和ESP
brake_sys->actuators.abs_active = false;
brake_sys->actuators.esp_active = false;
// 发送故障安全信号到其他系统
send_fail_safe_signal_to_powertrain();
send_fail_safe_signal_to_steering();
// 记录故障安全激活
log_fail_safe_activation(SYSTEM_BRAKE, get_system_time());
}
安全认证与测试
ISO 26262合规性
// ISO 26262合规性检查
typedef struct {
asil_level_t target_asil; // 目标ASIL等级
bool hazard_analysis_complete; // 危害分析完成
bool safety_requirements_defined; // 安全需求定义
bool safety_architecture_verified; // 安全架构验证
bool safety_implementation_tested; // 安全实现测试
bool safety_validation_passed; // 安全验证通过
float diagnostic_coverage; // 诊断覆盖率
float single_point_fault_metric; // 单点故障度量
float latent_fault_metric; // 潜在故障度量
} iso26262_compliance_t;
// ASIL等级验证
bool verify_asil_compliance(iso26262_compliance_t *compliance) {
// 检查诊断覆盖率要求
float required_dc = get_required_diagnostic_coverage(compliance->target_asil);
if (compliance->diagnostic_coverage < required_dc) {
return false;
}
// 检查单点故障度量
float required_spfm = get_required_spfm(compliance->target_asil);
if (compliance->single_point_fault_metric < required_spfm) {
return false;
}
// 检查潜在故障度量
float required_lfm = get_required_lfm(compliance->target_asil);
if (compliance->latent_fault_metric < required_lfm) {
return false;
}
// 检查所有必需的活动是否完成
return compliance->hazard_analysis_complete &&
compliance->safety_requirements_defined &&
compliance->safety_architecture_verified &&
compliance->safety_implementation_tested &&
compliance->safety_validation_passed;
}
// 安全度量计算
void calculate_safety_metrics(iso26262_compliance_t *compliance) {
// 计算诊断覆盖率
compliance->diagnostic_coverage = calculate_diagnostic_coverage();
// 计算单点故障度量
compliance->single_point_fault_metric = calculate_spfm();
// 计算潜在故障度量
compliance->latent_fault_metric = calculate_lfm();
}
// 安全测试执行
bool execute_safety_tests(void) {
bool all_tests_passed = true;
// 故障注入测试
if (!execute_fault_injection_tests()) {
all_tests_passed = false;
log_test_failure("Fault injection tests failed");
}
// 边界值测试
if (!execute_boundary_value_tests()) {
all_tests_passed = false;
log_test_failure("Boundary value tests failed");
}
// 压力测试
if (!execute_stress_tests()) {
all_tests_passed = false;
log_test_failure("Stress tests failed");
}
// 长期稳定性测试
if (!execute_endurance_tests()) {
all_tests_passed = false;
log_test_failure("Endurance tests failed");
}
return all_tests_passed;
}
总结
YTM32B1ME0x的安全特性与功能安全系统为汽车电子应用提供了全面的安全保障。通过硬件安全模块、内存保护、错误检测纠正、看门狗监控、时钟监控、电压监控、故障注入测试、安全状态机和综合故障诊断等多层安全机制，确保系统能够满足ISO 26262等功能安全标准的要求。
关键安全特性总结：
-
硬件安全模块: 提供加密、哈希、随机数生成和安全启动功能
-
内存保护单元: 防止非法内存访问，提供堆栈保护和动态权限管理
-
ECC错误检测: 自动检测和纠正内存错误，支持单比特和双比特错误处理
-
多级看门狗: 独立看门狗和窗口看门狗双重保护，支持任务级监控
-
时钟监控: 检测时钟失效并自动切换备用时钟，支持时钟恢复
-
电压监控: 监控供电电压，处理掉电和低电压情况
-
故障注入测试: 支持多种故障注入类型，验证故障检测覆盖率
-
安全状态机: 实现安全状态转换和故障处理策略
-
功能安全应用: 支持ASIL等级的汽车安全应用，如制动系统
-
ISO 26262合规: 满足功能安全标准要求，支持安全认证
这些安全特性的综合应用，使YTM32B1ME0x能够在严苛的汽车环境中提供可靠的安全保障，满足从ASIL A到ASIL D等不同安全等级的应用需求。
在下一篇文章中，我们将探讨YTM32B1ME0x的低功耗设计与电源管理，包括各种低功耗模式、动态电压频率调节、电源域管理等内容。
扫一扫
614
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
