223 lines
6.9 KiB
Rust
223 lines
6.9 KiB
Rust
#![no_std]
|
||
#![no_main]
|
||
|
||
use core::sync::atomic::{AtomicBool, Ordering};
|
||
|
||
use defmt::*;
|
||
use embassy_executor::Spawner;
|
||
use embassy_stm32::exti::ExtiInput;
|
||
use embassy_stm32::gpio::Pull;
|
||
use embassy_stm32::time::Hertz;
|
||
use embassy_stm32::usb::Driver;
|
||
use embassy_stm32::{bind_interrupts, peripherals, usb, Config};
|
||
use embassy_usb::class::hid::{HidReaderWriter, ReportId, RequestHandler, State};
|
||
use embassy_usb::control::OutResponse;
|
||
use embassy_usb::{Builder, Handler};
|
||
use futures::future::join;
|
||
use usbd_hid::descriptor::{KeyboardReport, SerializedDescriptor};
|
||
use {defmt_rtt as _, panic_probe as _};
|
||
|
||
bind_interrupts!(struct Irqs {
|
||
OTG_FS => usb::InterruptHandler<peripherals::USB_OTG_FS>;
|
||
});
|
||
|
||
#[embassy_executor::main]
|
||
async fn main(_spawner: Spawner) {
|
||
let mut config = Config::default();
|
||
{
|
||
use embassy_stm32::rcc::*;
|
||
config.rcc.hse = Some(Hse {
|
||
freq: Hertz(8_000_000),
|
||
mode: HseMode::Bypass,
|
||
});
|
||
config.rcc.pll_src = PllSource::HSE;
|
||
config.rcc.pll = Some(Pll {
|
||
prediv: PllPreDiv::DIV4,
|
||
mul: PllMul::MUL168,
|
||
divp: Some(PllPDiv::DIV2), // 8mhz / 4 * 168 / 2 = 168Mhz.
|
||
divq: Some(PllQDiv::DIV7), // 8mhz / 4 * 168 / 7 = 48Mhz.
|
||
divr: None,
|
||
});
|
||
config.rcc.ahb_pre = AHBPrescaler::DIV1;
|
||
config.rcc.apb1_pre = APBPrescaler::DIV4;
|
||
config.rcc.apb2_pre = APBPrescaler::DIV2;
|
||
config.rcc.sys = Sysclk::PLL1_P;
|
||
config.rcc.mux.clk48sel = mux::Clk48sel::PLL1_Q;
|
||
}
|
||
let p = embassy_stm32::init(config);
|
||
|
||
// Create the driver, from the HAL.
|
||
let mut ep_out_buffer = [0u8; 256];
|
||
let mut config = embassy_stm32::usb::Config::default();
|
||
// If the board you’re using doesn’t have the VBUS pin wired up correctly for detecting the USB bus voltage (e.g. on the f4 blackpill board), set this to false
|
||
config.vbus_detection = true;
|
||
let driver = Driver::new_fs(p.USB_OTG_FS, Irqs, p.PA12, p.PA11, &mut ep_out_buffer, config);
|
||
|
||
// Create embassy-usb Config
|
||
let mut config = embassy_usb::Config::new(0xc0de, 0xcafe);
|
||
config.manufacturer = Some("Embassy");
|
||
config.product = Some("HID keyboard example");
|
||
config.serial_number = Some("12345678");
|
||
config.max_power = 100;
|
||
config.max_packet_size_0 = 64;
|
||
|
||
// Required for windows compatibility.
|
||
// https://developer.nordicsemi.com/nRF_Connect_SDK/doc/1.9.1/kconfig/CONFIG_CDC_ACM_IAD.html#help
|
||
config.device_class = 0xEF;
|
||
config.device_sub_class = 0x02;
|
||
config.device_protocol = 0x01;
|
||
config.composite_with_iads = true;
|
||
|
||
// Create embassy-usb DeviceBuilder using the driver and config.
|
||
// It needs some buffers for building the descriptors.
|
||
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 mut request_handler = MyRequestHandler {};
|
||
let mut device_handler = MyDeviceHandler::new();
|
||
|
||
let mut state = State::new();
|
||
|
||
let mut builder = Builder::new(
|
||
driver,
|
||
config,
|
||
&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: None,
|
||
poll_ms: 60,
|
||
max_packet_size: 8,
|
||
};
|
||
|
||
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 button = ExtiInput::new(p.PC13, p.EXTI13, Pull::Down);
|
||
|
||
// Do stuff with the class!
|
||
let in_fut = async {
|
||
loop {
|
||
button.wait_for_rising_edge().await;
|
||
// signal_pin.wait_for_high().await;
|
||
info!("Button pressed!");
|
||
// Create a report with the A key pressed. (no shift modifier)
|
||
let report = KeyboardReport {
|
||
keycodes: [4, 0, 0, 0, 0, 0],
|
||
leds: 0,
|
||
modifier: 0,
|
||
reserved: 0,
|
||
};
|
||
// Send the report.
|
||
match writer.write_serialize(&report).await {
|
||
Ok(()) => {}
|
||
Err(e) => warn!("Failed to send report: {:?}", e),
|
||
};
|
||
|
||
button.wait_for_falling_edge().await;
|
||
// signal_pin.wait_for_low().await;
|
||
info!("Button released!");
|
||
let report = KeyboardReport {
|
||
keycodes: [0, 0, 0, 0, 0, 0],
|
||
leds: 0,
|
||
modifier: 0,
|
||
reserved: 0,
|
||
};
|
||
match writer.write_serialize(&report).await {
|
||
Ok(()) => {}
|
||
Err(e) => warn!("Failed to send report: {:?}", e),
|
||
};
|
||
}
|
||
};
|
||
|
||
let out_fut = async {
|
||
reader.run(false, &mut request_handler).await;
|
||
};
|
||
|
||
// Run everything concurrently.
|
||
// If we had made everything `'static` above instead, we could do this using separate tasks instead.
|
||
join(usb_fut, join(in_fut, out_fut)).await;
|
||
}
|
||
|
||
struct MyRequestHandler {}
|
||
|
||
impl RequestHandler for MyRequestHandler {
|
||
fn get_report(&mut self, id: ReportId, _buf: &mut [u8]) -> Option<usize> {
|
||
info!("Get report for {:?}", id);
|
||
None
|
||
}
|
||
|
||
fn set_report(&mut self, id: ReportId, data: &[u8]) -> OutResponse {
|
||
info!("Set report for {:?}: {=[u8]}", id, data);
|
||
OutResponse::Accepted
|
||
}
|
||
|
||
fn set_idle_ms(&mut self, id: Option<ReportId>, dur: u32) {
|
||
info!("Set idle rate for {:?} to {:?}", id, dur);
|
||
}
|
||
|
||
fn get_idle_ms(&mut self, id: Option<ReportId>) -> Option<u32> {
|
||
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.");
|
||
}
|
||
}
|
||
}
|