diff --git a/controller/Cargo.lock b/controller/Cargo.lock index f65f9ec..200b541 100644 --- a/controller/Cargo.lock +++ b/controller/Cargo.lock @@ -294,6 +294,7 @@ dependencies = [ "fixed", "fixed-macro", "heapless 0.8.0", + "hex", "log", "panic-probe", "pio", diff --git a/controller/Cargo.toml b/controller/Cargo.toml index 80042b4..5034e96 100644 --- a/controller/Cargo.toml +++ b/controller/Cargo.toml @@ -58,6 +58,7 @@ rand = { version = "0.8.5", default-features = false } embedded-sdmmc = "0.7.0" bt-hci = { version = "0.1.0", default-features = false, features = ["defmt"] } +hex = { version = "0.4.3", default-features=false} [profile.release] debug = 2 diff --git a/controller/src/main.rs b/controller/src/main.rs index c2780cc..9a0bd1a 100644 --- a/controller/src/main.rs +++ b/controller/src/main.rs @@ -5,28 +5,40 @@ #![no_main] #![allow(async_fn_in_trait)] +use core::fmt::Formatter; use core::str::from_utf8; +use bt_hci::cmd::info; use cyw43_pio::PioSpi; -use defmt::*; +use log::*; +//use embassy_rp::i2c::InterruptHandler; use embassy_executor::Spawner; use embassy_net::tcp::TcpSocket; use embassy_net::{Config, StackResources}; use embassy_rp::bind_interrupts; use embassy_rp::clocks::RoscRng; use embassy_rp::gpio::{Level, Output}; -use embassy_rp::peripherals::{DMA_CH0, PIO0}; +use embassy_rp::peripherals::{DMA_CH0, PIO0, USB}; use embassy_rp::pio::{InterruptHandler, Pio}; -use embassy_time::Duration; +use embassy_rp::usb::Driver; +use embassy_time::{Duration, Timer}; use embedded_io_async::Write; use rand::RngCore; +use reqwless::response; use static_cell::StaticCell; use {defmt_rtt as _, panic_probe as _}; bind_interrupts!(struct Irqs { PIO0_IRQ_0 => InterruptHandler; + I2C1_IRQ => embassy_rp::i2c::InterruptHandler; + USBCTRL_IRQ => embassy_rp::usb::InterruptHandler; }); +#[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 @@ -44,6 +56,14 @@ async fn main(spawner: Spawner) { let p = embassy_rp::init(Default::default()); let mut rng = RoscRng; + let driver = Driver::new(p.USB, Irqs); + spawner.spawn(logger_task(driver)).unwrap(); + + let sda = p.PIN_26; + let scl = p.PIN_27; + let config = embassy_rp::i2c::Config::default(); + let mut bus = embassy_rp::i2c::I2c::new_async(p.I2C1, scl, sda, Irqs, config); + let fw = include_bytes!("../../cyw43-firmware/43439A0.bin"); let clm = include_bytes!("../../cyw43-firmware/43439A0_clm.bin"); @@ -62,7 +82,7 @@ async fn main(spawner: Spawner) { static STATE: StaticCell = StaticCell::new(); let state = STATE.init(cyw43::State::new()); let (net_device, mut control, runner) = cyw43::new(state, pwr, spi, fw).await; - unwrap!(spawner.spawn(cyw43_task(runner))); + defmt::unwrap!(spawner.spawn(cyw43_task(runner))); control.init(clm).await; control @@ -83,7 +103,7 @@ async fn main(spawner: Spawner) { static RESOURCES: StaticCell> = StaticCell::new(); let (stack, runner) = embassy_net::new(net_device, config, RESOURCES.init(StackResources::new()), seed); - unwrap!(spawner.spawn(net_task(runner))); + defmt::unwrap!(spawner.spawn(net_task(runner))); //control.start_ap_open("cyw43", 5).await; control.start_ap_wpa2("cyw43", "password", 5).await; @@ -94,6 +114,17 @@ async fn main(spawner: Spawner) { let mut tx_buffer = [0; 4096]; let mut buf = [0; 4096]; + //embassy_time::Timer::after_millis(7000).await; + + //let _ = bus.write_async(0x88u16, [0x00]).await; + //let _ = bus.write_async(0x80u16, [0x01]).await; + //let _ = bus.write_async(0xFFu16, [0x01]).await; + //let _ = bus.write_async(0x00u16, [0x00]).await; + //let _ = bus.write_async(0x00u16, [0x01]).await; + //let _ = bus.write_async(0xFFu16, [0x00]).await; + //let _ = bus.write_async(0x80u16, [0x00]).await; + + loop { let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer); socket.set_timeout(Some(Duration::from_secs(10))); @@ -109,7 +140,7 @@ async fn main(spawner: Spawner) { control.gpio_set(0, true).await; loop { - let n = match socket.read(&mut buf).await { + let mut n = match socket.read(&mut buf).await { Ok(0) => { warn!("read EOF"); break; @@ -120,8 +151,50 @@ async fn main(spawner: Spawner) { break; } }; + info!("rxd {}", from_utf8(&buf[..n]).unwrap()); + Timer::after_millis(30).await; + + let mut segs = buf[..n].split(|c| *c == ' ' as u8); + + match char::from_u32(segs.next().unwrap()[0] as u32).unwrap() { + 'W' => { + let addr: [u8;1] = hex::FromHex::from_hex(segs.next().unwrap()).unwrap(); + let reg: [u8;1] = hex::FromHex::from_hex(segs.next().unwrap()).unwrap(); + let data: [u8;1] = hex::FromHex::from_hex(segs.next().unwrap()).unwrap(); + info!("writing {:?}", reg); + Timer::after_millis(30).await; + + bus.write_async(addr[0] as u16, [reg[0], data[0]]).await.unwrap(); + + buf[0] = b"O"[0]; + buf[1] = b"K"[0]; + n=2; + }, + 'R' => { + let addr: [u8;1] = hex::FromHex::from_hex(segs.next().unwrap()).unwrap(); + let reg: [u8;1] = hex::FromHex::from_hex(segs.next().unwrap()).unwrap(); + info!("writing {:?}, addr {addr:?}", reg); + + let mut response: [u8;2] = [0;2]; + + let _ = bus.write_read_async(addr[0] as u16, reg, &mut response).await; + info!("recd {:?}", response); + info!("recd {:#02x}", response[0]); + let _ = hex::encode_to_slice(response, &mut buf); + n = 4; + + + }, + _ => {} + + } + + //let mut response: [u8;2] = [0;2]; + + //let _ = bus.read_async(0xC0u16, &mut response).await; + //let _ = hex::encode_to_slice(response, &mut buf); match socket.write_all(&buf[..n]).await { Ok(()) => {}