badge -> sound

inside/Cargo.lock

@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "anyhow"
-version = "1.0.93"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775"
+checksum = "c1fd03a028ef38ba2276dce7e33fcd6369c158a1bca17946c4b1b701891c1ff7"
 
 [[package]]
 name = "autocfg"

inside/src/lib.rs

@@ -0,0 +1,69 @@
+#![no_std]
+#![no_main]
+#![feature(const_trait_impl)]
+
+use core::sync::atomic::AtomicU32;
+
+use blocking_network_stack::Socket;
+use embedded_hal::pwm::SetDutyCycle;
+use embedded_io::Write;
+use esp_hal::{delay::Delay, gpio::GpioPin, ledc::{channel::Channel, LowSpeed}, };
+use esp_println::println;
+use esp_wifi::wifi::{WifiDevice, WifiStaDevice};
+
+
+//pub fn handle<T,U,const V: u8>(slice: &[u8], motor: PwmPin<T,U, V,true>) {
+pub fn handle(slice: &[u8], motor: &mut Channel<LowSpeed, GpioPin<15>>, socket: &mut Socket<WifiDevice<WifiStaDevice>>) {
+    println!("dat: {:?}", slice);
+    let mut command = slice.trim_ascii().split(|c| *c == b' ');
+
+    // hate hate hate
+    static LAST_BADGE_LOW: AtomicU32 = AtomicU32::new(0);
+    static LAST_BADGE_HIG: AtomicU32 = AtomicU32::new(0);
+
+    match char::from_u32(command.next().unwrap()[0] as u32).unwrap() {
+        'D' => {
+            let hex = command.next().unwrap();
+            println!("{hex:#?}");
+            let buf: [u8;2] =  hex::FromHex::from_hex(hex).unwrap();
+            let power: u16 = u16::from_be_bytes(buf);
+            println!("{power}");
+            motor.set_duty_cycle(power).unwrap();
+        },
+        'O' => {
+            open_door(motor);
+        }
+        'B' => {
+            let buf: [u8;8] =  hex::FromHex::from_hex(command.next().unwrap()).unwrap();
+            let card: u64 = u64::from_ne_bytes(buf);
+            println!("card {card:#16x}");
+
+            LAST_BADGE_LOW.store(card as u32, core::sync::atomic::Ordering::SeqCst);
+            LAST_BADGE_HIG.store((card >> 32) as u32, core::sync::atomic::Ordering::SeqCst);
+
+            open_door(motor);
+        },
+        'G' => {
+
+            let mut last_badge: u64 = LAST_BADGE_LOW.load(core::sync::atomic::Ordering::SeqCst) as u64;
+            last_badge += (LAST_BADGE_HIG.load(core::sync::atomic::Ordering::SeqCst) as u64) << 32;
+
+            let _ = socket.write_fmt(
+                format_args!("B{last_badge}\r\n")
+            );
+        },
+        _ => {}
+        
+    }
+
+}
+
+pub fn open_door(motor: &mut Channel<LowSpeed, GpioPin<15>>) {
+    let delay = Delay::new();
+    let _ = motor.set_duty_cycle(0x533);
+    delay.delay_millis(3000);
+    //Timer::after_millis(3000).await;
+    let _ = motor.set_duty_cycle(0x4c8);
+    delay.delay_millis(750);
+    let _ = motor.set_duty_cycle(0x4CD);
+}

inside/src/main.rs

@@ -5,7 +5,7 @@
 use embedded_io::{Read, ReadReady, Write};
 use embedded_hal::pwm::SetDutyCycle;
 use esp_backtrace as _;
-use esp_hal::{gpio::Io, ledc::{channel, timer, LSGlobalClkSource, Ledc, LowSpeed}, prelude::*, rng::Rng, time::{self, Duration}};
+use esp_hal::{gpio::Io, ledc::{channel, timer, LSGlobalClkSource, Ledc, LowSpeed}, prelude::*, reset::software_reset, rng::Rng, time::{self, Duration}};
 use esp_println::{print, println};
 use esp_wifi::wifi::{utils::create_network_interface, AccessPointInfo, ClientConfiguration, Configuration, WifiError, WifiStaDevice};
 use smoltcp::iface::SocketStorage;
@@ -72,8 +72,8 @@ fn main() -> ! {
     let mut stack = Stack::new(iface, device, socket_set, now, rng.random());
 
     let client_config = Configuration::Client(ClientConfiguration {
-        ssid: include_str!("../../ssid").try_into().unwrap(),
-        password: include_str!("../../password").try_into().unwrap(),
+        ssid: "🐟".try_into().unwrap(),
+        password: "ilcougars1234".try_into().unwrap(),
         ..Default::default()
     });
     let res = controller.set_configuration(&client_config);
@@ -125,6 +125,17 @@ fn main() -> ! {
     socket.listen(4595).unwrap();
 
     loop {
+        loop {
+            match controller.is_connected() {
+                Ok(true) => break,
+                Ok(false) => {}
+                Err(err) => {
+                    log::error!("{:?}", err);
+                    log::info!("connecting: {:?}", controller.connect());
+                }
+            }
+        }
+
         socket.work();
 
         if !socket.is_open() {
@@ -148,6 +159,7 @@ fn main() -> ! {
                 if let Ok(len) = socket.read(&mut buffer[pos..]) {
                     let to_print = unsafe { core::str::from_utf8_unchecked(&buffer[..(pos + len)]) };
 
+                    println!("recv {}", to_print);
                     if to_print.contains("\r\n") {
                         print!("{}", to_print);
                         println!();
@@ -167,14 +179,7 @@ fn main() -> ! {
                 }
             }
 
-            let mut command = buffer[..pos].trim_ascii().split(|c| *c == b' ');
-            let buf: [u8;2] =  hex::FromHex::from_hex(command.next().unwrap()).unwrap();
-            let card: u16 = u16::from_be_bytes(buf);
-            println!("{card}");
-            motor.set_duty_cycle(card).unwrap();
-            
-            
-            handle(&buffer[..pos], &mut motor);
+            handle(&buffer[..pos], &mut motor, &mut socket);
 
             if !time_out {
                 let _ = socket.write_all(

outside/Cargo.lock

@@ -1372,6 +1372,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"
@@ -1572,6 +1578,7 @@ dependencies = [
  "fixed-macro",
  "heapless 0.8.0",
  "hex",
+ "itoa",
  "log",
  "panic-probe",
  "pio",

outside/Cargo.toml

@@ -60,6 +60,7 @@ 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"
 
 [profile.release]
 debug = 2

outside/src/main.rs

@@ -23,6 +23,7 @@ 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::uart::{BufferedInterruptHandler, BufferedUart};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::channel::Channel;
 use fixed::FixedU16;
@@ -31,14 +32,14 @@ use log::*;
 use embassy_executor::{InterruptExecutor, Spawner};
 use embassy_net::tcp::TcpSocket;
 use embassy_net::{Config, IpEndpoint, Ipv4Address, StackResources};
-use embassy_rp::{bind_interrupts, interrupt};
+use embassy_rp::{bind_interrupts, interrupt, uart};
 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_21, 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 embedded_io_async::{Read, ReadReady, Write};
 use rand::RngCore;
 use reqwless::response;
 use static_cell::StaticCell;
@@ -47,6 +48,7 @@ use defmt_rtt as _;
 bind_interrupts!(struct Irqs {
     PIO0_IRQ_0 => InterruptHandler<PIO0>;
     USBCTRL_IRQ => embassy_rp::usb::InterruptHandler<USB>;
+    UART1_IRQ => BufferedInterruptHandler<UART1>;
     
 });
 
@@ -105,6 +107,12 @@ async fn main(spawner: Spawner) {
     let data_0= Input::new(p.PIN_17, embassy_rp::gpio::Pull::None);
     let data_1= Input::new(p.PIN_16, embassy_rp::gpio::Pull::None);
 
+    let mut config = uart::Config::default();
+    config.baudrate = 115200;
+    let mut rx = [0; 2048];
+    let mut tx = [0; 2048];
+    let mut uart = BufferedUart::new(p.UART1, Irqs, p.PIN_20, p.PIN_21, &mut tx, &mut rx, config);
+
     let mut rng = RoscRng;
 
     let driver = Driver::new(p.USB, Irqs);
@@ -198,8 +206,17 @@ async fn main(spawner: Spawner) {
     loop {
         let card = CHANNEL.receive().await;
 
+        let num = (RoscRng::next_u32(&mut rng) % 5) + 1;
+        uart.write_all(b"AT+PLAYFILE=/").await.unwrap();
+        match card {
+            _ => uart.write_all(b"d").await.unwrap(),
+        };
+        uart.write_all(itoa::Buffer::new().format(num).as_bytes()).await.unwrap();
+        uart.write_all(b".mp3\r\n").await.unwrap();
+        //uart.write_all(b"AT+QUERY=4\r\n").await.unwrap();
+
         let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-        socket.set_timeout(Some(Duration::from_secs(10)));
+        socket.set_timeout(Some(Duration::from_secs(1)));
         info!("attempting conn to inside");
         if let Err(e) = socket.connect(IpEndpoint::new(Ipv4Address::new(169, 254, 2, 2).into_address(), 4595)).await {
             warn!("connect error: {:?}", e);
@@ -219,5 +236,6 @@ async fn main(spawner: Spawner) {
 
         socket.close();
         control.gpio_set(0, false).await;
+
     }
 }