376 lines
12 KiB
Rust
376 lines
12 KiB
Rust
//! This example uses the RP Pico W board Wifi chip (cyw43).
|
|
//! Creates an Access point Wifi network and creates a TCP endpoint on port 1234.
|
|
|
|
#![no_std]
|
|
#![no_main]
|
|
#![allow(async_fn_in_trait)]
|
|
|
|
use core::array;
|
|
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 bt_hci::cmd::info;
|
|
use critical_section::Mutex;
|
|
use cyw43::JoinOptions;
|
|
use cyw43_pio::PioSpi;
|
|
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::uart::{BufferedInterruptHandler, BufferedUart};
|
|
use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
|
|
use embassy_sync::channel::{Channel, Receiver};
|
|
use fixed::FixedU16;
|
|
use log::*;
|
|
//use embassy_rp::i2c::InterruptHandler;
|
|
use embassy_executor::{InterruptExecutor, Spawner};
|
|
use embassy_net::tcp::TcpSocket;
|
|
use embassy_net::{Config, IpEndpoint, Ipv4Address, StackResources};
|
|
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_20, PIN_21, PIN_22, PIN_26, PIN_27, PIO0, PWM_SLICE5, UART1, USB};
|
|
use embassy_rp::pio::{InterruptHandler, Pio};
|
|
use embassy_rp::usb::Driver;
|
|
use embassy_time::{Duration, Timer};
|
|
use embedded_io_async::{Read, ReadReady, Write};
|
|
use rand::RngCore;
|
|
use reqwless::response;
|
|
use static_cell::StaticCell;
|
|
use defmt_rtt as _;
|
|
|
|
bind_interrupts!(struct Irqs {
|
|
PIO0_IRQ_0 => InterruptHandler<PIO0>;
|
|
USBCTRL_IRQ => embassy_rp::usb::InterruptHandler<USB>;
|
|
UART1_IRQ => BufferedInterruptHandler<UART1>;
|
|
|
|
});
|
|
|
|
static READ_CARD: Mutex<RefCell<u64>> =
|
|
Mutex::new(RefCell::new(0));
|
|
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>) {
|
|
embassy_usb_logger::run!(1024, log::LevelFilter::Debug, driver);
|
|
}
|
|
|
|
#[embassy_executor::task]
|
|
async fn cyw43_task(runner: cyw43::Runner<'static, Output<'static>, PioSpi<'static, PIO0, 0, DMA_CH0>>) -> ! {
|
|
runner.run().await
|
|
}
|
|
|
|
#[embassy_executor::task]
|
|
async fn net_task(mut runner: embassy_net::Runner<'static, cyw43::NetDriver<'static>>) -> ! {
|
|
runner.run().await
|
|
}
|
|
|
|
#[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);
|
|
loop { }
|
|
}
|
|
|
|
#[embassy_executor::main]
|
|
async fn main(spawner: Spawner) {
|
|
let p = embassy_rp::init(Default::default());
|
|
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);
|
|
|
|
spawner.spawn(music_manager(p.UART1, Irqs, p.PIN_20, p.PIN_21)).unwrap();
|
|
|
|
|
|
let mut rng = RoscRng;
|
|
|
|
let driver = Driver::new(p.USB, Irqs);
|
|
spawner.spawn(logger_task(driver)).unwrap();
|
|
|
|
|
|
let fw = include_bytes!("../../cyw43-firmware/43439A0.bin");
|
|
let clm = include_bytes!("../../cyw43-firmware/43439A0_clm.bin");
|
|
|
|
// To make flashing faster for development, you may want to flash the firmwares independently
|
|
// at hardcoded addresses, instead of baking them into the program with `include_bytes!`:
|
|
// probe-rs download 43439A0.bin --binary-format bin --chip RP2040 --base-address 0x10100000
|
|
// probe-rs download 43439A0_clm.bin --binary-format bin --chip RP2040 --base-address 0x10140000
|
|
//let fw = unsafe { core::slice::from_raw_parts(0x10100000 as *const u8, 230321) };
|
|
//let clm = unsafe { core::slice::from_raw_parts(0x10140000 as *const u8, 4752) };
|
|
|
|
let pwr = Output::new(p.PIN_23, Level::Low);
|
|
let cs = Output::new(p.PIN_25, Level::High);
|
|
let mut pio = Pio::new(p.PIO0, Irqs);
|
|
let spi = PioSpi::new(&mut pio.common, pio.sm0, pio.irq0, cs, p.PIN_24, p.PIN_29, p.DMA_CH0);
|
|
|
|
static STATE: StaticCell<cyw43::State> = StaticCell::new();
|
|
let state = STATE.init(cyw43::State::new());
|
|
let (net_device, mut control, runner) = cyw43::new(state, pwr, spi, fw).await;
|
|
defmt::unwrap!(spawner.spawn(cyw43_task(runner)));
|
|
|
|
control.init(clm).await;
|
|
control
|
|
.set_power_management(cyw43::PowerManagementMode::PowerSave)
|
|
.await;
|
|
|
|
// Use a link-local address for communication without DHCP server
|
|
let config = Config::ipv4_static(embassy_net::StaticConfigV4 {
|
|
address: embassy_net::Ipv4Cidr::new(embassy_net::Ipv4Address::new(169, 254, 2, 1), 16),
|
|
dns_servers: heapless::Vec::new(),
|
|
gateway: None,
|
|
});
|
|
|
|
// Generate random seed
|
|
let seed = rng.next_u64();
|
|
|
|
// Init network stack
|
|
static RESOURCES: StaticCell<StackResources<3>> = StaticCell::new();
|
|
let (stack, runner) = embassy_net::new(net_device, config, RESOURCES.init(StackResources::new()), seed);
|
|
|
|
defmt::unwrap!(spawner.spawn(net_task(runner)));
|
|
|
|
loop {
|
|
match control
|
|
.join("door409", JoinOptions::new("babelite".as_bytes()))
|
|
.await
|
|
{
|
|
Ok(_) => break,
|
|
Err(err) => {
|
|
info!("join failed with status={}", err.status);
|
|
}
|
|
}
|
|
}
|
|
|
|
spawner.spawn(data_extractor()).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);
|
|
}
|
|
});
|
|
|
|
defmt::unwrap!(spawner.spawn(send_badge(CHANNEL.receiver(),stack)));
|
|
defmt::unwrap!(spawner.spawn(button_manager(p.PIN_22)));
|
|
defmt::unwrap!(spawner.spawn(wiggle_manager(p.PWM_SLICE5, p.PIN_26, p.PIN_27)));
|
|
|
|
}
|
|
|
|
#[embassy_executor::task]
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[embassy_executor::task]
|
|
async fn button_manager(pin: PIN_22) -> ! {
|
|
let mut button = Input::new(pin, embassy_rp::gpio::Pull::Up);
|
|
loop {
|
|
button.wait_for_rising_edge().await;
|
|
MUSIC.send(("d",5)).await;
|
|
Timer::after_millis(800).await;
|
|
}
|
|
}
|
|
|
|
|
|
#[embassy_executor::task]
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[embassy_executor::task]
|
|
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;
|
|
}
|
|
}
|