/***************************************************************************** * @file PathStorage.c * @brief 路径文件存储模块实现 * @author AI Assistant * @date 2025-12-19 *****************************************************************************/ #include "PathStorage.h" #include "MCUFlash.h" #include "HTTPClient.h" #include "Internet.h" #include "HIDO_Debug.h" #include "main.h" #include #include /***************************************************************************** * 私有宏定义 *****************************************************************************/ #define FLASH_WRITE_ALIGN 32 // FLASH写入对齐要求（32字节） #define SECTOR_SIZE (128 * 1024) // 扇区大小128KB #define DOWNLOAD_BUFFER_SIZE (32 * 1024) // HTTP下载缓冲区32KB #define MAX_RETRY_COUNT 3 // 最大重试次数 // CRC32存储位置：路径数据末尾4字节 #define CRC32_OFFSET(data_size) (data_size) /***************************************************************************** * 私有数据结构 *****************************************************************************/ typedef struct { E_PathStorageStatus status; // 当前状态 HIDO_UINT8 progress; // 下载进度0-100 HIDO_UINT32 total_size; // 文件总大小 HIDO_UINT32 received_size; // 已接收大小 HIDO_UINT32 write_offset; // 当前写入偏移 HIDO_UINT8 align_buffer[FLASH_WRITE_ALIGN]; // 对齐缓冲区 HIDO_UINT8 align_buffer_len; // 对齐缓冲区当前长度 HIDO_UINT32 crc32; // 累积CRC32 HIDO_UINT8 retry_count; // 重试计数 HIDO_CHAR url[256]; // 下载URL } PathStorageContext_t; /***************************************************************************** * 私有全局变量 *****************************************************************************/ static PathStorageContext_t s_context = { .status = PATH_STORAGE_STATUS_IDLE, .progress = 0, .total_size = 0, .received_size = 0, .write_offset = 0, .align_buffer_len = 0, .crc32 = 0, .retry_count = 0 }; /***************************************************************************** * 私有函数声明 *****************************************************************************/ static HIDO_INT32 PathStorage_HTTPCallback(HIDO_UINT32 resp_code, ST_HTTPGetFileResponse *resp, HIDO_UINT8 *data, HIDO_UINT32 len, HIDO_VOID *arg); static HIDO_INT32 PathStorage_WriteToFlash(HIDO_UINT8 *data, HIDO_UINT32 len); static HIDO_INT32 PathStorage_FlushAlignBuffer(void); static HIDO_UINT32 PathStorage_SoftwareCRC32(const HIDO_UINT8 *data, HIDO_UINT32 len, HIDO_UINT32 crc); /***************************************************************************** * CRC32查表法实现（标准CRC-32，多项式0x04C11DB7，初始值0） *****************************************************************************/ static const HIDO_UINT32 crc32_table[256] = { 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D }; /** * @brief 软件CRC32计算（查表法）- 匹配binascii.crc32(data, 0) * @param data 数据指针 * @param len 数据长度（字节） * @param crc 当前CRC值（传入上次结果，首次传入0） * @return 计算得到的CRC32 * * 注意：这个实现匹配Python的binascii.crc32(data, 0) * 内部使用标准CRC32查表，但需要对输入和输出做XOR转换 */ static HIDO_UINT32 PathStorage_SoftwareCRC32(const HIDO_UINT8 *data, HIDO_UINT32 len, HIDO_UINT32 crc) { // 转换：binascii.crc32(data, crc) = ~crc32_standard(data, ~crc) // 首次调用时crc=0，转换为标准CRC32的初始值0xFFFFFFFF crc = ~crc; // 标准查表CRC32算法 while (len--) { crc = crc32_table[(crc ^ *data++) & 0xFF] ^ (crc >> 8); } // 转换回binascii.crc32格式 return ~crc; } /***************************************************************************** * 函数实现 *****************************************************************************/ /** * @brief 初始化路径存储模块 */ HIDO_INT32 PathStorage_Init(void) { HIDO_INT32 ret; // STM32硬件CRC已在main.c中初始化 // 初始化FLASH ret = MCUFlash_Init(); if (ret != 0) { HIDO_Debug("[PathStorage] MCUFlash_Init failed: %d\r\n", ret); return ret; } // 初始化上下文 memset(&s_context, 0, sizeof(s_context)); s_context.status = PATH_STORAGE_STATUS_IDLE; HIDO_Debug("[PathStorage] Init success, base addr: 0x%08X\r\n", PATH_STORAGE_BASE_ADDR); return 0; } /** * @brief 从HTTP下载路径文件并存储到FLASH */ HIDO_INT32 PathStorage_DownloadFromHTTP(const HIDO_CHAR *url) { HIDO_INT32 ret; if (url == NULL) { HIDO_Debug("[PathStorage] Invalid URL\r\n"); return -1; } // 检查网络状态 if (!Internet_IsIPReady()) { HIDO_Debug("[PathStorage] Network not ready\r\n"); s_context.status = PATH_STORAGE_STATUS_FAIL_NETWORK; return -2; } // 检查状态 if (s_context.status == PATH_STORAGE_STATUS_DOWNLOADING) { HIDO_Debug("[PathStorage] Already downloading\r\n"); return -3; } // 重置上下文 memset(&s_context, 0, sizeof(s_context)); strncpy(s_context.url, url, sizeof(s_context.url) - 1); s_context.status = PATH_STORAGE_STATUS_DOWNLOADING; s_context.retry_count = 0; // 擦除FLASH（擦除4个扇区=512KB） HIDO_Debug("[PathStorage] Erasing FLASH...\r\n"); ret = MCUFlash_Erase(PATH_STORAGE_BASE_ADDR, PATH_STORAGE_MAX_SIZE); if (ret != 0) { HIDO_Debug("[PathStorage] MCUFlash_Erase failed: %d\r\n", ret); s_context.status = PATH_STORAGE_STATUS_FAIL_FLASH; return -4; } // ===== 详细诊断开始 ===== HIDO_Debug("[PathStorage] ===== Pre-Download Diagnostics =====\r\n"); // 1. 检查网络状态 HIDO_BOOL network_ready = Internet_IsIPReady(); HIDO_Debug("[PathStorage] 1. Network Status: %s\r\n", network_ready ? "READY" : "NOT READY"); if (!network_ready) { HIDO_Debug("[PathStorage] ERROR: Network not ready!\r\n"); s_context.status = PATH_STORAGE_STATUS_FAIL_NETWORK; return -5; } // 2. 检查HTTPClient状态 extern HIDO_INT32 HTTPClient_GetState(HIDO_VOID); HIDO_INT32 http_state = HTTPClient_GetState(); HIDO_Debug("[PathStorage] 2. HTTPClient State: %d (0=IDLE, 1=CONNECTING, 2=CONNECTED)\r\n", http_state); if (http_state != 0) { HIDO_Debug("[PathStorage] WARNING: HTTPClient not IDLE, trying to reset...\r\n"); extern HIDO_VOID HTTPClient_Reset(HIDO_VOID); HTTPClient_Reset(); // 短暂延迟确保重置生效 for(volatile HIDO_UINT32 i = 0; i < 100000; i++); http_state = HTTPClient_GetState(); HIDO_Debug("[PathStorage] HTTPClient State after reset: %d\r\n", http_state); } // 3. 检查URL参数 HIDO_Debug("[PathStorage] 3. URL: %s\r\n", url); HIDO_Debug("[PathStorage] 4. URL Length: %u\r\n", strlen(url)); // 准备HTTP下载选项（不使用Range头，下载完整文件） ST_HTTPGetFileOpt opt; memset(&opt, 0, sizeof(opt)); opt.m_u32RangeBegin = 0; opt.m_u32RangeEnd = 0; // 0表示不限制结束位置，让服务器返回完整文件 opt.m_acIfRange[0] = '\0'; HIDO_Debug("[PathStorage] 5. HTTP Options: Range=%u-%u\r\n", opt.m_u32RangeBegin, opt.m_u32RangeEnd); // 6. 检查回调函数 HIDO_Debug("[PathStorage] 6. Callback Function: 0x%08X\r\n", (HIDO_UINT32)PathStorage_HTTPCallback); HIDO_Debug("[PathStorage] ===== Starting HTTP Request =====\r\n"); // 启动HTTP下载 ret = HTTPClient_GetFile((HIDO_CHAR *)url, PathStorage_HTTPCallback, &opt, NULL); HIDO_Debug("[PathStorage] HTTPClient_GetFile returned: %d\r\n", ret); if (ret != 0) { HIDO_Debug("[PathStorage] ===== HTTP Request FAILED =====\r\n"); HIDO_Debug("[PathStorage] Final diagnostics:\r\n"); HIDO_Debug(" - Network Ready: %s\r\n", Internet_IsIPReady() ? "YES" : "NO"); HIDO_Debug(" - HTTPClient State: %d\r\n", HTTPClient_GetState()); HIDO_Debug(" - URL valid: %s\r\n", (url && strlen(url) > 0) ? "YES" : "NO"); HIDO_Debug(" - Options valid: YES (stack)\r\n"); HIDO_Debug("[PathStorage] Please check HTTPClient_GetFile implementation\r\n"); s_context.status = PATH_STORAGE_STATUS_FAIL_NETWORK; return -5; } HIDO_Debug("[PathStorage] ===== HTTP Request Started Successfully =====\r\n"); return 0; } /** * @brief HTTP下载回调函数 */ static HIDO_INT32 PathStorage_HTTPCallback(HIDO_UINT32 resp_code, ST_HTTPGetFileResponse *resp, HIDO_UINT8 *data, HIDO_UINT32 len, HIDO_VOID *arg) { HIDO_INT32 ret; // 检查响应 if (resp == NULL) { HIDO_Debug("[PathStorage] HTTP response is NULL\r\n"); s_context.status = PATH_STORAGE_STATUS_FAIL_NETWORK; return -1; } // 首次接收，记录文件总大小 if (s_context.total_size == 0) { s_context.total_size = resp->m_u32RangeTotal; HIDO_Debug("[PathStorage] Total size: %u bytes\r\n", s_context.total_size); // 检查大小是否合理（至少要有头部40字节） if (s_context.total_size < sizeof(MowerPathHeader_t)) { HIDO_Debug("[PathStorage] File too small: %u\r\n", s_context.total_size); s_context.status = PATH_STORAGE_STATUS_FAIL_FORMAT; return -1; } // 检查是否超过存储空间 if (s_context.total_size > PATH_STORAGE_MAX_SIZE - 4) { // 预留4字节存CRC32 HIDO_Debug("[PathStorage] File too large: %u\r\n", s_context.total_size); s_context.status = PATH_STORAGE_STATUS_FAIL_FLASH; return -1; } } // 数据为NULL表示下载结束 if (data == NULL || len == 0) { // 刷新对齐缓冲区 ret = PathStorage_FlushAlignBuffer(); if (ret != 0) { HIDO_Debug("[PathStorage] Flush align buffer failed\r\n"); s_context.status = PATH_STORAGE_STATUS_FAIL_FLASH; return -1; } // 将CRC32写入FLASH末尾 HIDO_UINT32 crc32_final = s_context.crc32; ret = MCUFlash_Write(PATH_STORAGE_BASE_ADDR + s_context.write_offset, (HIDO_UINT8 *)&crc32_final, sizeof(crc32_final)); if (ret != 0) { HIDO_Debug("[PathStorage] Write CRC32 failed: %d\r\n", ret); s_context.status = PATH_STORAGE_STATUS_FAIL_FLASH; return -1; } HIDO_Debug("[PathStorage] Download complete, size: %u, CRC32: 0x%08X\r\n", s_context.received_size, crc32_final); // 验证数据 ret = PathStorage_VerifyCRC32(); if (ret == 0) { s_context.status = PATH_STORAGE_STATUS_SUCCESS; s_context.progress = 100; HIDO_Debug("[PathStorage] Storage success!\r\n"); } else { s_context.status = PATH_STORAGE_STATUS_FAIL_CRC; HIDO_Debug("[PathStorage] CRC verify failed\r\n"); } return 0; } // 接收数据 s_context.received_size += len; // 更新进度 if (s_context.total_size > 0) { s_context.progress = (HIDO_UINT8)((s_context.received_size * 100) / s_context.total_size); } // 累积计算CRC32（使用软件CRC32，初始值0） s_context.crc32 = PathStorage_SoftwareCRC32(data, len, s_context.crc32); // 写入FLASH（处理32字节对齐） ret = PathStorage_WriteToFlash(data, len); if (ret != 0) { HIDO_Debug("[PathStorage] Write to flash failed: %d\r\n", ret); s_context.status = PATH_STORAGE_STATUS_FAIL_FLASH; return -1; } HIDO_Debug("[PathStorage] Progress: %u%% (%u/%u bytes)\r\n", s_context.progress, s_context.received_size, s_context.total_size); return 0; } /** * @brief 写入数据到FLASH（处理32字节对齐） */ static HIDO_INT32 PathStorage_WriteToFlash(HIDO_UINT8 *data, HIDO_UINT32 len) { HIDO_INT32 ret; HIDO_UINT32 write_len; HIDO_UINT32 offset = 0; // 先处理对齐缓冲区中的剩余数据 if (s_context.align_buffer_len > 0) { HIDO_UINT32 need = FLASH_WRITE_ALIGN - s_context.align_buffer_len; HIDO_UINT32 copy = (len < need) ? len : need; memcpy(s_context.align_buffer + s_context.align_buffer_len, data, copy); s_context.align_buffer_len += copy; offset += copy; // 如果凑够了32字节，写入FLASH if (s_context.align_buffer_len == FLASH_WRITE_ALIGN) { ret = MCUFlash_Write(PATH_STORAGE_BASE_ADDR + s_context.write_offset, s_context.align_buffer, FLASH_WRITE_ALIGN); if (ret != 0) { return ret; } s_context.write_offset += FLASH_WRITE_ALIGN; s_context.align_buffer_len = 0; } } // 写入32字节对齐的数据块 write_len = (len - offset) / FLASH_WRITE_ALIGN * FLASH_WRITE_ALIGN; if (write_len > 0) { ret = MCUFlash_Write(PATH_STORAGE_BASE_ADDR + s_context.write_offset, data + offset, write_len); if (ret != 0) { return ret; } s_context.write_offset += write_len; offset += write_len; } // 剩余不足32字节的数据放入对齐缓冲区 if (offset < len) { HIDO_UINT32 remain = len - offset; memcpy(s_context.align_buffer, data + offset, remain); s_context.align_buffer_len = remain; } return 0; } /** * @brief 刷新对齐缓冲区（补0xFF后写入） */ static HIDO_INT32 PathStorage_FlushAlignBuffer(void) { HIDO_INT32 ret; if (s_context.align_buffer_len == 0) { return 0; } // 补0xFF到32字节对齐 memset(s_context.align_buffer + s_context.align_buffer_len, 0xFF, FLASH_WRITE_ALIGN - s_context.align_buffer_len); // 写入FLASH ret = MCUFlash_Write(PATH_STORAGE_BASE_ADDR + s_context.write_offset, s_context.align_buffer, FLASH_WRITE_ALIGN); if (ret != 0) { return ret; } s_context.write_offset += FLASH_WRITE_ALIGN; s_context.align_buffer_len = 0; return 0; } /** * @brief 从FLASH读取路径文件头 */ HIDO_INT32 PathStorage_ReadHeader(MowerPathHeader_t *header) { HIDO_INT32 ret; if (header == NULL) { return -1; } // 从FLASH读取头部 ret = MCUFlash_Read(PATH_STORAGE_BASE_ADDR, (HIDO_UINT8 *)header, sizeof(MowerPathHeader_t)); if (ret != 0) { HIDO_Debug("[PathStorage] Read header failed: %d\r\n", ret); return ret; } // 验证头部 if (header->sof != PATH_FILE_SOF) { HIDO_Debug("[PathStorage] Invalid SOF: 0x%04X\r\n", header->sof); return -2; } if (header->type != PATH_FILE_TYPE) { HIDO_Debug("[PathStorage] Invalid type: 0x%02X\r\n", header->type); return -3; } if (header->version != PATH_FILE_VERSION) { HIDO_Debug("[PathStorage] Version mismatch: 0x%02X\r\n", header->version); // 版本不匹配只警告，不返回错误 } HIDO_Debug("[PathStorage] Header valid - PathID: 0x%08X, Origin: (%.8f, %.8f, %.2f), Boundary: %u, Path: %u\r\n", header->path_id, header->origin_lon, header->origin_lat, header->origin_alt, header->boundary_count, header->path_count); return 0; } /** * @brief 从FLASH读取指定的路径点数据 */ HIDO_INT32 PathStorage_ReadPoint(HIDO_BOOL is_boundary, HIDO_UINT32 index, PathPoint_t *point) { HIDO_INT32 ret; HIDO_UINT32 offset; MowerPathHeader_t header; if (point == NULL) { return -1; } // 读取头部获取点数信息 ret = PathStorage_ReadHeader(&header); if (ret != 0) { return ret; } // 检查索引范围 if (is_boundary) { if (index >= header.boundary_count) { HIDO_Debug("[PathStorage] Boundary index out of range: %u/%u\r\n", index, header.boundary_count); return -2; } offset = sizeof(MowerPathHeader_t) + index * sizeof(PathPoint_t); } else { if (index >= header.path_count) { HIDO_Debug("[PathStorage] Path index out of range: %u/%u\r\n", index, header.path_count); return -2; } offset = sizeof(MowerPathHeader_t) + header.boundary_count * sizeof(PathPoint_t) + index * sizeof(PathPoint_t); } // 从FLASH读取点数据 ret = MCUFlash_Read(PATH_STORAGE_BASE_ADDR + offset, (HIDO_UINT8 *)point, sizeof(PathPoint_t)); if (ret != 0) { HIDO_Debug("[PathStorage] Read point failed: %d\r\n", ret); return ret; } return 0; } /** * @brief 批量读取路径点数据 */ HIDO_INT32 PathStorage_ReadPoints(HIDO_BOOL is_boundary, HIDO_UINT32 start_index, HIDO_UINT32 count, PathPoint_t *points) { HIDO_INT32 ret; HIDO_UINT32 offset; HIDO_UINT32 max_count; HIDO_UINT32 read_count; MowerPathHeader_t header; if (points == NULL || count == 0) { return -1; } // 读取头部获取点数信息 ret = PathStorage_ReadHeader(&header); if (ret != 0) { return ret; } // 检查索引范围并调整读取数量 if (is_boundary) { max_count = header.boundary_count; offset = sizeof(MowerPathHeader_t) + start_index * sizeof(PathPoint_t); } else { max_count = header.path_count; offset = sizeof(MowerPathHeader_t) + header.boundary_count * sizeof(PathPoint_t) + start_index * sizeof(PathPoint_t); } if (start_index >= max_count) { HIDO_Debug("[PathStorage] Start index out of range: %u/%u\r\n", start_index, max_count); return -2; } read_count = (start_index + count > max_count) ? (max_count - start_index) : count; // 从FLASH批量读取 ret = MCUFlash_Read(PATH_STORAGE_BASE_ADDR + offset, (HIDO_UINT8 *)points, read_count * sizeof(PathPoint_t)); if (ret != 0) { HIDO_Debug("[PathStorage] Read points failed: %d\r\n", ret); return ret; } return read_count; } /** * @brief 获取当前存储状态 */ E_PathStorageStatus PathStorage_GetStatus(void) { return s_context.status; } /** * @brief 获取下载进度 */ HIDO_UINT8 PathStorage_GetProgress(void) { return s_context.progress; } /** * @brief 擦除FLASH中的路径数据 */ HIDO_INT32 PathStorage_Erase(void) { HIDO_INT32 ret; HIDO_Debug("[PathStorage] Erasing...\r\n"); ret = MCUFlash_Erase(PATH_STORAGE_BASE_ADDR, PATH_STORAGE_MAX_SIZE); if (ret != 0) { HIDO_Debug("[PathStorage] Erase failed: %d\r\n", ret); return ret; } // 重置上下文 memset(&s_context, 0, sizeof(s_context)); s_context.status = PATH_STORAGE_STATUS_IDLE; HIDO_Debug("[PathStorage] Erase success\r\n"); return 0; } /** * @brief 验证FLASH中路径文件的CRC32 */ HIDO_INT32 PathStorage_VerifyCRC32(void) { HIDO_INT32 ret; MowerPathHeader_t header; HIDO_UINT32 data_size; HIDO_UINT32 stored_crc32; HIDO_UINT32 calc_crc32; HIDO_UINT8 buffer[256]; HIDO_UINT32 offset = 0; // 读取头部 ret = PathStorage_ReadHeader(&header); if (ret != 0) { return ret; } // 计算数据大小（头部 + 所有点坐标） data_size = sizeof(MowerPathHeader_t) + (header.boundary_count + header.path_count) * sizeof(PathPoint_t); // 读取存储的CRC32（在数据末尾） ret = MCUFlash_Read(PATH_STORAGE_BASE_ADDR + data_size, (HIDO_UINT8 *)&stored_crc32, sizeof(stored_crc32)); if (ret != 0) { HIDO_Debug("[PathStorage] Read stored CRC32 failed: %d\r\n", ret); return ret; } // 分块读取并计算CRC32（使用软件CRC32，初始值0） calc_crc32 = 0; while (offset < data_size) { HIDO_UINT32 read_len = (data_size - offset > sizeof(buffer)) ? sizeof(buffer) : (data_size - offset); ret = MCUFlash_Read(PATH_STORAGE_BASE_ADDR + offset, buffer, read_len); if (ret != 0) { HIDO_Debug("[PathStorage] Read data for CRC failed: %d\r\n", ret); return ret; } // 累积计算软件CRC32 calc_crc32 = PathStorage_SoftwareCRC32(buffer, read_len, calc_crc32); offset += read_len; } // 比对CRC32 if (calc_crc32 != stored_crc32) { HIDO_Debug("[PathStorage] CRC32 mismatch - Stored: 0x%08X, Calc: 0x%08X\r\n", stored_crc32, calc_crc32); return -1; } HIDO_Debug("[PathStorage] CRC32 verify OK: 0x%08X\r\n", calc_crc32); return 0; }