/*****************************************************************************
|
* @file PathTest.c
|
* @brief 路径下载和读取测试模块 + OTA升级测试模块
|
* @author AI Assistant
|
* @date 2025-12-19
|
*****************************************************************************/
|
|
#include "PathTest.h"
|
#include "PathStorage.h"
|
#include "OTAUpgrade.h"
|
#include "TCPClient.h"
|
#include "HIDO_Debug.h"
|
#include "HIDO_Timer.h"
|
#include <string.h>
|
|
/*****************************************************************************
|
* 私有宏定义
|
*****************************************************************************/
|
#define MAX_BOUNDARY_POINTS 1000 // 边界点上限
|
#define MAX_PATH_POINTS 4000 // 路径点上限
|
#define TEST_CHECK_INTERVAL 1000 // 状态检查间隔(ms)
|
|
/*****************************************************************************
|
* 私有数据结构
|
*****************************************************************************/
|
|
|
typedef struct {
|
E_PathTestState state; // 当前测试状态
|
HIDO_BOOL tcp_connected_triggered; // TCP连接后是否已触发下载
|
HIDO_UINT32 last_check_tick; // 上次检查时间戳
|
HIDO_UINT32 boundary_read_count; // 已读取的边界点数
|
HIDO_UINT32 path_read_count; // 已读取的路径点数
|
} PathTestContext_t;
|
|
/*****************************************************************************
|
* 私有全局变量
|
*****************************************************************************/
|
static PathTestContext_t s_test_ctx = {
|
.state = PATH_TEST_STATE_IDLE,
|
.tcp_connected_triggered = HIDO_FALSE,
|
.last_check_tick = 0,
|
.boundary_read_count = 0,
|
.path_read_count = 0
|
};
|
|
// 数据缓冲区（避免占用过多栈空间）
|
static PathPoint_t s_boundary_buffer[100]; // 每次读取100个边界点
|
static PathPoint_t s_path_buffer[100]; // 每次读取100个路径点
|
|
/*****************************************************************************
|
* 私有函数声明
|
*****************************************************************************/
|
static void PathTest_StartDownload(void);
|
static void PathTest_CheckDownloadStatus(void);
|
static void PathTest_VerifyData(void);
|
static void PathTest_ReadAllPoints(void);
|
static HIDO_BOOL PathTest_IsTCPConnected(void);
|
|
/*****************************************************************************
|
* 函数实现
|
*****************************************************************************/
|
|
/**
|
* @brief 初始化路径测试模块
|
*/
|
HIDO_INT32 PathTest_Init(void)
|
{
|
memset(&s_test_ctx, 0, sizeof(s_test_ctx));
|
s_test_ctx.state = PATH_TEST_STATE_WAIT_NETWORK;
|
s_test_ctx.tcp_connected_triggered = HIDO_FALSE;
|
|
HIDO_Debug("[PathTest] Initialized, waiting for TCP connection...\r\n");
|
return 0;
|
}
|
|
/**
|
* @brief 路径测试主循环（需要在app_task中定期调用）
|
*/
|
void PathTest_Poll(void)
|
{
|
HIDO_UINT32 current_tick = HIDO_TimerGetTick();
|
|
// 限制检查频率
|
if (current_tick - s_test_ctx.last_check_tick < TEST_CHECK_INTERVAL) {
|
return;
|
}
|
s_test_ctx.last_check_tick = current_tick;
|
|
switch (s_test_ctx.state) {
|
case PATH_TEST_STATE_WAIT_NETWORK:
|
// 等待TCP连接
|
if (PathTest_IsTCPConnected() && !s_test_ctx.tcp_connected_triggered) {
|
HIDO_Debug("[PathTest] TCP connected! Starting path download test...\r\n");
|
PathTest_StartDownload();
|
s_test_ctx.tcp_connected_triggered = HIDO_TRUE;
|
s_test_ctx.state = PATH_TEST_STATE_DOWNLOADING;
|
}
|
break;
|
|
case PATH_TEST_STATE_DOWNLOADING:
|
// 检查下载状态
|
PathTest_CheckDownloadStatus();
|
break;
|
|
case PATH_TEST_STATE_VERIFY:
|
// 验证数据
|
PathTest_VerifyData();
|
break;
|
|
case PATH_TEST_STATE_READING:
|
// 读取所有点数据
|
PathTest_ReadAllPoints();
|
break;
|
|
case PATH_TEST_STATE_COMPLETE:
|
// 测试完成，停止轮询
|
HIDO_Debug("[PathTest] ===== TEST COMPLETED SUCCESSFULLY =====\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_IDLE;
|
break;
|
|
case PATH_TEST_STATE_FAILED:
|
// 测试失败，恢复TCP连接
|
HIDO_Debug("[PathTest] ===== TEST FAILED =====\r\n");
|
extern HIDO_INT32 TCPClient_Resume(void);
|
TCPClient_Resume();
|
s_test_ctx.state = PATH_TEST_STATE_IDLE;
|
break;
|
|
default:
|
break;
|
}
|
}
|
|
/**
|
* @brief 检查TCP是否已连接
|
*/
|
static HIDO_BOOL PathTest_IsTCPConnected(void)
|
{
|
// 通过extern访问TCPClient的状态
|
extern E_TCPClientState l_eTCPClientState;
|
return (l_eTCPClientState == TCP_CLIENT_STATE_CONNECTED);
|
}
|
|
/**
|
* @brief 启动路径文件下载
|
*/
|
static void PathTest_StartDownload(void)
|
{
|
const HIDO_CHAR *url = "http://39.99.43.227:8866/api/file/download/21b09df9-9232-4e38-a5cc-19458d324019_data.bin";
|
HIDO_INT32 ret;
|
|
HIDO_Debug("[PathTest] Starting download from: %s\r\n", url);
|
|
// 暂停TCP连接以停止差分数据接收
|
extern HIDO_INT32 TCPClient_Pause(void);
|
TCPClient_Pause();
|
|
ret = PathStorage_DownloadFromHTTP(url);
|
if (ret != 0) {
|
HIDO_Debug("[PathTest] Failed to start download: %d\r\n", ret);
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
}
|
}
|
|
/**
|
* @brief 检查下载状态
|
*/
|
static void PathTest_CheckDownloadStatus(void)
|
{
|
E_PathStorageStatus status = PathStorage_GetStatus();
|
HIDO_UINT8 progress = PathStorage_GetProgress();
|
|
// 每次检查时打印进度
|
if (progress > 0) {
|
HIDO_Debug("[PathTest] Download progress: %u%%\r\n", progress);
|
}
|
|
if (status == PATH_STORAGE_STATUS_SUCCESS) {
|
HIDO_Debug("[PathTest] Download completed successfully!\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_VERIFY;
|
} else if (status == PATH_STORAGE_STATUS_FAIL_NETWORK) {
|
HIDO_Debug("[PathTest] Download failed: Network error\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
} else if (status == PATH_STORAGE_STATUS_FAIL_FLASH) {
|
HIDO_Debug("[PathTest] Download failed: Flash error\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
} else if (status == PATH_STORAGE_STATUS_FAIL_CRC) {
|
HIDO_Debug("[PathTest] Download failed: CRC error\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
} else if (status == PATH_STORAGE_STATUS_FAIL_FORMAT) {
|
HIDO_Debug("[PathTest] Download failed: Format error\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
}
|
}
|
|
/**
|
* @brief 验证路径文件头数据
|
*/
|
static void PathTest_VerifyData(void)
|
{
|
MowerPathHeader_t header;
|
HIDO_INT32 ret;
|
|
HIDO_Debug("[PathTest] ===== Verifying Path File =====\r\n");
|
|
ret = PathStorage_ReadHeader(&header);
|
if (ret != 0) {
|
HIDO_Debug("[PathTest] Failed to read header: %d\r\n", ret);
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
return;
|
}
|
|
// 打印文件头信息
|
HIDO_Debug("[PathTest] File Header Info:\r\n");
|
HIDO_Debug(" SOF: 0x%04X\r\n", header.sof);
|
HIDO_Debug(" Type: 0x%02X\r\n", header.type);
|
HIDO_Debug(" Version: 0x%02X\r\n", header.version);
|
HIDO_Debug(" Path ID: 0x%08X\r\n", header.path_id);
|
HIDO_Debug(" Timestamp: %u\r\n", header.timestamp);
|
HIDO_Debug(" Origin Lon: %.8f\r\n", header.origin_lon);
|
HIDO_Debug(" Origin Lat: %.8f\r\n", header.origin_lat);
|
HIDO_Debug(" Origin Alt: %.2f m\r\n", header.origin_alt);
|
HIDO_Debug(" Boundary Count: %u (Max: %d)\r\n", header.boundary_count, MAX_BOUNDARY_POINTS);
|
HIDO_Debug(" Path Count: %u (Max: %d)\r\n", header.path_count, MAX_PATH_POINTS);
|
|
// 检查点数是否超出上限
|
if (header.boundary_count > MAX_BOUNDARY_POINTS) {
|
HIDO_Debug("[PathTest] ERROR: Boundary count exceeds limit!\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
return;
|
}
|
|
if (header.path_count > MAX_PATH_POINTS) {
|
HIDO_Debug("[PathTest] ERROR: Path count exceeds limit!\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
return;
|
}
|
|
// 验证CRC32
|
ret = PathStorage_VerifyCRC32();
|
if (ret != 0) {
|
HIDO_Debug("[PathTest] ERROR: CRC32 verification failed!\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
return;
|
}
|
|
HIDO_Debug("[PathTest] File verification passed!\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_READING;
|
s_test_ctx.boundary_read_count = 0;
|
s_test_ctx.path_read_count = 0;
|
}
|
|
/**
|
* @brief 读取所有路径点数据
|
*/
|
static void PathTest_ReadAllPoints(void)
|
{
|
MowerPathHeader_t header;
|
HIDO_INT32 ret;
|
HIDO_UINT32 i;
|
|
HIDO_Debug("[PathTest] ===== Reading All Points =====\r\n");
|
|
// 重新读取头部获取点数
|
ret = PathStorage_ReadHeader(&header);
|
if (ret != 0) {
|
HIDO_Debug("[PathTest] Failed to read header: %d\r\n", ret);
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
return;
|
}
|
|
// 读取边界点
|
HIDO_Debug("[PathTest] Reading %u boundary points...\r\n", header.boundary_count);
|
for (i = 0; i < header.boundary_count; i += 100) {
|
HIDO_UINT32 batch_size = (header.boundary_count - i > 100) ? 100 : (header.boundary_count - i);
|
ret = PathStorage_ReadPoints(HIDO_TRUE, i, batch_size, s_boundary_buffer);
|
|
if (ret < 0) {
|
HIDO_Debug("[PathTest] Failed to read boundary points at index %u: %d\r\n", i, ret);
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
return;
|
}
|
|
s_test_ctx.boundary_read_count += ret;
|
|
// 打印前3个和后3个点作为示例
|
if (i == 0) {
|
HIDO_Debug("[PathTest] First boundary points:\r\n");
|
for (HIDO_UINT32 j = 0; j < 3 && j < ret; j++) {
|
HIDO_Debug(" [%u] (%.3f, %.3f)\r\n", j,
|
s_boundary_buffer[j].x, s_boundary_buffer[j].y);
|
}
|
}
|
}
|
HIDO_Debug("[PathTest] Boundary points read: %u/%u\r\n",
|
s_test_ctx.boundary_read_count, header.boundary_count);
|
|
// 读取路径点
|
HIDO_Debug("[PathTest] Reading %u path points...\r\n", header.path_count);
|
for (i = 0; i < header.path_count; i += 100) {
|
HIDO_UINT32 batch_size = (header.path_count - i > 100) ? 100 : (header.path_count - i);
|
ret = PathStorage_ReadPoints(HIDO_FALSE, i, batch_size, s_path_buffer);
|
|
if (ret < 0) {
|
HIDO_Debug("[PathTest] Failed to read path points at index %u: %d\r\n", i, ret);
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
return;
|
}
|
|
s_test_ctx.path_read_count += ret;
|
|
// 打印前3个和后3个点作为示例
|
if (i == 0) {
|
HIDO_Debug("[PathTest] First path points:\r\n");
|
for (HIDO_UINT32 j = 0; j < 3 && j < ret; j++) {
|
HIDO_Debug(" [%u] (%.3f, %.3f)\r\n", j,
|
s_path_buffer[j].x, s_path_buffer[j].y);
|
}
|
}
|
}
|
HIDO_Debug("[PathTest] Path points read: %u/%u\r\n",
|
s_test_ctx.path_read_count, header.path_count);
|
|
// 验证读取数量
|
if (s_test_ctx.boundary_read_count == header.boundary_count &&
|
s_test_ctx.path_read_count == header.path_count) {
|
HIDO_Debug("[PathTest] All points read successfully!\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_COMPLETE;
|
} else {
|
HIDO_Debug("[PathTest] Point count mismatch!\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_FAILED;
|
}
|
|
// 恢复TCP连接
|
extern HIDO_INT32 TCPClient_Resume(void);
|
TCPClient_Resume();
|
}
|
|
/**
|
* @brief 手动触发测试（可在Shell中调用）
|
*/
|
void PathTest_Trigger(void)
|
{
|
HIDO_Debug("[PathTest] Manual trigger - resetting test state\r\n");
|
s_test_ctx.state = PATH_TEST_STATE_WAIT_NETWORK;
|
s_test_ctx.tcp_connected_triggered = HIDO_FALSE;
|
}
|
|
/**
|
* @brief 获取测试状态
|
*/
|
E_PathTestState PathTest_GetState(void)
|
{
|
return s_test_ctx.state;
|
}
|
|
/*****************************************************************************
|
* OTA升级测试功能
|
*****************************************************************************/
|
|
/*****************************************************************************
|
* 私有数据结构（OTA测试）
|
*****************************************************************************/
|
|
typedef struct {
|
E_OTATestState state; // 当前测试状态
|
HIDO_BOOL tcp_connected_triggered; // TCP连接后是否已触发下载
|
HIDO_UINT32 last_check_tick; // 上次检查时间戳
|
HIDO_UINT8 last_progress; // 上次进度
|
} OTATestContext_t;
|
|
/*****************************************************************************
|
* 私有全局变量（OTA测试）
|
*****************************************************************************/
|
static OTATestContext_t s_ota_test_ctx = {
|
.state = OTA_TEST_STATE_IDLE,
|
.tcp_connected_triggered = HIDO_FALSE,
|
.last_check_tick = 0,
|
.last_progress = 0
|
};
|
|
/*****************************************************************************
|
* 私有函数声明（OTA测试）
|
*****************************************************************************/
|
static void OTATest_StartDownload(void);
|
static void OTATest_CheckDownloadStatus(void);
|
static void OTATest_CheckDecryptStatus(void);
|
static void OTATest_CheckVerifyStatus(void);
|
|
/*****************************************************************************
|
* OTA测试函数实现
|
*****************************************************************************/
|
|
/**
|
* @brief 初始化OTA升级测试模块
|
*/
|
HIDO_INT32 OTATest_Init(void)
|
{
|
HIDO_INT32 ret;
|
|
// 初始化OTA模块
|
ret = OTA_Init();
|
if (ret != HIDO_OK) {
|
HIDO_Debug("[OTATest] OTA_Init failed: %d\r\n", ret);
|
return ret;
|
}
|
|
memset(&s_ota_test_ctx, 0, sizeof(s_ota_test_ctx));
|
s_ota_test_ctx.state = OTA_TEST_STATE_WAIT_NETWORK;
|
s_ota_test_ctx.tcp_connected_triggered = HIDO_FALSE;
|
|
HIDO_Debug("[OTATest] ===== OTA Upgrade Test Initialized =====\r\n");
|
HIDO_Debug("[OTATest] Waiting for TCP connection...\r\n");
|
return HIDO_OK;
|
}
|
|
/**
|
* @brief OTA测试主循环（需要在app_task中定期调用）
|
*/
|
void OTATest_Poll(void)
|
{
|
HIDO_UINT32 current_tick = HIDO_TimerGetTick();
|
|
// OTA模块需要周期调用（处理解密任务）
|
OTA_Poll();
|
|
// 限制检查频率
|
if (current_tick - s_ota_test_ctx.last_check_tick < TEST_CHECK_INTERVAL) {
|
return;
|
}
|
s_ota_test_ctx.last_check_tick = current_tick;
|
|
switch (s_ota_test_ctx.state) {
|
case OTA_TEST_STATE_WAIT_NETWORK:
|
// 等待TCP连接
|
if (PathTest_IsTCPConnected() && !s_ota_test_ctx.tcp_connected_triggered) {
|
HIDO_Debug("[OTATest] TCP connected! Starting OTA firmware download test...\r\n");
|
OTATest_StartDownload();
|
s_ota_test_ctx.tcp_connected_triggered = HIDO_TRUE;
|
s_ota_test_ctx.state = OTA_TEST_STATE_DOWNLOADING;
|
}
|
break;
|
|
case OTA_TEST_STATE_DOWNLOADING:
|
// 检查下载状态
|
OTATest_CheckDownloadStatus();
|
break;
|
|
case OTA_TEST_STATE_DECRYPTING:
|
// 检查解密状态
|
OTATest_CheckDecryptStatus();
|
break;
|
|
case OTA_TEST_STATE_VERIFYING:
|
// 检查校验状态
|
OTATest_CheckVerifyStatus();
|
break;
|
|
case OTA_TEST_STATE_COMPLETE:
|
// 测试完成，停止轮询
|
HIDO_Debug("[OTATest] ===== OTA TEST COMPLETED SUCCESSFULLY =====\r\n");
|
HIDO_Debug("[OTATest] Decrypted firmware is ready at 0x08140000\r\n");
|
s_ota_test_ctx.state = OTA_TEST_STATE_IDLE;
|
|
// 恢复TCP连接
|
extern HIDO_INT32 TCPClient_Resume(void);
|
TCPClient_Resume();
|
break;
|
|
case OTA_TEST_STATE_FAILED:
|
// 测试失败
|
HIDO_Debug("[OTATest] ===== OTA TEST FAILED =====\r\n");
|
s_ota_test_ctx.state = OTA_TEST_STATE_IDLE;
|
|
// 恢复TCP连接
|
extern HIDO_INT32 TCPClient_Resume(void);
|
TCPClient_Resume();
|
break;
|
|
default:
|
break;
|
}
|
}
|
|
/**
|
* @brief 启动OTA固件下载
|
*/
|
static void OTATest_StartDownload(void)
|
{
|
const HIDO_CHAR *url = "http://123.57.87.125:7001/hfs/STM32H743.Bin";
|
HIDO_INT32 ret;
|
|
HIDO_Debug("[OTATest] ===== Starting OTA Firmware Download =====\r\n");
|
HIDO_Debug("[OTATest] URL: %s\r\n", url);
|
|
// 暂停TCP连接以停止差分数据接收
|
extern HIDO_INT32 TCPClient_Pause(void);
|
TCPClient_Pause();
|
|
ret = OTA_StartDownload(url);
|
if (ret != HIDO_OK) {
|
HIDO_Debug("[OTATest] Failed to start download, error: %d\r\n", ret);
|
s_ota_test_ctx.state = OTA_TEST_STATE_FAILED;
|
} else {
|
HIDO_Debug("[OTATest] Download started successfully\r\n");
|
s_ota_test_ctx.last_progress = 0;
|
}
|
}
|
|
/**
|
* @brief 检查下载状态
|
*/
|
static void OTATest_CheckDownloadStatus(void)
|
{
|
E_OTAState ota_state = OTA_GetState();
|
HIDO_UINT8 progress = OTA_GetProgress();
|
|
// 进度变化时打印
|
if (progress != s_ota_test_ctx.last_progress && progress % 10 == 0) {
|
HIDO_Debug("[OTATest] Download progress: %u%%\r\n", progress);
|
s_ota_test_ctx.last_progress = progress;
|
}
|
|
if (ota_state == OTA_STATE_DOWNLOAD_COMPLETE) {
|
HIDO_Debug("[OTATest] Download completed! Starting decryption...\r\n");
|
|
// 启动解密
|
if (OTA_StartDecrypt() == HIDO_OK) {
|
s_ota_test_ctx.state = OTA_TEST_STATE_DECRYPTING;
|
s_ota_test_ctx.last_progress = 0;
|
} else {
|
HIDO_Debug("[OTATest] Failed to start decryption\r\n");
|
s_ota_test_ctx.state = OTA_TEST_STATE_FAILED;
|
}
|
} else if (ota_state == OTA_STATE_DOWNLOAD_FAILED) {
|
ST_OTAInfo info;
|
OTA_GetInfo(&info);
|
HIDO_Debug("[OTATest] Download failed, error code: %d\r\n", info.eLastError);
|
s_ota_test_ctx.state = OTA_TEST_STATE_FAILED;
|
}
|
}
|
|
/**
|
* @brief 检查解密状态
|
*/
|
static void OTATest_CheckDecryptStatus(void)
|
{
|
E_OTAState ota_state = OTA_GetState();
|
HIDO_UINT8 progress = OTA_GetProgress();
|
|
// 进度变化时打印
|
if (progress != s_ota_test_ctx.last_progress && progress % 10 == 0) {
|
HIDO_Debug("[OTATest] Decrypt progress: %u%%\r\n", progress);
|
s_ota_test_ctx.last_progress = progress;
|
}
|
|
if (ota_state == OTA_STATE_DECRYPT_COMPLETE) {
|
HIDO_Debug("[OTATest] Decryption completed! Starting verification...\r\n");
|
|
// 启动校验
|
if (OTA_VerifyFirmware() == HIDO_OK) {
|
s_ota_test_ctx.state = OTA_TEST_STATE_VERIFYING;
|
} else {
|
HIDO_Debug("[OTATest] Failed to start verification\r\n");
|
s_ota_test_ctx.state = OTA_TEST_STATE_FAILED;
|
}
|
} else if (ota_state == OTA_STATE_DECRYPT_FAILED) {
|
ST_OTAInfo info;
|
OTA_GetInfo(&info);
|
HIDO_Debug("[OTATest] Decryption failed, error code: %d\r\n", info.eLastError);
|
s_ota_test_ctx.state = OTA_TEST_STATE_FAILED;
|
}
|
}
|
|
/**
|
* @brief 检查校验状态
|
*/
|
static void OTATest_CheckVerifyStatus(void)
|
{
|
E_OTAState ota_state = OTA_GetState();
|
|
if (ota_state == OTA_STATE_VERIFY_SUCCESS) {
|
ST_OTAInfo info;
|
OTA_GetInfo(&info);
|
|
HIDO_Debug("[OTATest] ===== Firmware Verification SUCCESS! =====\r\n");
|
HIDO_Debug("[OTATest] Firmware size: %u bytes (%.1f KB)\r\n",
|
info.u32TotalSize, info.u32TotalSize / 1024.0f);
|
HIDO_Debug("[OTATest] Encrypted firmware at: 0x%08X\r\n", OTA_ENCRYPTED_FLASH_ADDR);
|
HIDO_Debug("[OTATest] Decrypted firmware at: 0x%08X\r\n", OTA_DECRYPTED_FLASH_ADDR);
|
|
s_ota_test_ctx.state = OTA_TEST_STATE_COMPLETE;
|
} else if (ota_state == OTA_STATE_VERIFY_FAILED) {
|
ST_OTAInfo info;
|
OTA_GetInfo(&info);
|
HIDO_Debug("[OTATest] Firmware verification FAILED, error code: %d\r\n", info.eLastError);
|
s_ota_test_ctx.state = OTA_TEST_STATE_FAILED;
|
}
|
}
|
|
/**
|
* @brief 手动触发OTA测试（可在Shell中调用）
|
*/
|
void OTATest_Trigger(void)
|
{
|
HIDO_Debug("[OTATest] Manual trigger - resetting test state\r\n");
|
OTA_Reset();
|
s_ota_test_ctx.state = OTA_TEST_STATE_WAIT_NETWORK;
|
s_ota_test_ctx.tcp_connected_triggered = HIDO_FALSE;
|
}
|
|
/**
|
* @brief 获取OTA测试状态
|
*/
|
E_OTATestState OTATest_GetState(void)
|
{
|
return s_ota_test_ctx.state;
|
}
|
