ank/cruisecontrol
1
Fork 0
Code Issues Activity

i2c shell

Browse source
This commit is contained in:
Andy Killorin 2024-09-25 15:04:43 -04:00
parent 16cd6d2546
commit 24e5c7ccd9
Signed by: ank
GPG key ID: 23F9463ECB67FE8C
3 changed files with 81 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
controller/Cargo.lock generated
View file

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

1
controller/Cargo.toml
View file

@ -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

85
controller/src/main.rs
View file

@ -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(()) => {}