gilles/asusctl
1
0
Fork 0
mirror of https://gitlab.com/asus-linux/asusctl.git synced 2026-02-06 00:15:04 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'fluke/1854-device' into 'next'

Browse Source 
Try to fix up multizone modes

See merge request asus-linux/asus-nb-ctrl!19
This commit is contained in:
Luke Jones
2021-02-01 22:09:17 +00:00
parent 4fe9ab70e5 c6fa860b2e
commit 06d37aa009
11 changed files with 252 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
CHANGELOG.md
View File

@@ -5,6 +5,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [Unreleased]
### Changed
- Write set+apply after each array in multizone
- Remove misc bad logic
- Use same code path as 0x1866 device to configure led support
- Remove duplicate code
- Set correct speeds for multizone
# [2.2.2] - 2021-01-31
### Changed

4
asus-nb-ctrl/src/ctrl_gfx/system.rs
View File

@@ -56,13 +56,13 @@ impl PciBus {
}
pub struct GraphicsDevice {
id: String,
_id: String,
functions: Vec<PciDevice>,
}
impl GraphicsDevice {
pub fn new(id: String, functions: Vec<PciDevice>) -> GraphicsDevice {
GraphicsDevice { id, functions }
GraphicsDevice { _id: id, functions }
}
pub fn exists(&self) -> bool {

81
asus-nb-ctrl/src/ctrl_leds.rs
View File

@@ -50,6 +50,8 @@ impl GetSupported for CtrlKbdBacklight {
.map(|x| *x)
.collect();
stock_led_modes = Some(modes);
} else {
stock_led_modes = Some(modes);
}
}
@@ -111,9 +113,14 @@ impl DbusKbdBacklight {
}
_ => {
if let Ok(json) = serde_json::to_string(&data) {
ctrl.do_command(data, &mut cfg)
.unwrap_or_else(|err| warn!("{}", err));
self.notify_led(&json).ok();
match ctrl.do_command(data, &mut cfg) {
Ok(_) => {
self.notify_led(&json).ok();
}
Err(err) => {
warn!("{}", err);
}
}
}
}
}
@@ -281,29 +288,29 @@ impl CtrlKbdBacklight {
config: Arc<Mutex<Config>>,
) -> Result<Self, RogError> {
// TODO: return error if *all* nodes are None
let led_node = Self::get_node_failover(
id_product,
None,
Self::scan_led_node,
).map_or_else(|err| {
warn!("led_node: {}", err);
None
}, |node| Some(node));
let led_node = Self::get_node_failover(id_product, None, Self::scan_led_node).map_or_else(
|err| {
warn!("led_node: {}", err);
None
},
|node| Some(node),
);
let kbd_node = Self::get_node_failover(
id_product,
condev_iface,
Self::scan_kbd_node,
).map_or_else(|err| {
warn!("kbd_node: {}", err);
None
}, |node| Some(node));
let kbd_node = Self::get_node_failover(id_product, condev_iface, Self::scan_kbd_node)
.map_or_else(
|err| {
warn!("kbd_node: {}", err);
None
},
|node| Some(node),
);
let bright_node = Self::get_kbd_bright_path();
if led_node.is_none() && kbd_node.is_none() && Self::get_kbd_bright_path().is_err() {
return Err(RogError::MissingFunction(
"All keyboard features missing, you may require a v5.11 series kernel or newer".into(),
"All keyboard features missing, you may require a v5.11 series kernel or newer"
.into(),
));
}
@@ -438,6 +445,7 @@ impl CtrlKbdBacklight {
fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
if let Some(led_node) = &self.led_node {
if let Ok(mut file) = OpenOptions::new().write(true).open(led_node) {
// println!("write: {:02x?}", &message);
return file
.write_all(message)
.map_err(|err| RogError::Write("write_bytes".into(), err));
@@ -529,6 +537,10 @@ impl CtrlKbdBacklight {
#[inline]
fn write_mode(&mut self, mode: &AuraModes) -> Result<(), RogError> {
let mode_num: u8 = u8::from(mode);
if !self.supported_modes.contains(&mode_num) {
return Err(RogError::NotSupported);
}
match mode {
AuraModes::PerKey(v) => {
if v.is_empty() || v[0].is_empty() {
@@ -538,27 +550,22 @@ impl CtrlKbdBacklight {
self.write_effect(v)?;
}
}
_ => {
let mode_num: u8 = u8::from(mode);
match mode {
AuraModes::MultiStatic(_) => {
if self.supported_modes.contains(&mode_num) {
let bytes: [[u8; LED_MSG_LEN]; 4] = mode.into();
for array in bytes.iter() {
self.write_bytes(array)?;
}
}
}
_ => {
if self.supported_modes.contains(&mode_num) {
let bytes: [u8; LED_MSG_LEN] = mode.into();
self.write_bytes(&bytes)?;
}
}
AuraModes::MultiStatic(_) | AuraModes::MultiBreathe(_) => {
let bytes: [[u8; LED_MSG_LEN]; 4] = mode.into();
for array in bytes.iter() {
self.write_bytes(array)?;
}
self.write_bytes(&LED_SET)?;
// Changes won't persist unless apply is set
self.write_bytes(&LED_APPLY)?;
return Ok(());
}
_ => {
let bytes: [u8; LED_MSG_LEN] = mode.into();
self.write_bytes(&bytes)?;
self.write_bytes(&LED_SET)?;
// Changes won't persist unless apply is set
self.write_bytes(&LED_APPLY)?;
}
}
Ok(())

4
asus-nb-ctrl/src/ctrl_rog_bios.rs
View File

@@ -21,7 +21,7 @@ static ASUS_POST_LOGO_SOUND: &str =
"/sys/firmware/efi/efivars/AsusPostLogoSound-607005d5-3f75-4b2e-98f0-85ba66797a3e";
pub struct CtrlRogBios {
config: Arc<Mutex<Config>>,
_config: Arc<Mutex<Config>>,
}
#[derive(Serialize, Deserialize)]
@@ -138,7 +138,7 @@ impl CtrlRogBios {
}
}
Ok(CtrlRogBios { config })
Ok(CtrlRogBios { _config: config })
}
fn set_path_mutable(path: &str) -> Result<(), RogError> {

16
asus-nb-ctrl/src/daemon.rs
View File

@@ -178,13 +178,15 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
}
});
object_server.with(&"/org/asuslinux/Charge".try_into()?, |obj: &CtrlCharge| {
let x = obj.limit();
obj.notify_charge(x as u8)
}).map_err(|err| {
warn!("object_server notify_charge error: {}", err);
})
.ok();
object_server
.with(&"/org/asuslinux/Charge".try_into()?, |obj: &CtrlCharge| {
let x = obj.limit();
obj.notify_charge(x as u8)
})
.map_err(|err| {
warn!("object_server notify_charge error: {}", err);
})
.ok();
loop {
if let Err(err) = object_server.try_handle_next() {

37
asus-nb-ctrl/src/laptops.rs
View File

@@ -1,4 +1,4 @@
use asus_nb::aura_modes::{AuraModes, BREATHING, STATIC, STROBE};
use asus_nb::aura_modes::{AuraModes, BREATHING, STATIC};
use log::{info, warn};
use serde_derive::{Deserialize, Serialize};
use std::fs::OpenOptions;
@@ -8,6 +8,9 @@ pub static LEDMODE_CONFIG_PATH: &str = "/etc/asusd/asusd-ledmodes.toml";
pub static HELP_ADDRESS: &str = "https://gitlab.com/asus-linux/asus-nb-ctrl";
static LAPTOP_DEVICES: [u16; 3] = [0x1866, 0x1869, 0x1854];
#[derive(Debug)]
pub struct LaptopBase {
usb_product: String,
condev_iface: Option<String>, // required for finding the Consumer Device interface
@@ -27,24 +30,22 @@ impl LaptopBase {
}
pub fn match_laptop() -> Option<LaptopBase> {
for device in rusb::devices().expect("Failed here").iter() {
let device_desc = device.device_descriptor().expect("Failed there");
for device in rusb::devices().expect("Couldn't get device").iter() {
let device_desc = device.device_descriptor().expect("Couldn't get device descriptor");
if device_desc.vendor_id() == 0x0b05 {
match device_desc.product_id() {
0x1866 => {
let laptop = select_1866_device("1866".to_owned());
if LAPTOP_DEVICES.contains(&device_desc.product_id()) {
let prod_str = format!("{:x?}", device_desc.product_id());
if device_desc.product_id() == 0x1854 {
let mut laptop = laptop(prod_str, None);
if laptop.supported_modes.is_empty() {
laptop.supported_modes = vec![STATIC, BREATHING];
}
return Some(laptop);
}
0x1869 => return Some(select_1866_device("1869".to_owned())),
0x1854 => {
info!("Found GL753 or similar");
return Some(LaptopBase {
usb_product: "1854".to_string(),
condev_iface: None,
supported_modes: vec![STATIC, BREATHING, STROBE],
});
}
_ => {}
let laptop = laptop(prod_str, Some("02".to_owned()));
return Some(laptop);
}
}
}
@@ -56,14 +57,14 @@ pub fn match_laptop() -> Option<LaptopBase> {
None
}
fn select_1866_device(prod: String) -> LaptopBase {
fn laptop(prod: String, condev_iface: Option<String>) -> LaptopBase {
let dmi = sysfs_class::DmiId::default();
let board_name = dmi.board_name().expect("Could not get board_name");
let prod_family = dmi.product_family().expect("Could not get product_family");
let mut laptop = LaptopBase {
usb_product: prod,
condev_iface: Some("02".to_owned()),
condev_iface,
supported_modes: vec![],
};

1
asus-nb-ctrl/src/main.rs
View File

@@ -153,6 +153,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
if let Some(lst) = mode.self_command_list() {
println!("\n{}", lst);
}
println!("\nHelp can also be requested on modes, e.g: static --help");
}
if mode.next_mode && mode.prev_mode {
println!("Please specify either next or previous")

202
asus-nb/src/aura_modes.rs
View File

@@ -1,6 +1,8 @@
use crate::cli_options;
use crate::cli_options::SetAuraBuiltin;
use crate::error::AuraError;
use gumdrop::Options;
use serde_derive::{Deserialize, Serialize};
use std::str::FromStr;
pub const STATIC: u8 = 0x00;
pub const BREATHING: u8 = 0x01;
@@ -15,41 +17,56 @@ pub const PULSE: u8 = 0x0a;
pub const COMET: u8 = 0x0b;
pub const FLASH: u8 = 0x0c;
pub const MULTISTATIC: u8 = 0x0d;
pub const MULTIBREATHE: u8 = 0x0e;
pub const PER_KEY: u8 = 0xff;
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct Colour(pub u8, pub u8, pub u8);
impl From<cli_options::Colour> for Colour {
fn from(c: cli_options::Colour) -> Self {
Colour(c.0, c.1, c.2)
}
}
impl Default for Colour {
fn default() -> Self {
Colour(128, 0, 0)
}
}
impl FromStr for Colour {
type Err = AuraError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if s.len() < 6 {
return Err(AuraError::ParseColour);
}
let r = u8::from_str_radix(&s[0..2], 16).or(Err(AuraError::ParseColour))?;
let g = u8::from_str_radix(&s[2..4], 16).or(Err(AuraError::ParseColour))?;
let b = u8::from_str_radix(&s[4..6], 16).or(Err(AuraError::ParseColour))?;
Ok(Colour(r, g, b))
}
}
#[derive(Debug, Copy, Clone, Deserialize, Serialize)]
pub enum Speed {
Low = 0xe1,
Med = 0xeb,
High = 0xf5,
}
impl From<cli_options::Speed> for Speed {
fn from(s: cli_options::Speed) -> Self {
match s {
cli_options::Speed::Low => Speed::Low,
cli_options::Speed::Med => Speed::Med,
cli_options::Speed::High => Speed::High,
}
}
}
impl Default for Speed {
fn default() -> Self {
Speed::Med
}
}
impl FromStr for Speed {
type Err = AuraError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let s = s.to_lowercase();
match s.as_str() {
"low" => Ok(Speed::Low),
"med" => Ok(Speed::Med),
"high" => Ok(Speed::High),
_ => Err(AuraError::ParseSpeed),
}
}
}
/// Used for Rainbow mode.
///
@@ -61,107 +78,108 @@ pub enum Direction {
Up,
Down,
}
impl From<cli_options::Direction> for Direction {
fn from(s: cli_options::Direction) -> Self {
match s {
cli_options::Direction::Right => Direction::Right,
cli_options::Direction::Left => Direction::Left,
cli_options::Direction::Up => Direction::Up,
cli_options::Direction::Down => Direction::Down,
}
}
}
impl Default for Direction {
fn default() -> Self {
Direction::Right
}
}
impl FromStr for Direction {
type Err = AuraError;
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
pub struct TwoColourSpeed {
pub colour: Colour,
pub colour2: Colour,
pub speed: Speed,
}
impl From<cli_options::TwoColourSpeed> for TwoColourSpeed {
fn from(mode: cli_options::TwoColourSpeed) -> Self {
TwoColourSpeed {
colour: mode.colour.into(),
colour2: mode.colour2.into(),
speed: mode.speed.into(),
fn from_str(s: &str) -> Result<Self, Self::Err> {
let s = s.to_lowercase();
match s.as_str() {
"right" => Ok(Direction::Right),
"up" => Ok(Direction::Up),
"down" => Ok(Direction::Down),
"left" => Ok(Direction::Left),
_ => Err(AuraError::ParseDirection),
}
}
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[derive(Debug, Clone, Options, Default, Deserialize, Serialize)]
pub struct SingleSpeed {
#[serde(skip)]
#[options(help = "print help message")]
help: bool,
#[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
pub speed: Speed,
}
impl From<cli_options::SingleSpeed> for SingleSpeed {
fn from(mode: cli_options::SingleSpeed) -> Self {
SingleSpeed {
speed: mode.speed.into(),
}
}
#[derive(Debug, Clone, Options, Default, Deserialize, Serialize)]
pub struct SingleSpeedDirection {
#[serde(skip)]
#[options(help = "print help message")]
help: bool,
#[options(no_long, meta = "", help = "set the direction: up, down, left, right")]
pub direction: Direction,
#[options(no_long, meta = "", help = "set the speed: low, med, high")]
pub speed: Speed,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[derive(Debug, Clone, Default, Options, Deserialize, Serialize)]
pub struct SingleColour {
#[serde(skip)]
#[options(help = "print help message")]
help: bool,
#[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour: Colour,
}
impl From<cli_options::SingleColour> for SingleColour {
fn from(mode: cli_options::SingleColour) -> Self {
SingleColour {
colour: mode.colour.into(),
}
}
#[derive(Debug, Clone, Default, Options, Deserialize, Serialize)]
pub struct SingleColourSpeed {
#[serde(skip)]
#[options(help = "print help message")]
help: bool,
#[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour: Colour,
#[options(no_long, meta = "", help = "set the speed: low, med, high")]
pub speed: Speed,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
pub struct MultiColour {
pub colour1: Colour,
#[derive(Debug, Clone, Options, Default, Deserialize, Serialize)]
pub struct TwoColourSpeed {
#[serde(skip)]
#[options(help = "print help message")]
help: bool,
#[options(no_long, meta = "", help = "set the first RGB value e.g, ff00ff")]
pub colour: Colour,
#[options(no_long, meta = "", help = "set the second RGB value e.g, ff00ff")]
pub colour2: Colour,
#[options(no_long, meta = "", help = "set the speed: low, med, high")]
pub speed: Speed,
}
#[derive(Debug, Clone, Default, Options, Deserialize, Serialize)]
pub struct MultiColour {
#[serde(skip)]
#[options(help = "print help message")]
help: bool,
#[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour1: Colour,
#[options(short = "b", meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour2: Colour,
#[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour3: Colour,
#[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour4: Colour,
}
impl From<cli_options::MultiColour> for MultiColour {
fn from(mode: cli_options::MultiColour) -> Self {
MultiColour {
colour1: mode.colour1.into(),
colour2: mode.colour2.into(),
colour3: mode.colour3.into(),
colour4: mode.colour4.into(),
}
}
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
pub struct SingleSpeedDirection {
pub direction: Direction,
#[derive(Debug, Clone, Default, Options, Deserialize, Serialize)]
pub struct MultiColourSpeed {
#[options(help = "print help message")]
help: bool,
#[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour1: Colour,
#[options(short = "b", meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour2: Colour,
#[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour3: Colour,
#[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour4: Colour,
#[options(no_long, meta = "", help = "set the speed: low, med, high")]
pub speed: Speed,
}
impl From<cli_options::SingleSpeedDirection> for SingleSpeedDirection {
fn from(mode: cli_options::SingleSpeedDirection) -> Self {
SingleSpeedDirection {
direction: mode.direction.into(),
speed: mode.speed.into(),
}
}
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
pub struct SingleColourSpeed {
pub colour: Colour,
pub speed: Speed,
}
impl From<cli_options::SingleColourSpeed> for SingleColourSpeed {
fn from(mode: cli_options::SingleColourSpeed) -> Self {
SingleColourSpeed {
colour: mode.colour.into(),
speed: mode.speed.into(),
}
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub enum AuraModes {
@@ -178,8 +196,10 @@ pub enum AuraModes {
Comet(SingleColour),
Flash(SingleColour),
MultiStatic(MultiColour),
MultiBreathe(MultiColourSpeed),
LedBrightness(u8),
// TODO: use a serializable structure for this (KeyColourArray)
#[serde(skip)]
PerKey(Vec<Vec<u8>>),
}
@@ -199,6 +219,7 @@ impl From<SetAuraBuiltin> for AuraModes {
SetAuraBuiltin::Comet(x) => AuraModes::Comet(x.into()),
SetAuraBuiltin::Flash(x) => AuraModes::Flash(x.into()),
SetAuraBuiltin::MultiStatic(x) => AuraModes::MultiStatic(x.into()),
SetAuraBuiltin::MultiBreathe(x) => AuraModes::MultiBreathe(x.into()),
}
}
}
@@ -234,6 +255,7 @@ impl From<&AuraModes> for u8 {
AuraModes::Comet(_) => COMET,
AuraModes::Flash(_) => FLASH,
AuraModes::MultiStatic(_) => MULTISTATIC,
AuraModes::MultiBreathe(_) => MULTIBREATHE,
AuraModes::PerKey(_) => PER_KEY,
_ => panic!("Invalid mode"),
}
@@ -256,6 +278,7 @@ impl From<&AuraModes> for &str {
AuraModes::Comet(_) => "Comet",
AuraModes::Flash(_) => "Flash",
AuraModes::MultiStatic(_) => "4-Zone Static Colours",
AuraModes::MultiBreathe(_) => "4-Zone Breathing Colours",
AuraModes::PerKey(_) => "RGB per-key",
_ => panic!("Invalid mode"),
}
@@ -280,6 +303,7 @@ impl From<u8> for AuraModes {
COMET => AuraModes::Comet(SingleColour::default()),
FLASH => AuraModes::Flash(SingleColour::default()),
MULTISTATIC => AuraModes::MultiStatic(MultiColour::default()),
MULTIBREATHE => AuraModes::MultiBreathe(MultiColourSpeed::default()),
PER_KEY => AuraModes::PerKey(vec![]),
_ => panic!("Invalid mode byte"),
}

159
asus-nb/src/cli_options.rs
View File

@@ -1,4 +1,10 @@
use crate::error::AuraError;
use crate::{
aura_modes::{
MultiColour, MultiColourSpeed, SingleColour, SingleColourSpeed, SingleSpeed,
SingleSpeedDirection, TwoColourSpeed,
},
error::AuraError,
};
use gumdrop::Options;
use serde_derive::{Deserialize, Serialize};
use std::str::FromStr;
@@ -48,148 +54,6 @@ impl ToString for LedBrightness {
}
}
#[derive(Deserialize, Serialize)]
pub struct Colour(pub u8, pub u8, pub u8);
impl Default for Colour {
fn default() -> Self {
Colour(255, 0, 0)
}
}
impl FromStr for Colour {
type Err = AuraError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
if s.len() < 6 {
return Err(AuraError::ParseColour);
}
let r = u8::from_str_radix(&s[0..2], 16).or(Err(AuraError::ParseColour))?;
let g = u8::from_str_radix(&s[2..4], 16).or(Err(AuraError::ParseColour))?;
let b = u8::from_str_radix(&s[4..6], 16).or(Err(AuraError::ParseColour))?;
Ok(Colour(r, g, b))
}
}
#[derive(Deserialize, Serialize)]
pub enum Speed {
Low = 0xe1,
Med = 0xeb,
High = 0xf5,
}
impl Default for Speed {
fn default() -> Self {
Speed::Med
}
}
impl FromStr for Speed {
type Err = AuraError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let s = s.to_lowercase();
match s.as_str() {
"low" => Ok(Speed::Low),
"med" => Ok(Speed::Med),
"high" => Ok(Speed::High),
_ => Err(AuraError::ParseSpeed),
}
}
}
/// Used for Rainbow mode.
///
/// Enum corresponds to the required integer value
#[derive(Deserialize, Serialize)]
pub enum Direction {
Right,
Left,
Up,
Down,
}
impl Default for Direction {
fn default() -> Self {
Direction::Right
}
}
impl FromStr for Direction {
type Err = AuraError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let s = s.to_lowercase();
match s.as_str() {
"right" => Ok(Direction::Right),
"up" => Ok(Direction::Up),
"down" => Ok(Direction::Down),
"left" => Ok(Direction::Left),
_ => Err(AuraError::ParseDirection),
}
}
}
#[derive(Default, Options, Deserialize, Serialize)]
pub struct TwoColourSpeed {
#[options(help = "print help message")]
help: bool,
#[options(no_long, meta = "HEX", help = "set the first RGB value e.g, ff00ff")]
pub colour: Colour,
#[options(no_long, meta = "HEX", help = "set the second RGB value e.g, ff00ff")]
pub colour2: Colour,
#[options(no_long, help = "set the speed: low, med, high")]
pub speed: Speed,
}
#[derive(Default, Options, Deserialize, Serialize)]
pub struct SingleSpeed {
#[options(help = "print help message")]
help: bool,
#[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
pub speed: Speed,
}
#[derive(Default, Options, Deserialize, Serialize)]
pub struct SingleColour {
#[options(help = "print help message")]
help: bool,
#[options(no_long, meta = "HEX", help = "set the RGB value e.g, ff00ff")]
pub colour: Colour,
}
#[derive(Default, Options, Deserialize, Serialize)]
pub struct MultiColour {
#[options(help = "print help message")]
help: bool,
#[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
pub colour1: Colour,
#[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
pub colour2: Colour,
#[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
pub colour3: Colour,
#[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
pub colour4: Colour,
}
#[derive(Default, Options, Deserialize, Serialize)]
pub struct SingleSpeedDirection {
#[options(help = "print help message")]
help: bool,
#[options(
no_long,
meta = "DIR",
help = "set the direction: up, down, left, right"
)]
pub direction: Direction,
#[options(no_long, help = "set the speed: low, med, high")]
pub speed: Speed,
}
#[derive(Default, Options, Deserialize, Serialize)]
pub struct SingleColourSpeed {
#[options(help = "print help message")]
help: bool,
#[options(no_long, meta = "HEX", help = "set the RGB value e.g, ff00ff")]
pub colour: Colour,
#[options(no_long, help = "set the speed: low, med, high")]
pub speed: Speed,
}
/// Byte value for setting the built-in mode.
///
/// Enum corresponds to the required integer value
@@ -221,14 +85,13 @@ pub enum SetAuraBuiltin {
Flash(SingleColour),
#[options(help = "4-zone multi-colour")]
MultiStatic(MultiColour),
#[options(help = "4-zone multi-colour breathing")]
MultiBreathe(MultiColourSpeed),
}
impl Default for SetAuraBuiltin {
fn default() -> Self {
SetAuraBuiltin::Static(SingleColour {
help: false,
colour: Colour(255, 0, 0),
})
SetAuraBuiltin::Static(SingleColour::default())
}
}
@@ -269,7 +132,7 @@ pub struct AniMeLeds {
no_long,
required,
short = "b",
meta = "BYTE",
meta = "",
help = "set all leds brightness value"
)]
led_brightness: u8,

43
asus-nb/src/lib.rs
View File

@@ -153,6 +153,7 @@ impl From<&AuraModes> for [u8; LED_MSG_LEN] {
let mut msg = [0u8; LED_MSG_LEN];
msg[0] = 0x5d;
msg[1] = 0xb3;
msg[7] = 0xeb;
match mode {
AuraModes::LedBrightness(n) => return aura_brightness_bytes(*n),
AuraModes::Static(_) => msg[3] = 0x00,
@@ -234,14 +235,15 @@ impl From<&AuraModes> for [[u8; LED_MSG_LEN]; 4] {
#[inline]
fn from(mode: &AuraModes) -> Self {
let mut msg = [[0u8; LED_MSG_LEN]; 4];
for (i, row) in msg.iter_mut().enumerate() {
row[0] = 0x5d;
row[1] = 0xb3;
row[2] = i as u8 + 1;
}
match mode {
AuraModes::MultiStatic(settings) => {
for (i, row) in msg.iter_mut().enumerate() {
row[0] = 0x5d;
row[1] = 0xb3;
row[2] = i as u8 + 1; // zone
row[3] = 0x00; // mode
row[7] = 0xeb; // static needs speed?
}
msg[0][4] = settings.colour1.0;
msg[0][5] = settings.colour1.1;
msg[0][6] = settings.colour1.2;
@@ -255,6 +257,35 @@ impl From<&AuraModes> for [[u8; LED_MSG_LEN]; 4] {
msg[3][5] = settings.colour4.1;
msg[3][6] = settings.colour4.2;
}
AuraModes::MultiBreathe(settings) => {
for (i, row) in msg.iter_mut().enumerate() {
row[0] = 0x5d;
row[1] = 0xb3;
row[2] = i as u8 + 1; // zone
row[3] = 0x01; // mode
}
let speed = match settings.speed {
aura_modes::Speed::Low => 0xfd,
aura_modes::Speed::Med => 0xfe,
aura_modes::Speed::High => 0xff,
};
msg[0][4] = settings.colour1.0;
msg[0][5] = settings.colour1.1;
msg[0][6] = settings.colour1.2;
msg[0][7] = speed; // fd, fe, ff
msg[1][4] = settings.colour2.0;
msg[1][5] = settings.colour2.1;
msg[1][6] = settings.colour2.2;
msg[1][7] = speed;
msg[2][4] = settings.colour3.0;
msg[2][5] = settings.colour3.1;
msg[2][6] = settings.colour3.2;
msg[2][7] = speed;
msg[3][4] = settings.colour4.0;
msg[3][5] = settings.colour4.1;
msg[3][6] = settings.colour4.2;
msg[3][7] = speed;
}
_ => panic!("Mode not convertable to 2D array: {}", <&str>::from(mode)),
}
msg

11
data/asusd-ledmodes.toml
View File

@@ -26,7 +26,7 @@ led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 255]
[[led_modes]]
prod_family = "ROG Strix"
board_names = ["GX531", "G512LV", "G712LV"]
led_modes = [0, 1, 2, 3, 10, 13]
led_modes = [0, 1, 2, 3, 10, 13, 14]
[[led_modes]]
prod_family = "ROG Strix"
@@ -36,7 +36,7 @@ led_modes = [0, 1, 2, 3, 10]
[[led_modes]]
prod_family = "Strix"
board_names = ["G731GV", "G731GW", "G531GV"]
led_modes = [0, 1, 2, 3, 13]
led_modes = [0, 1, 2, 3, 13, 14]
[[led_modes]]
prod_family = "Strix"
@@ -46,4 +46,9 @@ led_modes = [0, 1, 2, 3]
[[led_modes]]
prod_family = "Strix Scar"
board_names = ["G531", "G731"]
led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 255]
led_modes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 255]
[[led_modes]]
prod_family = "ROG"
board_names = ["GL553VE"]
led_modes = [0, 1, 2, 13, 14]