refactor out song playing

outside/src/main.rs

@@ -42,7 +42,7 @@ use embassy_rp::pio::{InterruptHandler, Pio};
 use embassy_rp::usb::Driver;
 use embassy_time::{Timer};
 use embedded_io_async::{Read, ReadReady, Write};
-use music::music_manager;
+use music::{music_manager, MUSIC};
 use rand::RngCore;
 use reqwless::response;
 use scanner::{data_extractor, spawn_poller};
@@ -67,7 +67,6 @@ static READ_CARD: Mutex<RefCell<u64>> =
 static BIT: AtomicU8 = AtomicU8::new(0);
 
 static CHANNEL: Channel<CriticalSectionRawMutex, u64, 1> = Channel::new();
-static MUSIC: Channel<CriticalSectionRawMutex, (&'static str, u8), 3> = Channel::new();
 static WAGS: AtomicU8 = AtomicU8::new(0);
 
 #[embassy_executor::task]

outside/src/music.rs

@@ -1,12 +1,12 @@
 use embassy_rp::uart;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::channel::Channel;
 use embassy_time::Timer;
 use embedded_io_async::Read;
 use embedded_io_async::Write;
 
 use super::WAGS;
 
-use super::MUSIC;
-
 use embassy_rp::uart::BufferedUart;
 
 use embassy_rp::peripherals::PIN_21;
@@ -18,6 +18,34 @@ use super::Irqs;
 use embassy_rp::peripherals::UART1;
 use log::*;
 
+pub static MUSIC: Channel<CriticalSectionRawMutex, (&'static str, u8), 3> = Channel::new();
+pub static COMMANDS: Channel<CriticalSectionRawMutex, (MusicCommand), 3> = Channel::new();
+
+enum Name {
+    Andy,
+    Evan,
+    Felix,
+    Phil,
+    Tess,
+    Amaia,
+    Prueky,
+    David,
+    Nathaniel,
+    Thia,
+    Michael,
+    Zoey,
+    Coke,
+    Unknown,
+}
+
+enum MusicCommand {
+    /// play a random clip for name, accepted if true
+    Introduce(Name, bool), 
+    /// 0-30
+    SetVolume(u8),
+    Play(&'static str),
+}
+
 #[embassy_executor::task]
 pub(crate) async fn music_manager(uart: UART1, irqs: Irqs, txp: PIN_20, rxp: PIN_21) -> ! {
     let mut config = uart::Config::default();
@@ -29,53 +57,49 @@ pub(crate) async fn music_manager(uart: UART1, irqs: Irqs, txp: PIN_20, rxp: PIN
 
     loop {
         let song = MUSIC.receive().await;
-        info!("playing: {}{}.mp3",song.0,song.1);
+        play_song(song.0, Some(song.1), &mut uart).await;
+    }
+}
+
+async fn play_song<'a>(prefix: &str, index: Option<u8>, uart: &mut BufferedUart<'a, UART1>) {
+    info!("playing: {}{}.mp3",prefix,index.unwrap_or(0));
 
     uart.write_all(b"AT+PLAYFILE=/").await.unwrap();
-        uart.write_all(song.0.as_bytes()).await.unwrap();
+    uart.write_all(prefix.as_bytes()).await.unwrap();
-        uart.write_all(itoa::Buffer::new().format(song.1).as_bytes()).await.unwrap();
+    if let Some(index) = index {
+        uart.write_all(itoa::Buffer::new().format(index).as_bytes()).await.unwrap();
+    }
     uart.write_all(b".mp3\r\n").await.unwrap();
 
-
     let mut buffer = [0;512];
-        let mut pos = 0;
+    info!("returned: {}",read_line(&mut buffer, uart).await.trim());
-        loop {
-            if let Ok(len) = uart.read(&mut buffer[pos..]).await {
-                let to_print = unsafe { core::str::from_utf8_unchecked(&buffer[..(pos + len)]) };
 
-                if to_print.contains("\r\n") {
-                    info!("{}", to_print);
-                    break;
-                }
-
-                pos += len;
-            } else {
-                break;
-            }
-        }
     uart.write_all(b"AT+QUERY=4\r\n").await.unwrap();
     let mut buffer = [0;512];
-        let mut pos = 0;
+    let output = read_line(&mut buffer, uart).await;
-        loop {
-            if let Ok(len) = uart.read(&mut buffer[pos..]).await {
-                let to_print = unsafe { core::str::from_utf8_unchecked(&buffer[..(pos + len)]) };
-
-                if to_print.contains("\r\n") {
-                    info!("{}", to_print);
-                    pos += len;
-                    break;
-                }
-
-                pos += len;
-            } else {
-                break;
-            }
-        }
-        let output = unsafe { core::str::from_utf8_unchecked(&buffer[..(pos)]) };
 
     if let Ok(length) = output.trim().parse::<u64>() {
         WAGS.store(length as u8, core::sync::atomic::Ordering::SeqCst);
         Timer::after_secs(length).await;
     }
 }
+
+async fn read_line<'a, 'b>(buffer: &'b mut [u8], uart: &mut BufferedUart<'a, UART1>) -> &'b str {
+    let mut pos = 0;
+    loop {
+        if let Ok(len) = uart.read(&mut buffer[pos..]).await {
+            let to_print = unsafe { core::str::from_utf8_unchecked(&buffer[..(pos + len)]) };
+
+            if to_print.contains("\r\n") {
+                //info!("{}", to_print);
+                pos += len;
+                break;
+            }
+
+            pos += len;
+        } else {
+            break;
+        }
+    }
+    return unsafe { core::str::from_utf8_unchecked(&buffer[..(pos)]) };
 }