use core::fmt::Write instead of home-rolled fmt

8 files changed, 16 insertions, 229 deletions

diff --git a/examples/mcxa/src/bin/dma_channel_link.rs b/examples/mcxa/src/bin/dma_channel_link.rs
index 92c7a9681..f7ab5d8fd 100644
--- a/examples/mcxa/src/bin/dma_channel_link.rs
+++ b/examples/mcxa/src/bin/dma_channel_link.rs
@@ -22,6 +22,7 @@ use embassy_mcxa::dma::{DmaCh0InterruptHandler, DmaCh1InterruptHandler, DmaCh2In
 use embassy_mcxa::lpuart::{Blocking, Config, Lpuart, LpuartTx};
 use embassy_mcxa::{bind_interrupts, pac};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
+use core::fmt::Write as _;
 
 // Buffers
 static mut SRC_BUFFER: [u32; 4] = [1, 2, 3, 4];
@@ -37,38 +38,9 @@ bind_interrupts!(struct Irqs {
     DMA_CH2 => DmaCh2InterruptHandler;
 });
 
-/// Helper to write a u32 as decimal ASCII to UART
-fn write_u32(tx: &mut LpuartTx<'_, Blocking>, val: u32) {
-    let mut buf = [0u8; 10];
-    let mut n = val;
-    let mut i = buf.len();
-
-    if n == 0 {
-        tx.blocking_write(b"0").ok();
-        return;
-    }
-
-    while n > 0 {
-        i -= 1;
-        buf[i] = b'0' + (n % 10) as u8;
-        n /= 10;
-    }
-
-    tx.blocking_write(&buf[i..]).ok();
-}
-
 /// Helper to print a buffer to UART
 fn print_buffer(tx: &mut LpuartTx<'_, Blocking>, buf_ptr: *const u32, len: usize) {
-    tx.blocking_write(b"[").ok();
-    unsafe {
-        for i in 0..len {
-            write_u32(tx, *buf_ptr.add(i));
-            if i < len - 1 {
-                tx.blocking_write(b", ").ok();
-            }
-        }
-    }
-    tx.blocking_write(b"]").ok();
+    write!(tx, "{:?}", unsafe { core::slice::from_raw_parts(buf_ptr, len) }).ok();
 }
 
 #[embassy_executor::main]
diff --git a/examples/mcxa/src/bin/dma_interleave_transfer.rs b/examples/mcxa/src/bin/dma_interleave_transfer.rs
index 7876e8978..98e301a7c 100644
--- a/examples/mcxa/src/bin/dma_interleave_transfer.rs
+++ b/examples/mcxa/src/bin/dma_interleave_transfer.rs
@@ -16,6 +16,7 @@ use embassy_mcxa::dma::{DmaCh0InterruptHandler, DmaChannel};
 use embassy_mcxa::lpuart::{Blocking, Config, Lpuart, LpuartTx};
 use embassy_mcxa::{bind_interrupts, pac};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
+use core::fmt::Write as _;
 
 // Bind DMA channel 0 interrupt using Embassy-style macro
 bind_interrupts!(struct Irqs {
@@ -29,38 +30,9 @@ const HALF_BUFF_LENGTH: usize = BUFFER_LENGTH / 2;
 static mut SRC_BUFFER: [u32; HALF_BUFF_LENGTH] = [0; HALF_BUFF_LENGTH];
 static mut DEST_BUFFER: [u32; BUFFER_LENGTH] = [0; BUFFER_LENGTH];
 
-/// Helper to write a u32 as decimal ASCII to UART
-fn write_u32(tx: &mut LpuartTx<'_, Blocking>, val: u32) {
-    let mut buf = [0u8; 10];
-    let mut n = val;
-    let mut i = buf.len();
-
-    if n == 0 {
-        tx.blocking_write(b"0").ok();
-        return;
-    }
-
-    while n > 0 {
-        i -= 1;
-        buf[i] = b'0' + (n % 10) as u8;
-        n /= 10;
-    }
-
-    tx.blocking_write(&buf[i..]).ok();
-}
-
 /// Helper to print a buffer to UART
 fn print_buffer(tx: &mut LpuartTx<'_, Blocking>, buf_ptr: *const u32, len: usize) {
-    tx.blocking_write(b"[").ok();
-    unsafe {
-        for i in 0..len {
-            write_u32(tx, *buf_ptr.add(i));
-            if i < len - 1 {
-                tx.blocking_write(b", ").ok();
-            }
-        }
-    }
-    tx.blocking_write(b"]").ok();
+    write!(tx, "{:?}", unsafe { core::slice::from_raw_parts(buf_ptr, len) }).ok();
 }
 
 #[embassy_executor::main]
diff --git a/examples/mcxa/src/bin/dma_mem_to_mem.rs b/examples/mcxa/src/bin/dma_mem_to_mem.rs
index 68f70e742..149e37326 100644
--- a/examples/mcxa/src/bin/dma_mem_to_mem.rs
+++ b/examples/mcxa/src/bin/dma_mem_to_mem.rs
@@ -19,6 +19,7 @@ use embassy_mcxa::dma::{DmaCh0InterruptHandler, DmaChannel, TransferOptions};
 use embassy_mcxa::lpuart::{Blocking, Config, Lpuart, LpuartTx};
 use embassy_mcxa::{bind_interrupts, pac};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
+use core::fmt::Write as _;
 
 // Bind DMA channel 0 interrupt using Embassy-style macro
 bind_interrupts!(struct Irqs {
@@ -32,40 +33,10 @@ static mut SRC_BUFFER: [u32; BUFFER_LENGTH] = [0; BUFFER_LENGTH];
 static mut DEST_BUFFER: [u32; BUFFER_LENGTH] = [0; BUFFER_LENGTH];
 static mut MEMSET_BUFFER: [u32; BUFFER_LENGTH] = [0; BUFFER_LENGTH];
 
-/// Helper to write a u32 as decimal ASCII to UART
-fn write_u32(tx: &mut LpuartTx<'_, Blocking>, val: u32) {
-    let mut buf = [0u8; 10]; // u32 max is 4294967295 (10 digits)
-    let mut n = val;
-    let mut i = buf.len();
-
-    if n == 0 {
-        tx.blocking_write(b"0").ok();
-        return;
-    }
-
-    while n > 0 {
-        i -= 1;
-        buf[i] = b'0' + (n % 10) as u8;
-        n /= 10;
-    }
-
-    tx.blocking_write(&buf[i..]).ok();
-}
-
 /// Helper to print a buffer as [v1, v2, v3, v4] to UART
 /// Takes a raw pointer to avoid warnings about shared references to mutable statics
 fn print_buffer(tx: &mut LpuartTx<'_, Blocking>, buf_ptr: *const [u32; BUFFER_LENGTH]) {
-    tx.blocking_write(b"[").ok();
-    unsafe {
-        let buf = &*buf_ptr;
-        for (i, val) in buf.iter().enumerate() {
-            write_u32(tx, *val);
-            if i < buf.len() - 1 {
-                tx.blocking_write(b", ").ok();
-            }
-        }
-    }
-    tx.blocking_write(b"]").ok();
+    write!(tx, "{:?}", unsafe { &*buf_ptr }).ok();
 }
 
 #[embassy_executor::main]
diff --git a/examples/mcxa/src/bin/dma_memset.rs b/examples/mcxa/src/bin/dma_memset.rs
index 95e365e47..bc4e78701 100644
--- a/examples/mcxa/src/bin/dma_memset.rs
+++ b/examples/mcxa/src/bin/dma_memset.rs
@@ -16,6 +16,7 @@ use embassy_mcxa::dma::{DmaCh0InterruptHandler, DmaChannel};
 use embassy_mcxa::lpuart::{Blocking, Config, Lpuart, LpuartTx};
 use embassy_mcxa::{bind_interrupts, pac};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
+use core::fmt::Write as _;
 
 // Bind DMA channel 0 interrupt using Embassy-style macro
 bind_interrupts!(struct Irqs {
@@ -28,38 +29,9 @@ const BUFFER_LENGTH: usize = 4;
 static mut PATTERN: u32 = 0;
 static mut DEST_BUFFER: [u32; BUFFER_LENGTH] = [0; BUFFER_LENGTH];
 
-/// Helper to write a u32 as decimal ASCII to UART
-fn write_u32(tx: &mut LpuartTx<'_, Blocking>, val: u32) {
-    let mut buf = [0u8; 10];
-    let mut n = val;
-    let mut i = buf.len();
-
-    if n == 0 {
-        tx.blocking_write(b"0").ok();
-        return;
-    }
-
-    while n > 0 {
-        i -= 1;
-        buf[i] = b'0' + (n % 10) as u8;
-        n /= 10;
-    }
-
-    tx.blocking_write(&buf[i..]).ok();
-}
-
 /// Helper to print a buffer to UART
 fn print_buffer(tx: &mut LpuartTx<'_, Blocking>, buf_ptr: *const u32, len: usize) {
-    tx.blocking_write(b"[").ok();
-    unsafe {
-        for i in 0..len {
-            write_u32(tx, *buf_ptr.add(i));
-            if i < len - 1 {
-                tx.blocking_write(b", ").ok();
-            }
-        }
-    }
-    tx.blocking_write(b"]").ok();
+    write!(tx, "{:?}", unsafe { core::slice::from_raw_parts(buf_ptr, len) }).ok();
 }
 
 #[embassy_executor::main]
diff --git a/examples/mcxa/src/bin/dma_ping_pong_transfer.rs b/examples/mcxa/src/bin/dma_ping_pong_transfer.rs
index f8f543382..728e4d408 100644
--- a/examples/mcxa/src/bin/dma_ping_pong_transfer.rs
+++ b/examples/mcxa/src/bin/dma_ping_pong_transfer.rs
@@ -31,6 +31,7 @@ use embassy_mcxa::dma::{self, DmaCh1InterruptHandler, DmaChannel, Tcd, TransferO
 use embassy_mcxa::lpuart::{Blocking, Config, Lpuart, LpuartTx};
 use embassy_mcxa::{bind_interrupts, pac};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
+use core::fmt::Write as _;
 
 // Source and destination buffers for Approach 1 (scatter/gather)
 static mut SRC: [u32; 8] = [1, 2, 3, 4, 5, 6, 7, 8];
@@ -87,38 +88,9 @@ bind_interrupts!(struct Irqs {
     DMA_CH1 => DmaCh1InterruptHandler;
 });
 
-/// Helper to write a u32 as decimal ASCII to UART
-fn write_u32(tx: &mut LpuartTx<'_, Blocking>, val: u32) {
-    let mut buf = [0u8; 10];
-    let mut n = val;
-    let mut i = buf.len();
-
-    if n == 0 {
-        tx.blocking_write(b"0").ok();
-        return;
-    }
-
-    while n > 0 {
-        i -= 1;
-        buf[i] = b'0' + (n % 10) as u8;
-        n /= 10;
-    }
-
-    tx.blocking_write(&buf[i..]).ok();
-}
-
 /// Helper to print a buffer to UART
 fn print_buffer(tx: &mut LpuartTx<'_, Blocking>, buf_ptr: *const u32, len: usize) {
-    tx.blocking_write(b"[").ok();
-    unsafe {
-        for i in 0..len {
-            write_u32(tx, *buf_ptr.add(i));
-            if i < len - 1 {
-                tx.blocking_write(b", ").ok();
-            }
-        }
-    }
-    tx.blocking_write(b"]").ok();
+    write!(tx, "{:?}", unsafe { core::slice::from_raw_parts(buf_ptr, len) }).ok();
 }
 
 #[embassy_executor::main]
diff --git a/examples/mcxa/src/bin/dma_scatter_gather.rs b/examples/mcxa/src/bin/dma_scatter_gather.rs
index 4b26bc2ed..ea553b843 100644
--- a/examples/mcxa/src/bin/dma_scatter_gather.rs
+++ b/examples/mcxa/src/bin/dma_scatter_gather.rs
@@ -20,6 +20,7 @@ use embassy_mcxa::dma::{self, DmaChannel, Tcd};
 use embassy_mcxa::lpuart::{Blocking, Config, Lpuart, LpuartTx};
 use embassy_mcxa::{bind_interrupts, pac};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
+use core::fmt::Write as _;
 
 // Source and destination buffers
 static mut SRC: [u32; 8] = [1, 2, 3, 4, 5, 6, 7, 8];
@@ -72,38 +73,10 @@ bind_interrupts!(struct Irqs {
     DMA_CH0 => ScatterGatherDmaHandler;
 });
 
-/// Helper to write a u32 as decimal ASCII to UART
-fn write_u32(tx: &mut LpuartTx<'_, Blocking>, val: u32) {
-    let mut buf = [0u8; 10];
-    let mut n = val;
-    let mut i = buf.len();
-
-    if n == 0 {
-        tx.blocking_write(b"0").ok();
-        return;
-    }
-
-    while n > 0 {
-        i -= 1;
-        buf[i] = b'0' + (n % 10) as u8;
-        n /= 10;
-    }
-
-    tx.blocking_write(&buf[i..]).ok();
-}
 
 /// Helper to print a buffer to UART
 fn print_buffer(tx: &mut LpuartTx<'_, Blocking>, buf_ptr: *const u32, len: usize) {
-    tx.blocking_write(b"[").ok();
-    unsafe {
-        for i in 0..len {
-            write_u32(tx, *buf_ptr.add(i));
-            if i < len - 1 {
-                tx.blocking_write(b", ").ok();
-            }
-        }
-    }
-    tx.blocking_write(b"]").ok();
+    write!(tx, "{:?}", unsafe { core::slice::from_raw_parts(buf_ptr, len) }).ok();
 }
 
 #[embassy_executor::main]
diff --git a/examples/mcxa/src/bin/dma_scatter_gather_builder.rs b/examples/mcxa/src/bin/dma_scatter_gather_builder.rs
index e483bb81f..29c54ca42 100644
--- a/examples/mcxa/src/bin/dma_scatter_gather_builder.rs
+++ b/examples/mcxa/src/bin/dma_scatter_gather_builder.rs
@@ -26,6 +26,7 @@ use embassy_mcxa::dma::{DmaCh0InterruptHandler, DmaChannel, ScatterGatherBuilder
 use embassy_mcxa::lpuart::{Blocking, Config, Lpuart, LpuartTx};
 use embassy_mcxa::{bind_interrupts, pac};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
+use core::fmt::Write as _;
 
 // Bind DMA channel 0 interrupt
 bind_interrupts!(struct Irqs {
@@ -42,27 +43,9 @@ static mut DST1: [u32; 4] = [0; 4];
 static mut DST2: [u32; 4] = [0; 4];
 static mut DST3: [u32; 4] = [0; 4];
 
-/// Helper to write a u32 as hex to UART
-fn write_hex(tx: &mut LpuartTx<'_, Blocking>, val: u32) {
-    const HEX: &[u8; 16] = b"0123456789ABCDEF";
-    for i in (0..8).rev() {
-        let nibble = ((val >> (i * 4)) & 0xF) as usize;
-        tx.blocking_write(&[HEX[nibble]]).ok();
-    }
-}
-
 /// Helper to print a buffer to UART
 fn print_buffer(tx: &mut LpuartTx<'_, Blocking>, buf_ptr: *const u32, len: usize) {
-    tx.blocking_write(b"[").ok();
-    unsafe {
-        for i in 0..len {
-            write_hex(tx, *buf_ptr.add(i));
-            if i < len - 1 {
-                tx.blocking_write(b", ").ok();
-            }
-        }
-    }
-    tx.blocking_write(b"]").ok();
+    write!(tx, "{:08X?}", unsafe { core::slice::from_raw_parts(buf_ptr, len) }).ok();
 }
 
 #[embassy_executor::main]
diff --git a/examples/mcxa/src/bin/dma_wrap_transfer.rs b/examples/mcxa/src/bin/dma_wrap_transfer.rs
index 82936d9d0..7fea4bf76 100644
--- a/examples/mcxa/src/bin/dma_wrap_transfer.rs
+++ b/examples/mcxa/src/bin/dma_wrap_transfer.rs
@@ -16,6 +16,7 @@ use embassy_mcxa::dma::{DmaCh0InterruptHandler, DmaChannel};
 use embassy_mcxa::lpuart::{Blocking, Config, Lpuart, LpuartTx};
 use embassy_mcxa::{bind_interrupts, pac};
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
+use core::fmt::Write as _;
 
 // Bind DMA channel 0 interrupt using Embassy-style macro
 bind_interrupts!(struct Irqs {
@@ -29,38 +30,9 @@ struct AlignedSrc([u32; 4]);
 static mut SRC: AlignedSrc = AlignedSrc([0; 4]);
 static mut DST: [u32; 8] = [0; 8];
 
-/// Helper to write a u32 as decimal ASCII to UART
-fn write_u32(tx: &mut LpuartTx<'_, Blocking>, val: u32) {
-    let mut buf = [0u8; 10];
-    let mut n = val;
-    let mut i = buf.len();
-
-    if n == 0 {
-        tx.blocking_write(b"0").ok();
-        return;
-    }
-
-    while n > 0 {
-        i -= 1;
-        buf[i] = b'0' + (n % 10) as u8;
-        n /= 10;
-    }
-
-    tx.blocking_write(&buf[i..]).ok();
-}
-
 /// Helper to print a buffer to UART
 fn print_buffer(tx: &mut LpuartTx<'_, Blocking>, buf_ptr: *const u32, len: usize) {
-    tx.blocking_write(b"[").ok();
-    unsafe {
-        for i in 0..len {
-            write_u32(tx, *buf_ptr.add(i));
-            if i < len - 1 {
-                tx.blocking_write(b", ").ok();
-            }
-        }
-    }
-    tx.blocking_write(b"]").ok();
+    write!(tx, "{:?}", unsafe { core::slice::from_raw_parts(buf_ptr, len) }).ok();
 }
 
 #[embassy_executor::main]