i2c shell

controller/Cargo.lock

@@ -294,6 +294,7 @@ dependencies = [
  "fixed",
  "fixed-macro",
  "heapless 0.8.0",
+ "hex",
  "log",
  "panic-probe",
  "pio",

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

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<PIO0>;
+    I2C1_IRQ => embassy_rp::i2c::InterruptHandler<embassy_rp::peripherals::I2C1>;
+    USBCTRL_IRQ => embassy_rp::usb::InterruptHandler<USB>;
 });
 
+#[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<cyw43::State> = 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<StackResources<3>> = 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(()) => {}