logger.rs

use core::cell::RefCell;
use core::fmt::Write;
use cortex_m::interrupt::Mutex;
use heapless::{consts::U1024, spsc::Queue};
use log::{Metadata, Record};

pub static LOGBUF: Mutex<RefCell<Buffer>> = Mutex::new(RefCell::new(Buffer::new()));

pub struct Buffer(pub Queue<u8, U1024>);

impl Buffer {
    const fn new() -> Self {
        Buffer(Queue::new())
    }
}

impl core::fmt::Write for Buffer {
    fn write_str(&mut self, s: &str) -> Result<(), core::fmt::Error> {
        for u8char in s.bytes() {
            let _e = self.0.enqueue(u8char);
        }
        Ok(())
    }
}

pub struct BufferLogger;

impl log::Log for BufferLogger {
    fn enabled(&self, _metadata: &Metadata) -> bool {
        true
    }

    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
            cortex_m::interrupt::free(|cs| {
                // make sure you are alone on the buffer
                let mut tx = LOGBUF.borrow(cs).borrow_mut();
                writeln!(
                    tx,
                    "{} {}: {}",
                    record.level(),
                    record.target(),
                    record.args()
                )
                .unwrap();
            });
        }
    }
    fn flush(&self) {}
}

Example of how to write it out over uart, this can be done whenever you want it.

        cortex_m::interrupt::free(|cs| {
            // Obtain mutex protected write part of serial port
            while let Some(b) = logger::LOGBUF
                .borrow(cs)
                .borrow_mut()
                .deref_mut()
                .0
                .dequeue()
            {
                let _e = write!(uart, "{}", b as char);
            }
        });