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

feat(main): 将全局函数重构为单例类模式

Browse Source 
- 将 debug_log 模块重构为 DebugLog 单例类，封装 UART、UDP 和环形缓冲区日志输出
- 将 health_monitor 模块重构为 HealthMonitor 单例类，统一健康状态管理和监控逻辑
- 更新 main.cpp 中的初始化调用，使用单例实例替代原有全局函数
- 添加健康监控任务作为第四个 FreeRTOS 任务，增强系统监控能力
- 更新固件版本从 0.2.11 到 0.3.0，反映架构重大变更
This commit is contained in:
小龙虾
2026-05-31 03:20:26 +08:00
parent 56f26fa0d1
commit 1586a81b97
16 changed files with 1501 additions and 2245 deletions
Download Patch File Download Diff File Expand all files Collapse all files
main/monitor/debug_log.cpp
+80 -149
View File
@@ -1,5 +1,5 @@
/*
* debug_log.c - 调试日志输出实现
/*
* debug_log.cpp - 调试日志输出实现
*
* 日志会同时写入三处：
* 1. UART0 串口（本地串口调试）
@@ -11,7 +11,7 @@
*
* 时序说明：
* esp_netif_init() 创建 tcpip 线程后才可安全使用 socket
* 本模块在首次 debug_log_send() 时才创建 socket（延迟创建）
* 本模块在首次 send() 时才创建 socket（延迟创建）
* WiFi 连接前 sendto() 会失败（无路由），日志仍可写入 UART 与 HTTP 日志缓冲
* WiFi 连接后 UDP 立即生效，无需额外操作
*/
@@ -30,60 +30,39 @@
static const char *TAG = "DEBUG_LOG";
/** @brief 当前调试日志过滤级别，运行时可动态调整。 */
debug_log_level_t g_debug_log_level = DEBUG_LOG_INFO;
/** @brief UDP 调试日志 socket 句柄，首次发送时延迟创建。 */
static int s_udp_sock = -1;
/** @brief UDP 调试日志目标地址。 */
static struct sockaddr_in s_debug_addr;
/** @brief 日志模块初始化标志。 */
static bool s_initialized = false;
// ============================================================
// 单例
// ============================================================
DebugLog& DebugLog::instance()
{
static DebugLog inst;
return inst;
}
// ============================================================
// 日志环形缓冲区（供 HTTP /logs 拉取）
// ============================================================
#define LOG_RING_SLOTS 64
#define LOG_RING_SIZE 256
static char s_log_ring[LOG_RING_SLOTS][LOG_RING_SIZE];
static int s_log_ring_lens[LOG_RING_SLOTS];
static int s_log_ring_head = 0; // 下次写入位置
static int s_log_ring_count = 0; // 已存条数（超过 LOG_RING_SLOTS 后不再增长，覆盖旧数据）
/** @brief 环形缓冲区互斥锁，保护多线程并发读写。 */
static SemaphoreHandle_t s_log_ring_mutex = NULL;
/**
* @brief 获取日志缓冲区中的条数
* @return 当前日志条数。
*/
int debug_log_ring_count(void)
int DebugLog::ringCount()
{
if (!s_log_ring_mutex) return 0;
xSemaphoreTake(s_log_ring_mutex, portMAX_DELAY);
int count = s_log_ring_count;
xSemaphoreGive(s_log_ring_mutex);
if (!m_logRingMutex) return 0;
xSemaphoreTake(m_logRingMutex, portMAX_DELAY);
int count = m_logRingCount;
xSemaphoreGive(m_logRingMutex);
return count;
}
// 读取并清空日志缓冲区，返回 JSON 数组字符串
// 调用者负责 free 返回值
/**
* @brief 读取并清空环形日志缓冲区，返回 JSON 数组字符串。
* @param out_len 输出 JSON 字符串长度（不含末尾 '\0'）。
* @return 成功返回需由调用者 free 的字符串；无日志或失败返回 NULL。
*/
char *debug_log_ring_drain_json(int *out_len)
char *DebugLog::ringDrainJson(int *out_len)
{
if (!s_log_ring_mutex) {
if (!m_logRingMutex) {
*out_len = 0;
return NULL;
}
xSemaphoreTake(s_log_ring_mutex, portMAX_DELAY);
xSemaphoreTake(m_logRingMutex, portMAX_DELAY);
int count = s_log_ring_count;
int count = m_logRingCount;
if (count == 0) {
xSemaphoreGive(s_log_ring_mutex);
xSemaphoreGive(m_logRingMutex);
*out_len = 0;
return NULL;
}
@@ -92,7 +71,7 @@ char *debug_log_ring_drain_json(int *out_len)
size_t buf_size = (size_t)count * 280 + 16;
char *json = (char *)malloc(buf_size);
if (!json) {
xSemaphoreGive(s_log_ring_mutex);
xSemaphoreGive(m_logRingMutex);
*out_len = 0;
return NULL;
}
@@ -101,17 +80,17 @@ char *debug_log_ring_drain_json(int *out_len)
json[pos++] = '[';
// 从最旧的开始读
int start = (count < LOG_RING_SLOTS) ? 0 : s_log_ring_head;
int start = (count < LOG_RING_SLOTS) ? 0 : m_logRingHead;
for (int i = 0; i < count && pos < (int)buf_size - 200; i++) {
int idx = (start + i) % LOG_RING_SLOTS;
int len = s_log_ring_lens[idx];
int len = m_logRingLens[idx];
if (len <= 0) continue;
if (i > 0) json[pos++] = ',';
pos += snprintf(json + pos, buf_size - pos, "\"");
for (int j = 0; j < len && pos < (int)buf_size - 10; j++) {
char c = s_log_ring[idx][j];
char c = m_logRing[idx][j];
if (c == '"' || c == '\\') {
json[pos++] = '\\';
json[pos++] = c;
@@ -129,109 +108,85 @@ char *debug_log_ring_drain_json(int *out_len)
json[pos] = '\0';
// 清空缓冲区
s_log_ring_head = 0;
/** @brief 环形缓冲区中已存储的日志条数。 */
s_log_ring_count = 0;
m_logRingHead = 0;
m_logRingCount = 0;
xSemaphoreGive(s_log_ring_mutex);
xSemaphoreGive(m_logRingMutex);
*out_len = pos;
return json;
}
/**
* @brief 写入一条日志到环形缓冲区
* @param data
* @param len
*/
static void log_ring_push(const char *data, int len)
void DebugLog::ringPush(const char *data, int len)
{
if (!s_log_ring_mutex || len <= 0) return;
if (!m_logRingMutex || len <= 0) return;
xSemaphoreTake(s_log_ring_mutex, portMAX_DELAY);
xSemaphoreTake(m_logRingMutex, portMAX_DELAY);
int copy_len = len;
if (copy_len >= LOG_RING_SIZE) copy_len = LOG_RING_SIZE - 1;
memcpy(s_log_ring[s_log_ring_head], data, copy_len);
s_log_ring[s_log_ring_head][copy_len] = '\0';
s_log_ring_lens[s_log_ring_head] = copy_len;
memcpy(m_logRing[m_logRingHead], data, copy_len);
m_logRing[m_logRingHead][copy_len] = '\0';
m_logRingLens[m_logRingHead] = copy_len;
/** @brief 环形缓冲区下一个写入位置。 */
s_log_ring_head = (s_log_ring_head + 1) % LOG_RING_SLOTS;
if (s_log_ring_count < LOG_RING_SLOTS) s_log_ring_count++;
m_logRingHead = (m_logRingHead + 1) % LOG_RING_SLOTS;
if (m_logRingCount < LOG_RING_SLOTS) m_logRingCount++;
xSemaphoreGive(s_log_ring_mutex);
xSemaphoreGive(m_logRingMutex);
}
// UART0 状态
static bool s_uart_initialized = false;
/** @brief 调试串口使用的 UART 端口号。 */
static uart_port_t s_uart_port = UART_NUM_0;
// ============================================================
// UART0 串口调试
// UART 调试日志
// ============================================================
/**
* @brief 初始化 UART0 调试串口，配置波特率和引脚映射。
* @return ESP_OK 成功，其他失败。
*/
esp_err_t uart_debug_init(void)
esp_err_t DebugLog::uartInit()
{
if (s_uart_initialized) {
if (m_uartInitialized) {
return ESP_OK;
}
uart_config_t uart_config;
memset(&uart_config, 0, sizeof(uart_config));
const uart_port_t uart_port = UART_NUM_0;
uart_config_t 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.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);
esp_err_t ret = uart_driver_install(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);
ret = uart_param_config(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,
ret = uart_set_pin(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;
}
/** @brief UART0 初始化标志。 */
s_uart_initialized = true;
m_uartInitialized = 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;
}
/**
* @brief 通过 UART0 发送一段原始字节数据。
* @param data 待发送的数据指针。
* @param len 数据长度。
* @return ESP_OK 成功，其他失败。
*/
esp_err_t uart_debug_send(const uint8_t *data, size_t len)
esp_err_t DebugLog::uartSend(const uint8_t *data, size_t len)
{
if (!s_uart_initialized) {
if (!m_uartInitialized) {
return ESP_ERR_INVALID_STATE;
}
int ret = uart_write_bytes(s_uart_port, data, len);
int ret = uart_write_bytes(UART_NUM_0, data, len);
if (ret < 0) {
return ESP_FAIL;
}
@@ -240,50 +195,38 @@ esp_err_t uart_debug_send(const uint8_t *data, size_t len)
}
// ============================================================
// UDP 调试日志
// 初始化（UART 立即可用，UDP socket 延迟到首次发送时创建）
// ============================================================
/**
* @brief 初始化（UART 立即可用，UDP socket 延迟到首次发送时创建）
* @return ESP_OK 成功，其他失败。
*/
esp_err_t debug_log_init(void)
esp_err_t DebugLog::init()
{
if (s_initialized) {
if (m_initialized) {
return ESP_OK;
}
uart_debug_init();
uartInit();
/** @brief 环形缓冲区互斥锁，保护多线程并发读写。 */
s_log_ring_mutex = xSemaphoreCreateMutex();
m_logRingMutex = xSemaphoreCreateMutex();
// 目标地址：单播到上位机
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);
memset(&m_debugAddr, 0, sizeof(m_debugAddr));
m_debugAddr.sin_family = AF_INET;
m_debugAddr.sin_port = htons(DEBUG_LOG_PORT);
m_debugAddr.sin_addr.s_addr = inet_addr(DEBUG_LOG_IP);
/** @brief 日志模块初始化标志。 */
s_initialized = true;
m_initialized = true;
ESP_LOGI(TAG, "调试日志已初始化，上位机 %s:%d", DEBUG_LOG_IP, DEBUG_LOG_PORT);
return ESP_OK;
}
/**
* @brief 延迟创建 UDP socket（首次发送时调用）
* @return
*/
static esp_err_t ensure_udp_socket(void)
esp_err_t DebugLog::ensureUdpSocket()
{
if (s_udp_sock >= 0) {
if (m_udpSock >= 0) {
return ESP_OK;
}
/** @brief UDP 调试日志 socket 句柄，首次发送时延迟创建。 */
s_udp_sock = socket(AF_INET, SOCK_DGRAM, 0);
if (s_udp_sock < 0) {
m_udpSock = socket(AF_INET, SOCK_DGRAM, 0);
if (m_udpSock < 0) {
ESP_LOGE(TAG, "创建 UDP socket 失败");
return ESP_FAIL;
}
@@ -292,32 +235,26 @@ static esp_err_t ensure_udp_socket(void)
return ESP_OK;
}
/**
* @brief 发送原始数据（UDP 单播 + UART 双通道）
* @param data 日志数据指针。
* @param len 数据长度。
* @return ESP_OK 成功，其他失败。
*/
esp_err_t debug_log_send(const uint8_t *data, size_t len)
esp_err_t DebugLog::send(const uint8_t *data, size_t len)
{
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 (m_uartInitialized) {
uart_ret = uartSend(data, len);
}
// UDP 通道（WiFi 未连接时 sendto 失败，静默跳过）
if (s_initialized) {
if (s_udp_sock < 0) {
ensure_udp_socket();
if (m_initialized) {
if (m_udpSock < 0) {
ensureUdpSocket();
}
if (s_udp_sock >= 0) {
if (m_udpSock >= 0) {
size_t send_len = len > 1024 ? 1024 : len;
int ret = sendto(s_udp_sock, data, send_len, 0,
(struct sockaddr *)&s_debug_addr, sizeof(s_debug_addr));
int ret = ::sendto(m_udpSock, data, send_len, 0,
(struct sockaddr *)&m_debugAddr, sizeof(m_debugAddr));
if (ret >= 0) {
udp_ret = ESP_OK;
}
@@ -325,7 +262,7 @@ esp_err_t debug_log_send(const uint8_t *data, size_t len)
}
// 同时写入环形缓冲区（供 HTTP /logs 拉取）
log_ring_push((const char *)data, (int)len);
ringPush((const char *)data, (int)len);
if (udp_ret == ESP_OK || uart_ret == ESP_OK) {
return ESP_OK;
@@ -333,19 +270,13 @@ esp_err_t debug_log_send(const uint8_t *data, size_t len)
return ESP_FAIL;
}
/**
* @brief 格式化日志输出
* @param level 日志级别。
* @param tag 日志标签。
* @param fmt 格式化字符串。
*/
void debug_log(debug_log_level_t level, const char *tag, const char *fmt, ...)
void DebugLog::log(debug_log_level_t level, const char *tag, const char *fmt, ...)
{
if (!s_initialized) {
debug_log_init();
if (!m_initialized) {
init();
}
if (level > g_debug_log_level) {
if (level > logLevel) {
return;
}
@@ -369,5 +300,5 @@ void debug_log(debug_log_level_t level, const char *tag, const char *fmt, ...)
char log_buf[600];
int total = snprintf(log_buf, sizeof(log_buf), "%s %s\n", prefix, msg);
debug_log_send((const uint8_t *)log_buf, total);
}
send((const uint8_t *)log_buf, total);
}