From 9f699e5772815d95da473dcec4f4f574e2659e06 Mon Sep 17 00:00:00 2001
From: Vo Trung Chi <chi.votrung@vn.bosch.com>
Date: Thu, 14 Mar 2024 23:02:22 +0700
Subject: [PATCH] stm32: add usb_hid_keyboard example
Signed-off-by: Vo Trung Chi <votrungchi_108@live.com>
---
examples/stm32f4/src/bin/usb_hid_keyboard.rs | 222 +++++++++++++++++++
1 file changed, 222 insertions(+)
create mode 100644 examples/stm32f4/src/bin/usb_hid_keyboard.rs
diff --git a/examples/stm32f4/src/bin/usb_hid_keyboard.rs b/examples/stm32f4/src/bin/usb_hid_keyboard.rs
new file mode 100644
index 000000000..19b5971fb
--- /dev/null
+++ b/examples/stm32f4/src/bin/usb_hid_keyboard.rs
@@ -0,0 +1,222 @@
+#![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_otg::Driver;
+use embassy_stm32::{bind_interrupts, peripherals, usb_otg, 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_otg::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;
+ }
+ 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_otg::Config::default();
+ 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 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: 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, &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(&self, id: ReportId, _buf: &mut [u8]) -> Option<usize> {
+ 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<ReportId>, dur: u32) {
+ info!("Set idle rate for {:?} to {:?}", id, dur);
+ }
+
+ fn get_idle_ms(&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.");
+ }
+ }
+}