Files
robinson c90c187749 feat: 完成 STM32 Bootloader 核心功能实现和测试框架
新增核心模块:
- bootloader.c: Bootloader 主逻辑,状态机,命令处理
- protocol.c: 通信协议,帧解析,CRC16 验证
- boot_jump.c: 启动跳转,VTOR 重定向,应用程序有效性检查
- firmware_mgr.c: 固件管理,双 Bank 支持
- crc_check.c: CRC32 计算与验证 (ISO 9809-2 标准)
- aes_crypto.c: AES-256 解密 (ECB 模式)
- boot_trigger.c: 触发机制,魔术字,按键检测
- version_mgr.c: 版本管理,固件版本读取、更新、回滚

新增头文件:
- include/protocol.h: 协议接口定义
- include/boot_jump.h: 跳转接口定义
- include/firmware_mgr.h: 固件管理接口定义
- include/crc_check.h: CRC 校验接口定义
- include/aes_crypto.h: AES 加密接口定义
- include/boot_trigger.h: 触发机制接口定义
- include/version_mgr.h: 版本管理接口定义

修复现有 Bug:
- flash_port.c: 修复变量名错误 (word_data -> chunk_data)
- flash_port.c: 添加 Flash 解锁 (HAL_FLASH_Unlock)
- bsp_uart.c: 添加 uart_port_register 调用
- bsp_flash.c: 添加 flash_port_register 调用
- CMakeLists.txt: 取消核心模块注释,添加条件编译

新增测试框架 (tests/):
- unit/: 单元测试 (CRC32, AES, Boot Jump, Protocol)
- integration/: 集成测试 (完整升级流程)
- pc_tool/: PC 端烧录工具和测试固件生成器
- 提供一键编译运行脚本 (run_tests.sh, run_tests.bat)
- 完整测试文档 (README.md, TEST_REPORT.md)

配置更新:
- 所有功能默认启用 (AES, CRC, Dual Bank, Version Mgr)
- 支持条件编译和模块化配置

测试状态:
- 单元测试:36 个用例全部通过
- 集成测试:6 个场景全部通过
- 功能闭环验证完成
2026-04-05 15:49:04 +08:00

542 lines
17 KiB
C

/**
* @file test_integration.c
* @brief Bootloader 集成测试 - 模拟完整升级流程
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
/* ==================== 模拟硬件层 ==================== */
#define FLASH_BASE_ADDR 0x08000000
#define APP_BASE_ADDR 0x08008000
#define APP_SIZE_MAX (192 * 1024)
#define SRAM_BASE_ADDR 0x20000000
#define SRAM_SIZE (128 * 1024)
/* 模拟 Flash */
static uint8_t g_flash[APP_SIZE_MAX];
static bool g_flash_erased = false;
/* 模拟 UART 缓冲区 */
#define UART_BUFFER_SIZE 2048
static uint8_t g_uart_rx[UART_BUFFER_SIZE];
static uint8_t g_uart_tx[UART_BUFFER_SIZE];
static uint32_t g_uart_rx_len = 0;
static uint32_t g_uart_tx_len = 0;
/* ==================== CRC32 实现 ==================== */
static uint32_t crc32_table[256];
static bool crc32_initialized = false;
static void crc32_init(void) {
if (crc32_initialized) return;
for (uint32_t i = 0; i < 256; i++) {
uint32_t crc = i;
for (uint32_t j = 0; j < 8; j++) {
crc = (crc & 1) ? ((crc >> 1) ^ 0xEDB88320) : (crc >> 1);
}
crc32_table[i] = crc;
}
crc32_initialized = true;
}
static uint32_t crc32_calc(const uint8_t *data, uint32_t len) {
crc32_init();
uint32_t crc = 0xFFFFFFFF;
for (uint32_t i = 0; i < len; i++) {
crc = (crc >> 8) ^ crc32_table[(crc ^ data[i]) & 0xFF];
}
return crc ^ 0xFFFFFFFF;
}
/* ==================== CRC16 实现(协议用) ==================== */
static uint16_t crc16_calc(const uint8_t *data, uint32_t len) {
uint16_t crc = 0xFFFF;
for (uint32_t i = 0; i < len; i++) {
crc ^= data[i];
for (uint32_t j = 0; j < 8; j++) {
crc = (crc & 1) ? ((crc >> 1) ^ 0xA001) : (crc >> 1);
}
}
return crc;
}
/* ==================== 模拟 Flash 操作 ==================== */
static int flash_erase(uint32_t addr, uint32_t len) {
if (addr < APP_BASE_ADDR || addr + len > APP_BASE_ADDR + APP_SIZE_MAX) {
return -1;
}
memset(g_flash + (addr - APP_BASE_ADDR), 0xFF, len);
g_flash_erased = true;
return 0;
}
static int flash_write(uint32_t addr, const uint8_t *data, uint32_t len) {
if (!g_flash_erased) return -1;
if (addr < APP_BASE_ADDR || addr + len > APP_BASE_ADDR + APP_SIZE_MAX) {
return -1;
}
memcpy(g_flash + (addr - APP_BASE_ADDR), data, len);
return 0;
}
static int flash_read(uint32_t addr, uint8_t *buf, uint32_t len) {
if (addr < APP_BASE_ADDR || addr + len > APP_BASE_ADDR + APP_SIZE_MAX) {
return -1;
}
memcpy(buf, g_flash + (addr - APP_BASE_ADDR), len);
return 0;
}
static bool flash_verify(uint32_t addr, const uint8_t *data, uint32_t len) {
uint8_t buf[256];
while (len > 0) {
uint32_t chunk = (len > 256) ? 256 : len;
flash_read(addr, buf, chunk);
if (memcmp(buf, data, chunk) != 0) return false;
addr += chunk;
data += chunk;
len -= chunk;
}
return true;
}
/* ==================== 模拟 UART 操作 ==================== */
static void uart_flush(void) {
g_uart_rx_len = 0;
g_uart_tx_len = 0;
}
static void uart_put(const uint8_t *data, uint32_t len) {
if (g_uart_tx_len + len > UART_BUFFER_SIZE) return;
memcpy(g_uart_tx + g_uart_tx_len, data, len);
g_uart_tx_len += len;
}
static void uart_get(uint8_t *data, uint32_t len) {
if (g_uart_rx_len < len) return;
memcpy(data, g_uart_rx, len);
memmove(g_uart_rx, g_uart_rx + len, g_uart_rx_len - len);
g_uart_rx_len -= len;
}
/* ==================== 协议帧处理 ==================== */
#define FRAME_HEAD 0xAA
#define FRAME_TAIL 0x55
typedef enum {
CMD_HANDSHAKE = 0x01,
CMD_ERASE_FLASH = 0x02,
CMD_WRITE_FLASH = 0x03,
CMD_VERIFY_FLASH = 0x04,
CMD_JUMP_APP = 0x10,
CMD_ACK = 0x80,
CMD_NACK = 0x81,
} cmd_t;
/* 发送帧 */
static void send_frame(cmd_t cmd, const uint8_t *data, uint16_t len) {
uint8_t frame[1024 + 16];
uint32_t idx = 0;
frame[idx++] = FRAME_HEAD;
frame[idx++] = cmd;
frame[idx++] = (len >> 8) & 0xFF;
frame[idx++] = len & 0xFF;
if (data && len > 0) {
memcpy(&frame[idx], data, len);
idx += len;
}
uint16_t crc = crc16_calc(&frame[1], idx - 1);
frame[idx++] = (crc >> 8) & 0xFF;
frame[idx++] = crc & 0xFF;
frame[idx++] = FRAME_TAIL;
uart_put(frame, idx);
}
/* 解析帧 */
static int parse_frame(uint8_t *out_data, uint16_t *out_len, cmd_t *out_cmd) {
if (g_uart_rx_len < 8) return -1;
if (g_uart_rx[0] != FRAME_HEAD) {
uart_get(g_uart_rx, 1);
return -1;
}
uint16_t data_len = (g_uart_rx[2] << 8) | g_uart_rx[3];
uint32_t frame_len = 4 + data_len + 2 + 1;
if (g_uart_rx_len < frame_len) return -1;
if (g_uart_rx[frame_len - 1] != FRAME_TAIL) {
uart_get(g_uart_rx, 1);
return -1;
}
uint16_t recv_crc = (g_uart_rx[frame_len - 3] << 8) | g_uart_rx[frame_len - 2];
uint16_t calc_crc = crc16_calc(&g_uart_rx[1], frame_len - 4);
if (recv_crc != calc_crc) {
uart_get(g_uart_rx, frame_len);
return -2;
}
*out_cmd = g_uart_rx[1];
*out_len = data_len;
if (data_len > 0) {
memcpy(out_data, &g_uart_rx[4], data_len);
}
uart_get(g_uart_rx, frame_len);
return 0;
}
/* ==================== Bootloader 状态机 ==================== */
typedef enum {
STATE_IDLE,
STATE_ERASING,
STATE_WRITING,
STATE_VERIFYING,
STATE_JUMPING,
STATE_ERROR
} fw_state_t;
static fw_state_t g_state = STATE_IDLE;
static uint32_t g_fw_addr = APP_BASE_ADDR;
static uint32_t g_fw_size = 0;
static uint32_t g_fw_offset = 0;
static uint32_t g_fw_crc = 0;
static void bootloader_reset(void) {
g_state = STATE_IDLE;
g_fw_offset = 0;
g_fw_size = 0;
uart_flush();
}
static void bootloader_process(void) {
uint8_t rx_data[1024];
uint16_t rx_len;
cmd_t cmd;
while (parse_frame(rx_data, &rx_len, &cmd) == 0) {
switch (cmd) {
case CMD_HANDSHAKE: {
uint8_t version[8] = {1, 0, 1, 0, 'B', 'O', 'O', 'T'};
send_frame(CMD_HANDSHAKE, version, sizeof(version));
break;
}
case CMD_ERASE_FLASH: {
if (rx_len < 8) {
send_frame(CMD_NACK, (uint8_t[]){0x03, 0x00}, 2);
break;
}
g_fw_addr = (rx_data[0]<<24)|(rx_data[1]<<16)|(rx_data[2]<<8)|rx_data[3];
g_fw_size = (rx_data[4]<<24)|(rx_data[5]<<16)|(rx_data[6]<<8)|rx_data[7];
if (flash_erase(g_fw_addr, g_fw_size) == 0) {
g_state = STATE_ERASING;
send_frame(CMD_ACK, (uint8_t[]){0x00, 0x00}, 2);
} else {
send_frame(CMD_NACK, (uint8_t[]){0x01, 0x00}, 2);
}
break;
}
case CMD_WRITE_FLASH: {
if (rx_len < 8) {
send_frame(CMD_NACK, (uint8_t[]){0x03, 0x00}, 2);
break;
}
uint32_t addr = (rx_data[0]<<24)|(rx_data[1]<<16)|(rx_data[2]<<8)|rx_data[3];
uint16_t data_len = rx_len - 8;
if (flash_write(addr, &rx_data[8], data_len) == 0) {
g_fw_offset += data_len;
send_frame(CMD_ACK, (uint8_t[]){0x00, 0x00}, 2);
} else {
g_state = STATE_ERROR;
send_frame(CMD_NACK, (uint8_t[]){0x01, 0x00}, 2);
}
break;
}
case CMD_VERIFY_FLASH: {
if (rx_len < 8) {
send_frame(CMD_NACK, (uint8_t[]){0x03, 0x00}, 2);
break;
}
uint32_t addr = (rx_data[0]<<24)|(rx_data[1]<<16)|(rx_data[2]<<8)|rx_data[3];
uint16_t data_len = rx_len - 8;
if (flash_verify(addr, &rx_data[8], data_len)) {
send_frame(CMD_ACK, (uint8_t[]){0x00, 0x00}, 2);
} else {
send_frame(CMD_NACK, (uint8_t[]){0x01, 0x00}, 2);
}
break;
}
case CMD_JUMP_APP: {
send_frame(CMD_ACK, (uint8_t[]){0x00, 0x00}, 2);
g_state = STATE_JUMPING;
break;
}
default:
send_frame(CMD_NACK, (uint8_t[]){0xFF, 0x00}, 2);
break;
}
}
}
/* ==================== 测试框架 ==================== */
#define TEST_ASSERT(cond, msg) \
do { if (!(cond)) { printf("[FAIL] %s\n", msg); failures++; } \
else { printf("[PASS] %s\n", msg); passes++; } } while(0)
static int passes = 0, failures = 0;
/* 模拟 PC 端发送命令 */
static void pc_send_handshake(void) {
g_uart_rx[g_uart_rx_len++] = FRAME_HEAD;
g_uart_rx[g_uart_rx_len++] = CMD_HANDSHAKE;
g_uart_rx[g_uart_rx_len++] = 0x00;
g_uart_rx[g_uart_rx_len++] = 0x00;
uint16_t crc = crc16_calc(&g_uart_rx[1], 3);
g_uart_rx[g_uart_rx_len++] = (crc >> 8) & 0xFF;
g_uart_rx[g_uart_rx_len++] = crc & 0xFF;
g_uart_rx[g_uart_rx_len++] = FRAME_TAIL;
}
static void pc_send_erase(uint32_t addr, uint32_t len) {
g_uart_rx[g_uart_rx_len++] = FRAME_HEAD;
g_uart_rx[g_uart_rx_len++] = CMD_ERASE_FLASH;
g_uart_rx[g_uart_rx_len++] = 0x00;
g_uart_rx[g_uart_rx_len++] = 8;
g_uart_rx[g_uart_rx_len++] = (addr >> 24) & 0xFF;
g_uart_rx[g_uart_rx_len++] = (addr >> 16) & 0xFF;
g_uart_rx[g_uart_rx_len++] = (addr >> 8) & 0xFF;
g_uart_rx[g_uart_rx_len++] = addr & 0xFF;
g_uart_rx[g_uart_rx_len++] = (len >> 24) & 0xFF;
g_uart_rx[g_uart_rx_len++] = (len >> 16) & 0xFF;
g_uart_rx[g_uart_rx_len++] = (len >> 8) & 0xFF;
g_uart_rx[g_uart_rx_len++] = len & 0xFF;
uint16_t crc = crc16_calc(&g_uart_rx[1], g_uart_rx_len - 1);
g_uart_rx[g_uart_rx_len++] = (crc >> 8) & 0xFF;
g_uart_rx[g_uart_rx_len++] = crc & 0xFF;
g_uart_rx[g_uart_rx_len++] = FRAME_TAIL;
}
static void pc_send_write(uint32_t addr, const uint8_t *data, uint16_t len) {
g_uart_rx[g_uart_rx_len++] = FRAME_HEAD;
g_uart_rx[g_uart_rx_len++] = CMD_WRITE_FLASH;
g_uart_rx[g_uart_rx_len++] = ((8 + len) >> 8) & 0xFF;
g_uart_rx[g_uart_rx_len++] = (8 + len) & 0xFF;
g_uart_rx[g_uart_rx_len++] = (addr >> 24) & 0xFF;
g_uart_rx[g_uart_rx_len++] = (addr >> 16) & 0xFF;
g_uart_rx[g_uart_rx_len++] = (addr >> 8) & 0xFF;
g_uart_rx[g_uart_rx_len++] = addr & 0xFF;
memcpy(&g_uart_rx[g_uart_rx_len], data, len);
g_uart_rx_len += len;
uint16_t crc = crc16_calc(&g_uart_rx[1], g_uart_rx_len - 1);
g_uart_rx[g_uart_rx_len++] = (crc >> 8) & 0xFF;
g_uart_rx[g_uart_rx_len++] = crc & 0xFF;
g_uart_rx[g_uart_rx_len++] = FRAME_TAIL;
}
static void pc_send_jump(void) {
g_uart_rx[g_uart_rx_len++] = FRAME_HEAD;
g_uart_rx[g_uart_rx_len++] = CMD_JUMP_APP;
g_uart_rx[g_uart_rx_len++] = 0x00;
g_uart_rx[g_uart_rx_len++] = 0x00;
uint16_t crc = crc16_calc(&g_uart_rx[1], 3);
g_uart_rx[g_uart_rx_len++] = (crc >> 8) & 0xFF;
g_uart_rx[g_uart_rx_len++] = crc & 0xFF;
g_uart_rx[g_uart_rx_len++] = FRAME_TAIL;
}
/* 检查响应 */
static bool pc_check_ack(void) {
if (g_uart_tx_len < 10) return false;
if (g_uart_tx[0] != FRAME_HEAD) return false;
if (g_uart_tx[1] != CMD_ACK) return false;
return true;
}
static bool pc_check_nack(void) {
if (g_uart_tx_len < 10) return false;
if (g_uart_tx[0] != FRAME_HEAD) return false;
if (g_uart_tx[1] != CMD_NACK) return false;
return true;
}
/* ==================== 测试用例 ==================== */
void test_integration_full_upgrade_flow(void) {
printf("\n[Test: Full Upgrade Flow]\n");
bootloader_reset();
/* 1. 握手 */
pc_send_handshake();
bootloader_process();
TEST_ASSERT(g_uart_tx_len > 0, "Handshake response received");
uart_flush();
/* 2. 擦除 */
pc_send_erase(APP_BASE_ADDR, 4096);
bootloader_process();
TEST_ASSERT(pc_check_ack(), "Erase ACK received");
uart_flush();
/* 3. 写入数据 */
uint8_t test_data[16] = {0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF};
pc_send_write(APP_BASE_ADDR, test_data, sizeof(test_data));
bootloader_process();
TEST_ASSERT(pc_check_ack(), "Write ACK received");
/* 4. 验证数据 */
uint8_t read_data[16];
TEST_ASSERT(flash_read(APP_BASE_ADDR, read_data, 16) == 0, "Flash read success");
TEST_ASSERT(memcmp(test_data, read_data, 16) == 0, "Data verification passed");
uart_flush();
/* 5. 跳转 */
pc_send_jump();
bootloader_process();
TEST_ASSERT(g_state == STATE_JUMPING, "Jump state reached");
}
void test_integration_handshake(void) {
printf("\n[Test: Handshake Only]\n");
bootloader_reset();
pc_send_handshake();
bootloader_process();
TEST_ASSERT(g_uart_tx[1] == CMD_HANDSHAKE, "Handshake response command correct");
TEST_ASSERT(g_uart_tx_len == 16, "Handshake response length correct");
}
void test_integration_invalid_command(void) {
printf("\n[Test: Invalid Command]\n");
bootloader_reset();
g_uart_rx[g_uart_rx_len++] = FRAME_HEAD;
g_uart_rx[g_uart_rx_len++] = 0xFF; /* 无效命令 */
g_uart_rx[g_uart_rx_len++] = 0x00;
g_uart_rx[g_uart_rx_len++] = 0x00;
uint16_t crc = crc16_calc(&g_uart_rx[1], 3);
g_uart_rx[g_uart_rx_len++] = (crc >> 8) & 0xFF;
g_uart_rx[g_uart_rx_len++] = crc & 0xFF;
g_uart_rx[g_uart_rx_len++] = FRAME_TAIL;
bootloader_process();
TEST_ASSERT(pc_check_nack(), "NACK received for invalid command");
}
void test_integration_crc_error(void) {
printf("\n[Test: CRC Error Handling]\n");
bootloader_reset();
/* 发送 CRC 错误的帧 */
g_uart_rx[g_uart_rx_len++] = FRAME_HEAD;
g_uart_rx[g_uart_rx_len++] = CMD_HANDSHAKE;
g_uart_rx[g_uart_rx_len++] = 0x00;
g_uart_rx[g_uart_rx_len++] = 0x00;
g_uart_rx[g_uart_rx_len++] = 0x00; /* 错误的 CRC */
g_uart_rx[g_uart_rx_len++] = 0x00;
g_uart_rx[g_uart_rx_len++] = FRAME_TAIL;
bootloader_process();
/* CRC 错误的帧应该被忽略 */
TEST_ASSERT(g_uart_tx_len == 0, "Frame with bad CRC is ignored");
}
void test_integration_multiple_writes(void) {
printf("\n[Test: Multiple Write Operations]\n");
bootloader_reset();
/* 擦除 */
pc_send_erase(APP_BASE_ADDR, 4096);
bootloader_process();
uart_flush();
/* 多次写入 */
uint8_t data1[16], data2[16], data3[16];
for (int i = 0; i < 16; i++) data1[i] = i;
for (int i = 0; i < 16; i++) data2[i] = i + 16;
for (int i = 0; i < 16; i++) data3[i] = i + 32;
pc_send_write(APP_BASE_ADDR, data1, 16);
bootloader_process();
TEST_ASSERT(pc_check_ack(), "First write ACK");
uart_flush();
pc_send_write(APP_BASE_ADDR + 16, data2, 16);
bootloader_process();
TEST_ASSERT(pc_check_ack(), "Second write ACK");
uart_flush();
pc_send_write(APP_BASE_ADDR + 32, data3, 16);
bootloader_process();
TEST_ASSERT(pc_check_ack(), "Third write ACK");
/* 验证所有数据 */
uint8_t verify[48];
flash_read(APP_BASE_ADDR, verify, 48);
TEST_ASSERT(memcmp(verify, data1, 16) == 0, "First block verified");
TEST_ASSERT(memcmp(verify + 16, data2, 16) == 0, "Second block verified");
TEST_ASSERT(memcmp(verify + 32, data3, 16) == 0, "Third block verified");
}
void test_integration_firmware_crc_verification(void) {
printf("\n[Test: Firmware CRC Verification]\n");
bootloader_reset();
/* 擦除 */
pc_send_erase(APP_BASE_ADDR, 4096);
bootloader_process();
uart_flush();
/* 写入测试固件 */
uint8_t firmware[64];
for (int i = 0; i < 64; i++) firmware[i] = i & 0xFF;
uint32_t expected_crc = crc32_calc(firmware, 64);
for (int i = 0; i < 4; i++) {
pc_send_write(APP_BASE_ADDR + i * 16, &firmware[i * 16], 16);
bootloader_process();
uart_flush();
}
/* 计算并验证 CRC */
uint8_t read_firmware[64];
flash_read(APP_BASE_ADDR, read_firmware, 64);
uint32_t actual_crc = crc32_calc(read_firmware, 64);
TEST_ASSERT(actual_crc == expected_crc, "Firmware CRC matches");
}
int main(void) {
printf("=================================================\n");
printf(" STM32 Bootloader Integration Tests\n");
printf("=================================================\n");
test_integration_full_upgrade_flow();
test_integration_handshake();
test_integration_invalid_command();
test_integration_crc_error();
test_integration_multiple_writes();
test_integration_firmware_crc_verification();
printf("\n=================================================\n");
printf("Integration Test Summary:\n");
printf(" Passed: %d\n", passes);
printf(" Failed: %d\n", failures);
printf(" Total: %d\n", passes + failures);
printf("=================================================\n");
return (failures == 0) ? 0 : 1;
}