Log Aggregation from Microcontrollers

In this lesson, you will learn how to design compact, wire-efficient serialization schemes to aggregate logs from resource-constrained microcontrollers over limited-bandwidth interfaces like UART.

The Challenge of Text-Based Logging

When logging on a high-end server, you might use JSON or verbose text. On a microcontroller, sending println!("Sensor 1 value is: {}", val); is a performance killer. It wastes flash memory to store string constants, cycles to format the text, and precious UART bandwidth to transmit ASCII characters. At 115,200 baud, a few verbose logs can easily saturate your bus and cause your real-time application to miss critical deadlines.

The Binary Serialization Approach

Instead of sending strings, we treat logs as structured binary events. We assign a unique u16 ID to every log site and serialize only the raw data arguments.

Consider this lightweight logging macro strategy:

#[repr(packed)]
struct LogEntry {
    id: u16,
    timestamp: u32,
    payload: u32,
}

// Instead of formatting, just push raw bytes
fn log_event(id: u16, data: u32) {
    let entry = LogEntry {
        id,
        timestamp: get_ticks(),
        payload: data,
    };
    // Transmit via DMA to minimize CPU blocking
    dma_send_bytes(unsafe { as_bytes(&entry) });
}

Decoupling the Sink

By shifting the burden of "formatting" to the host machine, the microcontroller remains a simple producer. The host maintains a lookup table (often extracted from the binary during the build process using a custom linker section) that maps the u16 IDs back to human-readable strings and format specifiers.

If the log site is (0x01, val), the host looks up 0x01 as "Sensor 1 value is: {}" and reconstructs the output in real-time. This reduces the UART payload size from dozens of bytes to exactly 10 bytes per log entry. When you combine this with DMA-driven UART transfers, you effectively offload the logging overhead from your primary execution loop, ensuring that log aggregation doesn't interfere with your real-time scheduling constraints.

Key Takeaway: By transmitting compact binary tokens instead of formatted strings, you eliminate expensive runtime formatting and preserve critical interface bandwidth in resource-constrained systems.