moved uart to init file, now main is purely about low power modes and sleeps

semestralka_2_uart/src/bin/main.rs

@@ -5,65 +5,17 @@
 use defmt::*;
 use embassy_stm32::pac;
 use embassy_executor::Spawner;
-use embassy_futures::yield_now;
-use embassy_stm32::bind_interrupts;
-use embassy_stm32::peripherals;
 use embassy_stm32::Config;
-use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel};
-use embassy_stm32::usart::{BufferedUart, Config as UsartConfig, BufferedInterruptHandler};
 use embassy_stm32::gpio::{Output, Level, Speed};
 use embassy_time::{Duration, Timer};
 
-use static_cell::StaticCell;
+use dma_gpio::config::BAUD;
-use dma_gpio::config::{
-    BAUD, PIPE_HW_RX, PIPE_HW_TX,
-};
-use dma_gpio::hw_uart_pc::driver::uart_task;
 use dma_gpio::wakeup::iwdg::{clear_wakeup_flags, init_watchdog_reset};
 use dma_gpio::sleep::shutdown;
 use dma_gpio::sleep::standby;
+use dma_gpio::hw_uart_pc::init::{init_hw_uart_to_pc, LowPowerCmd, CMD_CH};
 use {defmt_rtt as _, panic_probe as _};
 
-bind_interrupts!(struct Irqs {
-    USART1 => BufferedInterruptHandler<peripherals::USART1>;
-});
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum LowPowerCmd {
-    Standby8k,     // 1
-    StandbyFull,   // 2
-    Standby,       // 3
-    Shutdown,      // 4
-}
-
-static CMD_CH: Channel<CriticalSectionRawMutex, LowPowerCmd, 1> = Channel::new();
-
-#[embassy_executor::task]
-async fn uart_cmd_task() {
-    // Prompt once
-    let _ = PIPE_HW_TX
-        .write(b"Modes: 1=SB8, 2=SBfull, 3=SB, 4=SD\r\n")
-        .await;
-
-    let mut b = [0u8; 1];
-    loop {
-        let n = PIPE_HW_RX.read(&mut b).await;
-        if n == 0 {
-            continue;
-        }
-        match b[0] {
-            b'1' => { let _ = PIPE_HW_TX.write(b"ACK 1: standby 8KB\r\n").await; CMD_CH.send(LowPowerCmd::Standby8k).await; }
-            b'2' => { let _ = PIPE_HW_TX.write(b"ACK 2: standby full\r\n").await; CMD_CH.send(LowPowerCmd::StandbyFull).await; }
-            b'3' => { let _ = PIPE_HW_TX.write(b"ACK 3: standby\r\n").await; CMD_CH.send(LowPowerCmd::Standby).await; }
-            b'4' => { let _ = PIPE_HW_TX.write(b"ACK 4: shutdown\r\n").await; CMD_CH.send(LowPowerCmd::Shutdown).await; }
-            b'\r' | b'\n' | b' ' => {}
-            _ => { let _ = PIPE_HW_TX.write(b"ERR: use 1|2|3|4\r\n").await; }
-        }
-        yield_now().await;
-    }
-}
-
-
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
     info!("boot");
@@ -77,24 +29,8 @@ async fn main(spawner: Spawner) {
     led.set_high();
     info!("LED ON (MCU awake)");
 
-    // HARDWARE UART to the PC
+    // INIT HW UART
-    let mut cfg = UsartConfig::default();
+    init_hw_uart_to_pc(p.USART1, p.PA10, p.PA9, &spawner);
-    cfg.baudrate = BAUD;
-    static TX_BUF: StaticCell<[u8; 256]> = StaticCell::new();
-    static RX_BUF: StaticCell<[u8; 256]> = StaticCell::new();
-    let uart = BufferedUart::new(
-        p.USART1,
-        p.PA10, // RX pin
-        p.PA9,  // TX pin
-        TX_BUF.init([0; 256]),
-        RX_BUF.init([0; 256]),
-        Irqs,
-        cfg,
-    ).unwrap();
-    // let yield_period = usart1::setup_and_spawn(BAUD);
-    spawner.spawn(uart_task(uart, &PIPE_HW_TX, &PIPE_HW_RX).unwrap());
-    spawner.spawn(uart_cmd_task().unwrap());
-    // END OF HARDWARE UART to the PC
 
     // DEBUG INFO
     let dbg = pac::DBGMCU;

semestralka_2_uart/src/hw_uart_pc/init.rs

@@ -0,0 +1,98 @@
+// src/hw_uart_pc/init.rs
+
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::channel::Channel;
+use embassy_futures::yield_now;
+
+// UART HW init
+use crate::config::{BAUD, PIPE_HW_TX, PIPE_HW_RX};
+use crate::hw_uart_pc::driver::uart_task;
+use static_cell::StaticCell;
+use embassy_stm32::usart::BufferedInterruptHandler;
+use embassy_stm32::usart::{BufferedUart, Config as UsartConfig};
+use embassy_stm32::peripherals;
+use embassy_stm32::bind_interrupts;
+use embassy_executor::Spawner;
+use embassy_hal_internal::Peri;
+use embassy_stm32::peripherals::{USART1, PA9, PA10};
+use defmt::info;
+
+bind_interrupts!(struct Irqs {
+    USART1 => BufferedInterruptHandler<peripherals::USART1>;
+});
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum LowPowerCmd {
+    Standby8k,     // 1
+    StandbyFull,   // 2
+    Standby,       // 3
+    Shutdown,      // 4
+}
+
+pub static CMD_CH: Channel<CriticalSectionRawMutex, LowPowerCmd, 1> = Channel::new();
+
+#[embassy_executor::task]
+pub async fn uart_cmd_task() {
+    // Prompt once
+    let _ = PIPE_HW_TX
+        .write(b"Modes: 1=SB8, 2=SBfull, 3=SB, 4=SD\r\n")
+        .await;
+
+    let mut b = [0u8; 1];
+    loop {
+        let n = PIPE_HW_RX.read(&mut b).await;
+        if n == 0 {
+            continue;
+        }
+        match b[0] {
+            b'1' => {
+                let _ = PIPE_HW_TX.write(b"ACK 1: standby 8KB\r\n").await;
+                CMD_CH.send(LowPowerCmd::Standby8k).await;
+            }
+            b'2' => {
+                let _ = PIPE_HW_TX.write(b"ACK 2: standby full\r\n").await;
+                CMD_CH.send(LowPowerCmd::StandbyFull).await;
+            }
+            b'3' => {
+                let _ = PIPE_HW_TX.write(b"ACK 3: standby\r\n").await;
+                CMD_CH.send(LowPowerCmd::Standby).await;
+            }
+            b'4' => {
+                let _ = PIPE_HW_TX.write(b"ACK 4: shutdown\r\n").await;
+                CMD_CH.send(LowPowerCmd::Shutdown).await;
+            }
+            b'\r' | b'\n' | b' ' => {}
+            _ => { let _ = PIPE_HW_TX.write(b"ERR: use 1|2|3|4\r\n").await; }
+        }
+        yield_now().await;
+    }
+}
+
+pub fn init_hw_uart_to_pc(
+    usart1: Peri<'static, USART1>,
+    pa10: Peri<'static, PA10>,
+    pa9: Peri<'static, PA9>,
+    spawner: &Spawner,
+) {
+    let mut cfg = UsartConfig::default();
+    cfg.baudrate = BAUD;
+
+    static TX_BUF: StaticCell<[u8; 256]> = StaticCell::new();
+    static RX_BUF: StaticCell<[u8; 256]> = StaticCell::new();
+
+    let uart = BufferedUart::new(
+        usart1,
+        pa10, // RX pin
+        pa9,  // TX pin
+        TX_BUF.init([0; 256]),
+        RX_BUF.init([0; 256]),
+        Irqs,
+        cfg,
+    )
+    .unwrap();
+
+    spawner.spawn(uart_task(uart, &PIPE_HW_TX, &PIPE_HW_RX).unwrap());
+    spawner.spawn(uart_cmd_task().unwrap());
+
+    info!("USART1 initialized @ {} bps", BAUD);
+}

semestralka_2_uart/src/hw_uart_pc/mod.rs

@@ -2,3 +2,4 @@
 pub mod driver;
 pub mod usart1;
 pub mod safety;
+pub mod init;