feat: 集成 EasyLogger 并更新 UART DMA 回调

- 集成 EasyLogger，增强日志功能。
- 更新 UART DMA 回调以使用 EasyLogger 记录日志。
- 重新格式化 README.md，提升可读性和清晰度。
- 添加新的 CMSIS DSP 和 FreeRTOS 源文件。
- 更新 CMake 配置以包含 EasyLogger 源文件。

此提交改进了日志功能，为后续开发做好了准备。

Core/Bsp/bsp_beep.c

@@ -0,0 +1,37 @@
+#include "bsp_beep.h"
+#include "tim.h"
+
+/**
+ * @brief 蜂鸣器初始化（TIM3 CH1, PC6, 2.7KHz）
+ */
+void BEEP_Init(void) {
+    // 假设 CubeMX 已配置好 TIM3 CH1 (PC6) 为 PWM 输出，频率2.7KHz
+    // 这里只需启动 PWM
+    HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
+}
+
+/**
+ * @brief 打开蜂鸣器（输出PWM）
+ */
+void BEEP_On(void) {
+    __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, __HAL_TIM_GET_AUTORELOAD(&htim3) / 3); // 50% 占空比
+}
+
+/**
+ * @brief 关闭蜂鸣器（无PWM输出）
+ */
+void BEEP_Off(void) {
+    __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, 0);
+}
+
+/**
+ * @brief 翻转蜂鸣器状态
+ */
+void BEEP_Toggle(void) {
+    uint32_t cmp = __HAL_TIM_GET_COMPARE(&htim3, TIM_CHANNEL_1);
+    if (cmp == 0) {
+        BEEP_On();
+    } else {
+        BEEP_Off();
+    }
+}

Core/Bsp/bsp_beep.h

@@ -0,0 +1,19 @@
+#ifndef BSP_BEEP_H
+#define BSP_BEEP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "stm32f1xx_hal.h"
+
+void BEEP_Init(void);
+void BEEP_On(void);
+void BEEP_Off(void);
+void BEEP_Toggle(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // BSP_BEEP_H

Core/Bsp/bsp_uart.c

@@ -0,0 +1,87 @@
+#include "bsp_uart.h"
+#include "elog.h"
+
+/**
+ * @brief 使用 UART1 和 DMA 发送数据到 ESP12F 模块（用于 TCP 透传）
+ * @param data: 要发送的数据指针（以 \0 结尾）
+ * @return HAL_StatusTypeDef: HAL_OK 表示成功，其他值表示失败
+ */
+HAL_StatusTypeDef ESP12F_TCP_SendMessage(const char *data) {
+    if (data == NULL) {
+        return HAL_ERROR; // 参数无效
+    }
+
+    // 计算数据大小
+    uint16_t size = strlen(data);
+    if (size == 0) {
+        return HAL_ERROR; // 数据为空
+    }
+
+    // 启动 DMA 传输
+    return HAL_UART_Transmit_DMA(&huart1, (uint8_t *)data, size);
+}
+
+
+/* External DMA handle */
+extern DMA_HandleTypeDef hdma_usart1_rx;
+
+/* DMA 接收缓冲区及状态变量 */
+uint8_t uart1_rx_buf[UART1_RX_BUF_SIZE];    
+volatile uint16_t uart1_rx_len = 0;         /* 记录最近一次接收到的数据包长度 */
+volatile uint8_t uart1_rx_flag = 0;         /* 接收完成标志位：1表示有一帧新数据 */
+
+/**
+ * @brief 初始化 UART1 并启动 DMA 接收
+ * @details 该函数启动 UART1 的 DMA 接收功能，并启用 IDLE 线检测中断，
+ *          用于接收不定长数据包。当检测到 IDLE 事件时，表示一帧数据接收完成。
+ * @param 无
+ * @return 无
+ * @note 需要在调用此函数前确保 UART1 和 DMA 已经正确初始化
+ */
+void BSP_UART1_Init(void)
+{
+  /* 停止并重置 DMA 状态 */
+  HAL_UART_DMAStop(&huart1);  
+  uart1_rx_len = 0;
+  uart1_rx_flag = 0;
+  memset(uart1_rx_buf, 0, sizeof(uart1_rx_buf));
+  
+  /* 启动 DMA 接收，将接收到的数据存储到 uart1_rx_buf 缓冲区 */
+  HAL_UART_Receive_DMA(&huart1, uart1_rx_buf, UART1_RX_BUF_SIZE);
+
+  /* 使能串口空闲（IDLE）中断，用于判断不定长数据帧接收完成 */
+  __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
+}
+
+/**
+ * @brief UART 空闲中断回调函数
+ * @details 当串口线进入空闲状态（一帧数据传输结束）时被调用。
+ *          通过 DMA 计数器计算接收到的字节数，更新标志位供上层应用处理。
+ * @param huart: 串口句柄指针
+ */
+void UART_IDLE_Callback(UART_HandleTypeDef *huart) {
+  /* 仅处理 USART1 的实例 */
+  if (huart == NULL || huart->Instance != USART1)
+    return;
+
+  /* 清除空闲中断标志位（HAL库宏） */
+  __HAL_UART_CLEAR_IDLEFLAG(huart);
+  
+  /* 停止 DMA 以便安全读取计数器并更新状态 */
+  HAL_UART_DMAStop(huart);
+
+  /* 计算接收到的字节数：总缓冲区长度 - DMA 剩余传输计数 */
+  uint16_t recv_len = UART1_RX_BUF_SIZE - __HAL_DMA_GET_COUNTER(huart->hdmarx);
+
+  if (recv_len > 0 && recv_len < UART1_RX_BUF_SIZE) {
+    uart1_rx_len = recv_len;
+    uart1_rx_buf[recv_len] = '\0';  /* 添加字符串结束符，方便后续字符串处理 */
+    uart1_rx_flag = 1;              /* 置位标志，通知应用层新消息到达 */
+    
+    /* 仅供调试：在中断中打印接收到的数据（注意：printf 可能会影响实时性） */
+    elog_raw("UART1 Received: %s\r\n", (char *)uart1_rx_buf);
+  }
+
+  /* 重新启动新一轮的 DMA 接收 */
+  HAL_UART_Receive_DMA(&huart1, uart1_rx_buf, UART1_RX_BUF_SIZE);
+} 

Core/Bsp/bsp_uart.h

@@ -0,0 +1,34 @@
+#ifndef BSP_UART_H
+#define BSP_UART_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "stm32f1xx_hal.h"
+#include "usart.h"
+#include <string.h>
+#include <stdio.h>
+
+#define UART1_RX_BUF_SIZE  256
+
+/* 全局接收变量声明 */
+extern uint8_t uart1_rx_buf[UART1_RX_BUF_SIZE];  /* DMA 接收缓冲区 */
+extern volatile uint16_t uart1_rx_len;           /* 最近一次接收到的数据长度 */
+extern volatile uint8_t uart1_rx_flag;           /* 接收完成标志：1表示有新数据 */
+
+
+/**
+ * @brief 使用 UART1 和 DMA 发送数据到 ESP12F 模块（用于 TCP 透传）
+ * @param data: 要发送的数据指针（以 \0 结尾）
+ * @return HAL_StatusTypeDef: HAL_OK 表示成功，其他值表示失败
+ */
+HAL_StatusTypeDef ESP12F_TCP_SendMessage(const char *data);
+
+void BSP_UART1_Init(void);
+void UART_IDLE_Callback(UART_HandleTypeDef *huart);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BSP_UART_H */

Core/Bsp/easylogger/inc/elog.h

@@ -0,0 +1,272 @@
+//
+// Created by wangb on 25-6-4.
+//
+
+#ifndef ELOG_H
+#define ELOG_H
+
+#include "elog_cfg.h"
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* output log's level */
+#define ELOG_LVL_ASSERT                      0
+#define ELOG_LVL_ERROR                       1
+#define ELOG_LVL_WARN                        2
+#define ELOG_LVL_INFO                        3
+#define ELOG_LVL_DEBUG                       4
+#define ELOG_LVL_VERBOSE                     5
+
+
+/* the output silent level and all level for filter setting */
+#define ELOG_FILTER_LVL_SILENT               ELOG_LVL_ASSERT
+#define ELOG_FILTER_LVL_ALL                  ELOG_LVL_VERBOSE
+
+/* output log's level total number */
+#define ELOG_LVL_TOTAL_NUM                   6
+
+/* EasyLogger software version number */
+#define ELOG_SW_VERSION                      "2.2.99"
+
+/* EasyLogger assert for developer. */
+#ifdef ELOG_ASSERT_ENABLE
+    #define ELOG_ASSERT(EXPR)                                                 \
+    if (!(EXPR))                                                              \
+    {                                                                         \
+        if (elog_assert_hook == NULL) {                                       \
+            elog_a("elog", "(%s) has assert failed at %s:%ld.", #EXPR, __FUNCTION__, __LINE__); \
+            while (1);                                                        \
+        } else {                                                              \
+            elog_assert_hook(#EXPR, __FUNCTION__, __LINE__);                  \
+        }                                                                     \
+    }
+#else
+    #define ELOG_ASSERT(EXPR)                    ((void)0);
+#endif
+
+#ifndef ELOG_OUTPUT_ENABLE
+    #define elog_raw(...)
+    #define elog_assert(tag, ...)
+    #define elog_error(tag, ...)
+    #define elog_warn(tag, ...)
+    #define elog_info(tag, ...)
+    #define elog_debug(tag, ...)
+    #define elog_verbose(tag, ...)
+#else /* ELOG_OUTPUT_ENABLE */
+
+    #ifdef ELOG_FMT_USING_FUNC
+    #define ELOG_OUTPUT_FUNC __FUNCTION__
+    #else
+    #define ELOG_OUTPUT_FUNC NULL
+    #endif
+
+    #ifdef ELOG_FMT_USING_DIR
+    #define ELOG_OUTPUT_DIR __FILE__
+    #else
+    #define ELOG_OUTPUT_DIR NULL
+    #endif
+
+    #ifdef ELOG_FMT_USING_LINE
+    #define ELOG_OUTPUT_LINE __LINE__
+    #else
+    #define ELOG_OUTPUT_LINE 0
+    #endif
+
+    #define elog_raw(...)  elog_raw_output(__VA_ARGS__)
+    #if ELOG_OUTPUT_LVL >= ELOG_LVL_ASSERT
+        #define elog_assert(tag, ...) \
+                elog_output(ELOG_LVL_ASSERT, tag, ELOG_OUTPUT_DIR, ELOG_OUTPUT_FUNC, ELOG_OUTPUT_LINE, __VA_ARGS__)
+    #else
+        #define elog_assert(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL >= ELOG_LVL_ASSERT */
+
+    #if ELOG_OUTPUT_LVL >= ELOG_LVL_ERROR
+        #define elog_error(tag, ...) \
+                elog_output(ELOG_LVL_ERROR, tag, ELOG_OUTPUT_DIR, ELOG_OUTPUT_FUNC, ELOG_OUTPUT_LINE, __VA_ARGS__)
+    #else
+        #define elog_error(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL >= ELOG_LVL_ERROR */
+
+    #if ELOG_OUTPUT_LVL >= ELOG_LVL_WARN
+        #define elog_warn(tag, ...) \
+                elog_output(ELOG_LVL_WARN, tag, ELOG_OUTPUT_DIR, ELOG_OUTPUT_FUNC, ELOG_OUTPUT_LINE, __VA_ARGS__)
+    #else
+        #define elog_warn(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL >= ELOG_LVL_WARN */
+
+    #if ELOG_OUTPUT_LVL >= ELOG_LVL_INFO
+        #define elog_info(tag, ...) \
+                elog_output(ELOG_LVL_INFO, tag, ELOG_OUTPUT_DIR, ELOG_OUTPUT_FUNC, ELOG_OUTPUT_LINE, __VA_ARGS__)
+    #else
+        #define elog_info(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL >= ELOG_LVL_INFO */
+
+    #if ELOG_OUTPUT_LVL >= ELOG_LVL_DEBUG
+        #define elog_debug(tag, ...) \
+                elog_output(ELOG_LVL_DEBUG, tag, ELOG_OUTPUT_DIR, ELOG_OUTPUT_FUNC, ELOG_OUTPUT_LINE, __VA_ARGS__)
+    #else
+        #define elog_debug(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL >= ELOG_LVL_DEBUG */
+
+    #if ELOG_OUTPUT_LVL == ELOG_LVL_VERBOSE
+        #define elog_verbose(tag, ...) \
+                elog_output(ELOG_LVL_VERBOSE, tag, ELOG_OUTPUT_DIR, ELOG_OUTPUT_FUNC, ELOG_OUTPUT_LINE, __VA_ARGS__)
+    #else
+        #define elog_verbose(tag, ...)
+    #endif /* ELOG_OUTPUT_LVL == ELOG_LVL_VERBOSE */
+#endif /* ELOG_OUTPUT_ENABLE */
+
+/* all formats index */
+typedef enum {
+    ELOG_FMT_LVL    = 1 << 0, /**< level */
+    ELOG_FMT_TAG    = 1 << 1, /**< tag */
+    ELOG_FMT_TIME   = 1 << 2, /**< current time */
+    ELOG_FMT_P_INFO = 1 << 3, /**< process info */
+    ELOG_FMT_T_INFO = 1 << 4, /**< thread info */
+    ELOG_FMT_DIR    = 1 << 5, /**< file directory and name */
+    ELOG_FMT_FUNC   = 1 << 6, /**< function name */
+    ELOG_FMT_LINE   = 1 << 7, /**< line number */
+} ElogFmtIndex;
+
+/* macro definition for all formats */
+#define ELOG_FMT_ALL    (ELOG_FMT_LVL|ELOG_FMT_TAG|ELOG_FMT_TIME|ELOG_FMT_P_INFO|ELOG_FMT_T_INFO| \
+    ELOG_FMT_DIR|ELOG_FMT_FUNC|ELOG_FMT_LINE)
+
+/* output log's tag filter */
+typedef struct {
+    uint8_t level;
+    char tag[ELOG_FILTER_TAG_MAX_LEN + 1];
+    bool tag_use_flag; /**< false : tag is no used   true: tag is used */
+} ElogTagLvlFilter, *ElogTagLvlFilter_t;
+
+/* output log's filter */
+typedef struct {
+    uint8_t level;
+    char tag[ELOG_FILTER_TAG_MAX_LEN + 1];
+    char keyword[ELOG_FILTER_KW_MAX_LEN + 1];
+    ElogTagLvlFilter tag_lvl[ELOG_FILTER_TAG_LVL_MAX_NUM];
+} ElogFilter, *ElogFilter_t;
+
+/* easy logger */
+typedef struct {
+    ElogFilter filter;
+    size_t enabled_fmt_set[ELOG_LVL_TOTAL_NUM];
+    bool init_ok;
+    bool output_enabled;
+    bool output_lock_enabled;
+    bool output_is_locked_before_enable;
+    bool output_is_locked_before_disable;
+
+#ifdef ELOG_COLOR_ENABLE
+    bool text_color_enabled;
+#endif
+
+}EasyLogger, *EasyLogger_t;
+
+/* EasyLogger error code */
+typedef enum {
+    ELOG_NO_ERR,
+} ElogErrCode;
+
+/* elog.c */
+ElogErrCode elog_init(void);
+void elog_deinit(void);
+void elog_start(void);
+void elog_stop(void);
+void elog_set_output_enabled(bool enabled);
+bool elog_get_output_enabled(void);
+void elog_set_text_color_enabled(bool enabled);
+bool elog_get_text_color_enabled(void);
+void elog_set_fmt(uint8_t level, size_t set);
+void elog_set_filter(uint8_t level, const char *tag, const char *keyword);
+void elog_set_filter_lvl(uint8_t level);
+void elog_set_filter_tag(const char *tag);
+void elog_set_filter_kw(const char *keyword);
+void elog_set_filter_tag_lvl(const char *tag, uint8_t level);
+uint8_t elog_get_filter_tag_lvl(const char *tag);
+void elog_raw_output(const char *format, ...);
+void elog_output(uint8_t level, const char *tag, const char *file, const char *func,
+        const long line, const char *format, ...);
+void elog_output_lock_enabled(bool enabled);
+extern void (*elog_assert_hook)(const char* expr, const char* func, size_t line);
+void elog_assert_set_hook(void (*hook)(const char* expr, const char* func, size_t line));
+int8_t elog_find_lvl(const char *log);
+const char *elog_find_tag(const char *log, uint8_t lvl, size_t *tag_len);
+void elog_hexdump(const char *name, uint8_t width, const void *buf, uint16_t size);
+
+#define elog_a(tag, ...)     elog_assert(tag, __VA_ARGS__)
+#define elog_e(tag, ...)     elog_error(tag, __VA_ARGS__)
+#define elog_w(tag, ...)     elog_warn(tag, __VA_ARGS__)
+#define elog_i(tag, ...)     elog_info(tag, __VA_ARGS__)
+#define elog_d(tag, ...)     elog_debug(tag, __VA_ARGS__)
+#define elog_v(tag, ...)     elog_verbose(tag, __VA_ARGS__)
+
+/**
+ * log API short definition
+ * NOTE: The `LOG_TAG` and `LOG_LVL` must defined before including the <elog.h> when you want to use log_x API.
+ */
+#if !defined(LOG_TAG)
+    #define LOG_TAG          "NO_TAG"
+#endif
+#if !defined(LOG_LVL)
+    #define LOG_LVL          ELOG_LVL_VERBOSE
+#endif
+#if LOG_LVL >= ELOG_LVL_ASSERT
+    #define log_a(...)       elog_a(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_a(...)       ((void)0);
+#endif
+#if LOG_LVL >= ELOG_LVL_ERROR
+    #define log_e(...)       elog_e(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_e(...)       ((void)0);
+#endif
+#if LOG_LVL >= ELOG_LVL_WARN
+    #define log_w(...)       elog_w(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_w(...)       ((void)0);
+#endif
+#if LOG_LVL >= ELOG_LVL_INFO
+    #define log_i(...)       elog_i(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_i(...)       ((void)0);
+#endif
+#if LOG_LVL >= ELOG_LVL_DEBUG
+    #define log_d(...)       elog_d(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_d(...)       ((void)0);
+#endif
+#if LOG_LVL >= ELOG_LVL_VERBOSE
+    #define log_v(...)       elog_v(LOG_TAG, __VA_ARGS__)
+#else
+    #define log_v(...)       ((void)0);
+#endif
+
+/* assert API short definition */
+#if !defined(assert)
+    #define assert           ELOG_ASSERT
+#endif
+
+/* elog_buf.c */
+void elog_buf_enabled(bool enabled);
+void elog_flush(void);
+
+/* elog_async.c */
+void elog_async_enabled(bool enabled);
+size_t elog_async_get_log(char *log, size_t size);
+size_t elog_async_get_line_log(char *log, size_t size);
+
+/* elog_utils.c */
+size_t elog_strcpy(size_t cur_len, char *dst, const char *src);
+size_t elog_cpyln(char *line, const char *log, size_t len);
+void *elog_memcpy(void *dst, const void *src, size_t count);
+void easylogger_init(void);
+#ifdef __cplusplus
+}
+#endif
+#endif //ELOG_H

Core/Bsp/easylogger/inc/elog_cfg.h

@@ -0,0 +1,59 @@
+//
+// Created by wangb on 25-6-4.
+//
+
+#ifndef _ELOG_CFG_H_
+#define _ELOG_CFG_H_
+/*---------------------------------------------------------------------------*/
+/* enable log output. */
+#define ELOG_OUTPUT_ENABLE
+/* setting static output log level. range: from ELOG_LVL_ASSERT to ELOG_LVL_VERBOSE */
+#define ELOG_OUTPUT_LVL                          ELOG_LVL_VERBOSE
+/* enable assert check */
+#define ELOG_ASSERT_ENABLE
+/* buffer size for every line's log */
+#define ELOG_LINE_BUF_SIZE                       1024
+/* output line number max length */
+#define ELOG_LINE_NUM_MAX_LEN                    5
+/* output filter's tag max length */
+#define ELOG_FILTER_TAG_MAX_LEN                  30
+/* output filter's keyword max length */
+#define ELOG_FILTER_KW_MAX_LEN                   16
+/* output filter's tag level max num */
+#define ELOG_FILTER_TAG_LVL_MAX_NUM              5
+/* output newline sign */
+#define ELOG_NEWLINE_SIGN                        "\r\n" //换行
+/*---------------------------------------------------------------------------*/
+/* enable log color */
+#define ELOG_COLOR_ENABLE
+/* change the some level logs to not default color if you want */
+#define ELOG_COLOR_ASSERT                        (F_MAGENTA B_NULL S_NORMAL)
+#define ELOG_COLOR_ERROR                         (F_RED B_NULL S_NORMAL)
+#define ELOG_COLOR_WARN                          (F_YELLOW B_NULL S_NORMAL)
+#define ELOG_COLOR_INFO                          (F_CYAN B_NULL S_NORMAL)
+#define ELOG_COLOR_DEBUG                         (F_GREEN B_NULL S_NORMAL)
+#define ELOG_COLOR_VERBOSE                       (F_BLUE B_NULL S_NORMAL)
+/*---------------------------------------------------------------------------*/
+/* enable log fmt */
+/* comment it if you don't want to output them at all */
+#define ELOG_FMT_USING_FUNC
+#define ELOG_FMT_USING_DIR
+#define ELOG_FMT_USING_LINE
+/*---------------------------------------------------------------------------*/
+/* enable asynchronous output mode */
+//#define ELOG_ASYNC_OUTPUT_ENABLE
+/* the highest output level for async mode, other level will sync output */
+#define ELOG_ASYNC_OUTPUT_LVL                    ELOG_LVL_ASSERT
+/* buffer size for asynchronous output mode */
+#define ELOG_ASYNC_OUTPUT_BUF_SIZE               (ELOG_LINE_BUF_SIZE * 10)
+/* each asynchronous output's log which must end with newline sign */
+#define ELOG_ASYNC_LINE_OUTPUT
+/* asynchronous output mode using POSIX pthread implementation */
+#define ELOG_ASYNC_OUTPUT_USING_PTHREAD
+/*---------------------------------------------------------------------------*/
+/* enable buffered output mode */
+//#define ELOG_BUF_OUTPUT_ENABLE
+/* buffer size for buffered output mode */
+#define ELOG_BUF_OUTPUT_BUF_SIZE                 (ELOG_LINE_BUF_SIZE * 10)
+
+#endif /* _ELOG_CFG_H_ */

Core/Bsp/easylogger/port/elog_port.c

@@ -0,0 +1,109 @@
+//
+// Created by wangb on 25-6-4.
+//
+
+#include "elog.h"
+
+#include <stdio.h>
+#include "main.h"
+
+/**
+ * EasyLogger port initialize
+ *
+ * @return result
+ */
+ElogErrCode elog_port_init(void) {
+    ElogErrCode result = ELOG_NO_ERR;
+
+    /* add your code here */
+
+
+    return result;
+}
+
+/**
+ * EasyLogger port deinitialize
+ *
+ */
+void elog_port_deinit(void) {
+    /* add your code here */
+}
+
+/**
+ * output log port interface
+ *
+ * @param log output of log
+ * @param size log size
+ */
+void elog_port_output(const char *log, size_t size) {
+    /* add your code here */
+    printf("%.*s", size, log); //elog 的输出
+}
+
+/**
+ * output lock
+ */
+void elog_port_output_lock(void) {
+    /* add your code here */
+
+    __disable_irq(); //关闭全局中断
+}
+
+/**
+ * output unlock
+ */
+void elog_port_output_unlock(void) {
+    /* add your code here */
+    __enable_irq(); //开启全局中断
+}
+
+#include <stdio.h>
+
+/**
+ * get current time interface
+ *
+ * @return current time
+ */
+const char *elog_port_get_time(void) {
+
+
+    return "";
+}
+
+
+/**
+ * get current process name interface
+ *
+ * @return current process name
+ */
+const char *elog_port_get_p_info(void) {
+    /* add your code here */
+    return "";
+}
+
+/**
+ * get current thread name interface
+ *
+ * @return current thread name
+ */
+const char *elog_port_get_t_info(void) {
+ 
+    return "";
+}
+
+void easylogger_init(void) {
+    /* init Easylogger */
+    elog_init();
+
+    /* set EasyLogger log format */
+    elog_set_fmt(ELOG_LVL_ASSERT, ELOG_FMT_ALL & ~ELOG_FMT_P_INFO);
+    elog_set_fmt(ELOG_LVL_ERROR, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
+    elog_set_fmt(ELOG_LVL_WARN, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
+    elog_set_fmt(ELOG_LVL_INFO, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
+    elog_set_fmt(ELOG_LVL_DEBUG, ELOG_FMT_ALL & ~(ELOG_FMT_FUNC | ELOG_FMT_P_INFO));
+    elog_set_fmt(ELOG_LVL_VERBOSE, ELOG_FMT_ALL & ~(ELOG_FMT_FUNC | ELOG_FMT_P_INFO));
+
+
+    /* start EasyLogger */
+    elog_start();
+}

Core/Bsp/easylogger/src/elog.c

@@ -0,0 +1,912 @@
+//
+// Created by wangb on 25-6-4.
+//
+
+
+#define LOG_TAG      "elog"
+
+#include "elog.h"
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#if !defined(ELOG_OUTPUT_LVL)
+    #error "Please configure static output log level (in elog_cfg.h)"
+#endif
+
+#if !defined(ELOG_LINE_NUM_MAX_LEN)
+    #error "Please configure output line number max length (in elog_cfg.h)"
+#endif
+
+#if !defined(ELOG_LINE_BUF_SIZE)
+    #error "Please configure buffer size for every line's log (in elog_cfg.h)"
+#endif
+
+#if !defined(ELOG_FILTER_TAG_MAX_LEN)
+    #error "Please configure output filter's tag max length (in elog_cfg.h)"
+#endif
+
+#if !defined(ELOG_FILTER_KW_MAX_LEN)
+    #error "Please configure output filter's keyword max length (in elog_cfg.h)"
+#endif
+
+#if !defined(ELOG_NEWLINE_SIGN)
+    #error "Please configure output newline sign (in elog_cfg.h)"
+#endif
+
+/* output filter's tag level max num */
+#ifndef ELOG_FILTER_TAG_LVL_MAX_NUM
+#define ELOG_FILTER_TAG_LVL_MAX_NUM          4
+#endif
+
+#ifdef ELOG_COLOR_ENABLE
+/**
+ * CSI(Control Sequence Introducer/Initiator) sign
+ * more information on https://en.wikipedia.org/wiki/ANSI_escape_code
+ */
+#define CSI_START                      "\033["
+#define CSI_END                        "\033[0m"
+/* output log front color */
+#define F_BLACK                        "30;"
+#define F_RED                          "31;"
+#define F_GREEN                        "32;"
+#define F_YELLOW                       "33;"
+#define F_BLUE                         "34;"
+#define F_MAGENTA                      "35;"
+#define F_CYAN                         "36;"
+#define F_WHITE                        "37;"
+/* output log background color */
+#define B_NULL
+#define B_BLACK                        "40;"
+#define B_RED                          "41;"
+#define B_GREEN                        "42;"
+#define B_YELLOW                       "43;"
+#define B_BLUE                         "44;"
+#define B_MAGENTA                      "45;"
+#define B_CYAN                         "46;"
+#define B_WHITE                        "47;"
+/* output log fonts style */
+#define S_BOLD                         "1m"
+#define S_UNDERLINE                    "4m"
+#define S_BLINK                        "5m"
+#define S_NORMAL                       "22m"
+/* output log default color definition: [front color] + [background color] + [show style] */
+#ifndef ELOG_COLOR_ASSERT
+#define ELOG_COLOR_ASSERT              (F_MAGENTA B_NULL S_NORMAL)
+#endif
+#ifndef ELOG_COLOR_ERROR
+#define ELOG_COLOR_ERROR               (F_RED B_NULL S_NORMAL)
+#endif
+#ifndef ELOG_COLOR_WARN
+#define ELOG_COLOR_WARN                (F_YELLOW B_NULL S_NORMAL)
+#endif
+#ifndef ELOG_COLOR_INFO
+#define ELOG_COLOR_INFO                (F_CYAN B_NULL S_NORMAL)
+#endif
+#ifndef ELOG_COLOR_DEBUG
+#define ELOG_COLOR_DEBUG               (F_GREEN B_NULL S_NORMAL)
+#endif
+#ifndef ELOG_COLOR_VERBOSE
+#define ELOG_COLOR_VERBOSE             (F_BLUE B_NULL S_NORMAL)
+#endif
+#endif /* ELOG_COLOR_ENABLE */
+
+/* EasyLogger object */
+static EasyLogger elog;
+/* every line log's buffer */
+static char log_buf[ELOG_LINE_BUF_SIZE] = { 0 };
+/* level output info */
+static const char *level_output_info[] = {
+        [ELOG_LVL_ASSERT]  = "ASSERT/",
+        [ELOG_LVL_ERROR]   = "ERROR/",
+        [ELOG_LVL_WARN]    = "WARN/",
+        [ELOG_LVL_INFO]    = "INFO/",
+        [ELOG_LVL_DEBUG]   = "DEBUG/",
+        [ELOG_LVL_VERBOSE] = "VERBOS/",
+};
+
+#ifdef ELOG_COLOR_ENABLE
+/* color output info */
+static const char *color_output_info[] = {
+        [ELOG_LVL_ASSERT]  = ELOG_COLOR_ASSERT,
+        [ELOG_LVL_ERROR]   = ELOG_COLOR_ERROR,
+        [ELOG_LVL_WARN]    = ELOG_COLOR_WARN,
+        [ELOG_LVL_INFO]    = ELOG_COLOR_INFO,
+        [ELOG_LVL_DEBUG]   = ELOG_COLOR_DEBUG,
+        [ELOG_LVL_VERBOSE] = ELOG_COLOR_VERBOSE,
+};
+#endif /* ELOG_COLOR_ENABLE */
+
+static bool get_fmt_enabled(uint8_t level, size_t set);
+static bool get_fmt_used_and_enabled_u32(uint8_t level, size_t set, uint32_t arg);
+static bool get_fmt_used_and_enabled_ptr(uint8_t level, size_t set, const char* arg);
+static void elog_set_filter_tag_lvl_default(void);
+
+/* EasyLogger assert hook */
+void (*elog_assert_hook)(const char* expr, const char* func, size_t line);
+
+extern void elog_port_output(const char *log, size_t size);
+extern void elog_port_output_lock(void);
+extern void elog_port_output_unlock(void);
+
+/**
+ * EasyLogger initialize.
+ *
+ * @return result
+ */
+ElogErrCode elog_init(void) {
+    extern ElogErrCode elog_port_init(void);
+    extern ElogErrCode elog_async_init(void);
+
+    ElogErrCode result = ELOG_NO_ERR;
+
+    if (elog.init_ok == true) {
+        return result;
+    }
+
+    /* port initialize */
+    result = elog_port_init();
+    if (result != ELOG_NO_ERR) {
+        return result;
+    }
+
+#ifdef ELOG_ASYNC_OUTPUT_ENABLE
+    result = elog_async_init();
+    if (result != ELOG_NO_ERR) {
+        return result;
+    }
+#endif
+
+    /* enable the output lock */
+    elog_output_lock_enabled(true);
+    /* output locked status initialize */
+    elog.output_is_locked_before_enable = false;
+    elog.output_is_locked_before_disable = false;
+
+#ifdef ELOG_COLOR_ENABLE
+    /* enable text color by default */
+    elog_set_text_color_enabled(true);
+#endif
+
+    /* set level is ELOG_LVL_VERBOSE */
+    elog_set_filter_lvl(ELOG_LVL_VERBOSE);
+
+    /* set tag_level to default val */
+    elog_set_filter_tag_lvl_default();
+
+    elog.init_ok = true;
+
+    return result;
+}
+
+/**
+ * EasyLogger deinitialize.
+ *
+ */
+void elog_deinit(void) {
+    extern ElogErrCode elog_port_deinit(void);
+    extern ElogErrCode elog_async_deinit(void);
+
+    if (!elog.init_ok) {
+        return ;
+    }
+
+#ifdef ELOG_ASYNC_OUTPUT_ENABLE
+    elog_async_deinit();
+#endif
+
+    /* port deinitialize */
+    elog_port_deinit();
+
+    elog.init_ok = false;
+}
+
+
+/**
+ * EasyLogger start after initialize.
+ */
+void elog_start(void) {
+    if (!elog.init_ok) {
+        return ;
+    }
+
+    /* enable output */
+    elog_set_output_enabled(true);
+
+#if defined(ELOG_ASYNC_OUTPUT_ENABLE)
+    elog_async_enabled(true);
+#elif defined(ELOG_BUF_OUTPUT_ENABLE)
+    elog_buf_enabled(true);
+#endif
+
+
+}
+
+/**
+ * EasyLogger stop after initialize.
+ */
+void elog_stop(void) {
+    if (!elog.init_ok) {
+        return ;
+    }
+
+    /* disable output */
+    elog_set_output_enabled(false);
+
+#if defined(ELOG_ASYNC_OUTPUT_ENABLE)
+    elog_async_enabled(false);
+#elif defined(ELOG_BUF_OUTPUT_ENABLE)
+    elog_buf_enabled(false);
+#endif
+
+    /* show version */
+    log_i("EasyLogger V%s is deinitialize success.", ELOG_SW_VERSION);
+}
+
+
+/**
+ * set output enable or disable
+ *
+ * @param enabled TRUE: enable FALSE: disable
+ */
+void elog_set_output_enabled(bool enabled) {
+    ELOG_ASSERT((enabled == false) || (enabled == true));
+
+    elog.output_enabled = enabled;
+}
+
+#ifdef ELOG_COLOR_ENABLE
+/**
+ * set log text color enable or disable
+ *
+ * @param enabled TRUE: enable FALSE:disable
+ */
+void elog_set_text_color_enabled(bool enabled) {
+    ELOG_ASSERT((enabled == false) || (enabled == true));
+
+    elog.text_color_enabled = enabled;
+}
+
+/**
+ * get log text color enable status
+ *
+ * @return enable or disable
+ */
+bool elog_get_text_color_enabled(void) {
+    return elog.text_color_enabled;
+}
+#endif /* ELOG_COLOR_ENABLE */
+
+/**
+ * get output is enable or disable
+ *
+ * @return enable or disable
+ */
+bool elog_get_output_enabled(void) {
+    return elog.output_enabled;
+}
+
+/**
+ * set log output format. only enable or disable
+ *
+ * @param level level
+ * @param set format set
+ */
+void elog_set_fmt(uint8_t level, size_t set) {
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+
+    elog.enabled_fmt_set[level] = set;
+}
+
+/**
+ * set log filter all parameter
+ *
+ * @param level level
+ * @param tag tag
+ * @param keyword keyword
+ */
+void elog_set_filter(uint8_t level, const char *tag, const char *keyword) {
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+
+    elog_set_filter_lvl(level);
+    elog_set_filter_tag(tag);
+    elog_set_filter_kw(keyword);
+}
+
+/**
+ * set log filter's level
+ *
+ * @param level level
+ */
+void elog_set_filter_lvl(uint8_t level) {
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+
+    elog.filter.level = level;
+}
+
+/**
+ * set log filter's tag
+ *
+ * @param tag tag
+ */
+void elog_set_filter_tag(const char *tag) {
+    strncpy(elog.filter.tag, tag, ELOG_FILTER_TAG_MAX_LEN);
+}
+
+/**
+ * set log filter's keyword
+ *
+ * @param keyword keyword
+ */
+void elog_set_filter_kw(const char *keyword) {
+    strncpy(elog.filter.keyword, keyword, ELOG_FILTER_KW_MAX_LEN);
+}
+
+/**
+ * lock output
+ */
+void elog_output_lock(void) {
+    if (elog.output_lock_enabled) {
+        elog_port_output_lock();
+        elog.output_is_locked_before_disable = true;
+    } else {
+        elog.output_is_locked_before_enable = true;
+    }
+}
+
+/**
+ * unlock output
+ */
+void elog_output_unlock(void) {
+    if (elog.output_lock_enabled) {
+        elog_port_output_unlock();
+        elog.output_is_locked_before_disable = false;
+    } else {
+        elog.output_is_locked_before_enable = false;
+    }
+}
+
+/**
+ * set log filter's tag level val to default
+ */
+static void elog_set_filter_tag_lvl_default(void)
+{
+    uint8_t i = 0;
+
+    for (i =0; i< ELOG_FILTER_TAG_LVL_MAX_NUM; i++){
+        memset(elog.filter.tag_lvl[i].tag, '\0', ELOG_FILTER_TAG_MAX_LEN + 1);
+        elog.filter.tag_lvl[i].level = ELOG_FILTER_LVL_SILENT;
+        elog.filter.tag_lvl[i].tag_use_flag = false;
+    }
+}
+
+/**
+ * Set the filter's level by different tag.
+ * The log on this tag which level is less than it will stop output.
+ *
+ * example:
+ *     // the example tag log enter silent mode
+ *     elog_set_filter_tag_lvl("example", ELOG_FILTER_LVL_SILENT);
+ *     // the example tag log which level is less than INFO level will stop output
+ *     elog_set_filter_tag_lvl("example", ELOG_LVL_INFO);
+ *     // remove example tag's level filter, all level log will resume output
+ *     elog_set_filter_tag_lvl("example", ELOG_FILTER_LVL_ALL);
+ *
+ * @param tag log tag
+ * @param level The filter level. When the level is ELOG_FILTER_LVL_SILENT, the log enter silent mode.
+ *        When the level is ELOG_FILTER_LVL_ALL, it will remove this tag's level filer.
+ *        Then all level log will resume output.
+ *
+ */
+void elog_set_filter_tag_lvl(const char *tag, uint8_t level)
+{
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+    ELOG_ASSERT(tag != ((void *)0));
+    uint8_t i = 0;
+
+    if (!elog.init_ok) {
+        return;
+    }
+
+    elog_output_lock();
+    /* find the tag in arr */
+    for (i =0; i< ELOG_FILTER_TAG_LVL_MAX_NUM; i++){
+        if (elog.filter.tag_lvl[i].tag_use_flag == true &&
+            !strncmp(tag, elog.filter.tag_lvl[i].tag,ELOG_FILTER_TAG_MAX_LEN)){
+            break;
+        }
+    }
+
+    if (i < ELOG_FILTER_TAG_LVL_MAX_NUM){
+        /* find OK */
+        if (level == ELOG_FILTER_LVL_ALL){
+            /* remove current tag's level filter when input level is the lowest level */
+             elog.filter.tag_lvl[i].tag_use_flag = false;
+             memset(elog.filter.tag_lvl[i].tag, '\0', ELOG_FILTER_TAG_MAX_LEN + 1);
+             elog.filter.tag_lvl[i].level = ELOG_FILTER_LVL_SILENT;
+        } else{
+            elog.filter.tag_lvl[i].level = level;
+        }
+    } else{
+        /* only add the new tag's level filer when level is not ELOG_FILTER_LVL_ALL */
+        if (level != ELOG_FILTER_LVL_ALL){
+            for (i =0; i< ELOG_FILTER_TAG_LVL_MAX_NUM; i++){
+                if (elog.filter.tag_lvl[i].tag_use_flag == false){
+                    strncpy(elog.filter.tag_lvl[i].tag, tag, ELOG_FILTER_TAG_MAX_LEN);
+                    elog.filter.tag_lvl[i].level = level;
+                    elog.filter.tag_lvl[i].tag_use_flag = true;
+                    break;
+                }
+            }
+        }
+    }
+    elog_output_unlock();
+}
+
+/**
+ * get the level on tag's level filer
+ *
+ * @param tag tag
+ *
+ * @return It will return the lowest level when tag was not found.
+ *         Other level will return when tag was found.
+ */
+uint8_t elog_get_filter_tag_lvl(const char *tag)
+{
+    ELOG_ASSERT(tag != ((void *)0));
+    uint8_t i = 0;
+    uint8_t level = ELOG_FILTER_LVL_ALL;
+
+    if (!elog.init_ok) {
+        return level;
+    }
+
+    elog_output_lock();
+    /* find the tag in arr */
+    for (i =0; i< ELOG_FILTER_TAG_LVL_MAX_NUM; i++){
+        if (elog.filter.tag_lvl[i].tag_use_flag == true &&
+            !strncmp(tag, elog.filter.tag_lvl[i].tag,ELOG_FILTER_TAG_MAX_LEN)){
+            level = elog.filter.tag_lvl[i].level;
+            break;
+        }
+    }
+    elog_output_unlock();
+
+    return level;
+}
+
+/**
+ * output RAW format log
+ *
+ * @param format output format
+ * @param ... args
+ */
+void elog_raw_output(const char *format, ...) {
+    va_list args;
+    size_t log_len = 0;
+    int fmt_result;
+
+    /* check output enabled */
+    if (!elog.output_enabled) {
+        return;
+    }
+
+    /* args point to the first variable parameter */
+    va_start(args, format);
+
+    /* lock output */
+    elog_output_lock();
+
+    /* package log data to buffer */
+    fmt_result = vsnprintf(log_buf, ELOG_LINE_BUF_SIZE, format, args);
+
+    /* output converted log */
+    if ((fmt_result > -1) && (fmt_result <= ELOG_LINE_BUF_SIZE)) {
+        log_len = fmt_result;
+    } else {
+        log_len = ELOG_LINE_BUF_SIZE;
+    }
+    /* output log */
+#if defined(ELOG_ASYNC_OUTPUT_ENABLE)
+    extern void elog_async_output(uint8_t level, const char *log, size_t size);
+    /* raw log will using assert level */
+    elog_async_output(ELOG_LVL_ASSERT, log_buf, log_len);
+#elif defined(ELOG_BUF_OUTPUT_ENABLE)
+    extern void elog_buf_output(const char *log, size_t size);
+    elog_buf_output(log_buf, log_len);
+#else
+    elog_port_output(log_buf, log_len);
+#endif
+    /* unlock output */
+    elog_output_unlock();
+
+    va_end(args);
+}
+
+/**
+ * output the log
+ *
+ * @param level level
+ * @param tag tag
+ * @param file file name
+ * @param func function name
+ * @param line line number
+ * @param format output format
+ * @param ... args
+ *
+ */
+void elog_output(uint8_t level, const char *tag, const char *file, const char *func,
+        const long line, const char *format, ...) {
+    extern const char *elog_port_get_time(void);
+    extern const char *elog_port_get_p_info(void);
+    extern const char *elog_port_get_t_info(void);
+
+    size_t tag_len = strlen(tag), log_len = 0, newline_len = strlen(ELOG_NEWLINE_SIGN);
+    char line_num[ELOG_LINE_NUM_MAX_LEN + 1] = { 0 };
+    char tag_sapce[ELOG_FILTER_TAG_MAX_LEN / 2 + 1] = { 0 };
+    va_list args;
+    int fmt_result;
+
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+
+    /* check output enabled */
+    if (!elog.output_enabled) {
+        return;
+    }
+    /* level filter */
+    if (level > elog.filter.level || level > elog_get_filter_tag_lvl(tag)) {
+        return;
+    } else if (!strstr(tag, elog.filter.tag)) { /* tag filter */
+        return;
+    }
+    /* args point to the first variable parameter */
+    va_start(args, format);
+    /* lock output */
+    elog_output_lock();
+
+#ifdef ELOG_COLOR_ENABLE
+    /* add CSI start sign and color info */
+    if (elog.text_color_enabled) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, CSI_START);
+        log_len += elog_strcpy(log_len, log_buf + log_len, color_output_info[level]);
+    }
+#endif
+
+    /* package level info */
+    if (get_fmt_enabled(level, ELOG_FMT_LVL)) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, level_output_info[level]);
+    }
+    /* package tag info */
+    if (get_fmt_enabled(level, ELOG_FMT_TAG)) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, tag);
+        /* if the tag length is less than 50% ELOG_FILTER_TAG_MAX_LEN, then fill space */
+        if (tag_len <= ELOG_FILTER_TAG_MAX_LEN / 2) {
+            memset(tag_sapce, ' ', ELOG_FILTER_TAG_MAX_LEN / 2 - tag_len);
+            log_len += elog_strcpy(log_len, log_buf + log_len, tag_sapce);
+        }
+        log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+    }
+    /* package time, process and thread info */
+    if (get_fmt_enabled(level, ELOG_FMT_TIME | ELOG_FMT_P_INFO | ELOG_FMT_T_INFO)) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, "[");
+        /* package time info */
+        if (get_fmt_enabled(level, ELOG_FMT_TIME)) {
+            log_len += elog_strcpy(log_len, log_buf + log_len, elog_port_get_time());
+            if (get_fmt_enabled(level, ELOG_FMT_P_INFO | ELOG_FMT_T_INFO)) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+            }
+        }
+        /* package process info */
+        if (get_fmt_enabled(level, ELOG_FMT_P_INFO)) {
+            log_len += elog_strcpy(log_len, log_buf + log_len, elog_port_get_p_info());
+            if (get_fmt_enabled(level, ELOG_FMT_T_INFO)) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+            }
+        }
+        /* package thread info */
+        if (get_fmt_enabled(level, ELOG_FMT_T_INFO)) {
+            log_len += elog_strcpy(log_len, log_buf + log_len, elog_port_get_t_info());
+        }
+        log_len += elog_strcpy(log_len, log_buf + log_len, "] ");
+    }
+    /* package file directory and name, function name and line number info */
+    if (get_fmt_used_and_enabled_ptr(level, ELOG_FMT_DIR, file) ||
+            get_fmt_used_and_enabled_ptr(level, ELOG_FMT_FUNC, func) ||
+            get_fmt_used_and_enabled_u32(level, ELOG_FMT_LINE, line)) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, "(");
+        /* package file info */
+        if (get_fmt_used_and_enabled_ptr(level, ELOG_FMT_DIR, file)) {
+            log_len += elog_strcpy(log_len, log_buf + log_len, file);
+            if (get_fmt_used_and_enabled_ptr(level, ELOG_FMT_FUNC, func)) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, ":");
+            } else if (get_fmt_used_and_enabled_u32(level, ELOG_FMT_LINE, line)) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+            }
+        }
+        /* package line info */
+        if (get_fmt_used_and_enabled_u32(level, ELOG_FMT_LINE, line)) {
+            snprintf(line_num, ELOG_LINE_NUM_MAX_LEN, "%ld", line);
+            log_len += elog_strcpy(log_len, log_buf + log_len, line_num);
+            if (get_fmt_used_and_enabled_ptr(level, ELOG_FMT_FUNC, func)) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+            }
+        }
+        /* package func info */
+        if (get_fmt_used_and_enabled_ptr(level, ELOG_FMT_FUNC, func)) {
+            log_len += elog_strcpy(log_len, log_buf + log_len, func);
+
+        }
+        log_len += elog_strcpy(log_len, log_buf + log_len, ")");
+    }
+    /* package other log data to buffer. '\0' must be added in the end by vsnprintf. */
+    fmt_result = vsnprintf(log_buf + log_len, ELOG_LINE_BUF_SIZE - log_len, format, args);
+
+    va_end(args);
+    /* calculate log length */
+    if ((log_len + fmt_result <= ELOG_LINE_BUF_SIZE) && (fmt_result > -1)) {
+        log_len += fmt_result;
+    } else {
+        /* using max length */
+        log_len = ELOG_LINE_BUF_SIZE;
+    }
+    /* overflow check and reserve some space for CSI end sign and newline sign */
+#ifdef ELOG_COLOR_ENABLE
+    if (log_len + (sizeof(CSI_END) - 1) + newline_len > ELOG_LINE_BUF_SIZE) {
+        /* using max length */
+        log_len = ELOG_LINE_BUF_SIZE;
+        /* reserve some space for CSI end sign */
+        log_len -= (sizeof(CSI_END) - 1);
+#else
+    if (log_len + newline_len > ELOG_LINE_BUF_SIZE) {
+        /* using max length */
+        log_len = ELOG_LINE_BUF_SIZE;
+#endif /* ELOG_COLOR_ENABLE */
+        /* reserve some space for newline sign */
+        log_len -= newline_len;
+    }
+    /* keyword filter */
+    if (elog.filter.keyword[0] != '\0') {
+        /* add string end sign */
+        log_buf[log_len] = '\0';
+        /* find the keyword */
+        if (!strstr(log_buf, elog.filter.keyword)) {
+            /* unlock output */
+            elog_output_unlock();
+            return;
+        }
+    }
+
+#ifdef ELOG_COLOR_ENABLE
+    /* add CSI end sign */
+    if (elog.text_color_enabled) {
+        log_len += elog_strcpy(log_len, log_buf + log_len, CSI_END);
+    }
+#endif
+
+    /* package newline sign */
+    log_len += elog_strcpy(log_len, log_buf + log_len, ELOG_NEWLINE_SIGN);
+    /* output log */
+#if defined(ELOG_ASYNC_OUTPUT_ENABLE)
+    extern void elog_async_output(uint8_t level, const char *log, size_t size);
+    elog_async_output(level, log_buf, log_len);
+#elif defined(ELOG_BUF_OUTPUT_ENABLE)
+    extern void elog_buf_output(const char *log, size_t size);
+    elog_buf_output(log_buf, log_len);
+#else
+    elog_port_output(log_buf, log_len);
+#endif
+    /* unlock output */
+    elog_output_unlock();
+}
+
+/**
+ * get format enabled
+ *
+ * @param level level
+ * @param set format set
+ *
+ * @return enable or disable
+ */
+static bool get_fmt_enabled(uint8_t level, size_t set) {
+    ELOG_ASSERT(level <= ELOG_LVL_VERBOSE);
+
+    if (elog.enabled_fmt_set[level] & set) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+static bool get_fmt_used_and_enabled_u32(uint8_t level, size_t set, uint32_t arg) {
+    return arg && get_fmt_enabled(level, set);
+}
+static bool get_fmt_used_and_enabled_ptr(uint8_t level, size_t set, const char* arg) {
+    return arg && get_fmt_enabled(level, set);
+}
+
+/**
+ * enable or disable logger output lock
+ * @note disable this lock is not recommended except you want output system exception log
+ *
+ * @param enabled true: enable  false: disable
+ */
+void elog_output_lock_enabled(bool enabled) {
+    elog.output_lock_enabled = enabled;
+    /* it will re-lock or re-unlock before output lock enable */
+    if (elog.output_lock_enabled) {
+        if (!elog.output_is_locked_before_disable && elog.output_is_locked_before_enable) {
+            /* the output lock is unlocked before disable, and the lock will unlocking after enable */
+            elog_port_output_lock();
+        } else if (elog.output_is_locked_before_disable && !elog.output_is_locked_before_enable) {
+            /* the output lock is locked before disable, and the lock will locking after enable */
+            elog_port_output_unlock();
+        }
+    }
+}
+
+/**
+ * Set a hook function to EasyLogger assert. It will run when the expression is false.
+ *
+ * @param hook the hook function
+ */
+void elog_assert_set_hook(void (*hook)(const char* expr, const char* func, size_t line)) {
+    elog_assert_hook = hook;
+}
+
+/**
+ * find the log level
+ * @note make sure the log level is output on each format
+ *
+ * @param log log buffer
+ *
+ * @return log level, found failed will return -1
+ */
+int8_t elog_find_lvl(const char *log) {
+    ELOG_ASSERT(log);
+    /* make sure the log level is output on each format */
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_ASSERT] & ELOG_FMT_LVL);
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_ERROR] & ELOG_FMT_LVL);
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_WARN] & ELOG_FMT_LVL);
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_INFO] & ELOG_FMT_LVL);
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_DEBUG] & ELOG_FMT_LVL);
+    ELOG_ASSERT(elog.enabled_fmt_set[ELOG_LVL_VERBOSE] & ELOG_FMT_LVL);
+
+#ifdef ELOG_COLOR_ENABLE
+    uint8_t i;
+    size_t csi_start_len = strlen(CSI_START);
+    for(i = 0; i < ELOG_LVL_TOTAL_NUM; i ++) {
+        if (!strncmp(color_output_info[i], log + csi_start_len, strlen(color_output_info[i]))) {
+            return i;
+        }
+    }
+    /* found failed */
+    return -1;
+#else
+    switch (log[0]) {
+    case 'A': return ELOG_LVL_ASSERT;
+    case 'E': return ELOG_LVL_ERROR;
+    case 'W': return ELOG_LVL_WARN;
+    case 'I': return ELOG_LVL_INFO;
+    case 'D': return ELOG_LVL_DEBUG;
+    case 'V': return ELOG_LVL_VERBOSE;
+    default: return -1;
+    }
+#endif
+}
+
+/**
+ * find the log tag
+ * @note make sure the log tag is output on each format
+ * @note the tag don't have space in it
+ *
+ * @param log log buffer
+ * @param lvl log level, you can get it by @see elog_find_lvl
+ * @param tag_len found tag length
+ *
+ * @return log tag, found failed will return NULL
+ */
+const char *elog_find_tag(const char *log, uint8_t lvl, size_t *tag_len) {
+    const char *tag = NULL, *tag_end = NULL;
+
+    ELOG_ASSERT(log);
+    ELOG_ASSERT(tag_len);
+    ELOG_ASSERT(lvl < ELOG_LVL_TOTAL_NUM);
+    /* make sure the log tag is output on each format */
+    ELOG_ASSERT(elog.enabled_fmt_set[lvl] & ELOG_FMT_TAG);
+
+#ifdef ELOG_COLOR_ENABLE
+    tag = log + strlen(CSI_START) + strlen(color_output_info[lvl]) + strlen(level_output_info[lvl]);
+#else
+    tag = log + strlen(level_output_info[lvl]);
+#endif
+    /* find the first space after tag */
+    if ((tag_end = memchr(tag, ' ', ELOG_FILTER_TAG_MAX_LEN)) != NULL) {
+        *tag_len = tag_end - tag;
+    } else {
+        tag = NULL;
+    }
+
+    return tag;
+}
+
+/**
+ * dump the hex format data to log
+ *
+ * @param name name for hex object, it will show on log header
+ * @param width hex number for every line, such as: 16, 32
+ * @param buf hex buffer
+ * @param size buffer size
+ */
+void elog_hexdump(const char *name, uint8_t width, const void *buf, uint16_t size)
+{
+#define __is_print(ch)       ((unsigned int)((ch) - ' ') < 127u - ' ')
+
+    uint16_t i, j;
+    uint16_t log_len = 0;
+    const uint8_t *buf_p = buf;
+    char dump_string[8] = {0};
+    int fmt_result;
+
+    if (!elog.output_enabled) {
+        return;
+    }
+
+    /* level filter */
+    if (ELOG_LVL_DEBUG > elog.filter.level) {
+        return;
+    } else if (!strstr(name, elog.filter.tag)) { /* tag filter */
+        return;
+    }
+
+    /* lock output */
+    elog_output_lock();
+
+    for (i = 0; i < size; i += width) {
+        /* package header */
+        fmt_result = snprintf(log_buf, ELOG_LINE_BUF_SIZE, "D/HEX %s: %04X-%04X: ", name, i, i + width - 1);
+        /* calculate log length */
+        if ((fmt_result > -1) && (fmt_result <= ELOG_LINE_BUF_SIZE)) {
+            log_len = fmt_result;
+        } else {
+            log_len = ELOG_LINE_BUF_SIZE;
+        }
+        /* dump hex */
+        for (j = 0; j < width; j++) {
+            if (i + j < size) {
+                snprintf(dump_string, sizeof(dump_string), "%02X ", buf_p[i + j]);
+            } else {
+                strncpy(dump_string, "   ", sizeof(dump_string));
+            }
+            log_len += elog_strcpy(log_len, log_buf + log_len, dump_string);
+            if ((j + 1) % 8 == 0) {
+                log_len += elog_strcpy(log_len, log_buf + log_len, " ");
+            }
+        }
+        log_len += elog_strcpy(log_len, log_buf + log_len, "  ");
+        /* dump char for hex */
+        for (j = 0; j < width; j++) {
+            if (i + j < size) {
+                snprintf(dump_string, sizeof(dump_string), "%c", __is_print(buf_p[i + j]) ? buf_p[i + j] : '.');
+                log_len += elog_strcpy(log_len, log_buf + log_len, dump_string);
+            }
+        }
+        /* overflow check and reserve some space for newline sign */
+        if (log_len + strlen(ELOG_NEWLINE_SIGN) > ELOG_LINE_BUF_SIZE) {
+            log_len = ELOG_LINE_BUF_SIZE - strlen(ELOG_NEWLINE_SIGN);
+        }
+        /* package newline sign */
+        log_len += elog_strcpy(log_len, log_buf + log_len, ELOG_NEWLINE_SIGN);
+        /* do log output */
+#if defined(ELOG_ASYNC_OUTPUT_ENABLE)
+        extern void elog_async_output(uint8_t level, const char *log, size_t size);
+        elog_async_output(ELOG_LVL_DEBUG, log_buf, log_len);
+#elif defined(ELOG_BUF_OUTPUT_ENABLE)
+        extern void elog_buf_output(const char *log, size_t size);
+        elog_buf_output(log_buf, log_len);
+#else
+        elog_port_output(log_buf, log_len);
+#endif
+    }
+    /* unlock output */
+    elog_output_unlock();
+}

Core/Bsp/easylogger/src/elog_utils.c

@@ -0,0 +1,79 @@
+//
+// Created by wangb on 25-6-4.
+//
+
+#include "elog.h"
+#include <string.h>
+
+/**
+ * another copy string function
+ *
+ * @param cur_len current copied log length, max size is ELOG_LINE_BUF_SIZE
+ * @param dst destination
+ * @param src source
+ *
+ * @return copied length
+ */
+size_t elog_strcpy(size_t cur_len, char *dst, const char *src) {
+    const char *src_old = src;
+
+    assert(dst);
+    assert(src);
+
+    while (*src != 0) {
+        /* make sure destination has enough space */
+        if (cur_len++ < ELOG_LINE_BUF_SIZE) {
+            *dst++ = *src++;
+        } else {
+            break;
+        }
+    }
+    return src - src_old;
+}
+
+/**
+ * Copy line log split by newline sign. It will copy all log when the newline sign isn't find.
+ *
+ * @param line line log buffer
+ * @param log origin log buffer
+ * @param len origin log buffer length
+ *
+ * @return copy size
+ */
+size_t elog_cpyln(char *line, const char *log, size_t len) {
+    size_t newline_len = strlen(ELOG_NEWLINE_SIGN), copy_size = 0;
+
+    assert(line);
+    assert(log);
+
+    while (len--) {
+        *line++ = *log++;
+        copy_size++;
+        if (copy_size >= newline_len && !strncmp(log - newline_len, ELOG_NEWLINE_SIGN, newline_len)) {
+            break;
+        }
+    }
+    return copy_size;
+}
+
+/**
+ * This function will copy memory content from source address to destination
+ * address.
+ *
+ * @param dst the address of destination memory
+ * @param src  the address of source memory
+ * @param count the copied length
+ *
+ * @return the address of destination memory
+ */
+void *elog_memcpy(void *dst, const void *src, size_t count) {
+    char *tmp = (char *) dst, *s = (char *) src;
+
+    assert(dst);
+    assert(src);
+
+    while (count--)
+        *tmp++ = *s++;
+
+    return dst;
+}