Continue working on examples

12 files changed, 200 insertions, 171 deletions

diff --git a/examples/adc_interrupt.rs b/examples/adc_interrupt.rs
index 3be85ac75..536152539 100644
--- a/examples/adc_interrupt.rs
+++ b/examples/adc_interrupt.rs
@@ -4,13 +4,13 @@
 use embassy_executor::Spawner;
 use embassy_mcxa276::clocks::periph_helpers::{AdcClockSel, Div4};
 use embassy_mcxa276::clocks::PoweredClock;
+use embassy_mcxa276::lpuart::{Config, Lpuart};
 use hal::adc::{LpadcConfig, TriggerPriorityPolicy};
-use hal::uart;
 use mcxa_pac::adc1::cfg::{Pwrsel, Refsel};
 use mcxa_pac::adc1::cmdl1::{Adch, Mode};
 use mcxa_pac::adc1::ctrl::CalAvgs;
 use mcxa_pac::adc1::tctrl::Tcmd;
-use {cortex_m, embassy_mcxa276 as hal};
+use {embassy_mcxa276 as hal};
 mod common;
 
 use hal::{bind_interrupts, InterruptExt};
@@ -28,14 +28,25 @@ static KEEP_ADC: unsafe extern "C" fn() = ADC1;
 async fn main(_spawner: Spawner) {
     let p = hal::init(hal::config::Config::default());
 
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
         common::init_uart2(hal::pac());
     }
-
-    // let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    // let uart = uart::Uart::<uart::Lpuart2>::new(p.LPUART2, uart::Config::new(src));
-
-    // uart.write_str_blocking("\r\n=== ADC interrupt Example ===\r\n");
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
     unsafe {
         common::init_adc(hal::pac());
@@ -71,7 +82,7 @@ async fn main(_spawner: Spawner) {
     conv_trigger_config.enable_hardware_trigger = false;
     adc.set_conv_trigger_config(0, &conv_trigger_config);
 
-    // uart.write_str_blocking("\r\n=== ADC configuration done... ===\r\n");
+    uart.write_str_blocking("\r\n=== ADC configuration done... ===\r\n");
 
     adc.enable_interrupt(0x1);
 
@@ -88,7 +99,7 @@ async fn main(_spawner: Spawner) {
         while !adc.is_interrupt_triggered() {
             // Wait until the interrupt is triggered
         }
-        // uart.write_str_blocking("\r\n*** ADC interrupt TRIGGERED! ***\r\n");
+        uart.write_str_blocking("\r\n*** ADC interrupt TRIGGERED! ***\r\n");
         //TBD need to print the value
     }
 }
diff --git a/examples/adc_polling.rs b/examples/adc_polling.rs
index 4b5f9422d..2fe4153db 100644
--- a/examples/adc_polling.rs
+++ b/examples/adc_polling.rs
@@ -2,9 +2,11 @@
 #![no_main]
 
 use embassy_executor::Spawner;
+use embassy_mcxa276::clocks::periph_helpers::{AdcClockSel, Div4};
+use embassy_mcxa276::clocks::PoweredClock;
+use embassy_mcxa276::lpuart::{Config, Lpuart};
 use embassy_mcxa276 as hal;
 use hal::adc::{ConvResult, LpadcConfig, TriggerPriorityPolicy};
-use hal::uart;
 use mcxa_pac::adc1::cfg::{Pwrsel, Refsel};
 use mcxa_pac::adc1::cmdl1::{Adch, Mode};
 use mcxa_pac::adc1::ctrl::CalAvgs;
@@ -27,10 +29,27 @@ async fn main(_spawner: Spawner) {
         common::init_uart2(hal::pac());
     }
 
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let uart = uart::Uart::<uart::Lpuart2>::new(p.LPUART2, uart::Config::new(src));
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
+    unsafe {
+        common::init_uart2(hal::pac());
+    }
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
-    uart.write_str_blocking("\r\n=== ADC polling Example ===\r\n");
+    uart.blocking_write(b"\r\n=== ADC polling Example ===\r\n").unwrap();
 
     unsafe {
         common::init_adc(hal::pac());
@@ -47,6 +66,9 @@ async fn main(_spawner: Spawner) {
         enable_conv_pause: false,
         conv_pause_delay: 0,
         fifo_watermark: 0,
+        power: PoweredClock::NormalEnabledDeepSleepDisabled,
+        source: AdcClockSel::FroLfDiv,
+        div: Div4::no_div(),
     };
     let adc = hal::adc::Adc::<hal::adc::Adc1>::new(p.ADC1, adc_config);
 
diff --git a/examples/blink.rs b/examples/blink.rs
index 564353d5c..0f489abb9 100644
--- a/examples/blink.rs
+++ b/examples/blink.rs
@@ -28,10 +28,6 @@ async fn main(_spawner: Spawner) {
     unsafe {
         common::init_led(hal::pac());
     }
-    // Initialize OSTIMER for async timing
-    unsafe {
-        common::init_ostimer0(hal::pac());
-    }
 
     // Initialize embassy-time global driver backed by OSTIMER0
     hal::ostimer::time_driver::init(hal::config::Config::default().time_interrupt_priority, 1_000_000);
diff --git a/examples/hello.rs b/examples/hello.rs
index e39adaced..dbb53fdcf 100644
--- a/examples/hello.rs
+++ b/examples/hello.rs
@@ -2,15 +2,14 @@
 #![no_main]
 
 use embassy_executor::Spawner;
-use embassy_mcxa276 as hal;
-use hal::uart;
+use embassy_mcxa276::{self as hal, lpuart::{Blocking, Config, Lpuart}};
 
 mod common;
 
 use {defmt_rtt as _, panic_probe as _};
 
 /// Simple helper to write a byte as hex to UART
-fn write_hex_byte(uart: &hal::uart::Uart<hal::uart::Lpuart2>, byte: u8) {
+fn write_hex_byte(uart: &mut Lpuart<'_, Blocking>, byte: u8) {
     const HEX_DIGITS: &[u8] = b"0123456789ABCDEF";
     uart.write_byte(HEX_DIGITS[(byte >> 4) as usize]);
     uart.write_byte(HEX_DIGITS[(byte & 0xF) as usize]);
@@ -22,15 +21,25 @@ async fn main(_spawner: Spawner) {
 
     defmt::info!("boot");
 
-    // Board-level init for UART2 clocks and pins.
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
         common::init_uart2(hal::pac());
     }
-
-    // Get UART source frequency from clock configuration
-    // Using hardcoded frequency for now - dynamic detection may have issues
-    let src = 12_000_000; // FRO_LF_DIV at 12MHz with DIV=0
-    let uart = uart::Uart::<uart::Lpuart2>::new(p.LPUART2, uart::Config::new(src));
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
     // Print welcome message before any async delays to guarantee early console output
     uart.write_str_blocking("\r\n=== MCXA276 UART Echo Demo ===\r\n");
@@ -69,12 +78,12 @@ async fn main(_spawner: Spawner) {
                     let num_str = &command[4..];
                     if let Ok(num) = parse_u8(num_str) {
                         uart.write_str_blocking("Hex: 0x");
-                        write_hex_byte(&uart, num);
+                        write_hex_byte(&mut uart, num);
                         uart.write_str_blocking("\r\n");
                     } else {
                         uart.write_str_blocking("Invalid number for hex command\r\n");
                     }
-                } else if command.len() > 0 {
+                } else if !command.is_empty() {
                     uart.write_str_blocking("Unknown command: ");
                     uart.write_str_blocking(core::str::from_utf8(command).unwrap_or(""));
                     uart.write_str_blocking("\r\n");
@@ -103,7 +112,7 @@ async fn main(_spawner: Spawner) {
 fn parse_u8(bytes: &[u8]) -> Result<u8, ()> {
     let mut result = 0u8;
     for &b in bytes {
-        if b >= b'0' && b <= b'9' {
+        if b.is_ascii_digit() {
             result = result.checked_mul(10).ok_or(())?;
             result = result.checked_add(b - b'0').ok_or(())?;
         } else {
diff --git a/examples/lpuart_buffered.rs b/examples/lpuart_buffered.rs
index 6ae690c56..9e297ca67 100644
--- a/examples/lpuart_buffered.rs
+++ b/examples/lpuart_buffered.rs
@@ -22,7 +22,7 @@ unsafe extern "C" fn lpuart2_handler() {
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let _p = hal::init(hal::config::Config::default());
+    let p = hal::init(hal::config::Config::default());
 
     unsafe {
         hal::interrupt::install_irq_handler(mcxa_pac::Interrupt::LPUART2, lpuart2_handler);
@@ -33,7 +33,6 @@ async fn main(_spawner: Spawner) {
 
     unsafe {
         common::init_uart2(hal::pac());
-        common::init_ostimer0(hal::pac());
     }
 
     // UART configuration (enable both TX and RX)
@@ -51,9 +50,9 @@ async fn main(_spawner: Spawner) {
 
     // Create a buffered LPUART2 instance with both TX and RX
     let mut uart = BufferedLpuart::new(
-        p2.LPUART2,
-        p2.PIO2_2, // TX pin
-        p2.PIO2_3, // RX pin
+        p.LPUART2,
+        p.PIO2_2, // TX pin
+        p.PIO2_3, // RX pin
         Irqs,
         &mut tx_buf,
         &mut rx_buf,
diff --git a/examples/lpuart_polling.rs b/examples/lpuart_polling.rs
index 067c7eb53..c9630dca5 100644
--- a/examples/lpuart_polling.rs
+++ b/examples/lpuart_polling.rs
@@ -4,14 +4,13 @@
 use embassy_executor::Spawner;
 use {defmt_rtt as _, embassy_mcxa276 as hal, panic_probe as _};
 
-use crate::hal::lpuart::{lib, Config, Lpuart};
+use crate::hal::lpuart::{Config, Lpuart};
 
 mod common;
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let _p = hal::init(hal::config::Config::default());
-    let p2 = lib::init();
+    let p = hal::init(hal::config::Config::default());
 
     defmt::info!("boot");
 
@@ -30,9 +29,9 @@ async fn main(_spawner: Spawner) {
 
     // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     let lpuart = Lpuart::new_blocking(
-        p2.LPUART2, // Peripheral
-        p2.PIO2_2,  // TX pin
-        p2.PIO2_3,  // RX pin
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
         config,
     )
     .unwrap();
diff --git a/examples/ostimer_alarm.rs b/examples/ostimer_alarm.rs
index 4f29a2c7c..f3a84d312 100644
--- a/examples/ostimer_alarm.rs
+++ b/examples/ostimer_alarm.rs
@@ -4,12 +4,15 @@
 use core::sync::atomic::{AtomicBool, Ordering};
 
 use embassy_executor::Spawner;
-use hal::uart;
-use {cortex_m, embassy_mcxa276 as hal};
+use embassy_mcxa276 as hal;
 
 mod common;
 
-use embassy_mcxa276::{bind_interrupts, clocks::{periph_helpers::OstimerClockSel, PoweredClock}};
+use embassy_mcxa276::{
+    bind_interrupts,
+    clocks::{periph_helpers::OstimerClockSel, PoweredClock},
+    lpuart::{Config, Lpuart},
+};
 use {defmt_rtt as _, panic_probe as _};
 
 // Bind only OS_EVENT, and retain the symbol explicitly so it can't be GC'ed.
@@ -33,15 +36,26 @@ fn alarm_callback() {
 async fn main(_spawner: Spawner) {
     let p = hal::init(hal::config::Config::default());
 
-    // Enable/clock OSTIMER0 and UART2 before touching their registers
-    unsafe {
-        common::init_ostimer0(hal::pac());
-    }
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
         common::init_uart2(hal::pac());
     }
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let uart = uart::Uart::<uart::Lpuart2>::new(p.LPUART2, uart::Config::new(src));
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
+
     uart.write_str_blocking("OSTIMER Alarm Example\n");
 
     // Initialize embassy-time global driver backed by OSTIMER0
diff --git a/examples/ostimer_async.rs b/examples/ostimer_async.rs
index 27e14e022..2642a633d 100644
--- a/examples/ostimer_async.rs
+++ b/examples/ostimer_async.rs
@@ -2,8 +2,7 @@
 #![no_main]
 
 use embassy_executor::Spawner;
-use embassy_mcxa276 as hal;
-use hal::uart;
+use embassy_mcxa276::{self as hal, lpuart::{Config, Lpuart}};
 
 mod common;
 
@@ -22,18 +21,28 @@ static KEEP_OS_EVENT: unsafe extern "C" fn() = OS_EVENT;
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let _p = hal::init(hal::config::Config::default());
+    let p = hal::init(hal::config::Config::default());
 
-    // Enable/clock OSTIMER0 and UART2 before touching their registers
-    unsafe {
-        common::init_ostimer0(hal::pac());
-    }
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
         common::init_uart2(hal::pac());
     }
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let uart = uart::Uart::<uart::Lpuart2>::new(_p.LPUART2, uart::Config::new(src));
-    uart.write_str_blocking("boot\n");
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
+    uart.blocking_write(b"boot\n").unwrap();
 
     // Avoid mass NVIC writes here; DefaultHandler now safely returns.
 
diff --git a/examples/ostimer_counter.rs b/examples/ostimer_counter.rs
index 069e879d8..590c5a14b 100644
--- a/examples/ostimer_counter.rs
+++ b/examples/ostimer_counter.rs
@@ -7,7 +7,10 @@
 #![no_main]
 
 use embassy_executor::Spawner;
-use embassy_mcxa276::clocks::{periph_helpers::OstimerClockSel, PoweredClock};
+use embassy_mcxa276::{
+    clocks::{periph_helpers::OstimerClockSel, PoweredClock},
+    lpuart::{Blocking, Config, Lpuart},
+};
 use embassy_time::{Duration, Timer};
 use hal::bind_interrupts;
 use {defmt_rtt as _, embassy_mcxa276 as hal, panic_probe as _};
@@ -22,12 +25,25 @@ bind_interrupts!(struct Irqs {
 async fn main(_spawner: Spawner) {
     let p = hal::init(Default::default());
 
-    // Enable/clock OSTIMER0 and UART2 before touching their registers
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
         common::init_uart2(hal::pac());
     }
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let mut uart = hal::uart::Uart::<hal::uart::Lpuart2>::new(p.LPUART2, hal::uart::Config::new(src));
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
     uart.write_str_blocking("OSTIMER Counter Reading and Reset Example\n");
 
@@ -90,7 +106,7 @@ async fn main(_spawner: Spawner) {
 }
 
 // Helper function to write a u64 value as decimal string
-fn write_u64(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u64) {
+fn write_u64(uart: &mut Lpuart<'_, Blocking>, value: u64) {
     if value == 0 {
         uart.write_str_blocking("0");
         return;
diff --git a/examples/ostimer_race_test.rs b/examples/ostimer_race_test.rs
index 6e3d4ac21..131d10f64 100644
--- a/examples/ostimer_race_test.rs
+++ b/examples/ostimer_race_test.rs
@@ -12,7 +12,10 @@
 use core::sync::atomic::{AtomicU32, Ordering};
 
 use embassy_executor::Spawner;
-use embassy_mcxa276::clocks::{periph_helpers::OstimerClockSel, PoweredClock};
+use embassy_mcxa276::{
+    clocks::{periph_helpers::OstimerClockSel, PoweredClock},
+    lpuart::{Blocking, Config, Lpuart},
+};
 use embassy_time::{Duration, Timer};
 use hal::bind_interrupts;
 use {defmt_rtt as _, embassy_mcxa276 as hal, panic_probe as _};
@@ -43,7 +46,7 @@ fn alarm_callback() {
     }
 }
 
-fn report_default_handler(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>) {
+fn report_default_handler(uart: &mut Lpuart<'_, Blocking>) {
     let snapshot = hal::interrupt::default_handler_snapshot();
     if snapshot.count == 0 {
         return;
@@ -72,15 +75,25 @@ fn report_default_handler(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>) {
 async fn main(_spawner: Spawner) {
     let p = hal::init(Default::default());
 
-    // Enable/clock OSTIMER0 and UART2 before touching their registers
-    unsafe {
-        common::init_ostimer0(hal::pac());
-    }
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
         common::init_uart2(hal::pac());
     }
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let mut uart = hal::uart::Uart::<hal::uart::Lpuart2>::new(p.LPUART2, hal::uart::Config::new(src));
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
     uart.write_str_blocking("OSTIMER Race Condition Test Starting...\n");
 
@@ -140,7 +153,7 @@ async fn main(_spawner: Spawner) {
 // Test rapid alarm scheduling to stress interrupt handling
 async fn test_rapid_alarms(
     ostimer: &hal::ostimer::Ostimer<'_, hal::ostimer::Ostimer0>,
-    uart: &mut hal::uart::Uart<hal::uart::Lpuart2>,
+    uart: &mut Lpuart<'_, Blocking>,
 ) {
     let initial_count = ALARM_CALLBACK_COUNT.load(Ordering::SeqCst);
 
@@ -177,7 +190,7 @@ async fn test_rapid_alarms(
 // Test reading counter while interrupts are firing
 async fn test_counter_reading_during_interrupts(
     ostimer: &hal::ostimer::Ostimer<'_, hal::ostimer::Ostimer0>,
-    uart: &mut hal::uart::Uart<hal::uart::Lpuart2>,
+    uart: &mut Lpuart<'_, Blocking>,
 ) {
     let initial_interrupt_count = INTERRUPT_COUNT.load(Ordering::SeqCst);
 
@@ -238,7 +251,7 @@ async fn test_counter_reading_during_interrupts(
 // Test concurrent timer operations (embassy-time + alarms)
 async fn test_concurrent_operations(
     ostimer: &hal::ostimer::Ostimer<'_, hal::ostimer::Ostimer0>,
-    uart: &mut hal::uart::Uart<hal::uart::Lpuart2>,
+    uart: &mut Lpuart<'_, Blocking>,
 ) {
     let initial_interrupt_count = INTERRUPT_COUNT.load(Ordering::SeqCst);
 
@@ -267,7 +280,7 @@ async fn test_concurrent_operations(
 // Test timer reset during active operations
 async fn test_reset_during_operation(
     ostimer: &hal::ostimer::Ostimer<'_, hal::ostimer::Ostimer0>,
-    uart: &mut hal::uart::Uart<hal::uart::Lpuart2>,
+    uart: &mut Lpuart<'_, Blocking>,
     peripherals: &mcxa_pac::Peripherals,
 ) {
     let initial_counter = ostimer.now();
@@ -308,7 +321,7 @@ async fn test_reset_during_operation(
 }
 
 // Helper function to write a u32 value as decimal string
-fn write_u32(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u32) {
+fn write_u32(uart: &mut Lpuart<'_, Blocking>, value: u32) {
     if value == 0 {
         uart.write_str_blocking("0");
         return;
@@ -343,7 +356,7 @@ fn write_u32(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u32) {
     }
 }
 
-fn write_hex32(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u32) {
+fn write_hex32(uart: &mut Lpuart<'_, Blocking>, value: u32) {
     let mut buf = [b'0'; 8];
     let mut tmp = value;
     for i in (0..8).rev() {
@@ -355,15 +368,13 @@ fn write_hex32(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u32) {
         };
         tmp >>= 4;
     }
-    for b in &buf {
-        uart.write_byte(*b);
-    }
+    uart.blocking_write(&buf).unwrap();
 }
 
 // Helper function to write a u64 value as decimal string
-fn write_u64(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u64) {
+fn write_u64(uart: &mut Lpuart<'_, Blocking>, value: u64) {
     if value == 0 {
-        uart.write_str_blocking("0");
+        uart.blocking_write(b"0").unwrap();
         return;
     }
 
@@ -381,17 +392,17 @@ fn write_u64(uart: &mut hal::uart::Uart<hal::uart::Lpuart2>, value: u64) {
     while i > 0 {
         i -= 1;
         match buffer[i] {
-            b'0' => uart.write_str_blocking("0"),
-            b'1' => uart.write_str_blocking("1"),
-            b'2' => uart.write_str_blocking("2"),
-            b'3' => uart.write_str_blocking("3"),
-            b'4' => uart.write_str_blocking("4"),
-            b'5' => uart.write_str_blocking("5"),
-            b'6' => uart.write_str_blocking("6"),
-            b'7' => uart.write_str_blocking("7"),
-            b'8' => uart.write_str_blocking("8"),
-            b'9' => uart.write_str_blocking("9"),
-            _ => uart.write_str_blocking("?"),
+            b'0' => uart.blocking_write(b"0").unwrap(),
+            b'1' => uart.blocking_write(b"1").unwrap(),
+            b'2' => uart.blocking_write(b"2").unwrap(),
+            b'3' => uart.blocking_write(b"3").unwrap(),
+            b'4' => uart.blocking_write(b"4").unwrap(),
+            b'5' => uart.blocking_write(b"5").unwrap(),
+            b'6' => uart.blocking_write(b"6").unwrap(),
+            b'7' => uart.blocking_write(b"7").unwrap(),
+            b'8' => uart.blocking_write(b"8").unwrap(),
+            b'9' => uart.blocking_write(b"9").unwrap(),
+            _ => uart.blocking_write(b"?").unwrap(),
         }
     }
 }
diff --git a/examples/rtc_alarm.rs b/examples/rtc_alarm.rs
index c27fd4c55..1cda37054 100644
--- a/examples/rtc_alarm.rs
+++ b/examples/rtc_alarm.rs
@@ -2,13 +2,14 @@
 #![no_main]
 
 use embassy_executor::Spawner;
+use embassy_mcxa276::lpuart::{Config, Lpuart};
 use hal::rtc::{RtcDateTime, RtcInterruptEnable};
-use hal::{uart, InterruptExt};
-use {cortex_m, embassy_mcxa276 as hal};
+use hal::InterruptExt;
+use {embassy_mcxa276 as hal};
 
 mod common;
 
-type MyRtc = hal::rtc::Rtc<hal::rtc::Rtc0>;
+type MyRtc = hal::rtc::Rtc<'static, hal::rtc::Rtc0>;
 
 use embassy_mcxa276::bind_interrupts;
 use {defmt_rtt as _, panic_probe as _};
@@ -25,17 +26,28 @@ static KEEP_RTC: unsafe extern "C" fn() = RTC;
 async fn main(_spawner: Spawner) {
     let p = hal::init(hal::config::Config::default());
 
+    // Create UART configuration
+    let config = Config {
+        baudrate_bps: 115_200,
+        enable_tx: true,
+        enable_rx: true,
+        ..Default::default()
+    };
+
+    // Create UART instance using LPUART2 with PIO2_2 as TX and PIO2_3 as RX
     unsafe {
         common::init_uart2(hal::pac());
     }
-
-    let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-    let uart = uart::Uart::<uart::Lpuart2>::new(p.LPUART2, uart::Config::new(src));
+    let mut uart = Lpuart::new_blocking(
+        p.LPUART2, // Peripheral
+        p.PIO2_2,  // TX pin
+        p.PIO2_3,  // RX pin
+        config,
+    )
+    .unwrap();
 
     uart.write_str_blocking("\r\n=== RTC Alarm Example ===\r\n");
 
-    unsafe { hal::clocks::init_fro16k(hal::pac()) };
-
     let rtc_config = hal::rtc::get_default_config();
 
     let rtc = MyRtc::new(p.RTC0, rtc_config);
diff --git a/examples/uart_interrupt.rs b/examples/uart_interrupt.rs
deleted file mode 100644
index 190a4d850..000000000
--- a/examples/uart_interrupt.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-#![no_std]
-#![no_main]
-
-use embassy_executor::Spawner;
-// use embassy_mcxa276 as hal;
-// use hal::interrupt::typelevel::Handler;
-// use hal::uart;
-
-// mod common;
-
-// use embassy_mcxa276::bind_interrupts;
-// use {defmt_rtt as _, panic_probe as _};
-
-// // Bind LPUART2 interrupt to our handler
-// bind_interrupts!(struct Irqs {
-//     LPUART2 => hal::uart::UartInterruptHandler;
-// });
-
-// #[used]
-// #[no_mangle]
-// static KEEP_LPUART2: unsafe extern "C" fn() = LPUART2;
-
-// // Wrapper function for the interrupt handler
-// unsafe extern "C" fn lpuart2_handler() {
-//     hal::uart::UartInterruptHandler::on_interrupt();
-// }
-
-#[embassy_executor::main]
-async fn main(_spawner: Spawner) {
-//     let _p = hal::init(hal::config::Config::default());
-
-//     // Enable/clock UART2 before touching its registers
-//     unsafe {
-//         common::init_uart2(hal::pac());
-//     }
-//     let src = unsafe { hal::clocks::uart2_src_hz(hal::pac()) };
-//     let uart = uart::Uart::<uart::Lpuart2>::new(_p.LPUART2, uart::Config::new(src));
-
-//     // Configure LPUART2 interrupt for UART operation BEFORE any UART usage
-//     hal::interrupt::LPUART2.configure_for_uart(hal::interrupt::Priority::from(3));
-
-//     // Manually install the interrupt handler and enable RX IRQs in the peripheral
-//     unsafe {
-//         hal::interrupt::LPUART2.install_handler(lpuart2_handler);
-//         // Enable RX interrupts so the handler actually fires on incoming bytes
-//         uart.enable_rx_interrupts();
-//     }
-
-//     // Print welcome message
-//     uart.write_str_blocking("UART interrupt echo demo starting...\r\n");
-//     uart.write_str_blocking("Type characters to echo them back.\r\n");
-
-//     // Log using defmt if enabled
-//     defmt::info!("UART interrupt echo demo starting...");
-
-//     loop {
-//         // Check if we have received any data
-//         if uart.rx_data_available() {
-//             if let Some(byte) = uart.try_read_byte() {
-//                 // Echo it back
-//                 uart.write_byte(byte);
-//                 uart.write_str_blocking(" (received)\r\n");
-//             }
-//         } else {
-//             // No data available, wait a bit before checking again
-//             cortex_m::asm::delay(12_000_000); // ~1 second at 12MHz
-//         }
-//     }
-}