#![no_std] #![no_main] mod dispatch; mod kb_macro; mod keyboard; mod keypress; mod keysend; mod layout; use core::sync::atomic::{AtomicBool, Ordering}; use defmt::*; use embassy_executor::Spawner; use embassy_futures::join::{join, join4, join_array}; use embassy_rp::bind_interrupts; use embassy_rp::peripherals::USB; use embassy_rp::usb::{Driver, InterruptHandler}; use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex; use embassy_sync::channel::Channel; use embassy_usb::class::hid::{HidReaderWriter, ReportId, RequestHandler, State}; use embassy_usb::control::OutResponse; use embassy_usb::{Builder, Config, Handler}; use keypress::await_chord; use usbd_hid::descriptor::{KeyboardReport, SerializedDescriptor}; use crate::keypress::await_key; use {defmt_rtt as _, panic_probe as _}; bind_interrupts!(struct Irqs { USBCTRL_IRQ => InterruptHandler; }); pub(crate) const CHANNEL_SIZE: usize = 12; pub(crate) type MutexType = CriticalSectionRawMutex; pub(crate) type ChannelType = Channel; // pub(crate) type WriterType = HidWriter<'static, Driver<'static, USB>, 8>; // static LOCKED_WRITER: Mutex>> = // Mutex::new(RefCell::new(None)); const DEBOUNCE_TIMER: u64 = 5; const CHORD_TIMER: u64 = 200; #[embassy_executor::main] async fn main(_spawner: Spawner) { let p = embassy_rp::init(Default::default()); // Create the driver, from the HAL. let driver = Driver::new(p.USB, Irqs); // Create embassy-usb Config let mut config = Config::new(0x27db, 0x16c0); config.manufacturer = Some("Dan"); config.product = Some("Dandaboard SplitSimple"); config.serial_number = Some("DDB-SSK-0001a"); config.max_power = 100; config.max_packet_size_0 = 64; // Create embassy-usb DeviceBuilder using the driver and config. // It needs some buffers for building the descriptors. let mut device_descriptor = [0; 256]; let mut config_descriptor = [0; 256]; let mut bos_descriptor = [0; 256]; // You can also add a Microsoft OS descriptor. let mut msos_descriptor = [0; 256]; let mut control_buf = [0; 64]; let request_handler = MyRequestHandler {}; let mut device_handler = MyDeviceHandler::new(); let mut state = State::new(); let mut builder = Builder::new( driver, config, &mut device_descriptor, &mut config_descriptor, &mut bos_descriptor, &mut msos_descriptor, // &mut control_buf, ); builder.handler(&mut device_handler); // Create classes on the builder. let config = embassy_usb::class::hid::Config { report_descriptor: KeyboardReport::desc(), request_handler: Some(&request_handler), poll_ms: 10, max_packet_size: 64, }; let hid = HidReaderWriter::<_, 1, 8>::new(&mut builder, &mut state, config); // Build the builder. let mut usb = builder.build(); // Run the USB device. let usb_fut = usb.run(); let (reader, mut writer) = hid.split(); // let mut channel = Channel::::new(); let channel = ChannelType::new(); let senderloop = async { loop { info!("Awayting new messages"); let report = channel.receive().await; // Send the report. match writer.write_serialize(&report).await { Ok(()) => {} Err(e) => warn!("Failed to send report: {:?}", e), }; } }; let keys_fut = [ // await_key(p.PIN_1.into(), layout::KeypadKey::A1, &channel), await_key(p.PIN_2.into(), layout::KeypadKey::A2, &channel), await_key(p.PIN_3.into(), layout::KeypadKey::A3, &channel), await_key(p.PIN_4.into(), layout::KeypadKey::A4, &channel), await_key(p.PIN_6.into(), layout::KeypadKey::B2, &channel), await_key(p.PIN_7.into(), layout::KeypadKey::B3, &channel), await_key(p.PIN_8.into(), layout::KeypadKey::B4, &channel), await_key(p.PIN_12.into(), layout::KeypadKey::C2, &channel), await_key(p.PIN_10.into(), layout::KeypadKey::C3, &channel), await_key(p.PIN_9.into(), layout::KeypadKey::C4, &channel), ]; let chords_fut = [ await_chord( p.PIN_1.into(), &layout::KeypadKey::A1, &layout::A1, &channel, ), await_chord( p.PIN_5.into(), &layout::KeypadKey::B1, &layout::B1, &channel, ), await_chord( p.PIN_11.into(), &layout::KeypadKey::C1, &layout::C1, &channel, ), ]; let out_fut = async { reader.run(false, &request_handler).await; }; join( usb_fut, join4( senderloop, join_array(keys_fut), join_array(chords_fut), out_fut, ), ) .await; } struct MyRequestHandler {} impl RequestHandler for MyRequestHandler { fn get_report(&self, id: ReportId, _buf: &mut [u8]) -> Option { info!("Get report for {:?}", id); None } fn set_report(&self, id: ReportId, data: &[u8]) -> OutResponse { info!("Set report for {:?}: {=[u8]}", id, data); OutResponse::Accepted } fn set_idle_ms(&self, id: Option, dur: u32) { info!("Set idle rate for {:?} to {:?}", id, dur); } fn get_idle_ms(&self, id: Option) -> Option { info!("Get idle rate for {:?}", id); None } } struct MyDeviceHandler { configured: AtomicBool, } impl MyDeviceHandler { fn new() -> Self { MyDeviceHandler { configured: AtomicBool::new(false), } } } impl Handler for MyDeviceHandler { fn enabled(&mut self, enabled: bool) { self.configured.store(false, Ordering::Relaxed); if enabled { info!("Device enabled"); } else { info!("Device disabled"); } } fn reset(&mut self) { self.configured.store(false, Ordering::Relaxed); info!("Bus reset, the Vbus current limit is 100mA"); } fn addressed(&mut self, addr: u8) { self.configured.store(false, Ordering::Relaxed); info!("USB address set to: {}", addr); } fn configured(&mut self, configured: bool) { self.configured.store(configured, Ordering::Relaxed); if configured { info!( "Device configured, it may now draw up to the configured current limit from Vbus." ) } else { info!("Device is no longer configured, the Vbus current limit is 100mA."); } } }