chore: plan zero-heap static log buffer approach

Agent-Logs-Url: https://github.com/FKMTime/firmware/sessions/979ed59b-c59d-48c0-a2df-2d26d23bc225

Co-authored-by: filipton <37213766+filipton@users.noreply.github.com>

Author: Copilot

src/main.rs

@@ -381,44 +381,74 @@ async fn logger_task(global_state: GlobalState) {
     loop {
         Timer::after_millis(LOG_SEND_INTERVAL_MS).await;
 
-        let mut tmp_logs: Vec<String> = Vec::new();
-        for _ in 0..consts::LOG_BATCH_SIZE {
-            match utils::logger::LOGS_CHANNEL.try_receive() {
-                Ok(msg) => tmp_logs.push(msg),
-                Err(_) => break,
-            }
+        if ota_state() || sleep_state() {
+            // Drain and discard so the channel does not fill up.
+            while utils::logger::LOGS_CHANNEL.try_receive().is_ok() {}
+            continue;
         }
 
-        if ota_state() || sleep_state() {
+        // How many entries can we drain this tick?
+        let available = utils::logger::LOGS_CHANNEL.len().min(consts::LOG_BATCH_SIZE);
+        if available == 0 {
+            continue;
+        }
+
+        // Binary log packet layout:
+        //   [1]   packet type  = 0x01
+        //   [8]   current_time (u64 LE)
+        //   [1]   entry count  (u8)
+        //   per entry:
+        //     [2]   byte length  (u16 LE)
+        //     [N]   UTF-8 string
+        //
+        // Pre-compute worst-case payload size and trim the count until it fits
+        // in available heap, keeping MIN_HEAP_REMEANING as safety margin.
+        // This is a single, non-growing allocation — no serde_json, no copies.
+        const HEADER: usize = 10; // 1 + 8 + 1
+        const ENTRY_OVERHEAD: usize = 2; // u16 length prefix
+        let mut count = available;
+        loop {
+            if count == 0 {
+                break;
+            }
+            let max_payload =
+                HEADER + count * (ENTRY_OVERHEAD + utils::logger::LOG_MSG_MAX_LEN);
+            if esp_alloc::HEAP.free()
+                > max_payload + utils::logger::MIN_HEAP_REMEANING
+            {
+                break;
+            }
+            count -= 1;
+        }
+        if count == 0 {
             continue;
         }
 
-        if !tmp_logs.is_empty() {
-            tmp_logs.reverse();
-
-            // Drop oldest entries (end of vec after reverse) until the estimated
-            // serialised JSON fits comfortably in available heap.  Each pop()
-            // immediately frees the String's heap allocation, raising HEAP.free().
-            while tmp_logs.len() > 1 {
-                // Estimate: each entry contributes its byte length + 3 (quotes +
-                // comma), plus ~80 bytes of JSON wrapper.  Multiply by 2 to cover
-                // serde_json's internal growth doubling.
-                let estimated: usize =
-                    tmp_logs.iter().map(|s| s.len() + 3).sum::<usize>() * 2 + 80;
-                if esp_alloc::HEAP.free() > estimated + utils::logger::MIN_HEAP_REMEANING {
-                    break;
+        let capacity = HEADER + count * (ENTRY_OVERHEAD + utils::logger::LOG_MSG_MAX_LEN);
+        let mut payload: Vec<u8> = Vec::with_capacity(capacity);
+
+        let current_time = unsafe { crate::stackmat::CURRENT_TIME };
+        payload.push(0x01_u8); // packet type: Logs
+        payload.extend_from_slice(&current_time.to_le_bytes());
+        payload.push(count as u8); // placeholder; corrected below
+
+        let mut actual_count: u8 = 0;
+        for _ in 0..count {
+            match utils::logger::LOGS_CHANNEL.try_receive() {
+                Ok(msg) => {
+                    let b = msg.as_bytes();
+                    payload.extend_from_slice(&(b.len() as u16).to_le_bytes());
+                    payload.extend_from_slice(b);
+                    actual_count += 1;
+                    // `msg` (heapless::String, BSS-backed) is dropped here
                 }
-                tmp_logs.pop();
+                Err(_) => break,
             }
+        }
+        payload[9] = actual_count; // correct the count byte
 
-            ws::send_packet(structs::TimerPacket {
-                tag: None,
-                data: structs::TimerPacketInner::Logs {
-                    current_time: Some(unsafe { crate::stackmat::CURRENT_TIME }),
-                    logs: tmp_logs,
-                },
-            })
-            .await;
+        if actual_count > 0 {
+            ws::send_binary(payload).await;
         }
 
         #[cfg(not(feature = "release_build"))]

src/utils/logger.rs

@@ -1,10 +1,21 @@
 use crate::state::{ota_state, sleep_state};
-use alloc::string::String;
+use core::fmt::Write;
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel};
 
+/// Maximum byte length of a single log message stored in the channel.
+/// Messages longer than this are silently truncated.
+pub const LOG_MSG_MAX_LEN: usize = 200;
+
 const MAX_LOGS_SIZE: usize = 100;
 pub const MIN_HEAP_REMEANING: usize = 10240;
-pub static LOGS_CHANNEL: Channel<CriticalSectionRawMutex, String, MAX_LOGS_SIZE> = Channel::new();
+
+/// Log messages are stored as fixed-size inline strings so that the channel
+/// lives entirely in BSS — no heap allocations, no fragmentation.
+pub static LOGS_CHANNEL: Channel<
+    CriticalSectionRawMutex,
+    heapless::String<LOG_MSG_MAX_LEN>,
+    MAX_LOGS_SIZE,
+> = Channel::new();
 
 #[cfg(feature = "release_build")]
 pub const FILTER_MAX: log::LevelFilter = log::LevelFilter::Info;
@@ -63,11 +74,10 @@ impl log::Log for FkmLogger {
                 _ = LOGS_CHANNEL.try_receive();
             }
 
-            let msg = alloc::format!("{} - {}", record.level(), record.args());
-
-            // Do not send log msg to channel if heap space is too low!
-            // maybe not performent but thats ok
             if esp_alloc::HEAP.free() > MIN_HEAP_REMEANING {
+                let mut msg = heapless::String::<LOG_MSG_MAX_LEN>::new();
+                // write! truncates silently once the string is full
+                _ = write!(msg, "{} - {}", record.level(), record.args());
                 _ = LOGS_CHANNEL.try_send(msg);
             } else {
                 // clear logs channel if heap space is too low

src/ws.rs

@@ -605,6 +605,10 @@ pub async fn send_packet(packet: TimerPacket) {
     }
 }
 
+pub async fn send_binary(data: alloc::vec::Vec<u8>) {
+    FRAME_CHANNEL.send(WsFrameOwned::Binary(data)).await;
+}
+
 #[allow(dead_code)]
 pub fn clear_frame_channel() {
     FRAME_CHANNEL.clear();