Click the aboveblue text to follow us
In the field of embedded system development, logging systems are like black boxes in the digital world, carrying key information about the system’s operational status.
The traditional printf debugging method, while simple and easy to use, exposes significant issues such as low efficiency, high resource consumption, and poor maintainability when dealing with complex systems.
In typical applications of the 32-bit ARM Cortex-M4 processor, each call to the printf function consumes an average of 1.2ms of CPU time. When the system frequency reaches 1MHz for event triggering, log output can directly lead to delays in real-time tasks.
More critically, the standard library’s formatting process can trigger dynamic memory allocation, which can easily cause memory fragmentation issues in MMU-less embedded environments.
Traditional solutions have three major structural flaws:
- First, the synchronous blocking output mode leads to unpredictable task response times, which can cause priority inversion in RTOS multitasking environments;
- Second, the lack of a hierarchical filtering mechanism mixes debugging information with critical alerts; a smart meter project once experienced a watchdog reset due to log flooding;
- Third, fixed-format output is difficult to adapt to diverse persistent storage needs. In IoT devices sensitive to FLASH lifespan, uncompressed text logs significantly shorten the lifespan of storage media.
1
Hierarchical Control and Dynamic Filtering Mechanism
Define a five-level logging system: TRACE (0x01), DEBUG (0x02), INFO (0x04), WARN (0x08), ERROR (0x10), using bit masks to achieve runtime dynamic filtering.
The configuration module injects thresholds through environment variables. When the device is deployed in a production line testing environment, DEBUG level is enabled, while in field operation, it automatically switches to WARN level and above for log collection. This strategy reduced the log storage volume of an industrial gateway by 83%.
typedef enum { LOG_LVL_TRACE = 0x01, LOG_LVL_DEBUG = 0x02, LOG_LVL_INFO = 0x04, LOG_LVL_WARN = 0x08, LOG_LVL_ERROR = 0x10} LogLevel;
#define LOG_FILTER_MASK (LOG_LVL_ERROR | LOG_LVL_WARN)2
Asynchronous Processing and Zero-Copy Architecture
Construct a circular buffer shared memory model, using a double-pointer lock-free access design.
The producer (application task) directly writes log entries through memory mapping, while the consumer (log service) processes persistence operations in batches.
In a smart agriculture terminal project, this design reduced log write latency from milliseconds to microseconds, while avoiding context overhead caused by task switching.
#define SHM_SIZE 4096
struct ring_buffer { volatile uint32_t head; volatile uint32_t tail; uint8_t buffer[SHM_SIZE];};
void log_async_write(const char* msg) { uint32_t next_tail = (rb->tail + len) % SHM_SIZE; if (next_tail != rb->head) { memcpy(&rb->buffer[rb->tail], msg, len); rb->tail = next_tail; }}3
Cross-Platform Adaptation Layer Design
Abstract the Hardware Abstraction Layer (HAL) and implement platform-specific operations through function pointers.
In STM32F4 series MCUs, DMA serial transmission is used in conjunction with interrupt callback mechanisms; while in Linux embedded platforms, shared memory direct connection is achieved through mmap.
This design reduced the porting time of the log core code to different platforms to 2 person-days.
In a comparative test of an industrial robotic arm controller, significant differences were observed between the old and new solutions: the traditional printf solution caused motion control cycle jitter of ±15% under a logging pressure of 1000 times/second, while the new solution controlled the jitter within ±0.5%. In terms of storage, the binary log format combined with the LZ4 compression algorithm reduced 30 days of log data from 2.1GB to 380MB, decreasing FLASH erase cycles by 76%.
Clickto read the original text for more exciting content~