/*****************************************************************************
|
* @file OTAUpgrade.c
|
* @brief 4G OTA固件升级模块实现
|
* @author AI Assistant
|
* @date 2025-12-20
|
*****************************************************************************/
|
|
#include "OTAUpgrade.h"
|
#include "HTTPClient.h"
|
#include "MCUFlash.h"
|
#include "Internet.h"
|
#include "HIDO_Debug.h"
|
#include "HIDO_Util.h"
|
#include "string.h"
|
|
// 引入AES解密算法
|
#include "../decryption/aes.h"
|
|
/*****************************************************************************
|
* 宏定义
|
*****************************************************************************/
|
#define OTA_AES_BLOCK_SIZE 16 // AES加密块大小
|
#define OTA_FLASH_ALIGN_SIZE 32 // Flash写入对齐大小
|
#define OTA_DECRYPT_BUFFER_SIZE 512 // 解密缓冲区大小（32的倍数）
|
#define OTA_FILE_TERMINATOR_CR 0x0D // 文件结束符：回车符
|
#define OTA_FILE_TERMINATOR_LF 0x0A // 文件结束符：换行符
|
|
/*****************************************************************************
|
* 本地变量
|
*****************************************************************************/
|
static ST_OTAInfo l_stOTAInfo; // OTA升级信息
|
static HIDO_CHAR l_acDownloadUrl[256]; // 下载URL
|
static HIDO_UINT8 l_au8FlashWriteBuffer[OTA_FLASH_ALIGN_SIZE]; // Flash写入缓冲区
|
static HIDO_UINT32 l_u32FlashWriteBufferLen = 0; // 缓冲区当前长度
|
static HIDO_UINT32 l_u32FlashWrittenBytes = 0; // 已写入Flash的字节数（不含缓冲区）
|
|
// 解密相关变量
|
static HIDO_UINT8 l_au8DecryptBuffer[OTA_DECRYPT_BUFFER_SIZE]; // 解密缓冲区
|
static HIDO_UINT8 l_au8AESChainBlock[OTA_AES_BLOCK_SIZE]; // AES CBC模式链接块
|
static HIDO_BOOL l_bDecryptTaskRunning = HIDO_FALSE; // 解密任务运行标志
|
static HIDO_UINT32 l_u32DecryptFlashWrittenBytes = 0; // 解密Flash已写入字节数
|
|
// 超时和重试相关变量
|
#define OTA_DOWNLOAD_TIMEOUT_MS 30000 // 下载超时时间：30秒
|
#define OTA_MAX_RETRY_COUNT 3 // 最大重试次数
|
static HIDO_UINT32 l_u32LastProgressTick = 0; // 最后一次有进度的时间戳
|
static HIDO_UINT32 l_u32LastDownloadedSize = 0; // 上次记录的下载大小
|
static HIDO_UINT8 l_u8RetryCount = 0; // 当前重试次数
|
|
/*****************************************************************************
|
* 本地函数声明
|
*****************************************************************************/
|
static HIDO_INT32 OTA_HTTPDownloadCallback(HIDO_UINT32 _u32RespCode,
|
ST_HTTPGetFileResponse *_pstResponse,
|
HIDO_UINT8 *_pu8Data,
|
HIDO_UINT32 _u32Len,
|
HIDO_VOID *_pArg);
|
static HIDO_INT32 OTA_FlashWriteAligned(HIDO_UINT32 _u32BaseAddr,
|
HIDO_UINT32 _u32WrittenBytes,
|
const HIDO_UINT8 *_pu8Data,
|
HIDO_UINT32 _u32Len);
|
static HIDO_INT32 OTA_FlushFlashWriteBuffer(HIDO_UINT32 _u32BaseAddr,
|
HIDO_UINT32 _u32WrittenBytes,
|
HIDO_UINT32 *_pu32GlobalWrittenBytes);
|
static HIDO_VOID OTA_ProcessDecryptTask(HIDO_VOID);
|
|
/*****************************************************************************
|
* 函数实现
|
*****************************************************************************/
|
|
/**
|
* @brief 初始化OTA升级模块
|
*/
|
HIDO_INT32 OTA_Init(HIDO_VOID)
|
{
|
HIDO_INT32 ret;
|
|
HIDO_Debug("[OTA] Initializing OTA module...\r\n");
|
|
// 确保MCUFlash已初始化
|
ret = MCUFlash_Init();
|
if (ret != HIDO_OK) {
|
HIDO_Debug("[OTA] ERROR: MCUFlash_Init failed: %d\r\n", ret);
|
return ret;
|
}
|
|
// 初始化数据结构
|
memset(&l_stOTAInfo, 0, sizeof(l_stOTAInfo));
|
l_stOTAInfo.eState = OTA_STATE_IDLE;
|
l_stOTAInfo.eLastError = OTA_ERR_NONE;
|
|
memset(l_acDownloadUrl, 0, sizeof(l_acDownloadUrl));
|
memset(l_au8FlashWriteBuffer, 0xFF, sizeof(l_au8FlashWriteBuffer));
|
l_u32FlashWriteBufferLen = 0;
|
l_u32FlashWrittenBytes = 0;
|
l_u32DecryptFlashWrittenBytes = 0;
|
l_bDecryptTaskRunning = HIDO_FALSE;
|
|
HIDO_Debug("[OTA] Module initialized successfully\r\n");
|
|
return HIDO_OK;
|
}
|
|
/**
|
* @brief 启动OTA固件下载
|
*/
|
HIDO_INT32 OTA_StartDownload(const HIDO_CHAR *_pcUrl)
|
{
|
ST_HTTPGetFileOpt stOpt;
|
|
// 参数检查
|
if (_pcUrl == HIDO_NULL || strlen(_pcUrl) == 0) {
|
HIDO_Debug("[OTA] Invalid URL\r\n");
|
return OTA_ERR_INVALID_PARAM;
|
}
|
|
// 状态检查
|
if (l_stOTAInfo.eState != OTA_STATE_IDLE &&
|
l_stOTAInfo.eState != OTA_STATE_DOWNLOAD_FAILED) {
|
HIDO_Debug("[OTA] Busy, current state: %d\r\n", l_stOTAInfo.eState);
|
return OTA_ERR_BUSY;
|
}
|
|
// 网络检查
|
if (Internet_IsIPReady() != HIDO_TRUE) {
|
HIDO_Debug("[OTA] Network not ready\r\n");
|
l_stOTAInfo.eLastError = OTA_ERR_NO_NETWORK;
|
return OTA_ERR_NO_NETWORK;
|
}
|
|
// 保存URL
|
HIDO_UtilSnprintf(l_acDownloadUrl, sizeof(l_acDownloadUrl), "%s", _pcUrl);
|
|
// 擦除加密固件存储区
|
HIDO_Debug("[OTA] Erasing encrypted flash area: 0x%08X, size: %d KB\r\n",
|
OTA_ENCRYPTED_FLASH_ADDR, OTA_ENCRYPTED_FLASH_SIZE / 1024);
|
|
if (MCUFlash_Erase(OTA_ENCRYPTED_FLASH_ADDR, OTA_ENCRYPTED_FLASH_SIZE) != HIDO_OK) {
|
HIDO_Debug("[OTA] Flash erase failed\r\n");
|
l_stOTAInfo.eState = OTA_STATE_DOWNLOAD_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_FLASH_ERASE_FAILED;
|
return OTA_ERR_FLASH_ERASE_FAILED;
|
}
|
|
// 重置状态
|
l_stOTAInfo.eState = OTA_STATE_DOWNLOADING;
|
l_stOTAInfo.eLastError = OTA_ERR_NONE;
|
l_stOTAInfo.u32TotalSize = 0;
|
l_stOTAInfo.u32DownloadedSize = 0;
|
l_stOTAInfo.u32DecryptedSize = 0;
|
l_stOTAInfo.u8Progress = 0;
|
l_u32FlashWriteBufferLen = 0;
|
memset(l_au8FlashWriteBuffer, 0xFF, sizeof(l_au8FlashWriteBuffer));
|
|
// 初始化超时检测
|
l_u32LastProgressTick = xTaskGetTickCount();
|
l_u32LastDownloadedSize = 0;
|
|
// 配置HTTP下载选项（支持断点续传）
|
memset(&stOpt, 0, sizeof(stOpt));
|
stOpt.m_u32RangeBegin = 0; // 从头开始下载
|
stOpt.m_u32RangeEnd = 0; // 下载到文件末尾
|
|
// 如果有ETag，使用ETag进行断点续传验证
|
if (strlen(l_stOTAInfo.acETag) > 0) {
|
HIDO_UtilSnprintf(stOpt.m_acIfRange, sizeof(stOpt.m_acIfRange),
|
"%s", l_stOTAInfo.acETag);
|
}
|
|
HIDO_Debug("[OTA] Starting download from: %s\r\n", _pcUrl);
|
|
// 启动HTTP下载
|
HIDO_INT32 i32Ret = HTTPClient_GetFile((HIDO_CHAR *)_pcUrl, OTA_HTTPDownloadCallback, &stOpt, HIDO_NULL);
|
HIDO_Debug("[OTA] HTTPClient_GetFile returned: %d\r\n", i32Ret);
|
|
if (i32Ret != HIDO_OK) {
|
HIDO_Debug("[OTA] HTTPClient_GetFile failed - HTTPClient may be busy\r\n");
|
l_stOTAInfo.eState = OTA_STATE_DOWNLOAD_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_HTTP_FAILED;
|
return OTA_ERR_HTTP_FAILED;
|
}
|
|
return HIDO_OK;
|
}
|
|
/**
|
* @brief HTTP下载回调函数
|
*/
|
static HIDO_INT32 OTA_HTTPDownloadCallback(HIDO_UINT32 _u32RespCode,
|
ST_HTTPGetFileResponse *_pstResponse,
|
HIDO_UINT8 *_pu8Data,
|
HIDO_UINT32 _u32Len,
|
HIDO_VOID *_pArg)
|
{
|
HIDO_INT32 i32Ret;
|
|
HIDO_Debug("[OTA] Callback: RespCode=%d, DataLen=%d\r\n", _u32RespCode, _u32Len);
|
|
// 检查HTTP响应码
|
if (_u32RespCode != 200 && _u32RespCode != 206) {
|
HIDO_Debug("[OTA] HTTP error, response code: %d\r\n", _u32RespCode);
|
l_stOTAInfo.eState = OTA_STATE_DOWNLOAD_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_HTTP_FAILED;
|
|
// 标记为需要重试（而不是立即放弃）
|
// Poll函数会检测到DOWNLOAD_FAILED状态并触发重试
|
return HIDO_ERR;
|
}
|
|
// 首次回调，获取文件总大小
|
if (l_stOTAInfo.u32TotalSize == 0 && _pstResponse != HIDO_NULL) {
|
l_stOTAInfo.u32TotalSize = _pstResponse->m_u32RangeTotal;
|
|
// 检查文件大小是否超过256KB
|
if (l_stOTAInfo.u32TotalSize > OTA_ENCRYPTED_FLASH_SIZE) {
|
HIDO_Debug("[OTA] File too large: %d bytes (max: %d bytes)\r\n",
|
l_stOTAInfo.u32TotalSize, OTA_ENCRYPTED_FLASH_SIZE);
|
l_stOTAInfo.eState = OTA_STATE_DOWNLOAD_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_FILE_TOO_LARGE;
|
return HIDO_ERR;
|
}
|
|
// 保存ETag用于后续断点续传
|
if (strlen(_pstResponse->m_acETag) > 0) {
|
HIDO_UtilSnprintf(l_stOTAInfo.acETag, sizeof(l_stOTAInfo.acETag),
|
"%s", _pstResponse->m_acETag);
|
}
|
|
HIDO_Debug("[OTA] File size: %d bytes (%.1f KB), ETag: %s\r\n",
|
l_stOTAInfo.u32TotalSize,
|
l_stOTAInfo.u32TotalSize / 1024.0f,
|
l_stOTAInfo.acETag);
|
}
|
|
// 接收数据
|
if (_pu8Data != HIDO_NULL && _u32Len > 0) {
|
// 更新进度时间戳（有数据到达）
|
l_u32LastProgressTick = xTaskGetTickCount();
|
l_u32LastDownloadedSize = l_stOTAInfo.u32DownloadedSize;
|
|
// 写入Flash（带对齐处理）- 传递已写入Flash的字节数
|
i32Ret = OTA_FlashWriteAligned(OTA_ENCRYPTED_FLASH_ADDR,
|
l_u32FlashWrittenBytes,
|
_pu8Data, _u32Len);
|
if (i32Ret < 0) {
|
HIDO_Debug("[OTA] Flash write failed at offset: 0x%X\r\n",
|
l_stOTAInfo.u32DownloadedSize);
|
l_stOTAInfo.eState = OTA_STATE_DOWNLOAD_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_FLASH_WRITE_FAILED;
|
return HIDO_ERR;
|
}
|
|
// 更新下载阶段的Flash写入计数器
|
l_u32FlashWrittenBytes += i32Ret;
|
|
l_stOTAInfo.u32DownloadedSize += _u32Len;
|
|
// 更新进度
|
if (l_stOTAInfo.u32TotalSize > 0) {
|
l_stOTAInfo.u8Progress = (HIDO_UINT8)((l_stOTAInfo.u32DownloadedSize * 100) /
|
l_stOTAInfo.u32TotalSize);
|
}
|
|
// 每10%打印一次进度
|
static HIDO_UINT8 s_u8LastLogProgress = 0;
|
if (l_stOTAInfo.u8Progress >= s_u8LastLogProgress + 10) {
|
HIDO_Debug("[OTA] Download progress: %d%% (%d/%d bytes)\r\n",
|
l_stOTAInfo.u8Progress,
|
l_stOTAInfo.u32DownloadedSize,
|
l_stOTAInfo.u32TotalSize);
|
s_u8LastLogProgress = l_stOTAInfo.u8Progress;
|
}
|
}
|
|
// 下载完成
|
if (l_stOTAInfo.u32DownloadedSize >= l_stOTAInfo.u32TotalSize &&
|
l_stOTAInfo.u32TotalSize > 0) {
|
|
// 刷新缓冲区（写入剩余数据）
|
if (l_u32FlashWriteBufferLen > 0) {
|
OTA_FlushFlashWriteBuffer(OTA_ENCRYPTED_FLASH_ADDR,
|
l_u32FlashWrittenBytes,
|
&l_u32FlashWrittenBytes);
|
}
|
|
l_stOTAInfo.eState = OTA_STATE_DOWNLOAD_COMPLETE;
|
l_stOTAInfo.u8Progress = 100;
|
HIDO_Debug("[OTA] Download completed: %d bytes\r\n", l_stOTAInfo.u32DownloadedSize);
|
}
|
|
return HIDO_OK;
|
}
|
|
/**
|
* @brief Flash写入（带32字节对齐处理）
|
* @param _u32BaseAddr Flash基地址（例如0x08100000）
|
* @param _u32WrittenBytes 已成功写入Flash的字节数（不包括缓冲区中的数据）
|
* @param _pu8Data 待写入的数据
|
* @param _u32Len 数据长度
|
* @return HIDO_INT32 成功写入Flash的字节数
|
*/
|
static HIDO_INT32 OTA_FlashWriteAligned(HIDO_UINT32 _u32BaseAddr,
|
HIDO_UINT32 _u32WrittenBytes,
|
const HIDO_UINT8 *_pu8Data,
|
HIDO_UINT32 _u32Len)
|
{
|
HIDO_UINT32 u32WriteLen;
|
HIDO_UINT32 u32Offset = 0;
|
HIDO_UINT32 u32FlashWrittenThisCall = 0; // 本次调用写入Flash的字节数
|
HIDO_INT32 i32Ret;
|
|
while (u32Offset < _u32Len) {
|
// 计算可以写入缓冲区的数据长度
|
u32WriteLen = OTA_FLASH_ALIGN_SIZE - l_u32FlashWriteBufferLen;
|
if (u32WriteLen > (_u32Len - u32Offset)) {
|
u32WriteLen = _u32Len - u32Offset;
|
}
|
|
// 复制到缓冲区
|
memcpy(l_au8FlashWriteBuffer + l_u32FlashWriteBufferLen,
|
_pu8Data + u32Offset, u32WriteLen);
|
l_u32FlashWriteBufferLen += u32WriteLen;
|
u32Offset += u32WriteLen;
|
|
// 缓冲区满了，写入Flash
|
if (l_u32FlashWriteBufferLen >= OTA_FLASH_ALIGN_SIZE) {
|
// 计算实际Flash写入地址 = 基地址 + 历史已写入字节 + 本次调用已写入字节
|
HIDO_UINT32 u32FlashAddr = _u32BaseAddr + _u32WrittenBytes + u32FlashWrittenThisCall;
|
|
// 调试：打印第一次写入的详细信息
|
static HIDO_BOOL s_bFirstWriteLogged = HIDO_FALSE;
|
if (!s_bFirstWriteLogged && u32FlashAddr >= OTA_DECRYPTED_FLASH_ADDR) {
|
HIDO_Debug("[OTA] First decrypt write: Addr=0x%08X, Data[0-7]=%02X %02X %02X %02X %02X %02X %02X %02X\r\n",
|
u32FlashAddr,
|
l_au8FlashWriteBuffer[0], l_au8FlashWriteBuffer[1], l_au8FlashWriteBuffer[2], l_au8FlashWriteBuffer[3],
|
l_au8FlashWriteBuffer[4], l_au8FlashWriteBuffer[5], l_au8FlashWriteBuffer[6], l_au8FlashWriteBuffer[7]);
|
s_bFirstWriteLogged = HIDO_TRUE;
|
}
|
|
i32Ret = MCUFlash_Write(u32FlashAddr, l_au8FlashWriteBuffer, OTA_FLASH_ALIGN_SIZE);
|
if (i32Ret != HIDO_OK) {
|
HIDO_Debug("[OTA] MCUFlash_Write failed at 0x%08X (TotalWritten=0x%X)\r\n",
|
u32FlashAddr, _u32WrittenBytes + u32FlashWrittenThisCall);
|
return HIDO_ERR;
|
}
|
|
u32FlashWrittenThisCall += OTA_FLASH_ALIGN_SIZE;
|
l_u32FlashWriteBufferLen = 0;
|
memset(l_au8FlashWriteBuffer, 0xFF, sizeof(l_au8FlashWriteBuffer));
|
}
|
}
|
|
// 返回本次调用写入Flash的字节数（由调用者更新相应计数器）
|
return u32FlashWrittenThisCall;
|
}
|
|
/**
|
* @brief 刷新Flash写入缓冲区（写入剩余数据）
|
* @param _u32BaseAddr Flash基地址
|
* @param _u32WrittenBytes 已写入的字节数
|
* @param _pu32GlobalWrittenBytes 全局写入计数器指针（用于更新）
|
*/
|
static HIDO_INT32 OTA_FlushFlashWriteBuffer(HIDO_UINT32 _u32BaseAddr,
|
HIDO_UINT32 _u32WrittenBytes,
|
HIDO_UINT32 *_pu32GlobalWrittenBytes)
|
{
|
if (l_u32FlashWriteBufferLen > 0) {
|
// 剩余部分用0xFF填充到32字节对齐
|
memset(l_au8FlashWriteBuffer + l_u32FlashWriteBufferLen, 0xFF,
|
OTA_FLASH_ALIGN_SIZE - l_u32FlashWriteBufferLen);
|
|
HIDO_UINT32 u32FlashAddr = _u32BaseAddr + _u32WrittenBytes;
|
if (MCUFlash_Write(u32FlashAddr, l_au8FlashWriteBuffer, OTA_FLASH_ALIGN_SIZE) != HIDO_OK) {
|
HIDO_Debug("[OTA] Flush buffer failed at 0x%08X\r\n", u32FlashAddr);
|
return HIDO_ERR;
|
}
|
|
// 更新全局写入计数器
|
if (_pu32GlobalWrittenBytes != HIDO_NULL) {
|
*_pu32GlobalWrittenBytes += OTA_FLASH_ALIGN_SIZE;
|
}
|
|
l_u32FlashWriteBufferLen = 0;
|
memset(l_au8FlashWriteBuffer, 0xFF, sizeof(l_au8FlashWriteBuffer));
|
}
|
|
return HIDO_OK;
|
}
|
|
/**
|
* @brief 启动固件解密
|
*/
|
HIDO_INT32 OTA_StartDecrypt(HIDO_VOID)
|
{
|
HIDO_INT32 ret;
|
|
// 状态检查
|
if (l_stOTAInfo.eState != OTA_STATE_DOWNLOAD_COMPLETE) {
|
HIDO_Debug("[OTA] Cannot start decrypt, state: %d\r\n", l_stOTAInfo.eState);
|
return HIDO_ERR;
|
}
|
|
// 擦除解密固件存储区
|
HIDO_Debug("[OTA] Erasing decrypted flash area: 0x%08X, size: %d KB\r\n",
|
OTA_DECRYPTED_FLASH_ADDR, OTA_DECRYPTED_FLASH_SIZE / 1024);
|
|
if (MCUFlash_Erase(OTA_DECRYPTED_FLASH_ADDR, OTA_DECRYPTED_FLASH_SIZE) != HIDO_OK) {
|
HIDO_Debug("[OTA] Flash erase failed\r\n");
|
l_stOTAInfo.eState = OTA_STATE_DECRYPT_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_FLASH_ERASE_FAILED;
|
return OTA_ERR_FLASH_ERASE_FAILED;
|
}
|
|
HIDO_Debug("[OTA] Flash erased, waiting for stabilization...\r\n");
|
vTaskDelay(100); // 延迟100ms等待Flash稳定
|
|
// 重新初始化Flash（确保擦除后状态正确）
|
ret = MCUFlash_Init();
|
if (ret != HIDO_OK) {
|
HIDO_Debug("[OTA] Flash re-init failed: %d\r\n", ret);
|
l_stOTAInfo.eState = OTA_STATE_DECRYPT_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_FLASH_ERASE_FAILED;
|
return OTA_ERR_FLASH_ERASE_FAILED;
|
}
|
HIDO_Debug("[OTA] Flash re-initialized\r\n");
|
|
// 验证Flash是否已擦除（检查前64字节）
|
HIDO_UINT8 au8VerifyBuf[64];
|
if (MCUFlash_Read(OTA_DECRYPTED_FLASH_ADDR, au8VerifyBuf, 64) == HIDO_OK) {
|
HIDO_BOOL bEraseOk = HIDO_TRUE;
|
for (HIDO_UINT32 i = 0; i < 64; i++) {
|
if (au8VerifyBuf[i] != 0xFF) {
|
bEraseOk = HIDO_FALSE;
|
HIDO_Debug("[OTA] Erase verify FAILED at offset 0x%X: value=0x%02X\r\n", i, au8VerifyBuf[i]);
|
// 打印前16字节内容
|
HIDO_Debug("[OTA] First 16 bytes: ");
|
for (HIDO_UINT32 j = 0; j < 16; j++) {
|
HIDO_Debug("%02X ", au8VerifyBuf[j]);
|
}
|
HIDO_Debug("\r\n");
|
break;
|
}
|
}
|
if (bEraseOk) {
|
HIDO_Debug("[OTA] Erase verification PASSED (first 64 bytes all 0xFF)\r\n");
|
} else {
|
HIDO_Debug("[OTA] WARNING: Flash may not be fully erased, write may fail\r\n");
|
}
|
} else {
|
HIDO_Debug("[OTA] Erase verification read failed\r\n");
|
}
|
|
// 初始化AES解密
|
aesDecInit();
|
memset(l_au8AESChainBlock, 0, sizeof(l_au8AESChainBlock)); // CBC模式IV为全0
|
|
l_stOTAInfo.eState = OTA_STATE_DECRYPTING;
|
l_stOTAInfo.u32DecryptedSize = 0;
|
l_stOTAInfo.u8Progress = 0;
|
l_u32FlashWriteBufferLen = 0;
|
l_u32DecryptFlashWrittenBytes = 0; // 重置解密Flash写入计数器
|
memset(l_au8FlashWriteBuffer, 0xFF, sizeof(l_au8FlashWriteBuffer));
|
l_bDecryptTaskRunning = HIDO_TRUE;
|
|
HIDO_Debug("[OTA] Decryption started, size: %d bytes\r\n", l_stOTAInfo.u32TotalSize);
|
|
return HIDO_OK;
|
}
|
|
/**
|
* @brief 处理解密任务（分块执行，避免阻塞）
|
*/
|
static HIDO_VOID OTA_ProcessDecryptTask(HIDO_VOID)
|
{
|
HIDO_UINT32 u32ReadLen;
|
HIDO_UINT32 i;
|
HIDO_INT32 i32Ret;
|
|
if (!l_bDecryptTaskRunning) {
|
return;
|
}
|
|
// 每次处理一块数据（512字节）
|
if (l_stOTAInfo.u32DecryptedSize >= l_stOTAInfo.u32TotalSize) {
|
// 解密完成，刷新缓冲区
|
if (l_u32FlashWriteBufferLen > 0) {
|
OTA_FlushFlashWriteBuffer(OTA_DECRYPTED_FLASH_ADDR,
|
l_u32DecryptFlashWrittenBytes,
|
&l_u32DecryptFlashWrittenBytes);
|
}
|
|
l_bDecryptTaskRunning = HIDO_FALSE;
|
l_stOTAInfo.eState = OTA_STATE_DECRYPT_COMPLETE;
|
l_stOTAInfo.u8Progress = 100;
|
HIDO_Debug("[OTA] Decryption completed: %d bytes\r\n", l_stOTAInfo.u32DecryptedSize);
|
return;
|
}
|
|
// 读取加密数据
|
u32ReadLen = OTA_DECRYPT_BUFFER_SIZE;
|
if (l_stOTAInfo.u32DecryptedSize + u32ReadLen > l_stOTAInfo.u32TotalSize) {
|
u32ReadLen = l_stOTAInfo.u32TotalSize - l_stOTAInfo.u32DecryptedSize;
|
}
|
|
i32Ret = MCUFlash_Read(OTA_ENCRYPTED_FLASH_ADDR + l_stOTAInfo.u32DecryptedSize,
|
l_au8DecryptBuffer, u32ReadLen);
|
if (i32Ret != HIDO_OK) {
|
HIDO_Debug("[OTA] Read encrypted flash failed at offset: 0x%X\r\n",
|
l_stOTAInfo.u32DecryptedSize);
|
l_stOTAInfo.eState = OTA_STATE_DECRYPT_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_DECRYPT_FAILED;
|
l_bDecryptTaskRunning = HIDO_FALSE;
|
return;
|
}
|
|
// 调试：打印第一次读取的前16字节
|
if (l_stOTAInfo.u32DecryptedSize == 0) {
|
HIDO_Debug("[OTA] First encrypted block: %02X %02X %02X %02X %02X %02X %02X %02X\r\n",
|
l_au8DecryptBuffer[0], l_au8DecryptBuffer[1], l_au8DecryptBuffer[2], l_au8DecryptBuffer[3],
|
l_au8DecryptBuffer[4], l_au8DecryptBuffer[5], l_au8DecryptBuffer[6], l_au8DecryptBuffer[7]);
|
}
|
|
// AES-CBC解密（每16字节一块）
|
for (i = 0; i < u32ReadLen; i += OTA_AES_BLOCK_SIZE) {
|
aesDecrypt(l_au8DecryptBuffer + i, l_au8AESChainBlock);
|
}
|
|
// 调试：打印第一次解密的前16字节
|
if (l_stOTAInfo.u32DecryptedSize == 0) {
|
HIDO_Debug("[OTA] First decrypted block: %02X %02X %02X %02X %02X %02X %02X %02X\r\n",
|
l_au8DecryptBuffer[0], l_au8DecryptBuffer[1], l_au8DecryptBuffer[2], l_au8DecryptBuffer[3],
|
l_au8DecryptBuffer[4], l_au8DecryptBuffer[5], l_au8DecryptBuffer[6], l_au8DecryptBuffer[7]);
|
HIDO_Debug("[OTA] Writing to: BaseAddr=0x%08X, WrittenBytes=0x%X, Len=0x%X\r\n",
|
OTA_DECRYPTED_FLASH_ADDR, l_u32DecryptFlashWrittenBytes, u32ReadLen);
|
}
|
|
// 写入解密后的数据
|
i32Ret = OTA_FlashWriteAligned(OTA_DECRYPTED_FLASH_ADDR,
|
l_u32DecryptFlashWrittenBytes,
|
l_au8DecryptBuffer, u32ReadLen);
|
if (i32Ret < 0) {
|
HIDO_Debug("[OTA] Write decrypted flash failed at offset: 0x%X\r\n",
|
l_stOTAInfo.u32DecryptedSize);
|
l_stOTAInfo.eState = OTA_STATE_DECRYPT_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_FLASH_WRITE_FAILED;
|
l_bDecryptTaskRunning = HIDO_FALSE;
|
return;
|
}
|
|
// 更新解密阶段的Flash写入计数器
|
l_u32DecryptFlashWrittenBytes += i32Ret;
|
|
l_stOTAInfo.u32DecryptedSize += u32ReadLen;
|
|
// 更新进度
|
l_stOTAInfo.u8Progress = (HIDO_UINT8)((l_stOTAInfo.u32DecryptedSize * 100) /
|
l_stOTAInfo.u32TotalSize);
|
|
// 每10%打印一次进度
|
static HIDO_UINT8 s_u8LastLogProgress = 0;
|
if (l_stOTAInfo.u8Progress >= s_u8LastLogProgress + 10) {
|
HIDO_Debug("[OTA] Decrypt progress: %d%% (%d/%d bytes)\r\n",
|
l_stOTAInfo.u8Progress,
|
l_stOTAInfo.u32DecryptedSize,
|
l_stOTAInfo.u32TotalSize);
|
s_u8LastLogProgress = l_stOTAInfo.u8Progress;
|
}
|
}
|
|
/**
|
* @brief 启动固件校验
|
*/
|
HIDO_INT32 OTA_VerifyFirmware(HIDO_VOID)
|
{
|
HIDO_UINT32 u32CalculatedSum = 0;
|
HIDO_UINT32 u32StoredSum = 0;
|
HIDO_UINT32 i;
|
HIDO_UINT8 u8Byte;
|
HIDO_UINT8 au8ChecksumBytes[4];
|
|
// 状态检查
|
if (l_stOTAInfo.eState != OTA_STATE_DECRYPT_COMPLETE) {
|
HIDO_Debug("[OTA] Cannot verify, state: %d\r\n", l_stOTAInfo.eState);
|
return HIDO_ERR;
|
}
|
|
l_stOTAInfo.eState = OTA_STATE_VERIFYING;
|
HIDO_Debug("[OTA] Verifying firmware checksum...\r\n");
|
|
// 文件格式：[固件数据][校验和4字节][0x0D][0x0A]
|
// 从文件末尾向前查找 0x0D 0x0A 结束符
|
HIDO_UINT32 u32TerminatorPos = 0; // 0x0D的位置
|
HIDO_BOOL bFoundTerminator = HIDO_FALSE;
|
HIDO_UINT8 au8SearchBuf[64]; // 只搜索末尾64字节
|
HIDO_UINT32 u32SearchStart = (l_stOTAInfo.u32TotalSize > 64) ? (l_stOTAInfo.u32TotalSize - 64) : 0;
|
HIDO_UINT32 u32SearchLen = l_stOTAInfo.u32TotalSize - u32SearchStart;
|
|
// 读取文件末尾数据
|
if (MCUFlash_Read(OTA_DECRYPTED_FLASH_ADDR + u32SearchStart, au8SearchBuf, u32SearchLen) != HIDO_OK) {
|
HIDO_Debug("[OTA] Read flash failed for terminator search\r\n");
|
l_stOTAInfo.eState = OTA_STATE_VERIFY_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_DECRYPT_FAILED;
|
return HIDO_ERR;
|
}
|
|
// 从后向前搜索 0x0D 0x0A
|
for (i = u32SearchLen; i >= 2; i--) {
|
if (au8SearchBuf[i-2] == OTA_FILE_TERMINATOR_CR &&
|
au8SearchBuf[i-1] == OTA_FILE_TERMINATOR_LF) {
|
u32TerminatorPos = u32SearchStart + i - 2; // 0x0D的位置
|
bFoundTerminator = HIDO_TRUE;
|
HIDO_Debug("[OTA] Found terminator (0x0D 0x0A) at offset: 0x%X\r\n", u32TerminatorPos);
|
break;
|
}
|
}
|
|
// 未找到结束符
|
if (!bFoundTerminator) {
|
HIDO_Debug("[OTA] ERROR: Terminator (0x0D 0x0A) not found in file\r\n");
|
l_stOTAInfo.eState = OTA_STATE_VERIFY_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_DECRYPT_FAILED;
|
return HIDO_ERR;
|
}
|
|
// 校验文件最小长度：至少需要6字节（校验4字节+0x0D+0x0A）
|
if (u32TerminatorPos < 4) {
|
HIDO_Debug("[OTA] ERROR: File too short, terminator at 0x%X\r\n", u32TerminatorPos);
|
l_stOTAInfo.eState = OTA_STATE_VERIFY_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_DECRYPT_FAILED;
|
return HIDO_ERR;
|
}
|
|
// 校验和位置：0x0D前4字节
|
HIDO_UINT32 u32ChecksumPos = u32TerminatorPos - 4;
|
// 固件数据结束位置：校验和之前
|
HIDO_UINT32 u32DataEndPos = u32ChecksumPos;
|
|
HIDO_Debug("[OTA] Firmware data range: 0x0 - 0x%X (%d bytes)\r\n",
|
u32DataEndPos - 1, u32DataEndPos);
|
HIDO_Debug("[OTA] Checksum position: 0x%X - 0x%X\r\n",
|
u32ChecksumPos, u32ChecksumPos + 3);
|
|
// 计算校验和（固件数据部分，不包括校验和和结束符）
|
for (i = 0; i < u32DataEndPos; i++) {
|
if (MCUFlash_Read(OTA_DECRYPTED_FLASH_ADDR + i, &u8Byte, 1) != HIDO_OK) {
|
HIDO_Debug("[OTA] Read flash failed at offset: 0x%X\r\n", i);
|
l_stOTAInfo.eState = OTA_STATE_VERIFY_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_DECRYPT_FAILED;
|
return HIDO_ERR;
|
}
|
u32CalculatedSum += u8Byte;
|
}
|
u32CalculatedSum &= 0xFFFFFFFF;
|
|
// 读取存储的校验和（0x0D前4字节，小端序）
|
if (MCUFlash_Read(OTA_DECRYPTED_FLASH_ADDR + u32ChecksumPos,
|
au8ChecksumBytes, 4) != HIDO_OK) {
|
HIDO_Debug("[OTA] Read checksum failed\r\n");
|
l_stOTAInfo.eState = OTA_STATE_VERIFY_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_DECRYPT_FAILED;
|
return HIDO_ERR;
|
}
|
|
// 小端序转换
|
u32StoredSum = au8ChecksumBytes[0] |
|
(au8ChecksumBytes[1] << 8) |
|
(au8ChecksumBytes[2] << 16) |
|
(au8ChecksumBytes[3] << 24);
|
|
HIDO_Debug("[OTA] Calculated checksum: 0x%08X\r\n", u32CalculatedSum);
|
HIDO_Debug("[OTA] Stored checksum: 0x%08X\r\n", u32StoredSum);
|
|
// 对比校验和
|
if (u32CalculatedSum == u32StoredSum) {
|
l_stOTAInfo.eState = OTA_STATE_VERIFY_SUCCESS;
|
l_stOTAInfo.eLastError = OTA_ERR_NONE;
|
HIDO_Debug("[OTA] Firmware verification SUCCESS!\r\n");
|
return HIDO_OK;
|
} else {
|
l_stOTAInfo.eState = OTA_STATE_VERIFY_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_CHECKSUM_MISMATCH;
|
HIDO_Debug("[OTA] Firmware verification FAILED! Checksum mismatch\r\n");
|
return OTA_ERR_CHECKSUM_MISMATCH;
|
}
|
}
|
|
/**
|
* @brief 获取OTA升级信息
|
*/
|
HIDO_INT32 OTA_GetInfo(ST_OTAInfo *_pstInfo)
|
{
|
if (_pstInfo == HIDO_NULL) {
|
return HIDO_ERR;
|
}
|
|
memcpy(_pstInfo, &l_stOTAInfo, sizeof(ST_OTAInfo));
|
return HIDO_OK;
|
}
|
|
/**
|
* @brief 获取当前OTA状态
|
*/
|
E_OTAState OTA_GetState(HIDO_VOID)
|
{
|
return l_stOTAInfo.eState;
|
}
|
|
/**
|
* @brief 获取下载进度百分比
|
*/
|
HIDO_UINT8 OTA_GetProgress(HIDO_VOID)
|
{
|
return l_stOTAInfo.u8Progress;
|
}
|
|
/**
|
* @brief 取消当前OTA操作
|
*/
|
HIDO_INT32 OTA_Cancel(HIDO_VOID)
|
{
|
if (l_stOTAInfo.eState == OTA_STATE_DOWNLOADING) {
|
HTTPClient_Reset();
|
}
|
|
l_bDecryptTaskRunning = HIDO_FALSE;
|
l_stOTAInfo.eState = OTA_STATE_IDLE;
|
|
HIDO_Debug("[OTA] Operation cancelled\r\n");
|
return HIDO_OK;
|
}
|
|
/**
|
* @brief 重置OTA模块到空闲状态
|
*/
|
HIDO_VOID OTA_Reset(HIDO_VOID)
|
{
|
l_bDecryptTaskRunning = HIDO_FALSE;
|
memset(&l_stOTAInfo, 0, sizeof(l_stOTAInfo));
|
l_stOTAInfo.eState = OTA_STATE_IDLE;
|
l_stOTAInfo.eLastError = OTA_ERR_NONE;
|
memset(l_acDownloadUrl, 0, sizeof(l_acDownloadUrl));
|
|
HIDO_Debug("[OTA] Module reset\r\n");
|
}
|
|
/**
|
* @brief OTA模块周期性任务
|
*/
|
HIDO_VOID OTA_Poll(HIDO_VOID)
|
{
|
HIDO_UINT32 u32CurrentTick = xTaskGetTickCount();
|
HIDO_UINT32 u32ElapsedMs = u32CurrentTick - l_u32LastProgressTick;
|
|
// 检查下载超时或失败
|
if (l_stOTAInfo.eState == OTA_STATE_DOWNLOADING) {
|
// 如果超过30秒没有进度，认为下载超时
|
if (u32ElapsedMs > OTA_DOWNLOAD_TIMEOUT_MS) {
|
HIDO_Debug("[OTA] Download timeout! No data received for %d ms\r\n", u32ElapsedMs);
|
HIDO_Debug("[OTA] Downloaded: %d/%d bytes\r\n",
|
l_stOTAInfo.u32DownloadedSize, l_stOTAInfo.u32TotalSize);
|
|
// 标记为失败，触发重试逻辑
|
l_stOTAInfo.eState = OTA_STATE_DOWNLOAD_FAILED;
|
}
|
}
|
|
// 处理下载失败，尝试重试
|
if (l_stOTAInfo.eState == OTA_STATE_DOWNLOAD_FAILED) {
|
// 检查是否还有重试机会
|
if (l_u8RetryCount < OTA_MAX_RETRY_COUNT) {
|
l_u8RetryCount++;
|
HIDO_Debug("[OTA] Retry attempt %d/%d...\r\n",
|
l_u8RetryCount, OTA_MAX_RETRY_COUNT);
|
|
// 重置HTTP客户端状态（关闭之前的连接）
|
HIDO_Debug("[OTA] Resetting HTTP client...\r\n");
|
HTTPClient_Reset();
|
|
// 重新开始下载
|
l_stOTAInfo.eState = OTA_STATE_IDLE;
|
vTaskDelay(2000); // 延迟2秒确保连接完全关闭
|
|
if (OTA_StartDownload(l_acDownloadUrl) != HIDO_OK) {
|
HIDO_Debug("[OTA] Retry failed to start download\r\n");
|
l_stOTAInfo.eState = OTA_STATE_DOWNLOAD_FAILED;
|
l_stOTAInfo.eLastError = OTA_ERR_HTTP_FAILED;
|
// 注意：不要在这里return，让它继续循环重试
|
}
|
} else {
|
// 已达到最大重试次数，彻底放弃
|
HIDO_Debug("[OTA] Download failed after %d retries - GIVING UP\r\n", OTA_MAX_RETRY_COUNT);
|
l_stOTAInfo.eState = OTA_STATE_IDLE; // 回到空闲状态，停止重试
|
l_stOTAInfo.eLastError = OTA_ERR_HTTP_FAILED;
|
l_u8RetryCount = 0; // 重置重试计数
|
}
|
}
|
|
// 如果下载成功完成，重置重试计数
|
if (l_stOTAInfo.eState == OTA_STATE_DOWNLOAD_COMPLETE) {
|
if (l_u8RetryCount > 0) {
|
HIDO_Debug("[OTA] Download completed after %d retry(ies)\r\n", l_u8RetryCount);
|
l_u8RetryCount = 0;
|
}
|
}
|
|
// 处理解密任务
|
if (l_stOTAInfo.eState == OTA_STATE_DECRYPTING && l_bDecryptTaskRunning) {
|
OTA_ProcessDecryptTask();
|
}
|
}
|
