Merge pull request #850 from HaoboGu/feat/rynk-pr2-service-core

Add Rynk core service struct

Author: HaoboGu

rmk-config/src/default_config/event_default.toml

@@ -27,17 +27,17 @@ subs = 1
 [event.wpm_update]
 channel_size = 1
 pubs = 1
-subs = 1
+subs = 2
 
 [event.led_indicator]
 channel_size = 2
 pubs = 2
-subs = 3
+subs = 4
 
 [event.sleep_state]
 channel_size = 1
 pubs = 1
-subs = 1
+subs = 2
 
 # Power events
 [event.battery_status]

rmk-types/src/protocol/rynk/buffer.rs

@@ -114,7 +114,7 @@ pub const RYNK_MAX_PAYLOAD: usize = {
     m
 };
 
-/// Minimum buffer size required to hold any single Rynk frame
+/// Minimum buffer size required to hold any single Rynk message
 /// (header + max-payload). User-configured `RYNK_BUFFER_SIZE` must
 /// not be smaller than this.
 pub const RYNK_MIN_BUFFER_SIZE: usize = RYNK_HEADER_SIZE + RYNK_MAX_PAYLOAD;

rmk-types/src/protocol/rynk/cmd.rs

@@ -23,10 +23,10 @@
 
 use strum::FromRepr;
 
-/// Command tag carried in the [`Header`](super::Header) CMD field.
+/// Command tag carried in the header CMD field.
 ///
-/// The wire encoding is a plain `u16 LE` written by `Header::encode_into` —
-/// Cmd is never postcard-encoded, so no `Serialize`/`Deserialize`/`MaxSize`
+/// The wire encoding is a plain `u16 LE` written by [`RynkMessage::set_cmd`](super::RynkMessage::set_cmd) —
+/// `Cmd` is never postcard-encoded, so no `Serialize`/`Deserialize`/`MaxSize`
 /// derives are needed here.
 #[repr(u16)]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, FromRepr)]
@@ -82,7 +82,6 @@ pub enum Cmd {
 
     // ── Connection (0x07xx) ──
     GetConnectionType = 0x0701,
-    SetConnectionType = 0x0702,
     #[cfg(feature = "_ble")]
     GetBleStatus = 0x0703,
     #[cfg(feature = "_ble")]
@@ -97,6 +96,12 @@ pub enum Cmd {
     GetBatteryStatus = 0x0803,
     #[cfg(all(feature = "_ble", feature = "split"))]
     GetPeripheralStatus = 0x0804,
+    /// Latest WPM, sourced from the `WpmUpdate` topic snapshot.
+    GetWpm = 0x0805,
+    /// Latest sleep flag, sourced from the `SleepState` topic snapshot.
+    GetSleepState = 0x0806,
+    /// Latest HID LED bitmap, sourced from the `LedIndicator` topic snapshot.
+    GetLedIndicator = 0x0807,
 
     // ── Topics (0x80xx, server → host push) ──
     LayerChange = 0x8001,

rmk-types/src/protocol/rynk/header.rs

@@ -0,0 +1,135 @@
+//! Rynk wire-format message view.
+//!
+//! Fixed 5-byte header followed by a postcard-encoded payload:
+//!
+//! ```text
+//! ┌──────────────┬───────┬──────────────┐
+//! │  CMD u16 LE  │SEQ u8 │  LEN u16 LE  │  ← 5-byte header
+//! ├──────────────┴───────┴──────────────┤
+//! │          payload bytes ...          │
+//! └─────────────────────────────────────┘
+//! ```
+
+use super::RynkError;
+use super::cmd::Cmd;
+
+/// Size in bytes of the fixed Rynk header.
+pub const RYNK_HEADER_SIZE: usize = 5;
+
+/// Message operations for Rynk
+pub trait RynkMessage {
+    fn cmd(&self) -> Result<Cmd, RynkError>;
+    fn seq(&self) -> Result<u8, RynkError>;
+    fn payload_len(&self) -> Result<u16, RynkError>;
+    fn payload(&self) -> Result<&[u8], RynkError>;
+    fn payload_mut(&mut self) -> Result<&mut [u8], RynkError>;
+
+    fn set_cmd(&mut self, cmd: Cmd) -> Result<(), RynkError>;
+    fn set_seq(&mut self, seq: u8) -> Result<(), RynkError>;
+    fn set_payload_len(&mut self, len: u16) -> Result<(), RynkError>;
+}
+
+impl RynkMessage for [u8] {
+    fn cmd(&self) -> Result<Cmd, RynkError> {
+        if self.len() < RYNK_HEADER_SIZE {
+            return Err(RynkError::InvalidRequest);
+        }
+        Cmd::from_repr(u16::from_le_bytes([self[0], self[1]])).ok_or(RynkError::InvalidRequest)
+    }
+
+    fn seq(&self) -> Result<u8, RynkError> {
+        if self.len() < RYNK_HEADER_SIZE {
+            return Err(RynkError::InvalidRequest);
+        }
+        Ok(self[2])
+    }
+
+    fn payload_len(&self) -> Result<u16, RynkError> {
+        if self.len() < RYNK_HEADER_SIZE {
+            return Err(RynkError::InvalidRequest);
+        }
+        Ok(u16::from_le_bytes([self[3], self[4]]))
+    }
+
+    fn payload(&self) -> Result<&[u8], RynkError> {
+        if self.len() < RYNK_HEADER_SIZE {
+            return Err(RynkError::InvalidRequest);
+        }
+        Ok(&self[RYNK_HEADER_SIZE..])
+    }
+
+    fn payload_mut(&mut self) -> Result<&mut [u8], RynkError> {
+        if self.len() < RYNK_HEADER_SIZE {
+            return Err(RynkError::InvalidRequest);
+        }
+        Ok(&mut self[RYNK_HEADER_SIZE..])
+    }
+
+    fn set_cmd(&mut self, cmd: Cmd) -> Result<(), RynkError> {
+        if self.len() < RYNK_HEADER_SIZE {
+            return Err(RynkError::InvalidRequest);
+        }
+        self[0..2].copy_from_slice(&(cmd as u16).to_le_bytes());
+        Ok(())
+    }
+
+    fn set_seq(&mut self, seq: u8) -> Result<(), RynkError> {
+        if self.len() < RYNK_HEADER_SIZE {
+            return Err(RynkError::InvalidRequest);
+        }
+        self[2] = seq;
+        Ok(())
+    }
+
+    fn set_payload_len(&mut self, len: u16) -> Result<(), RynkError> {
+        if self.len() < RYNK_HEADER_SIZE {
+            return Err(RynkError::InvalidRequest);
+        }
+        self[3..5].copy_from_slice(&len.to_le_bytes());
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn round_trip_header_fields() {
+        let mut buf = [0u8; RYNK_HEADER_SIZE + 7];
+        buf.set_cmd(Cmd::GetVersion).unwrap();
+        buf.set_seq(0x42).unwrap();
+        buf.set_payload_len(7).unwrap();
+        buf.payload_mut().unwrap()[..7].copy_from_slice(&[1, 2, 3, 4, 5, 6, 7]);
+
+        assert_eq!(buf.cmd().unwrap(), Cmd::GetVersion);
+        assert_eq!(buf.seq().unwrap(), 0x42);
+        assert_eq!(buf.payload_len().unwrap(), 7);
+        assert_eq!(buf.payload().unwrap(), &[1, 2, 3, 4, 5, 6, 7]);
+    }
+
+    #[test]
+    fn cmd_rejects_short_buffer() {
+        let buf = [0u8; RYNK_HEADER_SIZE - 1];
+        assert_eq!(buf.cmd(), Err(RynkError::InvalidRequest));
+    }
+
+    #[test]
+    fn cmd_rejects_unknown_discriminant() {
+        let mut buf = [0u8; RYNK_HEADER_SIZE];
+        buf[0..2].copy_from_slice(&0xFFFFu16.to_le_bytes());
+        assert_eq!(buf.cmd(), Err(RynkError::InvalidRequest));
+    }
+
+    #[test]
+    fn every_accessor_rejects_short_buffer() {
+        let mut buf = [0u8; RYNK_HEADER_SIZE - 1];
+        assert_eq!(buf.seq(), Err(RynkError::InvalidRequest));
+        assert_eq!(buf.payload_len(), Err(RynkError::InvalidRequest));
+        assert!(buf.payload().is_err());
+        assert!(buf.payload_mut().is_err());
+        assert_eq!(buf.set_cmd(Cmd::GetVersion), Err(RynkError::InvalidRequest));
+        assert_eq!(buf.set_seq(0), Err(RynkError::InvalidRequest));
+        assert_eq!(buf.set_payload_len(0), Err(RynkError::InvalidRequest));
+    }
+}