Am I writing slow code? No, it's the keyboard EC who is slow - Seymour

examples/per-key-effect-2.rs

@@ -0,0 +1,83 @@
+use daemon::aura::{BuiltInModeByte, Key, KeyColourArray};
+use daemon::daemon::{DBUS_IFACE, DBUS_NAME, DBUS_PATH};
+use dbus::Error as DbusError;
+use dbus::{ffidisp::Connection, Message};
+use std::{thread, time};
+
+pub fn dbus_led_builtin_write(bytes: &[u8]) -> Result<(), Box<dyn std::error::Error>> {
+    let bus = Connection::new_system()?;
+    //let proxy = bus.with_proxy(DBUS_IFACE, "/", Duration::from_millis(5000));
+    let msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "ledmessage")?
+        .append1(bytes.to_vec());
+    let r = bus.send_with_reply_and_block(msg, 5000)?;
+    if let Some(reply) = r.get1::<&str>() {
+        println!("Success: {:x?}", reply);
+        return Ok(());
+    }
+    Err(Box::new(DbusError::new_custom("name", "message")))
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let bus = Connection::new_system()?;
+
+    let mut per_key_led = Vec::new();
+    let mut key_colours = KeyColourArray::new();
+    key_colours.set(Key::ROG, 255, 0, 0);
+    key_colours.set(Key::L, 255, 0, 0);
+    key_colours.set(Key::I, 255, 0, 0);
+    key_colours.set(Key::N, 255, 0, 0);
+    key_colours.set(Key::U, 255, 0, 0);
+    key_colours.set(Key::X, 255, 0, 0);
+    per_key_led.push(key_colours.clone());
+
+    for _ in 0..49 {
+        *key_colours.key(Key::ROG).0 -= 5;
+        *key_colours.key(Key::L).0 -= 5;
+        *key_colours.key(Key::I).0 -= 5;
+        *key_colours.key(Key::N).0 -= 5;
+        *key_colours.key(Key::U).0 -= 5;
+        *key_colours.key(Key::X).0 -= 5;
+        per_key_led.push(key_colours.clone());
+    }
+    for _ in 0..49 {
+        *key_colours.key(Key::ROG).0 += 5;
+        *key_colours.key(Key::L).0 += 5;
+        *key_colours.key(Key::I).0 += 5;
+        *key_colours.key(Key::N).0 += 5;
+        *key_colours.key(Key::U).0 += 5;
+        *key_colours.key(Key::X).0 += 5;
+        per_key_led.push(key_colours.clone());
+    }
+
+    let time = time::Duration::from_millis(1200);
+
+    let row = KeyColourArray::get_init_msg();
+    let msg =
+        Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "ledmessage")?.append1(row);
+    bus.send(msg).unwrap();
+
+    loop {
+        let now = std::time::Instant::now();
+        thread::sleep(time);
+
+        for group in &per_key_led {
+            let group = group.get();
+            let msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "ledeffect")?
+                .append1(&group[0].to_vec())
+                .append1(&group[1].to_vec())
+                .append1(&group[2].to_vec())
+                .append1(&group[3].to_vec())
+                .append1(&group[4].to_vec())
+                .append1(&group[5].to_vec())
+                .append1(&group[6].to_vec())
+                .append1(&group[7].to_vec())
+                .append1(&group[8].to_vec())
+                .append1(&group[9].to_vec());
+            bus.send(msg).unwrap();
+        }
+        let after = std::time::Instant::now();
+        let diff = after.duration_since(now);
+        dbg!(diff.as_millis());
+        return Ok(());
+    }
+}

examples/per-key-effect.rs

@@ -30,7 +30,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     key_colours.set(Key::X, 255, 0, 0);
     per_key_led.push(key_colours.clone());
 
-    for _ in 0..49 {
+    for _ in 0..46 {
         *key_colours.key(Key::ROG).0 -= 5;
         *key_colours.key(Key::L).0 -= 5;
         *key_colours.key(Key::I).0 -= 5;
@@ -39,7 +39,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         *key_colours.key(Key::X).0 -= 5;
         per_key_led.push(key_colours.clone());
     }
-    for _ in 0..49 {
+    for _ in 0..46 {
         *key_colours.key(Key::ROG).0 += 5;
         *key_colours.key(Key::L).0 += 5;
         *key_colours.key(Key::I).0 += 5;
@@ -49,7 +49,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         per_key_led.push(key_colours.clone());
     }
 
-    let time = time::Duration::from_millis(1000);
+    let time = time::Duration::from_micros(1600);
 
     let row = KeyColourArray::get_init_msg();
     let msg =
@@ -58,22 +58,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     loop {
         let now = std::time::Instant::now();
-        thread::sleep(time);
-
         for group in &per_key_led {
-            let group = group.get();
+            for row in group.get() {
-            let msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "ledeffect")?
+                thread::sleep(time);
-                .append1(&group[0].to_vec())
+                let msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "ledmessage")?
-                .append1(&group[1].to_vec())
+                    .append1(row.to_vec());
-                .append1(&group[2].to_vec())
+                bus.send(msg).unwrap();
-                .append1(&group[3].to_vec())
+                // if let Some(reply) = r.get1::<&str>() {
-                .append1(&group[4].to_vec())
+                //     println!("Success: {:x?}", reply);
-                .append1(&group[5].to_vec())
+                //     return Ok(());
-                .append1(&group[6].to_vec())
+                // }
-                .append1(&group[7].to_vec())
+            }
-                .append1(&group[8].to_vec())
-                .append1(&group[9].to_vec());
-            bus.send(msg).unwrap();
         }
         let after = std::time::Instant::now();
         let diff = after.duration_since(now);

src/core.rs

@@ -128,9 +128,16 @@ impl RogCore {
     }
 
     pub fn aura_write(&mut self, message: &[u8]) -> Result<(), AuraError> {
-        self.handle
+        match self
-            .write_interrupt(self.led_endpoint, message, Duration::from_micros(1))
+            .handle
-            .unwrap();
+            .write_interrupt(self.led_endpoint, message, Duration::from_millis(1))
+        {
+            Ok(_) => {}
+            Err(err) => match err {
+                rusb::Error::Timeout => {}
+                _ => error!("Failed to read keyboard interrupt: {:?}", err),
+            },
+        }
         Ok(())
     }
 

src/daemon.rs

@@ -127,31 +127,37 @@ pub fn start_daemon() -> Result<(), Box<dyn Error>> {
 
     let supported = Vec::from(laptop.supported_modes());
     loop {
+        // A no-comp loop takes 2 milliseconds
+        // With effect, up to 16ms
+        // With single write, 3ms
+        // Actual EC for keyboard seems to take longer to process
         //thread::sleep(Duration::from_millis(2));
         connection
-            .process(Duration::from_millis(1))
+            .process(Duration::from_millis(20))
             .unwrap_or_else(|err| {
                 error!("{:?}", err);
                 false
             });
 
+        // 700u per write
         if let Ok(mut lock) = input.try_borrow_mut() {
             if let Some(bytes) = &*lock {
                 rogcore.aura_set_and_save(&supported, &bytes)?;
                 *lock = None;
             }
         }
+
         if let Ok(mut lock) = effect.try_borrow_mut() {
             if let Some(bytes) = &*lock {
-                // It takes up to 20 milliseconds to write a complete colour block...
+                // It takes up to 10 milliseconds to write a complete colour block...
-                //let now = std::time::Instant::now();
+                // let now = std::time::Instant::now();
                 for row in bytes {
                     rogcore.aura_write(&row)?;
                 }
                 *lock = None;
-                //let after = std::time::Instant::now();
+                // let after = std::time::Instant::now();
-                //let diff = after.duration_since(now);
+                // let diff = after.duration_since(now);
-                //dbg!(diff.as_millis());
+                // dbg!(diff.as_millis());
             }
         }