cbb/ESP32_COMM
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(ota_relay): 实现WiFi/AP双模式和CANFD 3通道SPI协议

Browse Source 
- 新增AP/STA双工作模式，通过app_config.h配置切换
- 实现CANFD 3通道SPI协议，支持主通信通道和备用通道
- 添加GD32命令ID定义和HTTP API接口
- 集成上位机WebUI，支持固件上传和CAN帧发送

refactor(debug_log): 支持UDP+UART双通道调试输出

- 新增UART0串口调试功能，TX=GPIO21, RX=GPIO20, 115200波特率
- 实现UDP socket延迟创建机制，避免网络初始化冲突
- 调试日志同时输出到UDP和UART双通道

docs(README): 更新项目文档和目录结构说明

- 更新硬件平台和模块功能描述
- 添加WiFi工作模式配置说明
- 补充CANFD协议和GD32命令定义
- 增加HTTP API和上位机WebUI使用指南

fix(health_monitor): 优化健康监控和系统状态报告

- 增强温度和电压监控的警告提示信息
- 添加WiFi RSSI监控和健康状态更新
- 修复安全关机触发条件和状态变更日志

style(main): 优化程序入口和任务创建流程

- 修复网络接口初始化顺序问题
- 添加任务创建结果检查和错误处理
- 增加系统启动信息和CPU频率显示
- 新增周期性状态监控任务，每10秒打印系统状态
This commit is contained in:
小龙虾
2026-04-28 01:06:17 +08:00
parent 47ffe1bd54
commit 064eb7e03f
11 changed files with 563 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main/core/main.cpp
+130 -7
View File
@@ -1,11 +1,16 @@
/*
* ESP32-C3FH4 OTA 中继 - 程序入口
* 四个 FreeRTOS 任务：System Monitor / OTA Relay / WiFi Server / BLE GATT
*
* 新增：周期性状态监控任务，每 10 秒打印系统状态
*/
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_chip_info.h"
#include "esp_system.h"
#include "esp_clk_tree.h"
#include "esp_netif.h"
#include "monitor/health_monitor.h"
#include "relay/ota_relay.h"
@@ -15,21 +20,33 @@
#include "transport/protocol.h"
#include "monitor/debug_log.h"
// 状态监控任务
static void status_monitor_task(void *pvParameters);
extern "C" void app_main(void)
{
// 【关键】在所有任务创建之前初始化网络接口
// esp_timer 内部依赖 tcpip 线程，health_monitor_task 的 esp_timer_create
// 会在 scheduler 启动后立即执行。如果 esp_netif_init() 没有提前调用，
// tcpip 线程的 mailbox 还未创建，此时 esp_timer 发消息给 tcpip 线程就会崩溃。
// esp_netif_init() 可以安全调用多次，后续 wifi_ota_task 中的调用是多余的但不报错。
ESP_ERROR_CHECK(esp_netif_init());
esp_chip_info_t chip_info;
esp_chip_info(&chip_info);
// 初始化调试日志（UDP 输出到上位机）
// 初始化调试日志（UDP 输出到上位机 + UART0 串口）
debug_log_init();
DEBUG_INFO("MAIN", "========================================");
DEBUG_INFO("MAIN", "ESP32-C3 OTA Relay v1.0 启动");
DEBUG_INFO("MAIN", "Chip: %s, Rev %d", CONFIG_IDF_TARGET, chip_info.revision);
DEBUG_INFO("MAIN", "Free heap: %lu bytes", esp_get_free_heap_size());
DEBUG_INFO("MAIN", "CPU Freq: %d MHz", CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ);
DEBUG_INFO("MAIN", "========================================");
// 健康监控任务（温度 + 电压 + WiFi RSSI）
xTaskCreatePinnedToCore(
BaseType_t xRet;
xRet = xTaskCreatePinnedToCore(
health_monitor_task,
"health_mon",
4096,
@@ -38,6 +55,11 @@ extern "C" void app_main(void)
NULL,
0
);
if (xRet != pdPASS) {
DEBUG_ERR("MAIN", "创建 health_monitor_task 失败");
} else {
DEBUG_INFO("MAIN", "健康监控任务已创建");
}
// 初始化协议层（CRC、AES）
protocol_init();
@@ -51,9 +73,6 @@ extern "C" void app_main(void)
DEBUG_INFO("MAIN", "SPI 总线初始化完成");
}
// 创建 FreeRTOS 任务
BaseType_t xRet;
// OTA 中继任务（中高优先级）
xRet = xTaskCreatePinnedToCore(
ota_relay_task,
@@ -66,6 +85,8 @@ extern "C" void app_main(void)
);
if (xRet != pdPASS) {
DEBUG_ERR("MAIN", "创建 ota_relay_task 失败");
} else {
DEBUG_INFO("MAIN", "OTA 中继任务已创建");
}
// WiFi OTA 服务器任务
@@ -80,6 +101,8 @@ extern "C" void app_main(void)
);
if (xRet != pdPASS) {
DEBUG_ERR("MAIN", "创建 wifi_ota_task 失败");
} else {
DEBUG_INFO("MAIN", "WiFi OTA 任务已创建");
}
// BLE OTA 任务
@@ -94,8 +117,108 @@ extern "C" void app_main(void)
);
if (xRet != pdPASS) {
DEBUG_ERR("MAIN", "创建 ble_ota_task 失败");
} else {
DEBUG_INFO("MAIN", "BLE OTA 任务已创建");
}
// 状态监控任务（低优先级，周期性打印系统状态）
xRet = xTaskCreatePinnedToCore(
status_monitor_task,
"status_mon",
4096,
NULL,
configMAX_PRIORITIES - 5,
NULL,
0
);
if (xRet != pdPASS) {
DEBUG_ERR("MAIN", "创建 status_monitor_task 失败");
} else {
DEBUG_INFO("MAIN", "状态监控任务已创建");
}
DEBUG_INFO("MAIN", "========================================");
DEBUG_INFO("MAIN", "所有任务创建完成，OTA Relay 运行中");
DEBUG_INFO("MAIN", "调试日志输出到上位机: %s:%d", DEBUG_LOG_IP, DEBUG_LOG_PORT);
DEBUG_INFO("MAIN", "调试日志输出: UDP(%s:%d) + UART0(GPIO21/TX, 115200)",
DEBUG_LOG_IP, DEBUG_LOG_PORT);
DEBUG_INFO("MAIN", "========================================");
}
// ============================================================
// 状态监控任务 - 每 10 秒打印系统状态
// ============================================================
static void status_monitor_task(void *pvParameters)
{
(void)pvParameters;
DEBUG_INFO("STAT", "状态监控任务启动");
uint32_t loop_count = 0;
while (1) {
loop_count++;
// 获取系统信息
uint32_t free_heap = esp_get_free_heap_size();
uint32_t min_free_heap = esp_get_minimum_free_heap_size();
health_state_t health = health_get_current();
relay_state_t relay = ota_relay_get_state();
int8_t rssi = wifi_get_rssi();
bool wifi_conn = wifi_is_connected();
// 打印状态头
DEBUG_INFO("STAT", "========== 系统状态 #%lu ==========", (unsigned long)loop_count);
// 内存状态
DEBUG_INFO("STAT", "内存: 空闲=%lu 字节, 最低=%lu 字节",
(unsigned long)free_heap, (unsigned long)min_free_heap);
// 健康状态
const char *health_str;
switch (health) {
case SYS_NORMAL: health_str = "正常"; break;
case SYS_WARNING: health_str = "警告"; break;
case SYS_CRITICAL: health_str = "危险"; break;
case SYS_SAFE_SHUTDOWN: health_str = "安全关机"; break;
default: health_str = "未知"; break;
}
DEBUG_INFO("STAT", "健康状态: %s (%d)", health_str, health);
// WiFi 状态
if (wifi_conn) {
DEBUG_INFO("STAT", "WiFi: 已连接, RSSI=%d dBm", rssi);
} else {
DEBUG_INFO("STAT", "WiFi: 未连接");
}
// OTA 中继状态
const char *relay_str;
switch (relay) {
case RELAY_IDLE: relay_str = "空闲"; break;
case RELAY_HANDSHAKE_IDLE: relay_str = "等待握手"; break;
case RELAY_HANDSHAKE_SENT: relay_str = "握手请求已发送"; break;
case RELAY_CHALLENGE_SENT: relay_str = "挑战已发送"; break;
case RELAY_CHALLENGE_RESPOND: relay_str = "收到握手响应"; break;
case RELAY_SESSION_KEY_SENT: relay_str = "会话密钥已发送"; break;
case RELAY_AUTH_COMPLETE: relay_str = "认证完成"; break;
case RELAY_SIZE_SENT: relay_str = "大小已发送"; break;
case RELAY_SIZE_ACK: relay_str = "大小确认"; break;
case RELAY_RECEIVING: relay_str = "接收中"; break;
case RELAY_RELAY_ACTIVE: relay_str = "转发中"; break;
case RELAY_PACKET_SENT: relay_str = "数据包已发送"; break;
case RELAY_PACKET_ACK_OK: relay_str = "ACK 正常"; break;
case RELAY_PACKET_ACK_RETRY: relay_str = "需要重试"; break;
case RELAY_RECEIVE_DONE: relay_str = "接收完成"; break;
case RELAY_TRANSFER_DONE: relay_str = "传输完成"; break;
case RELAY_FINISH_SENT: relay_str = "结束已发送"; break;
case RELAY_DONE: relay_str = "OTA 完成"; break;
case RELAY_ERROR: relay_str = "错误"; break;
default: relay_str = "未知"; break;
}
DEBUG_INFO("STAT", "OTA 中继: %s (%d)", relay_str, relay);
DEBUG_INFO("STAT", "======================================");
// 每 10 秒打印一次
vTaskDelay(pdMS_TO_TICKS(10000));
}
}
main/include/app_config.h
+3 -5
View File
@@ -12,8 +12,7 @@
// ============================================================
// 0 = AP 模式（设备当热点）
// 1 = STA 模式（连接路由器）
#define CONFIG_WIFI_MODE_IS_STA 1
inline constexpr uint8_t CONFIG_WIFI_MODE = 1;
inline constexpr uint8_t CONFIG_WIFI_MODE = 0;
// ============================================================
// WiFi STA 模式配置（连接路由器）
@@ -23,10 +22,9 @@ inline constexpr const char* WIFI_STA_PASSWORD = "q13362875622";
inline constexpr uint32_t WIFI_STA_CONNECT_TIMEOUT_MS = 30000;
// STA 静态 IP
inline constexpr uint8_t WIFI_STA_USE_STATIC_IP = 0; // 设为 1 启用静态 IP
#define WIFI_STA_STATIC_IP_IS_ENABLED 0
inline constexpr uint8_t WIFI_STA_USE_STATIC_IP = 1; // 设为 1 启用静态 IP
#if WIFI_STA_STATIC_IP_IS_ENABLED
#if WIFI_STA_USE_STATIC_IP
inline constexpr const char* WIFI_STA_STATIC_IP = "192.168.1.100";
inline constexpr const char* WIFI_STA_STATIC_GW = "192.168.1.1";
inline constexpr const char* WIFI_STA_STATIC_NETMASK = "255.255.255.0";
main/monitor/debug_log.cpp
+134 -22
View File
@@ -3,14 +3,19 @@
*
* 通过 UDP socket 发送调试日志到上位机
* 上位机需监听 <DEBUG_LOG_IP>:<DEBUG_LOG_PORT>
*
* 支持双通道输出：UDP + UART0 串口
* UART0: TX=GPIO21, RX=GPIO20, 115200 波特率
*/
#include <string.h>
#include <stdio.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include "freertos/task.h"
#include "esp_log.h"
#include "esp_err.h"
#include "driver/uart.h"
#include "debug_log.h"
@@ -22,13 +27,104 @@ static int s_udp_sock = -1;
static struct sockaddr_in s_debug_addr;
static bool s_initialized = false;
// 初始化 UDP socket
// UART0 状态
static bool s_uart_initialized = false;
static uart_port_t s_uart_port = UART_NUM_0;
// ============================================================
// UART0 串口调试
// ============================================================
esp_err_t uart_debug_init(void)
{
if (s_uart_initialized) {
return ESP_OK;
}
uart_config_t uart_config;
memset(&uart_config, 0, sizeof(uart_config));
uart_config.baud_rate = UART_DEBUG_BAUD_RATE;
uart_config.data_bits = UART_DATA_8_BITS;
uart_config.parity = UART_PARITY_DISABLE;
uart_config.stop_bits = UART_STOP_BITS_1;
uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
uart_config.source_clk = UART_SCLK_DEFAULT;
uart_config.rx_flow_ctrl_thresh = 0;
esp_err_t ret = uart_driver_install(s_uart_port, 1024, 0, 0, NULL, 0);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "UART0 驱动安装失败: %s", esp_err_to_name(ret));
return ret;
}
ret = uart_param_config(s_uart_port, &uart_config);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "UART0 参数配置失败: %s", esp_err_to_name(ret));
return ret;
}
ret = uart_set_pin(s_uart_port, UART_DEBUG_TX_GPIO, UART_DEBUG_RX_GPIO,
UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "UART0 引脚配置失败: %s", esp_err_to_name(ret));
return ret;
}
s_uart_initialized = true;
ESP_LOGI(TAG, "UART0 调试输出已初始化 (TX=GPIO%d, RX=GPIO%d, %d baud)",
UART_DEBUG_TX_GPIO, UART_DEBUG_RX_GPIO, UART_DEBUG_BAUD_RATE);
return ESP_OK;
}
esp_err_t uart_debug_send(const uint8_t *data, size_t len)
{
if (!s_uart_initialized) {
return ESP_ERR_INVALID_STATE;
}
int ret = uart_write_bytes(s_uart_port, data, len);
if (ret < 0) {
return ESP_FAIL;
}
return ESP_OK;
}
// ============================================================
// UDP 调试日志
// ============================================================
// 初始化 UDP socket（注意：socket 创建延迟到 debug_log_send 首次调用时）
// 因为 esp_netif_init() 会在 wifi_ota_task 里调用，提前创建 socket 会导致 tcpip 线程未就绪而崩溃
esp_err_t debug_log_init(void)
{
if (s_initialized) {
return ESP_OK;
}
// 初始化 UART0（不需要网络）
uart_debug_init();
// 延迟创建 socket：先只初始化目标地址，socket 在 debug_log_send 首次发 UDP 时创建
memset(&s_debug_addr, 0, sizeof(s_debug_addr));
s_debug_addr.sin_family = AF_INET;
s_debug_addr.sin_port = htons(DEBUG_LOG_PORT);
s_debug_addr.sin_addr.s_addr = inet_addr(DEBUG_LOG_IP);
s_initialized = true;
ESP_LOGI(TAG, "调试日志已初始化（UDP socket 延迟创建），上位机 IP=%s:%d", DEBUG_LOG_IP, DEBUG_LOG_PORT);
return ESP_OK;
}
// 延迟创建 UDP socket（仅在首次发送 UDP 时调用）
static esp_err_t ensure_udp_socket(void)
{
if (s_udp_sock >= 0) {
return ESP_OK; // 已创建
}
// 创建 UDP socket
s_udp_sock = socket(AF_INET, SOCK_DGRAM, 0);
if (s_udp_sock < 0) {
@@ -36,38 +132,54 @@ esp_err_t debug_log_init(void)
return ESP_FAIL;
}
// 设置目标地址
memset(&s_debug_addr, 0, sizeof(s_debug_addr));
s_debug_addr.sin_family = AF_INET;
s_debug_addr.sin_port = htons(DEBUG_LOG_PORT);
s_debug_addr.sin_addr.s_addr = inet_addr(DEBUG_LOG_IP);
s_initialized = true;
ESP_LOGI(TAG, "调试日志已初始化，上位机 IP=%s:%d", DEBUG_LOG_IP, DEBUG_LOG_PORT);
ESP_LOGI(TAG, "UDP socket 创建成功");
return ESP_OK;
}
// 发送原始数据到上位机
// 发送原始数据到上位机（UDP + UART 双通道）
esp_err_t debug_log_send(const uint8_t *data, size_t len)
{
if (!s_initialized || s_udp_sock < 0) {
return ESP_ERR_INVALID_STATE;
esp_err_t udp_ret = ESP_FAIL;
esp_err_t uart_ret = ESP_FAIL;
// UART 通道发送
if (s_uart_initialized) {
uart_ret = uart_debug_send(data, len);
}
if (len > 1024) {
len = 1024; // 限制单次发送大小
// UDP 通道发送（延迟创建 socket）
if (s_initialized) {
// 首次 UDP 发送前才创建 socket
if (s_udp_sock < 0) {
if (ensure_udp_socket() != ESP_OK) {
// socket 创建失败，走 UART 通道
} else {
udp_ret = ESP_OK; // 标记为已就绪
}
}
if (s_udp_sock >= 0) {
if (len > 1024) {
len = 1024; // 限制单次发送大小
}
int ret = sendto(s_udp_sock, data, len, 0,
(struct sockaddr *)&s_debug_addr, sizeof(s_debug_addr));
if (ret < 0) {
udp_ret = ESP_FAIL;
} else {
udp_ret = ESP_OK;
}
}
}
int ret = sendto(s_udp_sock, data, len, 0,
(struct sockaddr *)&s_debug_addr, sizeof(s_debug_addr));
if (ret < 0) {
// 静默失败，避免影响正常流程
return ESP_FAIL;
// 至少一个通道成功即返回成功
if (udp_ret == ESP_OK || uart_ret == ESP_OK) {
return ESP_OK;
}
return ESP_OK;
return ESP_FAIL;
}
// 格式化日志输出
main/monitor/debug_log.h
+15 -1
View File
@@ -3,6 +3,9 @@
*
* 通过 UDP socket 将调试信息发送到上位机
* 上位机监听 <udp_ip>/<udp_port> 接收日志
*
* 支持双通道输出：UDP + UART0 串口
* UART0: TX=GPIO21, RX=GPIO20, 115200 波特率
*/
#ifndef DEBUG_LOG_H
#define DEBUG_LOG_H
@@ -14,6 +17,11 @@
// 调试日志配置（DEBUG_LOG_IP/PORT/ENABLED 已在 app_config.h 中定义）
// UART0 调试配置
#define UART_DEBUG_TX_GPIO 21
#define UART_DEBUG_RX_GPIO 20
#define UART_DEBUG_BAUD_RATE 115200
// 日志级别
typedef enum {
DEBUG_LOG_NONE = 0,
@@ -27,9 +35,15 @@ typedef enum {
// 当前日志级别（运行时可改）
extern debug_log_level_t g_debug_log_level;
// 初始化调试日志系统（启动 UDP 客户端）
// 初始化调试日志系统（启动 UDP 客户端 + UART0）
esp_err_t debug_log_init(void);
// UART0 串口调试初始化
esp_err_t uart_debug_init(void);
// UART0 串口发送
esp_err_t uart_debug_send(const uint8_t *data, size_t len);
// 发送原始数据到上位机
esp_err_t debug_log_send(const uint8_t *data, size_t len);
main/monitor/health_monitor.cpp
+51 -6
View File
@@ -60,11 +60,13 @@ static void temp_monitor_callback(void *arg)
if (temp >= TEMP_CRITICAL) {
g_health_state = SYS_SAFE_SHUTDOWN;
DEBUG_ERR("TEMP", "危险: 温度 %.1f°C >= %d°C，触发安全关机", temp, TEMP_CRITICAL);
DEBUG_ERR("TEMP", "!!! 危险 !!! 温度 %.1f°C >= %d°C，触发安全关机", temp, TEMP_CRITICAL);
DEBUG_ERR("TEMP", "健康状态变更为: SYS_SAFE_SHUTDOWN");
} else if (temp >= TEMP_WARNING) {
if (g_health_state < SYS_WARNING) {
g_health_state = SYS_WARNING;
DEBUG_WARN("TEMP", "警告: 温度 %.1f°C >= %d°C", temp, TEMP_WARNING);
DEBUG_WARN("TEMP", "健康状态变更为: SYS_WARNING");
}
}
}
@@ -79,12 +81,16 @@ static void voltage_monitor_callback(void *arg)
if (voltage < 2.3f) {
g_health_state = SYS_SAFE_SHUTDOWN;
DEBUG_ERR("VOLT", "危险: 电压 %.2fV < 2.3V，触发安全关机", voltage);
DEBUG_ERR("VOLT", "!!! 危险 !!! 电压 %.2fV < 2.3V，触发安全关机", voltage);
DEBUG_ERR("VOLT", "健康状态变更为: SYS_SAFE_SHUTDOWN");
} else if (voltage < 2.5f) {
if (g_health_state < SYS_WARNING) {
g_health_state = SYS_WARNING;
DEBUG_WARN("VOLT", "警告: 电压 %.2fV < 2.5V", voltage);
DEBUG_WARN("VOLT", "健康状态变更为: SYS_WARNING");
}
} else {
DEBUG_INFO("VOLT", "电压正常: %.2fV", voltage);
}
}
@@ -93,7 +99,7 @@ static void voltage_monitor_callback(void *arg)
// ----------------------------------------
void health_monitor_task(void *pvParameters)
{
DEBUG_INFO("MON", "健康监控任务启动");
DEBUG_INFO("MON", "=== 健康监控任务启动 ===");
// 初始化内置温度传感器（测量范围 20°C ~ 80°C）
temperature_sensor_config_t temp_config = TEMPERATURE_SENSOR_CONFIG_DEFAULT(20, 80);
@@ -116,13 +122,38 @@ void health_monitor_task(void *pvParameters)
esp_timer_create(&timer_args, &temp_timer);
esp_timer_start_periodic(temp_timer, 5 * 1000000); // 5秒
DEBUG_INFO("MON", "温度监控定时器已启动 (间隔 5 秒)");
// 启动时检查一次电压
voltage_monitor_callback(NULL);
// 每5秒打印一次健康状态
uint32_t loop_count = 0;
while (1) {
DEBUG_INFO("MON", "健康状态: %d, 空闲堆: %lu",
g_health_state, esp_get_free_heap_size());
loop_count++;
uint32_t free_heap = esp_get_free_heap_size();
const char *state_str;
switch (g_health_state) {
case SYS_NORMAL: state_str = "正常"; break;
case SYS_WARNING: state_str = "警告"; break;
case SYS_CRITICAL: state_str = "危险"; break;
case SYS_SAFE_SHUTDOWN: state_str = "安全关机"; break;
default: state_str = "未知"; break;
}
DEBUG_INFO("MON", "--- 健康状态 #%lu ---", (unsigned long)loop_count);
DEBUG_INFO("MON", "健康状态: %s (%d)", state_str, g_health_state);
DEBUG_INFO("MON", "空闲堆: %lu 字节", (unsigned long)free_heap);
// 堆内存警告
if (free_heap < HEAP_WARNING_MIN) {
DEBUG_WARN("MON", "空闲堆内存不足: %lu < %d", (unsigned long)free_heap, HEAP_WARNING_MIN);
}
DEBUG_INFO("MON", "===================");
vTaskDelay(pdMS_TO_TICKS(5000));
}
}
@@ -132,7 +163,7 @@ void health_monitor_task(void *pvParameters)
// ----------------------------------------
void health_log_event(const char *event, int value)
{
DEBUG_WARN("HEALTH", "[健康日志] %s: %d", event, value);
DEBUG_INFO("HEALTH", "[健康事件] %s: %d", event, value);
}
// ----------------------------------------
@@ -143,25 +174,36 @@ health_status_t health_check_before_ota(void)
health_status_t status = HEALTH_MON_OK;
if (g_health_state >= SYS_SAFE_SHUTDOWN) {
DEBUG_WARN("HEALTH", "OTA 前检查: SYS_SAFE_SHUTDOWN，禁止传输");
return HEALTH_MON_SHUTDOWN;
} else if (g_health_state >= SYS_CRITICAL) {
DEBUG_WARN("HEALTH", "OTA 前检查: SYS_CRITICAL，禁止传输");
return HEALTH_MON_CRITICAL;
} else if (g_health_state >= SYS_WARNING) {
status = HEALTH_MON_WARNING;
DEBUG_WARN("HEALTH", "OTA 前检查: SYS_WARNING，继续传输但需注意");
}
wifi_ap_record_t ap_info;
if (esp_wifi_sta_get_ap_info(&ap_info) == ESP_OK) {
if (ap_info.rssi < WIFI_RSSI_CRITICAL) {
g_health_state = SYS_CRITICAL;
DEBUG_WARN("HEALTH", "OTA 前检查: WiFi RSSI %d < %d (危险阈值)",
ap_info.rssi, WIFI_RSSI_CRITICAL);
return HEALTH_MON_CRITICAL;
} else if (ap_info.rssi < WIFI_RSSI_NORMAL) {
if (status < HEALTH_MON_WARNING) {
status = HEALTH_MON_WARNING;
}
DEBUG_WARN("HEALTH", "OTA 前检查: WiFi RSSI %d < %d (警告阈值)",
ap_info.rssi, WIFI_RSSI_NORMAL);
}
}
if (status == HEALTH_MON_OK) {
DEBUG_DBG("HEALTH", "OTA 前检查: 正常");
}
return status;
}
@@ -169,11 +211,13 @@ health_status_t health_update_from_wifi_rssi(int8_t rssi)
{
if (rssi < WIFI_RSSI_CRITICAL) {
g_health_state = SYS_CRITICAL;
DEBUG_WARN("HEALTH", "WiFi RSSI 危险: %d dBm < %d dBm", rssi, WIFI_RSSI_CRITICAL);
health_log_event("WIFI危险", rssi);
return HEALTH_MON_CRITICAL;
} else if (rssi < WIFI_RSSI_NORMAL) {
if (g_health_state < SYS_WARNING) {
g_health_state = SYS_WARNING;
DEBUG_WARN("HEALTH", "WiFi RSSI 警告: %d dBm < %d dBm", rssi, WIFI_RSSI_NORMAL);
health_log_event("WIFI警告", rssi);
}
return HEALTH_MON_WARNING;
@@ -181,6 +225,7 @@ health_status_t health_update_from_wifi_rssi(int8_t rssi)
if (g_health_state == SYS_WARNING && rssi >= WIFI_RSSI_NORMAL) {
g_health_state = SYS_NORMAL;
DEBUG_INFO("HEALTH", "WiFi RSSI 恢复: %d dBm >= %d dBm", rssi, WIFI_RSSI_NORMAL);
health_log_event("WIFI恢复", rssi);
}
main/relay/ota_relay.cpp
+31 -11
View File
@@ -152,6 +152,7 @@ esp_err_t flash_read_chunk(uint32_t offset, uint8_t *data, size_t len)
static ota_result_t send_handshake_req(void)
{
DEBUG_INFO("OTA", "=== 阶段1: 握手开始 ===");
DEBUG_INFO("OTA", "发送 HANDSHAKE_REQ (0x00 0xAC)");
uint8_t tx_frame[32];
uint8_t rx_frame[32];
@@ -160,11 +161,12 @@ static ota_result_t send_handshake_req(void)
frame_build(CMD_HANDSHAKE_REQ, payload, sizeof(payload), tx_frame);
g_relay_state = RELAY_HANDSHAKE_SENT;
DEBUG_INFO("OTA", "状态: RELAY_HANDSHAKE_SENT");
esp_err_t err = spi_sync_transfer(CMD_HANDSHAKE_REQ, payload, sizeof(payload),
rx_frame, sizeof(rx_frame), 3000);
if (err != ESP_OK) {
DEBUG_ERR("OTA", "HANDSHAKE_REQ 失败");
DEBUG_ERR("OTA", "HANDSHAKE_REQ 失败, err=%d", err);
g_relay_state = RELAY_ERROR;
return OTA_RESULT_ERR_TIMEOUT;
}
@@ -188,38 +190,45 @@ static ota_result_t send_nonce_and_authenticate(void)
scramble_generate(timestamp, mem_addr, rand_seed, nonce_server);
DEBUG_INFO("OTA", "发送 CHALLENGE，包含 nonce_server (16B)");
DEBUG_INFO("OTA", "--- 认证步骤 1: 发送 CHALLENGE ---");
DEBUG_INFO("OTA", "发送 nonce_server (16B), timestamp=0x%08X", timestamp);
g_relay_state = RELAY_CHALLENGE_SENT;
DEBUG_INFO("OTA", "状态: RELAY_CHALLENGE_SENT");
frame_build(CMD_CHALLENGE, nonce_server, 16, tx_frame);
esp_err_t err = spi_sync_transfer(CMD_CHALLENGE, nonce_server, 16,
rx_frame, sizeof(rx_frame), 5000);
if (err != ESP_OK) {
DEBUG_ERR("OTA", "CHALLENGE 发送失败");
DEBUG_ERR("OTA", "CHALLENGE 发送失败, err=%d", err);
g_relay_state = RELAY_ERROR;
return OTA_RESULT_ERR_TIMEOUT;
}
g_relay_state = RELAY_CHALLENGE_RESPOND;
DEBUG_INFO("OTA", "已收到 GD32 握手数据包");
DEBUG_INFO("OTA", "状态: RELAY_CHALLENGE_RESPOND");
// 发送 SESSION_KEY（带变换后的随机数）
uint8_t transformed_nonce[16];
memcpy(transformed_nonce, nonce_server, 16);
DEBUG_INFO("OTA", "发送 SESSION_KEY（带变换后的随机数）");
DEBUG_INFO("OTA", "--- 认证步骤 2: 发送 SESSION_KEY ---");
DEBUG_INFO("OTA", "发送变换后的随机数 (16B)");
g_relay_state = RELAY_SESSION_KEY_SENT;
DEBUG_INFO("OTA", "状态: RELAY_SESSION_KEY_SENT");
frame_build(CMD_SESSION_KEY, transformed_nonce, 16, tx_frame);
esp_err_t err2 = spi_sync_transfer(CMD_SESSION_KEY, transformed_nonce, 16,
rx_frame, sizeof(rx_frame), 3000);
if (err2 != ESP_OK) {
DEBUG_ERR("OTA", "SESSION_KEY 发送失败, err=%d", err2);
g_relay_state = RELAY_ERROR;
return OTA_RESULT_ERR_TIMEOUT;
}
g_relay_state = RELAY_AUTH_COMPLETE;
DEBUG_INFO("OTA", "状态: RELAY_AUTH_COMPLETE");
DEBUG_INFO("OTA", "=== 阶段1 认证完成: 安全通道已建立 ===");
uint8_t k_session[16] = {0};
@@ -234,7 +243,8 @@ static ota_result_t send_firmware_size(uint32_t size)
uint8_t tx_frame[32];
uint8_t rx_frame[32];
DEBUG_INFO("OTA", "=== 阶段2: 发送大小 ===");
DEBUG_INFO("OTA", "=== 阶段2: 发送固件大小 ===");
DEBUG_INFO("OTA", "固件大小: %u 字节", size);
uint8_t size_payload[4];
size_payload[0] = (uint8_t)(size & 0xFF);
@@ -243,18 +253,20 @@ static ota_result_t send_firmware_size(uint32_t size)
size_payload[3] = (uint8_t)((size >> 24) & 0xFF);
g_relay_state = RELAY_SIZE_SENT;
DEBUG_INFO("OTA", "状态: RELAY_SIZE_SENT");
frame_build(CMD_SEND_SIZE, size_payload, 4, tx_frame);
esp_err_t err = spi_sync_transfer(CMD_SEND_SIZE, size_payload, 4,
rx_frame, sizeof(rx_frame), 3000);
if (err != ESP_OK) {
DEBUG_ERR("OTA", "SEND_SIZE 失败");
DEBUG_ERR("OTA", "SEND_SIZE 失败, err=%d", err);
g_relay_state = RELAY_ERROR;
return OTA_RESULT_ERR_TIMEOUT;
}
DEBUG_INFO("OTA", "大小已发送: %u 字节，等待 GD32 确认...", size);
g_relay_state = RELAY_SIZE_ACK;
DEBUG_INFO("OTA", "状态: RELAY_SIZE_ACK");
return OTA_RESULT_OK;
}
@@ -266,6 +278,7 @@ static ota_result_t relay_packets_from_flash(void)
ota_meta_t meta;
if (meta_load(&meta) != ESP_OK) {
DEBUG_ERR("OTA", "元数据加载失败");
return OTA_RESULT_ERR_STORAGE;
}
@@ -275,7 +288,9 @@ static ota_result_t relay_packets_from_flash(void)
uint8_t rx_buf[32];
ota_result_t result = OTA_RESULT_OK;
DEBUG_INFO("OTA", "准备转发 %u 包，每包 48 字节", total_packets);
DEBUG_INFO("OTA", "总包数: %u, 每包 48 字节", total_packets);
DEBUG_INFO("OTA", "状态: RELAY_RELAY_ACTIVE");
g_relay_state = RELAY_RELAY_ACTIVE;
for (uint32_t seq = 0; seq < total_packets; seq++) {
// 发送每个包前检查健康状态
@@ -292,7 +307,7 @@ static ota_result_t relay_packets_from_flash(void)
esp_err_t err = flash_read_chunk(flash_offset, &tx_buf[2], chunk_size);
if (err != ESP_OK) {
DEBUG_ERR("OTA", "Flash 读取失败，偏移=%u", flash_offset);
DEBUG_ERR("OTA", "Flash 读取失败, offset=%u, err=%d", flash_offset, err);
return OTA_RESULT_ERR_STORAGE;
}
@@ -310,7 +325,7 @@ static ota_result_t relay_packets_from_flash(void)
err = spi_sync_transfer(cmd, tx_buf, tx_len, rx_buf, sizeof(rx_buf), 3000);
if (err != ESP_OK) {
DEBUG_WARN("OTA", "数据包 %u 发送失败，重试中...", seq);
DEBUG_WARN("OTA", "数据包 %u 发送失败, err=%d, 重试中...", seq, err);
result = OTA_RESULT_ERR_TIMEOUT;
break;
}
@@ -320,12 +335,14 @@ static ota_result_t relay_packets_from_flash(void)
// 每 10% 记录一次进度
if (seq % (total_packets / 10 + 1) == 0) {
uint32_t progress = (seq * 100) / total_packets;
DEBUG_INFO("OTA", "转发进度: %u/%u 包 (%u%%)",
seq, total_packets, (seq * 100) / total_packets);
seq, total_packets, progress);
}
}
g_relay_state = RELAY_RECEIVE_DONE;
DEBUG_INFO("OTA", "状态: RELAY_RECEIVE_DONE");
return result;
}
@@ -333,6 +350,7 @@ static ota_result_t relay_packets_from_flash(void)
static ota_result_t finish_ota(void)
{
DEBUG_INFO("OTA", "=== 阶段4: 结束 OTA ===");
DEBUG_INFO("OTA", "发送 FINISH_OTA (0x0A 0xAC)");
uint8_t tx_frame[16];
uint8_t rx_frame[16];
@@ -341,11 +359,12 @@ static ota_result_t finish_ota(void)
frame_build(CMD_FINISH_OTA, payload, sizeof(payload), tx_frame);
g_relay_state = RELAY_FINISH_SENT;
DEBUG_INFO("OTA", "状态: RELAY_FINISH_SENT");
esp_err_t err = spi_sync_transfer(CMD_FINISH_OTA, payload, sizeof(payload),
rx_frame, sizeof(rx_frame), 5000);
if (err != ESP_OK) {
DEBUG_ERR("OTA", "FINISH_OTA 失败");
DEBUG_ERR("OTA", "FINISH_OTA 失败, err=%d", err);
g_relay_state = RELAY_ERROR;
return OTA_RESULT_ERR_TIMEOUT;
}
@@ -356,6 +375,7 @@ static ota_result_t finish_ota(void)
memset(&g_session_ctx, 0, sizeof(session_ctx_t));
g_relay_state = RELAY_DONE;
DEBUG_INFO("OTA", "状态: RELAY_DONE");
DEBUG_INFO("OTA", "=== OTA 完成 ===");
meta_clear();
main/server/wifi_ota.cpp
+46 -13
View File
@@ -36,7 +36,7 @@ static httpd_handle_t s_http_server = NULL;
// ----------------------------------------
static esp_err_t wifi_init_ap(void)
{
DEBUG_INFO("WIFI", "初始化 WiFi AP 模式...");
DEBUG_INFO("WIFI", "=== 初始化 WiFi AP 模式 ===");
s_wifi_mode = OTA_WIFI_MODE_AP;
@@ -48,12 +48,15 @@ static esp_err_t wifi_init_ap(void)
wifi_config.ap.authmode = WIFI_AUTH_WPA_WPA2_PSK;
wifi_config.ap.channel = WIFI_AP_CHANNEL;
DEBUG_INFO("WIFI", "AP SSID: %s, Channel: %d", WIFI_AP_SSID, WIFI_AP_CHANNEL);
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &wifi_config));
ESP_ERROR_CHECK(esp_wifi_start());
DEBUG_INFO("WIFI", "WiFi AP 已启动: %s", WIFI_AP_SSID);
DEBUG_INFO("WIFI", "AP IP 地址: 192.168.4.1");
DEBUG_INFO("WIFI", "最大连接数: %d", WIFI_AP_MAX_CONNECT);
return ESP_OK;
}
@@ -63,7 +66,7 @@ static esp_err_t wifi_init_ap(void)
// ----------------------------------------
static esp_err_t wifi_init_sta(void)
{
DEBUG_INFO("WIFI", "初始化 WiFi STA 模式...");
DEBUG_INFO("WIFI", "=== 初始化 WiFi STA 模式 ===");
s_wifi_mode = OTA_WIFI_MODE_STA;
@@ -74,6 +77,8 @@ static esp_err_t wifi_init_sta(void)
memcpy(wifi_config.sta.ssid, WIFI_STA_SSID, strlen(WIFI_STA_SSID) + 1);
memcpy(wifi_config.sta.password, WIFI_STA_PASSWORD, strlen(WIFI_STA_PASSWORD) + 1);
DEBUG_INFO("WIFI", "STA SSID: %s", WIFI_STA_SSID);
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
ESP_ERROR_CHECK(esp_wifi_start());
@@ -133,10 +138,11 @@ static void wifi_set_static_ip(void)
// ----------------------------------------
static esp_err_t ota_upload_handler(httpd_req_t *req)
{
DEBUG_INFO("WIFI", "收到固件上传请求, 内容长度: %d", req->content_len);
DEBUG_INFO("WIFI", "=== HTTP: POST /ota/upload ===");
DEBUG_INFO("WIFI", "收到固件上传请求, 内容长度: %d 字节", req->content_len);
if (req->content_len > OTA_MAX_FIRMWARE_SIZE) {
DEBUG_ERR("WIFI", "固件太大: %d 字节", req->content_len);
DEBUG_ERR("WIFI", "固件太大: %d 字节 (最大 %d)", req->content_len, OTA_MAX_FIRMWARE_SIZE);
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "固件太大");
return ESP_FAIL;
}
@@ -151,7 +157,7 @@ static esp_err_t ota_upload_handler(httpd_req_t *req)
int ret = httpd_req_recv(req, (char *)buf, to_read);
if (ret <= 0) {
DEBUG_ERR("WIFI", "请求接收失败");
DEBUG_ERR("WIFI", "HTTP 请求接收失败");
httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "接收失败");
return ESP_FAIL;
}
@@ -169,7 +175,8 @@ static esp_err_t ota_upload_handler(httpd_req_t *req)
.checksum = {0}
};
meta_save(&meta);
DEBUG_INFO("WIFI", "开始固件存储: %u 字节", total_size);
DEBUG_INFO("WIFI", "开始固件存储: %u 字节, %u 块",
total_size, meta.chunk_count);
}
first_chunk = 0;
}
@@ -177,13 +184,18 @@ static esp_err_t ota_upload_handler(httpd_req_t *req)
uint32_t flash_offset = (received / OTA_BLOCK_SIZE) * OTA_BLOCK_SIZE;
esp_err_t err = flash_write_chunk(flash_offset, buf, ret);
if (err != ESP_OK) {
DEBUG_ERR("WIFI", "Flash 写入失败 at offset %u", flash_offset);
DEBUG_ERR("WIFI", "Flash 写入失败, offset=%u, err=%d", flash_offset, err);
}
meta_update(flash_offset + ret, received / OTA_BLOCK_SIZE);
received += ret;
DEBUG_DBG("WIFI", "已接收: %d / %d 字节", received, req->content_len);
// 每 10% 打印进度
if (received % (req->content_len / 10 + 1) < OTA_BLOCK_SIZE) {
uint32_t progress = (received * 100) / req->content_len;
DEBUG_INFO("WIFI", "上传进度: %d / %d 字节 (%u%%)", received, req->content_len, progress);
}
}
DEBUG_INFO("WIFI", "固件存储完成: %d 字节", received);
@@ -207,6 +219,7 @@ static esp_err_t ota_upload_handler(httpd_req_t *req)
static esp_err_t ota_relay_trigger_handler(httpd_req_t *req)
{
(void)req;
DEBUG_INFO("WIFI", "=== HTTP: POST /ota/relay ===");
DEBUG_INFO("WIFI", "收到触发 OTA 中继请求");
wifi_ota_signal_relay();
@@ -220,6 +233,8 @@ static esp_err_t ota_relay_trigger_handler(httpd_req_t *req)
// HTTP GET /ota/status 处理器
static esp_err_t ota_status_handler(httpd_req_t *req)
{
DEBUG_INFO("WIFI", "=== HTTP: GET /ota/status ===");
ota_meta_t meta;
meta_load(&meta);
@@ -232,6 +247,10 @@ static esp_err_t ota_status_handler(httpd_req_t *req)
s_ota_storage_done ? "true" : "false",
g_relay_state);
DEBUG_INFO("WIFI", "OTA 状态: total=%lu, stored=%lu, done=%s",
(unsigned long)meta.total_size, (unsigned long)meta.stored_size,
s_ota_storage_done ? "true" : "false");
httpd_resp_set_type(req, "application/json");
httpd_resp_send(req, resp, len);
@@ -241,12 +260,17 @@ static esp_err_t ota_status_handler(httpd_req_t *req)
// HTTP GET /health 处理器
static esp_err_t health_handler(httpd_req_t *req)
{
DEBUG_INFO("WIFI", "=== HTTP: GET /health ===");
health_state_t state = health_get_current();
uint32_t free_heap = esp_get_free_heap_size();
char resp[128];
int len = snprintf(resp, sizeof(resp),
"{\"health\": %d, \"free_heap\": %lu}",
state, (unsigned long)esp_get_free_heap_size());
state, (unsigned long)free_heap);
DEBUG_INFO("WIFI", "健康状态: %d, 空闲堆: %lu", state, (unsigned long)free_heap);
httpd_resp_set_type(req, "application/json");
httpd_resp_send(req, resp, len);
@@ -386,7 +410,8 @@ static esp_err_t http_ota_server_start(void)
config.server_port = HTTP_SERVER_PORT;
config.stack_size = HTTP_SERVER_STACK_SIZE;
DEBUG_INFO("WIFI", "启动 HTTP 服务器，端口 %d...", config.server_port);
DEBUG_INFO("WIFI", "=== 启动 HTTP OTA 服务器 ===");
DEBUG_INFO("WIFI", "HTTP 服务器端口: %d", config.server_port);
esp_err_t err = httpd_start(&s_http_server, &config);
if (err != ESP_OK) {
@@ -452,6 +477,7 @@ static esp_err_t http_ota_server_start(void)
httpd_register_uri_handler(s_http_server, &can_status_uri);
DEBUG_INFO("WIFI", "HTTP 服务器已启动");
DEBUG_INFO("WIFI", "注册端点: /ota/upload, /ota/relay, /ota/status, /health, /wifi/status, /can/send, /can/status");
return ESP_OK;
}
@@ -504,19 +530,23 @@ void wifi_ota_task(void *pvParameters)
{
(void)pvParameters;
DEBUG_INFO("WIFI", "WiFi OTA 任务启动");
DEBUG_INFO("WIFI", "=== WiFi OTA 任务启动 ===");
// 初始化 NVS
esp_err_t err = nvs_flash_init();
if (err != ESP_OK) {
DEBUG_ERR("WIFI", "NVS 初始化失败: %s", esp_err_to_name(err));
} else {
DEBUG_INFO("WIFI", "NVS 初始化成功");
}
// 初始化网络接口
ESP_ERROR_CHECK(esp_netif_init());
DEBUG_INFO("WIFI", "网络接口初始化成功");
// STA 优先，失败自动切 AP
#if CONFIG_WIFI_MODE_IS_STA
DEBUG_INFO("WIFI", "工作模式: STA (优先)");
err = wifi_init_sta();
if (err == ESP_OK) {
char ip_str[16] = {0};
@@ -536,6 +566,7 @@ void wifi_ota_task(void *pvParameters)
}
}
#else
DEBUG_INFO("WIFI", "工作模式: AP");
wifi_init_ap();
#endif
@@ -545,7 +576,7 @@ void wifi_ota_task(void *pvParameters)
DEBUG_ERR("WIFI", "HTTP 服务器启动失败");
}
DEBUG_INFO("WIFI", "WiFi OTA 服务器就绪");
DEBUG_INFO("WIFI", "=== WiFi OTA 服务器就绪 ===");
// 定期检查 WiFi 状态
while (1) {
@@ -554,7 +585,9 @@ void wifi_ota_task(void *pvParameters)
health_update_from_wifi_rssi(rssi);
if (rssi < WIFI_RSSI_CRITICAL) {
DEBUG_WARN("WIFI", "WiFi RSSI 危险: %d dBm", rssi);
DEBUG_WARN("WIFI", "WiFi RSSI 危险: %d dBm (阈值: %d)", rssi, WIFI_RSSI_CRITICAL);
} else if (rssi < WIFI_RSSI_WARNING) {
DEBUG_WARN("WIFI", "WiFi RSSI 较弱: %d dBm", rssi);
}
}
main/transport/protocol.cpp
+23 -7
View File
@@ -19,7 +19,8 @@ void protocol_init(void)
{
if (s_protocol_initialized) return;
DEBUG_INFO("PROT", "初始化协议层（CRC16、硬件AES-CBC）...");
DEBUG_INFO("PROT", "=== 初始化协议层 ===");
DEBUG_INFO("PROT", "协议层功能: CRC16 Modbus + 硬件 AES-128-CBC");
s_protocol_initialized = true;
DEBUG_INFO("PROT", "协议层就绪");
@@ -65,6 +66,8 @@ int frame_build(uint8_t cmd, const uint8_t *payload, size_t len, uint8_t *out_fr
out_frame[idx++] = (uint8_t)(crc & 0xFF);
out_frame[idx++] = (uint8_t)((crc >> 8) & 0xFF);
DEBUG_DBG("PROT", "帧构建: cmd=0x%02X, len=%zu, crc=0x%04X", cmd, len, crc);
return idx;
}
@@ -73,13 +76,14 @@ int frame_parse(const uint8_t *frame, size_t frame_len,
uint8_t *out_cmd, uint8_t *out_payload, size_t *out_len)
{
if (frame_len < 6) {
DEBUG_WARN("PROT", "帧太短: %zu < 6", frame_len);
return -1;
}
size_t idx = 0;
if (frame[idx++] != FRAME_SOF) {
DEBUG_WARN("PROT", "无效 SOF: 0x%02X", frame[0]);
DEBUG_WARN("PROT", "无效 SOF: 0x%02X (期望 0x%02X)", frame[0], FRAME_SOF);
return -1;
}
@@ -89,13 +93,13 @@ int frame_parse(const uint8_t *frame, size_t frame_len,
idx += 2;
if (payload_len > FRAME_MAX_PAYLOAD) {
DEBUG_ERR("PROT", "Payload 长度太大: %zu", payload_len);
DEBUG_ERR("PROT", "Payload 长度太大: %zu > %d", payload_len, FRAME_MAX_PAYLOAD);
return -1;
}
size_t expected_len = 1 + 1 + 2 + payload_len + 2;
if (frame_len < expected_len) {
DEBUG_WARN("PROT", "帧太短: %zu < %zu", frame_len, expected_len);
DEBUG_WARN("PROT", "帧太短: %zu < %zu (期望)", frame_len, expected_len);
return -1;
}
@@ -103,10 +107,12 @@ int frame_parse(const uint8_t *frame, size_t frame_len,
uint16_t calc_crc = crc16_modbus(frame, idx + payload_len);
if (received_crc != calc_crc) {
DEBUG_WARN("PROT", "CRC 不匹配: 0x%04X vs 0x%04X", received_crc, calc_crc);
DEBUG_WARN("PROT", "CRC 不匹配: 收到=0x%04X, 计算=0x%04X", received_crc, calc_crc);
return -1;
}
DEBUG_DBG("PROT", "帧解析: cmd=0x%02X, len=%zu, crc=0x%04X OK", cmd, payload_len, calc_crc);
if (out_payload && out_len) {
memcpy(out_payload, &frame[idx], payload_len);
*out_len = payload_len;
@@ -124,6 +130,7 @@ int protocol_aes_encrypt(const uint8_t *plaintext, size_t len,
uint8_t *ciphertext_out)
{
if (!plaintext || !key || !iv || !ciphertext_out) {
DEBUG_ERR("PROT", "AES 加密参数无效");
return -1;
}
@@ -136,6 +143,8 @@ int protocol_aes_encrypt(const uint8_t *plaintext, size_t len,
if (pad == 0) pad = 16;
memset(&padded[len], pad, pad);
DEBUG_DBG("PROT", "AES 加密: 明文=%zu 字节, 填充后=%zu 字节, 填充值=0x%02X", len, padded_len, pad);
// 硬件 AES-CBC 加密（使用 ESP32-C3 硬件 AES 加速器）
esp_aes_context aes_ctx;
esp_aes_init(&aes_ctx);
@@ -155,6 +164,7 @@ int protocol_aes_encrypt(const uint8_t *plaintext, size_t len,
esp_aes_free(&aes_ctx);
if (ret == 0) {
DEBUG_DBG("PROT", "AES 加密成功: %zu -> %zu 字节", len, padded_len);
return padded_len;
} else {
DEBUG_ERR("PROT", "esp_aes_crypt_cbc 加密失败: %d", ret);
@@ -168,14 +178,17 @@ int protocol_aes_decrypt(const uint8_t *ciphertext, size_t len,
uint8_t *plaintext_out)
{
if (!ciphertext || !key || !iv || !plaintext_out) {
DEBUG_ERR("PROT", "AES 解密参数无效");
return -1;
}
if (len % 16 != 0 || len == 0) {
DEBUG_ERR("PROT", "Ciphertext 长度无效: %zu", len);
DEBUG_ERR("PROT", "Ciphertext 长度无效: %zu (必须为 16 的倍数)", len);
return -1;
}
DEBUG_DBG("PROT", "AES 解密: 密文=%zu 字节", len);
// 硬件 AES-CBC 解密（使用 ESP32-C3 硬件 AES 加速器）
esp_aes_context aes_ctx;
esp_aes_init(&aes_ctx);
@@ -206,7 +219,10 @@ int protocol_aes_decrypt(const uint8_t *ciphertext, size_t len,
return -1;
}
return len - pad;
size_t orig_len = len - pad;
DEBUG_DBG("PROT", "AES 解密成功: %zu -> %zu 字节 (填充=%d)", len, orig_len, pad);
return orig_len;
}
// 搅伴算法 - 生成随机数
main/transport/spi_master.cpp
+30 -9
View File
@@ -20,7 +20,7 @@ spi_device_handle_t g_spi_device = NULL;
// SPI2 总线初始化
esp_err_t spi_master_init(void)
{
DEBUG_INFO("SPI", "初始化 SPI2 (VSPI)...");
DEBUG_INFO("SPI", "=== 初始化 SPI2 (VSPI) ===");
spi_bus_config_t bus_cfg = {};
bus_cfg.mosi_io_num = 8;
@@ -30,6 +30,10 @@ esp_err_t spi_master_init(void)
bus_cfg.quadhd_io_num = -1;
bus_cfg.max_transfer_sz = 256;
DEBUG_INFO("SPI", "SPI2 引脚: MOSI=GPIO8, MISO=GPIO7, SCLK=GPIO6");
DEBUG_INFO("SPI", "SPI2 配置: CLK=%d MHz, CS=GPIO%d, 最大传输=%d 字节",
SPI_CLOCK_HZ / 1000000, SPI_MASTER_CS_GPIO, bus_cfg.max_transfer_sz);
esp_err_t ret = spi_bus_initialize(SPI2_HOST, &bus_cfg, SPI_DMA_CH_AUTO);
if (ret != ESP_OK) {
DEBUG_ERR("SPI", "SPI 总线初始化失败: %s", esp_err_to_name(ret));
@@ -53,7 +57,9 @@ esp_err_t spi_master_init(void)
return ret;
}
DEBUG_INFO("SPI", "SPI2 已初始化: CLK=40MHz, CS=GPIO4");
DEBUG_INFO("SPI", "SPI2 已初始化: CLK=%dMHz, CS=GPIO%d, 模式=%d",
SPI_CLOCK_HZ / 1000000, SPI_MASTER_CS_GPIO, SPI_MODE);
DEBUG_INFO("SPI", "SPI 设备句柄: %p", g_spi_device);
return ESP_OK;
}
@@ -69,6 +75,9 @@ esp_err_t spi_sync_transfer(uint8_t cmd, const uint8_t *payload,
return ESP_ERR_INVALID_STATE;
}
DEBUG_DBG("SPI", "SPI 传输: cmd=0x%02X, 发送=%zu 字节, 接收=%zu 字节",
cmd, payload_len, recv_len);
spi_transaction_t t = {};
t.cmd = cmd;
t.length = payload_len * 8;
@@ -83,6 +92,8 @@ esp_err_t spi_sync_transfer(uint8_t cmd, const uint8_t *payload,
esp_err_t ret = spi_device_transmit(g_spi_device, &t);
if (ret != ESP_OK) {
DEBUG_WARN("SPI", "SPI 发送 cmd=0x%02X 失败: %s", cmd, esp_err_to_name(ret));
} else {
DEBUG_DBG("SPI", "SPI 传输完成: cmd=0x%02X", cmd);
}
return ret;
@@ -110,19 +121,22 @@ static int can_frame_send(can_channel_t channel, uint32_t ext_id,
uint32_t timeout_ms)
{
if (g_spi_device == NULL) {
DEBUG_ERR("SPI", "CAN 发送: SPI 设备未初始化");
return -1;
}
if (dlc == 0 || dlc > CAN_MAX_DLC) {
DEBUG_ERR("SPI", "DLC 无效: %d", dlc);
DEBUG_ERR("SPI", "CAN[ch%d] DLC 无效: %d (范围 1~%d)", channel, dlc, CAN_MAX_DLC);
return -2;
}
if (channel >= CAN_CHANNEL_MAX) {
DEBUG_ERR("SPI", "通道号无效: %d", channel);
DEBUG_ERR("SPI", "CAN 通道号无效: %d (范围 0~%d)", channel, CAN_CHANNEL_MAX - 1);
return -3;
}
DEBUG_DBG("SPI", "CAN[ch%d] ID=0x%08X 发送: DLC=%d", channel, ext_id, dlc);
// 构建 CANFD 帧: [通道(1B)] [EXT_ID(4B)] [DATA(dlc B)]
uint8_t tx_buf[1 + 4 + CAN_MAX_DLC] = {0};
tx_buf[0] = (uint8_t)channel;
@@ -159,11 +173,12 @@ static int can_frame_send(can_channel_t channel, uint32_t ext_id,
uint8_t copy_len = (resp_dlc < recv_max) ? resp_dlc : recv_max;
memcpy(recv_buf, &rx_buf[5], copy_len);
DEBUG_INFO("SPI", "CAN[ch%d] ID=0x%08X 响应 DLC=%d",
resp_channel, resp_id, copy_len);
DEBUG_INFO("SPI", "CAN[ch%d] ID=0x%08X 响应: DLC=%d, 接收=%d 字节",
resp_channel, resp_id, copy_len, copy_len);
return copy_len;
}
DEBUG_DBG("SPI", "CAN[ch%d] ID=0x%08X 发送完成 (无响应)", channel, ext_id);
return 0;
}
@@ -192,18 +207,24 @@ esp_err_t spi_transfer_with_retry(uint8_t cmd, const uint8_t *payload,
esp_err_t ret;
int retry_count = 0;
DEBUG_INFO("SPI", "SPI 传输 (带重试): cmd=0x%02X, 最大重试=%d", cmd, max_retries);
while (retry_count < max_retries) {
ret = spi_sync_transfer(cmd, payload, payload_len,
recv_buf, recv_len, 3000);
if (ret == ESP_OK) {
if (retry_count > 0) {
DEBUG_INFO("SPI", "SPI 传输成功 (重试 %d 次后成功)", retry_count);
}
return ESP_OK;
}
retry_count++;
DEBUG_WARN("SPI", "SPI 重试 %d/%d, cmd=0x%02X", retry_count, max_retries, cmd);
DEBUG_WARN("SPI", "SPI 重试 %d/%d, cmd=0x%02X, err=%s",
retry_count, max_retries, cmd, esp_err_to_name(ret));
vTaskDelay(pdMS_TO_TICKS(100));
}
DEBUG_ERR("SPI", "SPI 传输 %d 次重试后失败", max_retries);
DEBUG_ERR("SPI", "SPI 传输 %d 次重试后失败, cmd=0x%02X", max_retries, cmd);
return ESP_ERR_TIMEOUT;
}
}