/** * @file test_integration.c * @brief Bootloader 集成测试 - 模拟完整升级流程 */ #include #include #include #include /* ==================== 模拟硬件层 ==================== */ #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; }