gilles/asusctl
1
0
Fork 0
mirror of https://gitlab.com/asus-linux/asusctl.git synced 2026-01-22 17:33:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Luke
2020-04-24 23:41:00 +12:00
parent 9846437efb
commit f05103b5c9
4 changed files with 118 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
examples/per-key-effect-2.rs Normal file
View File

@@ -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(());
}
}

31
examples/per-key-effect.rs
View File

@@ -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();
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();
for row in group.get() {
thread::sleep(time);
let msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "ledmessage")?
.append1(row.to_vec());
bus.send(msg).unwrap();
// if let Some(reply) = r.get1::<&str>() {
// println!("Success: {:x?}", reply);
// return Ok(());
// }
}
}
let after = std::time::Instant::now();
let diff = after.duration_since(now);

13
src/core.rs
View File

@@ -128,9 +128,16 @@ impl RogCore {
}
pub fn aura_write(&mut self, message: &[u8]) -> Result<(), AuraError> {
self.handle
.write_interrupt(self.led_endpoint, message, Duration::from_micros(1))
.unwrap();
match self
.handle
.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(())
}

18
src/daemon.rs
View File

@@ -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...
//let now = std::time::Instant::now();
// It takes up to 10 milliseconds to write a complete colour block...
// let now = std::time::Instant::now();
for row in bytes {
rogcore.aura_write(&row)?;
}
*lock = None;
//let after = std::time::Instant::now();
//let diff = after.duration_since(now);
//dbg!(diff.as_millis());
// let after = std::time::Instant::now();
// let diff = after.duration_since(now);
// dbg!(diff.as_millis());
}
}