refactored handlers into modules

inside/.gitignore

@@ -1 +1,3 @@
-target
+debug/
+target/
+**/*.rs.bk

inside/src/main.rs

@@ -85,7 +85,7 @@ async fn main(spawner: Spawner) {
     c.divider = 40.into();
     c.top = 62_500; // 20ms
     c.compare_b = 4687; // 1.5ms
-    let mut pwm = Pwm::new_output_b(p.PWM_SLICE0, p.PIN_1, c.clone());
+    let mut pwm = Pwm::new_output_b(p.PWM_SLICE1, p.PIN_3, c.clone());
     
     let fw = include_bytes!("../../cyw43-firmware/43439A0.bin");
     let clm = include_bytes!("../../cyw43-firmware/43439A0_clm.bin");
@@ -171,7 +171,6 @@ async fn main(spawner: Spawner) {
             
 
             info!("rxd {}", from_utf8(&buf[..n]).unwrap());
-            Timer::after_millis(30).await;
 
             let mut segs = buf[..n].trim_ascii().split(|c| *c == ' ' as u8);
 

outside/Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "aead"
@@ -126,6 +126,12 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
 
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
 [[package]]
 name = "base64"
 version = "0.21.7"
@@ -254,6 +260,12 @@ dependencies = [
  "unicode-width",
 ]
 
+[[package]]
+name = "const-default"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b396d1f76d455557e1218ec8066ae14bba60b4b36ecd55577ba979f5db7ecaa"
+
 [[package]]
 name = "const-oid"
 version = "0.9.6"
@@ -801,6 +813,18 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "embedded-alloc"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f2de9133f68db0d4627ad69db767726c99ff8585272716708227008d3f1bddd"
+dependencies = [
+ "const-default",
+ "critical-section",
+ "linked_list_allocator",
+ "rlsf",
+]
+
 [[package]]
 name = "embedded-graphics"
 version = "0.7.1"
@@ -1372,6 +1396,12 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itoa"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
+
 [[package]]
 name = "lalrpop"
 version = "0.19.12"
@@ -1419,6 +1449,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "linked_list_allocator"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afa463f5405ee81cdb9cc2baf37e08ec7e4c8209442b5d72c04cfb2cd6e6286"
+
 [[package]]
 name = "litrs"
 version = "0.4.1"
@@ -1561,6 +1597,7 @@ dependencies = [
  "embassy-time",
  "embassy-usb",
  "embassy-usb-logger",
+ "embedded-alloc",
  "embedded-graphics",
  "embedded-hal 1.0.0",
  "embedded-hal-async",
@@ -1572,6 +1609,7 @@ dependencies = [
  "fixed-macro",
  "heapless 0.8.0",
  "hex",
+ "itoa",
  "log",
  "panic-probe",
  "pio",
@@ -1584,6 +1622,7 @@ dependencies = [
  "smart-leds",
  "st7789",
  "static_cell",
+ "talc",
  "usbd-hid",
 ]
 
@@ -1880,7 +1919,7 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66584b58c3b0cd8cfea750408a932fe86df79ee05ccc87ee745a8e6be4a1abe0"
 dependencies = [
- "base64",
+ "base64 0.21.7",
  "buffered-io",
  "defmt",
  "embedded-io",
@@ -1904,6 +1943,18 @@ dependencies = [
  "bytemuck",
 ]
 
+[[package]]
+name = "rlsf"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "222fb240c3286247ecdee6fa5341e7cdad0ffdf8e7e401d9937f2d58482a20bf"
+dependencies = [
+ "cfg-if",
+ "const-default",
+ "libc",
+ "svgbobdoc",
+]
+
 [[package]]
 name = "rp-pac"
 version = "6.0.0"
@@ -2155,6 +2206,19 @@ version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
+[[package]]
+name = "svgbobdoc"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2c04b93fc15d79b39c63218f15e3fdffaa4c227830686e3b7c5f41244eb3e50"
+dependencies = [
+ "base64 0.13.1",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "unicode-width",
+]
+
 [[package]]
 name = "syn"
 version = "1.0.109"
@@ -2177,6 +2241,15 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "talc"
+version = "4.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fcad3be1cfe36eb7d716a04791eba36a197da9d9b6ea1e28e64ac569da3701d"
+dependencies = [
+ "lock_api",
+]
+
 [[package]]
 name = "term"
 version = "0.7.0"

outside/Cargo.toml

@@ -60,6 +60,9 @@ embedded-sdmmc = "0.7.0"
 
 bt-hci = { version = "0.1.0", default-features = false, features = ["defmt"] }
 hex = { version = "0.4.3", default-features=false}
+itoa = "1.0.14"
+embedded-alloc = "0.6.0"
+talc = "4.4.2"
 
 [profile.release]
 debug = 2

outside/src/auth.rs

@@ -0,0 +1,64 @@
+
+use super::MUSIC;
+
+use embassy_net::{IpEndpoint, Ipv4Address};
+use embassy_time::Duration;
+
+use embassy_net::tcp::TcpSocket;
+
+use embassy_rp::clocks::RoscRng;
+
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+
+use embassy_sync::channel::Receiver;
+use embedded_io_async::Write;
+use log::*;
+use rand::RngCore;
+
+#[embassy_executor::task]
+pub(crate) async fn send_badge(channel: Receiver<'static,CriticalSectionRawMutex,u64,1>,stack: embassy_net::Stack<'static>) -> ! {
+    let mut rx_buffer = [0; 4096];
+    let mut tx_buffer = [0; 4096];
+    loop {
+        let card = channel.receive().await;
+
+        let mut rng = RoscRng;
+        let num = (RoscRng::next_u32(&mut rng) % 5) + 1;
+        let name = match card {
+            0x2c55dc3f5 => "evan",
+            0x3161dc3f7 => "andy",
+            _ => "d",
+        };
+
+        let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
+        socket.set_timeout(Some(Duration::from_secs(10)));
+        info!("attempting conn to inside");
+        if let Err(e) = socket.connect(IpEndpoint::new(Ipv4Address::new(169, 254, 1, 1).into_address(), 1234)).await {
+            warn!("connect error: {:?}", e);
+            continue;
+        }
+
+        info!("Connected to {:?}", socket.remote_endpoint());
+
+        let mut data: [u8;18] = [b'0';18];
+        data[0] = b'B';
+        data[1] = b' ';
+        hex::encode_to_slice(&card.to_ne_bytes(), &mut data[2..]).unwrap();
+
+        let to_print = unsafe { core::str::from_utf8_unchecked(&data) };
+        info!("data: {to_print}");
+
+        //socket.write_all(b"O \r\n").await.unwrap();
+
+        socket.write_all(&data).await.unwrap();
+        info!("wrote to {:?}", socket.remote_endpoint());
+
+        socket.flush().await.unwrap();
+
+        socket.close();
+        info!("disconnected");
+
+        MUSIC.send(("a",num as u8)).await;
+        MUSIC.send((name,num as u8)).await;
+    }
+}

outside/src/main.rs

@@ -10,10 +10,12 @@ use core::borrow::BorrowMut;
 use core::cell::RefCell;
 use core::fmt::Formatter;
 use core::marker::PhantomData;
+use core::mem::MaybeUninit;
 use core::panic::PanicInfo;
 use core::str::from_utf8;
 use core::sync::atomic::{AtomicU8};
 
+use auth::send_badge;
 use bt_hci::cmd::info;
 use critical_section::Mutex;
 use cyw43::JoinOptions;
@@ -22,9 +24,10 @@ use embassy_futures::join::join;
 use embassy_futures::yield_now;
 use embassy_rp::interrupt::typelevel::{Handler, Interrupt, IO_IRQ_BANK0};
 use embassy_rp::multicore::{spawn_core1, Stack};
-use embassy_rp::pwm::{self, Pwm};
+use embassy_rp::pwm::{self};
+use embassy_rp::uart::{BufferedInterruptHandler};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use embassy_sync::channel::Channel;
+use embassy_sync::channel::{Channel};
 use fixed::FixedU16;
 use log::*;
 //use embassy_rp::i2c::InterruptHandler;
@@ -34,19 +37,28 @@ use embassy_net::{Config, IpEndpoint, Ipv4Address, StackResources};
 use embassy_rp::{bind_interrupts, interrupt};
 use embassy_rp::clocks::RoscRng;
 use embassy_rp::gpio::{AnyPin, Input, InterruptTrigger, Level, Output};
-use embassy_rp::peripherals::{DMA_CH0, PIN_21, PIO0, USB};
+use embassy_rp::peripherals::{DMA_CH0, PIN_22, PIO0, UART1, USB};
 use embassy_rp::pio::{InterruptHandler, Pio};
 use embassy_rp::usb::Driver;
-use embassy_time::{Duration, Timer};
-use embedded_io_async::Write;
+use embassy_time::{Timer};
+use embedded_io_async::{Read, ReadReady, Write};
+use music::music_manager;
 use rand::RngCore;
 use reqwless::response;
+use scanner::{data_extractor, spawn_poller};
 use static_cell::StaticCell;
 use defmt_rtt as _;
+use wiggle::wiggle_manager;
+
+mod wiggle;
+mod music;
+mod scanner;
+mod auth;
 
 bind_interrupts!(struct Irqs {
     PIO0_IRQ_0 => InterruptHandler<PIO0>;
     USBCTRL_IRQ => embassy_rp::usb::InterruptHandler<USB>;
+    UART1_IRQ => BufferedInterruptHandler<UART1>;
     
 });
 
@@ -55,6 +67,8 @@ 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]
 async fn logger_task(driver: Driver<'static, USB>) {
@@ -72,29 +86,6 @@ async fn net_task(mut runner: embassy_net::Runner<'static, cyw43::NetDriver<'sta
 }
 
 
-
-#[embassy_executor::task]
-async fn data_extractor() -> ! {
-    let mut last_bit = 0;
-    loop {
-        Timer::after_millis(75).await;
-        let card = critical_section::with(|cs| {
-            READ_CARD.borrow(cs).clone().into_inner()
-        });
-        let bit = BIT.load(core::sync::atomic::Ordering::SeqCst);
-        if bit == last_bit {
-            if card !=0 {
-                info!("read a card: {card:#16x}");
-                CHANNEL.send(card).await;
-            }
-            critical_section::with(|cs| {
-                READ_CARD.replace(cs, 0);
-            });
-        }
-        last_bit = bit;
-    }
-}
-
 #[panic_handler]
 fn panic( info: &PanicInfo) -> ! {
     error!("{}", info);
@@ -104,8 +95,6 @@ fn panic( info: &PanicInfo) -> ! {
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
-    let data_0= Input::new(p.PIN_21, embassy_rp::gpio::Pull::None);
-    let data_1= Input::new(p.PIN_16, embassy_rp::gpio::Pull::None);
 
     let mut rng = RoscRng;
 
@@ -166,74 +155,21 @@ async fn main(spawner: Spawner) {
         }
     }
 
-    //control.start_ap_open("door409", 5).await;
-    //control.start_ap_wpa2("door409-outside", "outerbabes", 5).await;
-
-    let mut rx_buffer = [0; 4096];
-    let mut tx_buffer = [0; 4096];
-    let mut buf = [0; 4096];
-
+    spawner.spawn(music_manager(p.UART1, Irqs, p.PIN_20, p.PIN_21)).unwrap();
     spawner.spawn(data_extractor()).unwrap();
+    spawn_poller(p.CORE1, p.PIN_17, p.PIN_16);
+    spawner.spawn(send_badge(CHANNEL.receiver(),stack)).unwrap();
+    spawner.spawn(button_manager(p.PIN_22)).unwrap();
+    spawner.spawn(wiggle_manager(p.PWM_SLICE5, p.PIN_26, p.PIN_27)).unwrap();
 
-    let mut partial: u64 = 0;
-    let mut bit: u8 = 0;
-    let mut prev: (bool,bool) = (false,false);
-
-    static mut CORE1_STACK: Stack<4096> = Stack::new();
-    spawn_core1(p.CORE1, unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) }, move || {
-        loop {
-            let current = (data_0.is_low(), data_1.is_low());
-            if current.1 && !prev.1 {
-                partial |= 1 << bit;
-                bit += 1;
-            }
-            if current.0 && !prev.0 {
-                partial &= !(1u64).rotate_left(bit as u32);
-                bit += 1;
-            }
-            prev=current;
-
-            critical_section::with(|cs| {
-                let mut foreign_partial = READ_CARD.borrow_ref_mut(cs);
-
-                // may or may not be sound, should work fine given no noise on the signal
-                if *foreign_partial != partial && !current.0 && !current.1 {
-                    bit = 0;
-                    partial = *foreign_partial;
-                }
-
-                *foreign_partial = partial;
-            });
-
-            BIT.store(bit, core::sync::atomic::Ordering::SeqCst);
-        }
-    });
-
+}
 
+#[embassy_executor::task]
+async fn button_manager(pin: PIN_22) -> ! {
+    let mut button = Input::new(pin, embassy_rp::gpio::Pull::Up);
     loop {
-        let card = CHANNEL.receive().await;
-
-        let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-        socket.set_timeout(Some(Duration::from_secs(10)));
-        info!("attempting conn to inside");
-        control.gpio_set(0, false).await;
-        if let Err(e) = socket.connect(IpEndpoint::new(Ipv4Address::new(169, 254, 1, 1).into_address(), 1234)).await {
-            warn!("connect error: {:?}", e);
-            continue;
-        }
-
-        info!("Connected to {:?}", socket.remote_endpoint());
-        control.gpio_set(0, true).await;
-
-        let mut data: [u8;18] = [b' ';18];
-        data[0] = b'B';
-        data[1] = b' ';
-        hex::encode_to_slice(&card.to_ne_bytes(), &mut data[2..]).unwrap();
-
-        socket.write_all(&data).await.unwrap();
-        info!("wrote to {:?}", socket.remote_endpoint());
-
-        socket.close();
-        control.gpio_set(0, false).await;
+        button.wait_for_rising_edge().await;
+        MUSIC.send(("d",5)).await;
+        Timer::after_millis(800).await;
     }
 }

outside/src/music.rs

@@ -0,0 +1,81 @@
+use embassy_rp::uart;
+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;
+
+use embassy_rp::peripherals::PIN_20;
+
+use super::Irqs;
+
+use embassy_rp::peripherals::UART1;
+use log::*;
+
+#[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();
+    config.baudrate = 115200;
+    let mut rx = [0; 2048];
+    let mut tx = [0; 2048];
+
+    let mut uart = BufferedUart::new(uart, irqs, txp, rxp, &mut tx, &mut rx, config);
+
+    loop {
+        let song = MUSIC.receive().await;
+        info!("playing: {}{}.mp3",song.0,song.1);
+
+        uart.write_all(b"AT+PLAYFILE=/").await.unwrap();
+        uart.write_all(song.0.as_bytes()).await.unwrap();
+        uart.write_all(itoa::Buffer::new().format(song.1).as_bytes()).await.unwrap();
+        uart.write_all(b".mp3\r\n").await.unwrap();
+
+
+        let mut buffer = [0;512];
+        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);
+                    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;
+        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;
+        }
+    }
+}

outside/src/scanner.rs

@@ -0,0 +1,76 @@
+
+use embassy_rp::gpio::Input;
+use embassy_rp::multicore::spawn_core1;
+use embassy_rp::multicore::Stack;
+use embassy_rp::peripherals::CORE1;
+use embassy_rp::peripherals::PIN_16;
+use embassy_rp::peripherals::PIN_17;
+use embassy_time::Timer;
+use log::info;
+
+use super::CHANNEL;
+
+use super::BIT;
+
+use super::READ_CARD;
+
+#[embassy_executor::task]
+pub(crate) async fn data_extractor() -> ! {
+    let mut last_bit = 0;
+    loop {
+        Timer::after_millis(75).await;
+        let card = critical_section::with(|cs| {
+            READ_CARD.borrow(cs).clone().into_inner()
+        });
+        let bit = BIT.load(core::sync::atomic::Ordering::SeqCst);
+        if bit == last_bit {
+            if card !=0 {
+                info!("read a card: {card:#16x}");
+                CHANNEL.send(card).await;
+            }
+            critical_section::with(|cs| {
+                READ_CARD.replace(cs, 0);
+            });
+        }
+        last_bit = bit;
+    }
+}
+
+pub fn spawn_poller(core: CORE1, data_0: PIN_17, data_1: PIN_16) {
+    let data_0= Input::new(data_0, embassy_rp::gpio::Pull::None);
+    let data_1= Input::new(data_1, embassy_rp::gpio::Pull::None);
+
+    let mut partial: u64 = 0;
+    let mut bit: u8 = 0;
+    let mut prev: (bool,bool) = (false,false);
+
+    static mut CORE1_STACK: Stack<4096> = Stack::new();
+    spawn_core1(core, unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) }, move || {
+        loop {
+            let current = (data_0.is_low(), data_1.is_low());
+            if current.1 && !prev.1 {
+                partial |= 1 << bit;
+                bit += 1;
+            }
+            if current.0 && !prev.0 {
+                partial &= !(1u64).rotate_left(bit as u32);
+                bit += 1;
+            }
+            prev=current;
+
+            critical_section::with(|cs| {
+                let mut foreign_partial = READ_CARD.borrow_ref_mut(cs);
+
+                // may or may not be sound, should work fine given no noise on the signal
+                if *foreign_partial != partial && !current.0 && !current.1 {
+                    bit = 0;
+                    partial = *foreign_partial;
+                }
+
+                *foreign_partial = partial;
+            });
+
+            BIT.store(bit, core::sync::atomic::Ordering::SeqCst);
+        }
+    });
+}

outside/src/wiggle.rs

@@ -0,0 +1,55 @@
+use embassy_rp::clocks::RoscRng;
+
+use embassy_rp::pwm;
+use embassy_time::Timer;
+use rand::RngCore;
+
+use super::WAGS;
+
+use embassy_rp::pwm::Pwm;
+
+use embassy_rp::peripherals::PIN_27;
+
+use embassy_rp::peripherals::PIN_26;
+
+use embassy_rp::peripherals::PWM_SLICE5;
+
+#[embassy_executor::task]
+pub(crate) async fn wiggle_manager(pwm: PWM_SLICE5, head: PIN_26, tail: PIN_27) -> ! {
+    let mut c: pwm::Config = Default::default();
+    c.divider = 40.into();
+    c.top = 62_500; // 20ms
+    c.compare_a = 4687; // 1.5ms
+    c.compare_b = 4687; // 1.5ms
+    let mut pwm = Pwm::new_output_ab(pwm, head, tail, c.clone());
+
+    loop {
+        let mut wags;
+        loop {
+            // atomics aren't actually real
+            wags = WAGS.load(core::sync::atomic::Ordering::SeqCst);
+            if wags != 0 {
+                WAGS.store(0, core::sync::atomic::Ordering::SeqCst);
+                break;
+            }
+
+            c.compare_b = 6248;
+            pwm.set_config(&c);
+
+            Timer::after_millis(50).await;
+        
+        }
+
+        let positions = [6200,4800,6248,4700, 5500];
+
+        let mut rng = RoscRng;
+        for _ in 0..wags {
+
+            let idx = rng.next_u32();
+            c.compare_b = positions[idx as usize % positions.len()];
+            pwm.set_config(&c);
+
+            Timer::after_millis(idx as u64 % 600).await;
+        }
+    }
+}