Wire up Lpuart pins (#43)

Allow the HAL lpuart driver to correctly configure pins as requested on init.

6 files changed, 27 insertions, 107 deletions

diff --git a/examples/src/bin/adc_interrupt.rs b/examples/src/bin/adc_interrupt.rs
index 0d3a75a28..83d8046b3 100644
--- a/examples/src/bin/adc_interrupt.rs
+++ b/examples/src/bin/adc_interrupt.rs
@@ -6,7 +6,6 @@ use embassy_mcxa_examples::init_adc_pins;
 use hal::adc::{LpadcConfig, TriggerPriorityPolicy};
 use hal::clocks::periph_helpers::{AdcClockSel, Div4};
 use hal::clocks::PoweredClock;
-use hal::lpuart::{Config, Lpuart};
 use hal::pac::adc1::cfg::{Pwrsel, Refsel};
 use hal::pac::adc1::cmdl1::{Adch, Mode};
 use hal::pac::adc1::ctrl::CalAvgs;
@@ -26,26 +25,7 @@ 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 P2_2 as TX and P2_3 as RX
-    unsafe {
-        embassy_mcxa_examples::init_uart2_pins();
-    }
-    let mut uart = Lpuart::new_blocking(
-        p.LPUART2, // Peripheral
-        p.P2_2,    // TX pin
-        p.P2_3,    // RX pin
-        config,
-    )
-    .unwrap();
-    uart.write_str_blocking("\r\n=== ADC interrupt Example ===\r\n");
+    defmt::info!("ADC interrupt Example");
 
     unsafe {
         init_adc_pins();
@@ -81,7 +61,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");
+    defmt::info!("ADC configuration done...");
 
     adc.enable_interrupt(0x1);
 
@@ -98,7 +78,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");
+        defmt::info!("*** ADC interrupt TRIGGERED! ***");
         //TBD need to print the value
     }
 }
diff --git a/examples/src/bin/adc_polling.rs b/examples/src/bin/adc_polling.rs
index 02ac321b5..ddf3f586b 100644
--- a/examples/src/bin/adc_polling.rs
+++ b/examples/src/bin/adc_polling.rs
@@ -1,19 +1,15 @@
 #![no_std]
 #![no_main]
 
-use core::fmt::Write;
-
 use embassy_executor::Spawner;
-use embassy_mcxa_examples::{init_adc_pins, init_uart2_pins};
+use embassy_mcxa_examples::init_adc_pins;
 use hal::adc::{ConvResult, LpadcConfig, TriggerPriorityPolicy};
 use hal::clocks::periph_helpers::{AdcClockSel, Div4};
 use hal::clocks::PoweredClock;
-use hal::lpuart::{Config, Lpuart};
 use hal::pac::adc1::cfg::{Pwrsel, Refsel};
 use hal::pac::adc1::cmdl1::{Adch, Mode};
 use hal::pac::adc1::ctrl::CalAvgs;
 use hal::pac::adc1::tctrl::Tcmd;
-use heapless::String;
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 
 const G_LPADC_RESULT_SHIFT: u32 = 0;
@@ -22,28 +18,11 @@ const G_LPADC_RESULT_SHIFT: u32 = 0;
 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 P2_2 as TX and P2_3 as RX
     unsafe {
-        init_uart2_pins();
         init_adc_pins();
     }
-    let mut uart = Lpuart::new_blocking(
-        p.LPUART2, // Peripheral
-        p.P2_2,    // TX pin
-        p.P2_3,    // RX pin
-        config,
-    )
-    .unwrap();
 
-    uart.write_str_blocking("\r\n=== ADC polling Example ===\r\n");
+    defmt::info!("=== ADC polling Example ===");
 
     let adc_config = LpadcConfig {
         enable_in_doze_mode: true,
@@ -75,7 +54,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");
+    defmt::info!("=== ADC configuration done... ===");
 
     loop {
         adc.do_software_trigger(1);
@@ -84,8 +63,6 @@ async fn main(_spawner: Spawner) {
             result = hal::adc::get_conv_result();
         }
         let value = result.unwrap().conv_value >> G_LPADC_RESULT_SHIFT;
-        let mut buf: String<16> = String::new(); // adjust size as needed
-        write!(buf, "\r\nvalue: {}\r\n", value).unwrap();
-        uart.write_str_blocking(&buf);
+        defmt::info!("value: {=u16}", value);
     }
 }
diff --git a/examples/src/bin/hello.rs b/examples/src/bin/hello.rs
index 0362480c1..f426d1898 100644
--- a/examples/src/bin/hello.rs
+++ b/examples/src/bin/hello.rs
@@ -27,9 +27,6 @@ async fn main(_spawner: Spawner) {
     };
 
     // Create UART instance using LPUART2 with P2_2 as TX and P2_3 as RX
-    unsafe {
-        embassy_mcxa_examples::init_uart2_pins();
-    }
     let mut uart = Lpuart::new_blocking(
         p.LPUART2, // Peripheral
         p.P2_2,    // TX pin
diff --git a/examples/src/bin/lpuart_buffered.rs b/examples/src/bin/lpuart_buffered.rs
index 4c9294f57..7f77d557d 100644
--- a/examples/src/bin/lpuart_buffered.rs
+++ b/examples/src/bin/lpuart_buffered.rs
@@ -2,39 +2,28 @@
 #![no_main]
 
 use embassy_executor::Spawner;
-use embassy_mcxa as hal;
-use embassy_mcxa::interrupt::typelevel::Handler;
+use embassy_mcxa::clocks::config::Div8;
 use embassy_mcxa::lpuart::buffered::BufferedLpuart;
 use embassy_mcxa::lpuart::Config;
 use embassy_mcxa::{bind_interrupts, lpuart};
-use embassy_mcxa_examples::init_uart2_pins;
-use embedded_io_async::{Read, Write};
+use embedded_io_async::Write;
+use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 
 // Bind OS_EVENT for timers plus LPUART2 IRQ for the buffered driver
 bind_interrupts!(struct Irqs {
     LPUART2 => lpuart::buffered::BufferedInterruptHandler::<hal::peripherals::LPUART2>;
 });
 
-// Wrapper function for the interrupt handler
-unsafe extern "C" fn lpuart2_handler() {
-    lpuart::buffered::BufferedInterruptHandler::<hal::peripherals::LPUART2>::on_interrupt();
-}
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = hal::init(hal::config::Config::default());
-
-    unsafe {
-        hal::interrupt::install_irq_handler(hal::pac::Interrupt::LPUART2, lpuart2_handler);
-    }
+    let mut cfg = hal::config::Config::default();
+    cfg.clock_cfg.sirc.fro_12m_enabled = true;
+    cfg.clock_cfg.sirc.fro_lf_div = Some(Div8::no_div());
+    let p = hal::init(cfg);
 
     // Configure NVIC for LPUART2
     hal::interrupt::LPUART2.configure_for_uart(hal::interrupt::Priority::P3);
 
-    unsafe {
-        init_uart2_pins();
-    }
-
     // UART configuration (enable both TX and RX)
     let config = Config {
         baudrate_bps: 115_200,
@@ -69,7 +58,7 @@ async fn main(_spawner: Spawner) {
     // Echo loop
     let mut buf = [0u8; 4];
     loop {
-        rx.read_exact(&mut buf[..]).await.unwrap();
-        tx.write_all(&buf[..]).await.unwrap();
+        let used = rx.read(&mut buf).await.unwrap();
+        tx.write_all(&buf[..used]).await.unwrap();
     }
 }
diff --git a/examples/src/bin/lpuart_polling.rs b/examples/src/bin/lpuart_polling.rs
index c8666e64a..9cea418cc 100644
--- a/examples/src/bin/lpuart_polling.rs
+++ b/examples/src/bin/lpuart_polling.rs
@@ -2,22 +2,20 @@
 #![no_main]
 
 use embassy_executor::Spawner;
-use embassy_mcxa_examples::init_uart2_pins;
+use embassy_mcxa::clocks::config::Div8;
 use {defmt_rtt as _, embassy_mcxa as hal, panic_probe as _};
 
 use crate::hal::lpuart::{Config, Lpuart};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = hal::init(hal::config::Config::default());
+    let mut cfg = hal::config::Config::default();
+    cfg.clock_cfg.sirc.fro_12m_enabled = true;
+    cfg.clock_cfg.sirc.fro_lf_div = Some(Div8::no_div());
+    let p = hal::init(cfg);
 
     defmt::info!("boot");
 
-    // Board-level init for UART2 clocks and pins.
-    unsafe {
-        init_uart2_pins();
-    }
-
     // Create UART configuration
     let config = Config {
         baudrate_bps: 115_200,
diff --git a/examples/src/bin/rtc_alarm.rs b/examples/src/bin/rtc_alarm.rs
index 6f8a77101..a7800a2d1 100644
--- a/examples/src/bin/rtc_alarm.rs
+++ b/examples/src/bin/rtc_alarm.rs
@@ -3,7 +3,6 @@
 
 use embassy_executor::Spawner;
 use embassy_mcxa as hal;
-use hal::lpuart::{Config, Lpuart};
 use hal::rtc::{RtcDateTime, RtcInterruptEnable};
 use hal::InterruptExt;
 
@@ -24,27 +23,7 @@ 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 P2_2 as TX and P2_3 as RX
-    unsafe {
-        embassy_mcxa_examples::init_uart2_pins();
-    }
-    let mut uart = Lpuart::new_blocking(
-        p.LPUART2, // Peripheral
-        p.P2_2,    // TX pin
-        p.P2_3,    // RX pin
-        config,
-    )
-    .unwrap();
-
-    uart.write_str_blocking("\r\n=== RTC Alarm Example ===\r\n");
+    defmt::info!("=== RTC Alarm Example ===");
 
     let rtc_config = hal::rtc::get_default_config();
 
@@ -61,14 +40,14 @@ async fn main(_spawner: Spawner) {
 
     rtc.stop();
 
-    uart.write_str_blocking("Time set to: 2025-10-15 14:30:00\r\n");
+    defmt::info!("Time set to: 2025-10-15 14:30:00");
     rtc.set_datetime(now);
 
     let mut alarm = now;
     alarm.second += 10;
 
     rtc.set_alarm(alarm);
-    uart.write_str_blocking("Alarm set for: 2025-10-15 14:30:10 (+10 seconds)\r\n");
+    defmt::info!("Alarm set for: 2025-10-15 14:30:10 (+10 seconds)");
 
     rtc.set_interrupt(RtcInterruptEnable::RTC_ALARM_INTERRUPT_ENABLE);
 
@@ -82,14 +61,14 @@ async fn main(_spawner: Spawner) {
 
     rtc.start();
 
-    uart.write_str_blocking("RTC started, waiting for alarm...\r\n");
+    defmt::info!("RTC started, waiting for alarm...");
 
     loop {
         if rtc.is_alarm_triggered() {
-            uart.write_str_blocking("\r\n*** ALARM TRIGGERED! ***\r\n");
+            defmt::info!("*** ALARM TRIGGERED! ***");
             break;
         }
     }
 
-    uart.write_str_blocking("Example complete - Test PASSED!\r\n");
+    defmt::info!("Example complete - Test PASSED!");
 }