From 6b80c49a59ab3e52d7b3e86ff8d99080f26af2e0 Mon Sep 17 00:00:00 2001 From: Andy Killorin <37423245+Speedy6451@users.noreply.github.com> Date: Wed, 4 Dec 2024 22:19:51 -0500 Subject: [PATCH] badge -> sound --- inside/Cargo.lock | 4 +-- inside/src/lib.rs | 69 +++++++++++++++++++++++++++++++++++++++++++++ inside/src/main.rs | 27 ++++++++++-------- outside/Cargo.lock | 7 +++++ outside/Cargo.toml | 1 + outside/src/main.rs | 26 ++++++++++++++--- 6 files changed, 117 insertions(+), 17 deletions(-) create mode 100644 inside/src/lib.rs diff --git a/inside/Cargo.lock b/inside/Cargo.lock index 4a24684..2613710 100644 --- a/inside/Cargo.lock +++ b/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" diff --git a/inside/src/lib.rs b/inside/src/lib.rs new file mode 100644 index 0000000..a2b6b91 --- /dev/null +++ b/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(slice: &[u8], motor: PwmPin) { +pub fn handle(slice: &[u8], motor: &mut Channel>, socket: &mut Socket>) { + 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>) { + 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); +} diff --git a/inside/src/main.rs b/inside/src/main.rs index c40fbfe..73ebc1c 100644 --- a/inside/src/main.rs +++ b/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( diff --git a/outside/Cargo.lock b/outside/Cargo.lock index e0cbe6a..d14bb57 100644 --- a/outside/Cargo.lock +++ b/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", diff --git a/outside/Cargo.toml b/outside/Cargo.toml index 80849da..4e93ad5 100644 --- a/outside/Cargo.toml +++ b/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 diff --git a/outside/src/main.rs b/outside/src/main.rs index 1e73086..d07cf7e 100644 --- a/outside/src/main.rs +++ b/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; USBCTRL_IRQ => embassy_rp::usb::InterruptHandler; + UART1_IRQ => BufferedInterruptHandler; }); @@ -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; + } }