Merge pull request #110 from RobertZ2011/keyboard-service

First keyboard service commits

Author: RobertZ2011

embedded-service/src/keyboard.rs

@@ -0,0 +1,120 @@
+//! Keyboard service data types and common functionality
+use core::cell::Cell;
+
+use embassy_sync::once_lock::OnceLock;
+
+use crate::buffer::SharedRef;
+use crate::comms::{self, EndpointID, External, Internal};
+
+/// Keyboard device ID
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct DeviceId(pub u8);
+
+/// Keyboard key
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Key(pub u8);
+
+/// Key event data
+#[derive(Debug, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum KeyEvent {
+    /// Key release
+    Break(Key),
+    /// Key press
+    Make(Key),
+}
+
+/// Keyboard event messages
+#[derive(Clone)]
+pub enum Event<'a> {
+    /// Key press event
+    KeyEvent(DeviceId, SharedRef<'a, KeyEvent>),
+}
+
+/// Top-level message data enum
+#[derive(Clone)]
+pub enum MessageData<'a> {
+    /// Event
+    Event(Event<'a>),
+}
+
+/// Top-level message struct
+#[derive(Clone)]
+pub struct Message<'a> {
+    /// Target/source device ID
+    pub device_id: DeviceId,
+    /// Message data
+    pub data: MessageData<'a>,
+}
+
+/// Broadcast target configuration
+#[derive(Copy, Clone, Default)]
+pub struct BroadcastConfig {
+    /// Enable broadcasting to the HID endpoint
+    broadcast_hid: bool,
+    /// Enable broadcasting to the host endpoint
+    broadcast_host: bool,
+}
+
+/// Keyboard service context
+struct Context {
+    broadcast_config: Cell<BroadcastConfig>,
+}
+
+static CONTEXT: OnceLock<Context> = OnceLock::new();
+
+/// Initialize common keyboard service functionality
+pub fn init() {
+    CONTEXT.get_or_init(|| Context {
+        broadcast_config: Cell::new(BroadcastConfig::default()),
+    });
+}
+
+/// Enable broadcasting messages to the host endpoint
+pub async fn enable_broadcast_host() {
+    let context = CONTEXT.get().await;
+
+    let mut config = context.broadcast_config.get();
+    config.broadcast_host = true;
+    context.broadcast_config.set(config);
+}
+
+/// Enable broadcasting messages to the HID endpoint
+pub async fn enable_broadcast_hid() {
+    let context = CONTEXT.get().await;
+
+    let mut config = context.broadcast_config.get();
+    config.broadcast_hid = true;
+    context.broadcast_config.set(config);
+}
+
+/// Broadcast a keyboard message to the specified endpoints
+pub async fn broadcast_message_with_config(from: DeviceId, config: BroadcastConfig, data: MessageData<'static>) {
+    let message = Message { device_id: from, data };
+
+    if config.broadcast_hid {
+        let _ = comms::send(
+            EndpointID::Internal(Internal::Keyboard),
+            EndpointID::Internal(Internal::Hid),
+            &message,
+        )
+        .await;
+    }
+
+    if config.broadcast_host {
+        let _ = comms::send(
+            EndpointID::Internal(Internal::Keyboard),
+            EndpointID::External(External::Host),
+            &message,
+        )
+        .await;
+    }
+}
+
+/// Broadcast a keyboard message using the global broadcast config
+pub async fn broadcast_message(from: DeviceId, data: MessageData<'static>) {
+    let config = CONTEXT.get().await.broadcast_config.get();
+    broadcast_message_with_config(from, config, data).await;
+}

embedded-service/src/lib.rs

@@ -12,11 +12,13 @@ pub mod buffer;
 pub mod comms;
 pub mod fmt;
 pub mod hid;
+pub mod keyboard;
 pub mod type_c;
 
 /// initialize all service static interfaces as required. Ideally, this is done before subsystem initialization
 pub async fn init() {
     comms::init();
     activity::init();
     hid::init();
+    keyboard::init();
 }

examples/std/src/bin/keyboard.rs

@@ -0,0 +1,143 @@
+use embassy_executor::{Executor, Spawner};
+use embassy_sync::once_lock::OnceLock;
+use embassy_time::Timer;
+use embedded_services::keyboard::{self, DeviceId, Key, KeyEvent};
+use embedded_services::{comms, define_static_buffer};
+use log::info;
+use static_cell::StaticCell;
+
+/// Mock that generates keyboard messages
+mod device {
+    use std::borrow::BorrowMut;
+
+    use embedded_services::buffer::OwnedRef;
+    use embedded_services::keyboard::{self, DeviceId, Event, Key, KeyEvent, MessageData};
+
+    pub struct Device {
+        id: DeviceId,
+        event_buffer: OwnedRef<'static, KeyEvent>,
+    }
+
+    impl Device {
+        pub fn new(id: DeviceId, event_buffer: OwnedRef<'static, KeyEvent>) -> Self {
+            Self { id, event_buffer }
+        }
+
+        pub async fn key_down(&self, key: Key) {
+            {
+                let mut borrow = self.event_buffer.borrow_mut();
+                let buf: &mut [KeyEvent] = borrow.borrow_mut();
+
+                buf[0] = KeyEvent::Make(key);
+            }
+
+            keyboard::broadcast_message(
+                self.id,
+                MessageData::Event(Event::KeyEvent(self.id, self.event_buffer.reference().slice(0..1))),
+            )
+            .await;
+        }
+
+        pub async fn key_up(&self, key: Key) {
+            {
+                let mut borrow = self.event_buffer.borrow_mut();
+                let buf: &mut [KeyEvent] = borrow.borrow_mut();
+
+                buf[0] = KeyEvent::Break(key);
+            }
+
+            keyboard::broadcast_message(
+                self.id,
+                MessageData::Event(Event::KeyEvent(self.id, self.event_buffer.reference().slice(0..1))),
+            )
+            .await;
+        }
+    }
+}
+
+/// Mock host device
+mod host {
+    use std::borrow::Borrow;
+
+    use embedded_services::comms::{self, Endpoint, EndpointID, External, MailboxDelegate};
+    use embedded_services::keyboard::{Event, KeyEvent, Message, MessageData};
+    use log::info;
+
+    pub struct Host {
+        pub tp: Endpoint,
+    }
+
+    impl Host {
+        pub fn new() -> Self {
+            Self {
+                tp: Endpoint::uninit(EndpointID::External(External::Host)),
+            }
+        }
+    }
+
+    impl MailboxDelegate for Host {
+        fn receive(&self, message: &comms::Message) {
+            if let Some(message) = message.data.get::<Message>() {
+                match &message.data {
+                    MessageData::Event(Event::KeyEvent(id, events)) => {
+                        let borrow = events.borrow();
+                        let buf: &[KeyEvent] = borrow.borrow();
+
+                        for event in buf {
+                            info!("Host received event from device {}: {:?}", id.0, event);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+const DEVICE0_ID: DeviceId = DeviceId(0);
+
+#[embassy_executor::task]
+async fn device() {
+    define_static_buffer!(buffer, KeyEvent, [KeyEvent::Break(Key(0)); 8]);
+
+    info!("Device task");
+    static DEVICE0: OnceLock<device::Device> = OnceLock::new();
+    let this = DEVICE0.get_or_init(|| device::Device::new(DEVICE0_ID, buffer::get_mut().unwrap()));
+    info!("Registering device 0 endpoint");
+
+    loop {
+        info!("Sending message");
+        this.key_down(Key(0x04)).await;
+        Timer::after_millis(250).await;
+        this.key_up(Key(0x04)).await;
+        Timer::after_secs(1).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn host() {
+    info!("Host task");
+    static HOST: OnceLock<host::Host> = OnceLock::new();
+    let this = HOST.get_or_init(|| host::Host::new());
+    info!("Registering host endpoint");
+    comms::register_endpoint(this, &this.tp).await.unwrap();
+}
+
+#[embassy_executor::task]
+async fn run(spawner: Spawner) {
+    embedded_services::init().await;
+
+    keyboard::enable_broadcast_host().await;
+
+    spawner.must_spawn(host());
+    spawner.must_spawn(device());
+}
+
+fn main() {
+    env_logger::builder().filter_level(log::LevelFilter::Info).init();
+
+    static EXECUTOR: StaticCell<Executor> = StaticCell::new();
+    let executor = EXECUTOR.init(Executor::new());
+    executor.run(|spawner| {
+        spawner.must_spawn(run(spawner));
+    });
+}