Add LED support for GX703HS

Closes #207

.gitlab-ci.yml

@@ -10,6 +10,7 @@ stages:
 test:
   script:
     - cargo check #+nightly check --features "clippy"
+    - cargo test
 
 build:
   only:

CHANGELOG.md

@@ -4,7 +4,77 @@ All notable changes to this project will be documented in this file.
 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]
+## [Unreleased ]
+
+## [4.2.0] - 2022-07-16
+### Added
+- Support for GA402 Anime Matrix display (Author: I-Al-Istannen & Luke Jones)
+- Support for power-config of all LED zones. See `asusctrl led-power --help` (Author: Luke Jones, With much help from: @MNS26)
+- Full support for multizone LED <logo, keyboard, lightbar> (Author: Luke Jones, With much help from: @MNS26)
+- Add ability to load extra data from `/etc/asusd/asusd-user-ledmodes.toml` for LED support if file exits
+- Support for G513IM LED modes
+- Support for GX703HS LED modes
+### Changed
+- Dbus interface for Aura config has been changed, all power control is done with `SetLedsEnabled` and `SetLedsDisabled`
+- Data for anime-matrix now requires passing the laptop model as enum
+- Extra unit tests for anime stuff to help verify things
+
+### Added
+- Support for GA503R LED modes
+### Changed
+- Refactor LED and AniMe tasks
+- Reload keyboard brightness on resume from sleep/hiber
+
+## [4.1.1] - 2022-06-21
+### Changed
+- Fixes to anime matrix system thread cancelation
+
+## [4.1.0] - 2022-06-20
+### Changed
+- Huge refactor to use zbus 2.2 + zvariant 3.0 in system-daemon.
+- Daemons with tasks now use `smol` for async ops.
+- Fixes to fan-curve settings from CLI (Author: Armas Span)
+- Add brightness to anime zbus notification
+- Adjust how threads in AniMe matrix controller work
+- Use proper power-state packet for keyboard LED's (Author: Martin Piffault)
+### Added
+- Support for GA402R LED modes
+- Support for GU502LV LED modes
+- Support for G512 LED modes
+- Support for G513IC LED modes (Author: dada513)
+- Support for G513QM LED modes (Author: Martin Piffault)
+- Add side-LED toggle support (Author: Martin Piffault)
+- Support reloading keyboard mode on wake (from sleep/hiber)
+- Support reloading charge-level on wake (from sleep/hiber)
+- Support running AniMe animation blocks on wake/sleep and boot/shutdown events
+
+# [4.0.7] - 2021-12-19
+### Changed
+- Fix incorrect power-profile validation
+- Update asusd-ledmodes.toml to support Asus Rog Strix G15 G513QE (@LordVicky)
+- Update patch notes and links
+
+# [4.0.6] - 2021-11-01
+### Changed
+- Fix CLI for bios toggles
+### Added
+- Extra commands for AniMe: pixel-image, gif, pixel-gif
+
+# [4.0.5] - 2021-10-27
+### Changed
+- Convert fan curve percentage to 0-255 expected by kernel driver only if '%' char is used, otherwise the expected range for fan power is 0-255
+- Use correct error in daemon for invalid charging limit
+- Enforce charging limit values in range 20-100
+### Added
+- LED modes for G513QR
+
+# [4.0.4] - 2021-10-02
+### Changed
+- Add missing Profile commands
+- Spawn tasks on individual threads to prevent blocking
+- Don't force fan-curve default on reload
+- Begin obsoleting the graphics switch command in favour of supergfxctl
+- Slim down the notification daemon to pure ASUS notifications
 
 # [4.0.3] - 2021-09-16
 ### Changed

Cargo.toml

@@ -2,7 +2,9 @@
 members = ["asusctl", "asus-notify", "daemon", "daemon-user", "rog-supported", "rog-dbus", "rog-anime", "rog-aura", "rog-profiles"]
 
 [profile.release]
-lto = true
+# thin = 57s, asusd = 9.0M
+# fat = 72s, asusd = 6.4M
+lto = "fat"
 debug = false
 opt-level = 3
 panic = "abort"

MANUAL.md

@@ -60,17 +60,17 @@ The defaults are located at `/etc/asusd/asusd-ledmodes.toml`, and on `asusd` sta
 Example:
 ```toml
 [[led_data]]
-prod_family = "ROG Zephyrus M15"
-board_names = ["GU502LU"]
-standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = false
+prod_family = "Strix"
+board_names = ["GL504G"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = ["Key1", "Key2", "Key3", "Key4", "Logo", "BarLeft", "BarRight"]
 per_key = false
 ```
 
 1. `prod_family`: you can find this in `journalctl -b -u asusd`, or `cat /sys/class/dmi/id/product_name`. It should be copied as written. There can be multiple `led-data` groups of the same `prod_family` with differing `board_names`.
 2. `board_names`: is an array of board names in this product family. Find this in the journal as above or by `cat /sys/class/dmi/id/board_name`.
 3. `standard` are the factory preset modes, the names should corrospond to Armory Crate names
-4. `multizone`: some keyboards have 4 zones of LED control, this enables setting a colour in each zone. The keyboard must support this or it has no effect.
+4. `multizone`: some models have 4 to 7 zones of LED control as shown in the example. If the laptop has no zones then an empty array will suffice.
 5. `per_key`: enable per-key RGB effects. The keyboard must support this or it has no effect.
 
 ##### /etc/asusd/aura.conf
@@ -97,7 +97,7 @@ These options are not written to the config file as they are stored in efivars.
 
 ### Profiles
 
-asusctl can support setting a power profile via platform_profile drivers. This requires [power-profiles-daemon](https://gitlab.freedesktop.org/hadess/power-profiles-daemon) v0.9.0 minimum. It also requires the kernel patch for platform_profile support to be applied form [here](https://lkml.org/lkml/2021/8/18/1022) - this patch is included in the "rog" kernels we build for fedora and arch, and will hit kernel 5.15 upstream.
+asusctl can support setting a power profile via platform_profile drivers. This requires [power-profiles-daemon](https://gitlab.freedesktop.org/hadess/power-profiles-daemon) v0.10.0 minimum. It also requires the kernel patch for platform_profile support to be applied form [here](https://lkml.org/lkml/2021/8/18/1022) - this patch is merged to 5.15 kernel upstream.
 
 A common use of asusctl is to bind the `fn+f5` (fan) key to `asusctl profile -n` to cycle through the 3 profiles:
 1. Balanced
@@ -106,7 +106,7 @@ A common use of asusctl is to bind the `fn+f5` (fan) key to `asusctl profile -n`
 
 #### Fan curves
 
-Fan curve support requires a laptop that supports it (this is detected automatically) and the kernel patch from [here](https://lkml.org/lkml/2021/8/29/50) which is still in review as of 29/09/21. As with Profiles, this is included in the kernels we build, and will hit 5.15 kernel upstream.
+Fan curve support requires a laptop that supports it (this is detected automatically) and the kernel patch from [here](https://lkml.org/lkml/2021/10/23/250) which is accepted for the 5.17 kernel release .
 
 The fan curve format can be of varying formats:
 
@@ -356,4 +356,4 @@ Reference to any ASUS products, services, processes, or other information and/or
 
 The use of ROG and ASUS trademarks within this website and associated tools and libraries is only to provide a recognisable identifier to users to enable them to associate that these tools will work with ASUS ROG laptops.
 
----
+---

README.md

@@ -5,10 +5,11 @@
 `asusd` is a utility for Linux to control many aspects of various ASUS laptops
 but can also be used with non-asus laptops with reduced features.
 
-## Kernel patches required
+## Kernel support
 
-1. https://lkml.org/lkml/2021/8/20/232
-2. https://lkml.org/lkml/2021/8/18/1022
+**The minimum supported kernel version is 5.15**
+
+Fan curve control on laptops with this feature require [this patch](https://lkml.org/lkml/2021/10/23/250) which has been merged for 5.17 upstream.
 
 ## Goals
 
@@ -24,10 +25,6 @@ supported (while asusd might still run fine on them). For best support use fedor
 Point 4? asusd currently uses a tiny fraction of cpu time, and less than 1Mb of ram, the way
 a system-level daemon should.
 
-**NOTICE:**
-
-Various patches are required for keyboard support. See [this post](https://asus-linux.org/blog/updates-2021-05-06/) for details on status and which kernels will have which patches.
-
 ## Discord
 
 [Discord server link](https://discord.gg/4ZKGd7Un5t)
@@ -61,27 +58,27 @@ will probably suffer another rename once it becomes generic enough to do so.
 
 # BUILDING
 
-Requirements are rust >= 1.47 installed from rustup.io if the distro provided version is too old, and `make`.
+Requirements are rust >= 1.57 installed from rustup.io if the distro provided version is too old, and `make`.
 
-**Ubuntu:** `apt install libclang-dev libudev-dev`
+**Ubuntu (unsuported):**
 
-**fedora:** `dnf install clang-devel systemd-devel`
+    apt install libclang-dev libudev-dev
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+    make
+    sudo make install
+
+**fedora:**
+
+    dnf install clang-devel systemd-devel cargo
+    make
+    sudo make install
 
 ## Installing
+- Fedora copr = https://copr.fedorainfracloud.org/coprs/lukenukem/asus-linux/
+- openSUSE = https://download.opensuse.org/repositories/home:/luke_nukem:/asus/
+- Ubuntu = not supported due to packaging woes, but you can build and install on your own.
 
-Download repositories are available [here](https://download.opensuse.org/repositories/home:/luke_nukem:/asus/) for the latest versions of Fedora, Ubuntu, and openSUSE.
-
-### Ubuntu
-
-    sudo su -c "echo 'deb https://download.opensuse.org/repositories/home:/luke_nukem:/asus/xUbuntu_21.04/ /' > /etc/apt/sources.list.d/luke_nukem.list"
-    curl -fsSL https://download.opensuse.org/repositories/home:/luke_nukem:/asus/xUbuntu_21.04/Release.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/home_luke_nukem.gpg > /dev/null
-    sudo apt-get update
-    sudo apt-get install asusctl dkms-hid-asus-rog
-
-
----
-
-Run `make` then `sudo make install` then reboot.
+=======
 
 The default init method is to use the udev rule, this ensures that the service is
 started when the device is initialised and ready.

asus-notify/Cargo.toml

@@ -1,20 +1,20 @@
 [package]
 name = "asus-notify"
-version = "3.0.2"
+version = "3.1.0"
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-zbus = "^1.9"
+zbus = "^2.2"
 # serialisation
 serde_json = "^1.0"
 rog_dbus = { path = "../rog-dbus" }
 rog_aura = { path = "../rog-aura" }
 rog_supported = { path = "../rog-supported" }
 rog_profiles = { path = "../rog-profiles" }
-supergfxctl = { git = "https://gitlab.com/asus-linux/supergfxctl.git", tag = "2.0.0" }
+smol = "^1.2"
 
 [dependencies.notify-rust]
 version = "^4.3"

asus-notify/src/main.rs

@@ -1,15 +1,16 @@
 use notify_rust::{Hint, Notification, NotificationHandle};
 use rog_aura::AuraEffect;
-use rog_dbus::{DbusProxies, Signals};
+use rog_dbus::{
+    zbus_charge::ChargeProxy, zbus_led::LedProxy, zbus_profile::ProfileProxy,
+    zbus_rogbios::RogBiosProxy,
+};
 use rog_profiles::Profile;
-use std::error::Error;
-use std::sync::mpsc::channel;
-use std::thread::sleep;
-use std::time::Duration;
-use std::{process, thread};
-use supergfxctl::gfx_vendors::{GfxRequiredUserAction, GfxVendors};
-use supergfxctl::zbus_proxy::GfxProxy;
-use zbus::Connection;
+use smol::{future, Executor};
+use std::{
+    error::Error,
+    sync::{Arc, Mutex},
+};
+use zbus::export::futures_util::StreamExt;
 
 const NOTIF_HEADER: &str = "ROG Control";
 
@@ -19,7 +20,7 @@ macro_rules! notify {
             notif.close();
         }
         if let Ok(x) = $notifier($data) {
-            $last_notif = Some(x);
+            $last_notif.replace(x);
         }
     };
 }
@@ -34,99 +35,99 @@ macro_rules! base_notification {
     };
 }
 
+type SharedHandle = Arc<Mutex<Option<NotificationHandle>>>;
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("asus-notify version {}", env!("CARGO_PKG_VERSION"));
     println!("   rog-dbus version {}", rog_dbus::VERSION);
-    println!("supergfxctl version {}", supergfxctl::VERSION);
 
-    let (proxies, conn) = DbusProxies::new()?;
-    let signals = Signals::new(&proxies)?;
+    let last_notification: SharedHandle = Arc::new(Mutex::new(None));
 
-    let mut last_notification: Option<NotificationHandle> = None;
+    let executor = Executor::new();
+    // BIOS notif
+    let x = last_notification.clone();
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = RogBiosProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_post_boot_sound().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = x.try_lock() {
+                            notify!(do_post_sound_notif, lock, &out.sound());
+                        }
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
 
-    let recv = proxies.setup_recv(conn);
-    let mut err_count = 0;
+    // Charge notif
+    let x = last_notification.clone();
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = ChargeProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_charge().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = x.try_lock() {
+                            notify!(do_charge_notif, lock, &out.limit);
+                        }
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
 
-    gfx_thread()?;
+    // Profile notif
+    let x = last_notification.clone();
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = ProfileProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_profile().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = x.try_lock() {
+                            notify!(do_thermal_notif, lock, &out.profile);
+                        }
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
+
+    // LED notif
+    executor
+        .spawn(async move {
+            let conn = zbus::Connection::system().await.unwrap();
+            let proxy = LedProxy::new(&conn).await.unwrap();
+            if let Ok(p) = proxy.receive_notify_led().await {
+                p.for_each(|e| {
+                    if let Ok(out) = e.args() {
+                        if let Ok(ref mut lock) = last_notification.try_lock() {
+                            notify!(do_led_notif, lock, &out.data);
+                        }
+                    }
+                    future::ready(())
+                })
+                .await;
+            };
+        })
+        .detach();
 
     loop {
-        sleep(Duration::from_millis(100));
-        if let Err(err) = recv.next_signal() {
-            if err_count < 3 {
-                err_count += 1;
-                println!("{}", err);
-            }
-            if err_count == 3 {
-                err_count += 1;
-                println!("Max error count reached. Spooling silently.");
-            }
-            sleep(Duration::from_millis(2000));
-            continue;
-        }
-        err_count = 0;
-
-        if let Ok(data) = signals.led_mode.try_recv() {
-            notify!(do_led_notif, last_notification, &data);
-        }
-        if let Ok(data) = signals.profile.try_recv() {
-            notify!(do_thermal_notif, last_notification, &data);
-        }
-        if let Ok(data) = signals.charge.try_recv() {
-            notify!(do_charge_notif, last_notification, &data);
-        }
+        smol::block_on(executor.tick());
     }
 }
 
-fn gfx_thread() -> Result<(), Box<dyn std::error::Error>> {
-    let mut last_notification: Option<NotificationHandle> = None;
-
-    let conn = Connection::new_system()?;
-    let proxy = GfxProxy::new(&conn)?;
-
-    let (tx1, rx1) = channel();
-    proxy.connect_notify_gfx(tx1)?;
-
-    let (tx2, rx2) = channel();
-    proxy.connect_notify_action(tx2)?;
-
-    thread::spawn(move || loop {
-        if proxy
-            .next_signal()
-            .map_err(|e| println!("Error: {}", e))
-            .is_err()
-        {
-            break;
-        }
-
-        if let Ok(data) = rx1.try_recv() {
-            notify!(do_gfx_notif, last_notification, &data);
-        }
-
-        if let Ok(data) = rx2.try_recv() {
-            match data {
-                GfxRequiredUserAction::Logout | GfxRequiredUserAction::Reboot => {
-                    do_gfx_action_notif(&data)
-                        .map_err(|e| {
-                            println!("Error: {}", e);
-                        })
-                        .ok();
-                }
-                GfxRequiredUserAction::Integrated => {
-                    base_notification!(
-                        "You must be in integrated mode first to switch to the requested mode"
-                    )
-                    .map_err(|e| {
-                        println!("Error: {}", e);
-                    })
-                    .ok();
-                }
-                GfxRequiredUserAction::None => {}
-            }
-        }
-    });
-    Ok(())
-}
-
 fn do_thermal_notif(profile: &Profile) -> Result<NotificationHandle, Box<dyn Error>> {
     let icon = match profile {
         Profile::Balanced => "asus_notif_yellow",
@@ -160,51 +161,6 @@ fn do_charge_notif(limit: &u8) -> Result<NotificationHandle, notify_rust::error:
     base_notification!(&format!("Battery charge limit changed to {}", limit))
 }
 
-fn do_gfx_notif(vendor: &GfxVendors) -> Result<NotificationHandle, notify_rust::error::Error> {
-    let icon = match vendor {
-        GfxVendors::Nvidia => "/usr/share/icons/hicolor/scalable/status/gpu-nvidia.svg",
-        GfxVendors::Integrated => "/usr/share/icons/hicolor/scalable/status/gpu-integrated.svg",
-        GfxVendors::Compute => "/usr/share/icons/hicolor/scalable/status/gpu-compute.svg",
-        GfxVendors::Vfio => "/usr/share/icons/hicolor/scalable/status/gpu-vfio.svg",
-        GfxVendors::Hybrid => "/usr/share/icons/hicolor/scalable/status/gpu-hybrid.svg",
-    };
-    Notification::new()
-        .summary(NOTIF_HEADER)
-        .body(&format!(
-            "Graphics mode changed to {}",
-            <&str>::from(vendor)
-        ))
-        .timeout(2000)
-        .icon(icon)
-        .show()
-}
-
-fn do_gfx_action_notif(vendor: &GfxRequiredUserAction) -> Result<(), notify_rust::error::Error> {
-    let mut notif = Notification::new()
-        .summary(NOTIF_HEADER)
-        .timeout(2000)
-        .urgency(notify_rust::Urgency::Critical)
-        .icon("/usr/share/icons/hicolor/scalable/status/notification-reboot.svg")
-        .finalize();
-
-    if matches!(vendor, GfxRequiredUserAction::Logout) {
-        notif.action("logout", "Logout now?");
-    } else if matches!(vendor, GfxRequiredUserAction::Reboot) {
-        notif.action("reboot", "Reboot now?");
-    }
-
-    notif.body("Graphics mode changed");
-    notif.show()?.wait_for_action(|action| match action {
-        "logout" => {
-            process::Command::new("gnome-session-quit").spawn().ok();
-        }
-        "reboot" => {
-            process::Command::new("systemctl")
-                .arg("reboot")
-                .spawn()
-                .ok();
-        }
-        _ => (),
-    });
-    Ok(())
+fn do_post_sound_notif(on: &bool) -> Result<NotificationHandle, notify_rust::error::Error> {
+    base_notification!(&format!("BIOS Post sound {}", on))
 }

asusctl/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "asusctl"
-version = "4.0.3"
+version = "4.0.7"
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-zbus = "^1.9.1"
+zbus = "^2.2"
 rog_anime = { path = "../rog-anime" }
 rog_aura = { path = "../rog-aura" }
 rog_dbus = { path = "../rog-dbus" }
@@ -15,13 +15,12 @@ rog_profiles = { path = "../rog-profiles" }
 rog_supported = { path = "../rog-supported" }
 daemon = { path = "../daemon" }
 gumdrop = "^0.8"
-supergfxctl = { git = "https://gitlab.com/asus-linux/supergfxctl.git", tag = "2.0.0" }
 toml = "^0.5.8"
 
 sysfs-class = "^0.1.2"
 
 [dev-dependencies]
-tinybmp = "^0.2.3"
-glam = "0.14.0"
+tinybmp = "^0.3.3"
+glam = "0.20.5"
 rog_dbus = { path = "../rog-dbus" }
 gif = "^0.11.2"

asusctl/examples/anime-diag-png.rs

@@ -1,10 +1,10 @@
 use std::{env, error::Error, path::Path, process::exit};
 
-use rog_anime::{AnimeDataBuffer, AnimeDiagonal};
-use rog_dbus::RogDbusClient;
+use rog_anime::{usb::get_anime_type, AnimeDiagonal, AnimeType};
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 3 {
@@ -13,13 +13,19 @@ fn main() -> Result<(), Box<dyn Error>> {
         exit(-1);
     }
 
-    let matrix =
-        AnimeDiagonal::from_png(Path::new(&args[1]), None, args[2].parse::<f32>().unwrap())?;
+    let matrix = AnimeDiagonal::from_png(
+        Path::new(&args[1]),
+        None,
+        args[2].parse::<f32>().unwrap(),
+        AnimeType::GA401,
+    )?;
+
+    let anime_type = get_anime_type()?;
 
     client
         .proxies()
         .anime()
-        .write(<AnimeDataBuffer>::from(&matrix))
+        .write(matrix.into_data_buffer(anime_type))
         .unwrap();
 
     Ok(())

asusctl/examples/anime-diag.rs

@@ -1,7 +1,7 @@
 use std::{thread::sleep, time::Duration};
 
-use rog_anime::{AnimeDataBuffer, AnimeDiagonal};
-use rog_dbus::RogDbusClient;
+use rog_anime::{usb::get_anime_type, AnimeDiagonal, AnimeType};
+use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:
 // Top row start at 1, ends at 32
@@ -9,10 +9,10 @@ use rog_dbus::RogDbusClient;
 // 74w x 36h diagonal used by the windows app
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     for step in (2..50).rev() {
-        let mut matrix = AnimeDiagonal::new(None);
+        let mut matrix = AnimeDiagonal::new(AnimeType::GA401, None);
         for c in (0..60).into_iter().step_by(step) {
             for i in matrix.get_mut().iter_mut() {
                 i[c] = 50;
@@ -25,8 +25,12 @@ fn main() {
             }
         }
 
-        let m = <AnimeDataBuffer>::from(&matrix);
-        client.proxies().anime().write(m).unwrap();
+        let anime_type = get_anime_type().unwrap();
+        client
+            .proxies()
+            .anime()
+            .write(matrix.into_data_buffer(anime_type))
+            .unwrap();
         sleep(Duration::from_millis(300));
     }
 }

asusctl/examples/anime-gif.rs

@@ -1,10 +1,10 @@
 use std::{env, path::Path, thread::sleep};
 
-use rog_anime::{ActionData, ActionLoader, Sequences};
-use rog_dbus::RogDbusClient;
+use rog_anime::{usb::get_anime_type, ActionData, ActionLoader, Sequences};
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 3 {
@@ -14,7 +14,8 @@ fn main() {
 
     let path = Path::new(&args[1]);
     let brightness = args[2].parse::<f32>().unwrap();
-    let mut seq = Sequences::new();
+    let anime_type = get_anime_type().unwrap();
+    let mut seq = Sequences::new(anime_type);
     seq.insert(
         0,
         &ActionLoader::AsusAnimation {

asusctl/examples/anime-grid.rs

@@ -1,5 +1,5 @@
-use rog_anime::{AnimeDataBuffer, AnimeGrid};
-use rog_dbus::RogDbusClient;
+use rog_anime::{usb::get_anime_type, AnimeDataBuffer, AnimeGrid};
+use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:
 // Top row start at 1, ends at 32
@@ -7,8 +7,9 @@ use rog_dbus::RogDbusClient;
 // 74w x 36h diagonal used by the windows app
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
-    let mut matrix = AnimeGrid::new(None);
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let anime_type = get_anime_type().unwrap();
+    let mut matrix = AnimeGrid::new(anime_type);
     let tmp = matrix.get_mut();
 
     let mut i = 0;

asusctl/examples/anime-outline.rs

@@ -1,128 +1,129 @@
-use rog_anime::AnimeDataBuffer;
-use rog_dbus::RogDbusClient;
+use rog_anime::{usb::get_anime_type, AnimeDataBuffer};
+use rog_dbus::RogDbusClientBlocking;
 
 // In usable data:
 // Top row start at 1, ends at 32
 
 fn main() {
-    let (client, _) = RogDbusClient::new().unwrap();
-    let mut matrix = AnimeDataBuffer::new();
-    matrix.get_mut()[1] = 100; // start = 1
-    for n in matrix.get_mut()[2..32].iter_mut() {
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
+    let anime_type = get_anime_type().unwrap();
+    let mut matrix = AnimeDataBuffer::new(anime_type);
+    matrix.data_mut()[1] = 100; // start = 1
+    for n in matrix.data_mut()[2..32].iter_mut() {
         *n = 250;
     }
-    matrix.get_mut()[32] = 100; // end
-    matrix.get_mut()[34] = 100; // start x = 0
-    matrix.get_mut()[66] = 100; // end
-    matrix.get_mut()[69] = 100; // start x = 1
-    matrix.get_mut()[101] = 100; // end
-    matrix.get_mut()[102] = 100; // start
-    matrix.get_mut()[134] = 100; // end
-    matrix.get_mut()[137] = 100; // start
-    matrix.get_mut()[169] = 100; // end
-    matrix.get_mut()[170] = 100; // start
-    matrix.get_mut()[202] = 100; // end
-    matrix.get_mut()[204] = 100; // start
-    matrix.get_mut()[236] = 100; // end
-    matrix.get_mut()[237] = 100; // start
-    matrix.get_mut()[268] = 100; // end
-    matrix.get_mut()[270] = 100; // start
-    matrix.get_mut()[301] = 100; // end
-    matrix.get_mut()[302] = 100; // start
-    matrix.get_mut()[332] = 100; // end
-    matrix.get_mut()[334] = 100; // start
-    matrix.get_mut()[364] = 100; // end
-    matrix.get_mut()[365] = 100; // start
-    matrix.get_mut()[394] = 100; // end
-    matrix.get_mut()[396] = 100; // start
-    matrix.get_mut()[425] = 100; // end
-    matrix.get_mut()[426] = 100; // start
-    matrix.get_mut()[454] = 100; // end
-    matrix.get_mut()[456] = 100; // start
-    matrix.get_mut()[484] = 100; // end
-    matrix.get_mut()[485] = 100; // start
-    matrix.get_mut()[512] = 100; // end
-    matrix.get_mut()[514] = 100; // start
-    matrix.get_mut()[541] = 100; // end
-    matrix.get_mut()[542] = 100; // start
-    matrix.get_mut()[568] = 100; // end
-    matrix.get_mut()[570] = 100; // start
-    matrix.get_mut()[596] = 100; // end
-    matrix.get_mut()[597] = 100; // start
-    matrix.get_mut()[622] = 100; // end
-    matrix.get_mut()[624] = 100; // start
-    matrix.get_mut()[649] = 100; // end
-    matrix.get_mut()[650] = 100; // start
-    matrix.get_mut()[674] = 100; // end
-    matrix.get_mut()[676] = 100; // start
-    matrix.get_mut()[700] = 100; // end
-    matrix.get_mut()[701] = 100; // start
-    matrix.get_mut()[724] = 100; // end
-    matrix.get_mut()[726] = 100; // start
-    matrix.get_mut()[749] = 100; // end
-    matrix.get_mut()[750] = 100; // start
-    matrix.get_mut()[772] = 100; // end
-    matrix.get_mut()[774] = 100; // start
-    matrix.get_mut()[796] = 100; // end
-    matrix.get_mut()[797] = 100; // start
-    matrix.get_mut()[818] = 100; // end
-    matrix.get_mut()[820] = 100; // start
-    matrix.get_mut()[841] = 100; // end
-    matrix.get_mut()[842] = 100; // start
-    matrix.get_mut()[862] = 100; // end
-    matrix.get_mut()[864] = 100; // start
-    matrix.get_mut()[884] = 100; // end
-    matrix.get_mut()[885] = 100; // start
-    matrix.get_mut()[904] = 100; // end
-    matrix.get_mut()[906] = 100; // start
-    matrix.get_mut()[925] = 100; // end
-    matrix.get_mut()[926] = 100; // start
-    matrix.get_mut()[944] = 100; // end
-    matrix.get_mut()[946] = 100; // start
-    matrix.get_mut()[964] = 100; // end
-    matrix.get_mut()[965] = 100; // start
-    matrix.get_mut()[982] = 100; // end
-    matrix.get_mut()[984] = 100; // start
-    matrix.get_mut()[1001] = 100; // end
-    matrix.get_mut()[1002] = 100; // start
-    matrix.get_mut()[1018] = 100; // end
-    matrix.get_mut()[1020] = 100; // start
-    matrix.get_mut()[1036] = 100; // end
-    matrix.get_mut()[1037] = 100; // start
-    matrix.get_mut()[1052] = 100; // end
-    matrix.get_mut()[1054] = 100; // start
-    matrix.get_mut()[1069] = 100; // end
-    matrix.get_mut()[1070] = 100; // start
-    matrix.get_mut()[1084] = 100; // end
-    matrix.get_mut()[1086] = 100; // start
-    matrix.get_mut()[1100] = 100; // end
-    matrix.get_mut()[1101] = 100; // start
-    matrix.get_mut()[1114] = 100; // end
-    matrix.get_mut()[1116] = 100; // start
-    matrix.get_mut()[1129] = 100; // end
-    matrix.get_mut()[1130] = 100; // start
-    matrix.get_mut()[1142] = 100; // end
-    matrix.get_mut()[1144] = 100; // start
-    matrix.get_mut()[1156] = 100; // end
-    matrix.get_mut()[1157] = 100; // start
-    matrix.get_mut()[1168] = 100; // end
-    matrix.get_mut()[1170] = 100; // start
-    matrix.get_mut()[1181] = 100; // end
-    matrix.get_mut()[1182] = 100; // start
-    matrix.get_mut()[1192] = 100; // end
-    matrix.get_mut()[1194] = 100; // start
-    matrix.get_mut()[1204] = 100; // end
-    matrix.get_mut()[1205] = 100; // start
-    matrix.get_mut()[1214] = 100; // end
-    matrix.get_mut()[1216] = 100; // start
-    matrix.get_mut()[1225] = 100; // end
-    matrix.get_mut()[1226] = 100; // start
-    matrix.get_mut()[1234] = 100; // end
-    matrix.get_mut()[1236] = 100; // start
-    for n in matrix.get_mut()[1237..1244].iter_mut() {
+    matrix.data_mut()[32] = 100; // end
+    matrix.data_mut()[34] = 100; // start x = 0
+    matrix.data_mut()[66] = 100; // end
+    matrix.data_mut()[69] = 100; // start x = 1
+    matrix.data_mut()[101] = 100; // end
+    matrix.data_mut()[102] = 100; // start
+    matrix.data_mut()[134] = 100; // end
+    matrix.data_mut()[137] = 100; // start
+    matrix.data_mut()[169] = 100; // end
+    matrix.data_mut()[170] = 100; // start
+    matrix.data_mut()[202] = 100; // end
+    matrix.data_mut()[204] = 100; // start
+    matrix.data_mut()[236] = 100; // end
+    matrix.data_mut()[237] = 100; // start
+    matrix.data_mut()[268] = 100; // end
+    matrix.data_mut()[270] = 100; // start
+    matrix.data_mut()[301] = 100; // end
+    matrix.data_mut()[302] = 100; // start
+    matrix.data_mut()[332] = 100; // end
+    matrix.data_mut()[334] = 100; // start
+    matrix.data_mut()[364] = 100; // end
+    matrix.data_mut()[365] = 100; // start
+    matrix.data_mut()[394] = 100; // end
+    matrix.data_mut()[396] = 100; // start
+    matrix.data_mut()[425] = 100; // end
+    matrix.data_mut()[426] = 100; // start
+    matrix.data_mut()[454] = 100; // end
+    matrix.data_mut()[456] = 100; // start
+    matrix.data_mut()[484] = 100; // end
+    matrix.data_mut()[485] = 100; // start
+    matrix.data_mut()[512] = 100; // end
+    matrix.data_mut()[514] = 100; // start
+    matrix.data_mut()[541] = 100; // end
+    matrix.data_mut()[542] = 100; // start
+    matrix.data_mut()[568] = 100; // end
+    matrix.data_mut()[570] = 100; // start
+    matrix.data_mut()[596] = 100; // end
+    matrix.data_mut()[597] = 100; // start
+    matrix.data_mut()[622] = 100; // end
+    matrix.data_mut()[624] = 100; // start
+    matrix.data_mut()[649] = 100; // end
+    matrix.data_mut()[650] = 100; // start
+    matrix.data_mut()[674] = 100; // end
+    matrix.data_mut()[676] = 100; // start
+    matrix.data_mut()[700] = 100; // end
+    matrix.data_mut()[701] = 100; // start
+    matrix.data_mut()[724] = 100; // end
+    matrix.data_mut()[726] = 100; // start
+    matrix.data_mut()[749] = 100; // end
+    matrix.data_mut()[750] = 100; // start
+    matrix.data_mut()[772] = 100; // end
+    matrix.data_mut()[774] = 100; // start
+    matrix.data_mut()[796] = 100; // end
+    matrix.data_mut()[797] = 100; // start
+    matrix.data_mut()[818] = 100; // end
+    matrix.data_mut()[820] = 100; // start
+    matrix.data_mut()[841] = 100; // end
+    matrix.data_mut()[842] = 100; // start
+    matrix.data_mut()[862] = 100; // end
+    matrix.data_mut()[864] = 100; // start
+    matrix.data_mut()[884] = 100; // end
+    matrix.data_mut()[885] = 100; // start
+    matrix.data_mut()[904] = 100; // end
+    matrix.data_mut()[906] = 100; // start
+    matrix.data_mut()[925] = 100; // end
+    matrix.data_mut()[926] = 100; // start
+    matrix.data_mut()[944] = 100; // end
+    matrix.data_mut()[946] = 100; // start
+    matrix.data_mut()[964] = 100; // end
+    matrix.data_mut()[965] = 100; // start
+    matrix.data_mut()[982] = 100; // end
+    matrix.data_mut()[984] = 100; // start
+    matrix.data_mut()[1001] = 100; // end
+    matrix.data_mut()[1002] = 100; // start
+    matrix.data_mut()[1018] = 100; // end
+    matrix.data_mut()[1020] = 100; // start
+    matrix.data_mut()[1036] = 100; // end
+    matrix.data_mut()[1037] = 100; // start
+    matrix.data_mut()[1052] = 100; // end
+    matrix.data_mut()[1054] = 100; // start
+    matrix.data_mut()[1069] = 100; // end
+    matrix.data_mut()[1070] = 100; // start
+    matrix.data_mut()[1084] = 100; // end
+    matrix.data_mut()[1086] = 100; // start
+    matrix.data_mut()[1100] = 100; // end
+    matrix.data_mut()[1101] = 100; // start
+    matrix.data_mut()[1114] = 100; // end
+    matrix.data_mut()[1116] = 100; // start
+    matrix.data_mut()[1129] = 100; // end
+    matrix.data_mut()[1130] = 100; // start
+    matrix.data_mut()[1142] = 100; // end
+    matrix.data_mut()[1144] = 100; // start
+    matrix.data_mut()[1156] = 100; // end
+    matrix.data_mut()[1157] = 100; // start
+    matrix.data_mut()[1168] = 100; // end
+    matrix.data_mut()[1170] = 100; // start
+    matrix.data_mut()[1181] = 100; // end
+    matrix.data_mut()[1182] = 100; // start
+    matrix.data_mut()[1192] = 100; // end
+    matrix.data_mut()[1194] = 100; // start
+    matrix.data_mut()[1204] = 100; // end
+    matrix.data_mut()[1205] = 100; // start
+    matrix.data_mut()[1214] = 100; // end
+    matrix.data_mut()[1216] = 100; // start
+    matrix.data_mut()[1225] = 100; // end
+    matrix.data_mut()[1226] = 100; // start
+    matrix.data_mut()[1234] = 100; // end
+    matrix.data_mut()[1236] = 100; // start
+    for n in matrix.data_mut()[1237..1244].iter_mut() {
         *n = 250;
     }
-    matrix.get_mut()[1244] = 100; // end
+    matrix.data_mut()[1244] = 100; // end
     println!("{:?}", &matrix);
 
     client.proxies().anime().write(matrix).unwrap();

asusctl/examples/anime-png.rs

@@ -1,12 +1,13 @@
 use std::{env, error::Error, path::Path, process::exit};
 
 use rog_anime::{
+    usb::get_anime_type,
     AnimeDataBuffer, {AnimeImage, Vec2},
 };
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 7 {
@@ -15,6 +16,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         exit(-1);
     }
 
+    let anime_type = get_anime_type()?;
     let matrix = AnimeImage::from_png(
         Path::new(&args[1]),
         args[2].parse::<f32>().unwrap(),
@@ -24,6 +26,7 @@ fn main() -> Result<(), Box<dyn Error>> {
             args[5].parse::<f32>().unwrap(),
         ),
         args[6].parse::<f32>().unwrap(),
+        anime_type,
     )?;
 
     client

asusctl/examples/anime-spinning.rs

@@ -3,12 +3,13 @@ use std::{
 };
 
 use rog_anime::{
+    usb::get_anime_type,
     AnimeDataBuffer, {AnimeImage, Vec2},
 };
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let (client, _) = RogDbusClient::new().unwrap();
+    let (client, _) = RogDbusClientBlocking::new().unwrap();
 
     let args: Vec<String> = env::args().into_iter().collect();
     if args.len() != 7 {
@@ -17,6 +18,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         exit(-1);
     }
 
+    let anime_type = get_anime_type()?;
     let mut matrix = AnimeImage::from_png(
         Path::new(&args[1]),
         args[2].parse::<f32>().unwrap(),
@@ -26,6 +28,7 @@ fn main() -> Result<(), Box<dyn Error>> {
             args[5].parse::<f32>().unwrap(),
         ),
         args[6].parse::<f32>().unwrap(),
+        anime_type,
     )?;
 
     loop {

asusctl/src/anime_cli.rs

@@ -1,54 +1,4 @@
 use gumdrop::Options;
-use rog_aura::error::Error;
-use std::str::FromStr;
-
-#[derive(Copy, Clone, Debug)]
-pub enum AnimeStatusValue {
-    On,
-    Off,
-}
-impl FromStr for AnimeStatusValue {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "on" => Ok(AnimeStatusValue::On),
-            "off" => Ok(AnimeStatusValue::Off),
-            _ => {
-                print!("Invalid argument, must be one of: on, off");
-                Err(Error::ParseAnime)
-            }
-        }
-    }
-}
-impl From<AnimeStatusValue> for bool {
-    fn from(value: AnimeStatusValue) -> Self {
-        match value {
-            AnimeStatusValue::On => true,
-            AnimeStatusValue::Off => false,
-        }
-    }
-}
-
-#[derive(Options)]
-pub struct AnimeLeds {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(
-        no_long,
-        required,
-        short = "b",
-        meta = "",
-        help = "set all leds brightness value"
-    )]
-    led_brightness: u8,
-}
-impl AnimeLeds {
-    pub fn led_brightness(&self) -> u8 {
-        self.led_brightness
-    }
-}
 
 #[derive(Options)]
 pub struct AnimeCommand {
@@ -56,21 +6,30 @@ pub struct AnimeCommand {
     pub help: bool,
     #[options(
         meta = "",
-        help = "turn on/off the panel (accept/reject write requests)"
+        help = "enable/disable the panel LEDs (does not erase last image)"
     )]
-    pub turn: Option<AnimeStatusValue>,
-    #[options(meta = "", help = "turn on/off the panel at boot (with Asus effect)")]
-    pub boot: Option<AnimeStatusValue>,
+    pub enable: Option<bool>,
+    #[options(
+        meta = "",
+        help = "enable/disable system animations (boot/sleep/shutdown)"
+    )]
+    pub boot_enable: Option<bool>,
+    #[options(meta = "", help = "set global AniMe brightness value")]
+    pub brightness: Option<f32>,
     #[options(command)]
     pub command: Option<AnimeActions>,
 }
 
 #[derive(Options)]
 pub enum AnimeActions {
-    #[options(help = "change all leds brightness")]
-    Leds(AnimeLeds),
-    #[options(help = "display an image png")]
+    #[options(help = "display a PNG image")]
     Image(AnimeImage),
+    #[options(help = "display a diagonal/pixel-perfect PNG")]
+    PixelImage(AnimeImageDiagonal),
+    #[options(help = "display an animated GIF")]
+    Gif(AnimeGif),
+    #[options(help = "display an animated diagonal/pixel-perfect GIF")]
+    PixelGif(AnimeGifDiagonal),
 }
 
 #[derive(Options)]
@@ -90,3 +49,53 @@ pub struct AnimeImage {
     #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
     pub bright: f32,
 }
+
+#[derive(Options)]
+pub struct AnimeImageDiagonal {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
+    pub path: String,
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
+    pub bright: f32,
+}
+
+#[derive(Options)]
+pub struct AnimeGif {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
+    pub path: String,
+    #[options(meta = "", default = "1.0", help = "scale 1.0 == normal")]
+    pub scale: f32,
+    #[options(meta = "", default = "0.0", help = "x position (float)")]
+    pub x_pos: f32,
+    #[options(meta = "", default = "0.0", help = "y position (float)")]
+    pub y_pos: f32,
+    #[options(meta = "", default = "0.0", help = "the angle in radians")]
+    pub angle: f32,
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
+    pub bright: f32,
+    #[options(
+        meta = "",
+        default = "1",
+        help = "how many loops to play - 0 is infinite"
+    )]
+    pub loops: u32,
+}
+
+#[derive(Options)]
+pub struct AnimeGifDiagonal {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
+    pub path: String,
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
+    pub bright: f32,
+    #[options(
+        meta = "",
+        default = "1",
+        help = "how many loops to play - 0 is infinite"
+    )]
+    pub loops: u32,
+}

asusctl/src/aura_cli.rs

@@ -2,6 +2,53 @@ use gumdrop::Options;
 use rog_aura::{error::Error, AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
 use std::str::FromStr;
 
+#[derive(Options)]
+pub struct LedPowerCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(command)]
+    pub command: Option<SetAuraEnabled>,
+}
+
+#[derive(Options)]
+pub enum SetAuraEnabled {
+    #[options(help = "set <keyboard, logo, lightbar> to enabled while the device is booting")]
+    Boot(AuraEnabled),
+    #[options(help = "set <keyboard, logo, lightbar> to animate while the device is suspended")]
+    Sleep(AuraEnabled),
+    #[options(help = "set <keyboard, logo, lightbar> to enabled while device is awake")]
+    Awake(AuraEnabled),
+    #[options(help = "set <keyboard, logo, lightbar> to animate while the device is shutdown")]
+    Shutdown(AuraEnabled),
+}
+
+#[derive(Debug, Clone, Default, Options)]
+pub struct AuraEnabled {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "<true/false>")]
+    pub keyboard: Option<bool>,
+    #[options(meta = "", help = "<true/false>")]
+    pub logo: Option<bool>,
+    #[options(meta = "", help = "<true/false>")]
+    pub lightbar: Option<bool>,
+}
+
+// impl FromStr for AuraEnabled {
+//     type Err = Error;
+
+//     fn from_str(s: &str) -> Result<Self, Self::Err> {
+//         let s = s.to_lowercase();
+//         dbg!(s);
+//         Ok(Self {
+//             help: false,
+//             keyboard: None,
+//             logo: None,
+//             lightbar: None,
+//         })
+//     }
+// }
+
 #[derive(Options)]
 pub struct LedBrightness {
     level: Option<u32>,
@@ -50,7 +97,14 @@ pub struct SingleSpeed {
     help: bool,
     #[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
     pub speed: Speed,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
 }
+
 #[derive(Debug, Clone, Options, Default)]
 pub struct SingleSpeedDirection {
     #[options(help = "print help message")]
@@ -59,6 +113,12 @@ pub struct SingleSpeedDirection {
     pub direction: Direction,
     #[options(no_long, meta = "", help = "set the speed: low, med, high")]
     pub speed: Speed,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
 }
 
 #[derive(Debug, Clone, Default, Options)]
@@ -67,6 +127,12 @@ pub struct SingleColour {
     help: bool,
     #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
     pub colour: Colour,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
 }
 
 #[derive(Debug, Clone, Default, Options)]
@@ -77,6 +143,12 @@ pub struct SingleColourSpeed {
     pub colour: Colour,
     #[options(no_long, meta = "", help = "set the speed: low, med, high")]
     pub speed: Speed,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
 }
 
 #[derive(Debug, Clone, Options, Default)]
@@ -89,10 +161,16 @@ pub struct TwoColourSpeed {
     pub colour2: Colour,
     #[options(no_long, meta = "", help = "set the speed: low, med, high")]
     pub speed: Speed,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
 }
 
 #[derive(Debug, Clone, Default, Options)]
-pub struct MultiColour {
+pub struct MultiZone {
     #[options(help = "print help message")]
     help: bool,
     #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
@@ -152,10 +230,6 @@ pub enum SetAuraBuiltin {
     Comet(SingleColour),
     #[options(help = "set a wide vertical line zooming from left")]
     Flash(SingleColour),
-    #[options(help = "4-zone multi-colour")]
-    MultiStatic(MultiColour),
-    #[options(help = "4-zone multi-colour breathing")]
-    MultiBreathe(MultiColourSpeed),
 }
 
 impl Default for SetAuraBuiltin {
@@ -168,6 +242,7 @@ impl From<&SingleColour> for AuraEffect {
     fn from(aura: &SingleColour) -> Self {
         Self {
             colour1: aura.colour,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -177,6 +252,7 @@ impl From<&SingleSpeed> for AuraEffect {
     fn from(aura: &SingleSpeed) -> Self {
         Self {
             speed: aura.speed,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -187,6 +263,7 @@ impl From<&SingleColourSpeed> for AuraEffect {
         Self {
             colour1: aura.colour,
             speed: aura.speed,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -197,6 +274,7 @@ impl From<&TwoColourSpeed> for AuraEffect {
         Self {
             colour1: aura.colour,
             colour2: aura.colour2,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -207,6 +285,7 @@ impl From<&SingleSpeedDirection> for AuraEffect {
         Self {
             speed: aura.speed,
             direction: aura.direction,
+            zone: aura.zone,
             ..Default::default()
         }
     }
@@ -275,55 +354,6 @@ impl From<&SetAuraBuiltin> for AuraEffect {
                 data.mode = AuraModeNum::Flash;
                 data
             }
-            _ => AuraEffect::default(),
         }
     }
 }
-
-impl From<&SetAuraBuiltin> for Vec<AuraEffect> {
-    fn from(aura: &SetAuraBuiltin) -> Vec<AuraEffect> {
-        let mut zones = vec![AuraEffect::default(); 4];
-        match aura {
-            SetAuraBuiltin::MultiStatic(data) => {
-                zones[0].mode = AuraModeNum::Static;
-                zones[0].zone = AuraZone::One;
-                zones[0].colour1 = data.colour1;
-
-                zones[1].mode = AuraModeNum::Static;
-                zones[1].zone = AuraZone::Two;
-                zones[1].colour1 = data.colour2;
-
-                zones[2].mode = AuraModeNum::Static;
-                zones[2].zone = AuraZone::Three;
-                zones[2].colour1 = data.colour3;
-
-                zones[3].mode = AuraModeNum::Static;
-                zones[3].zone = AuraZone::Four;
-                zones[3].colour1 = data.colour4;
-            }
-            SetAuraBuiltin::MultiBreathe(data) => {
-                zones[0].mode = AuraModeNum::Breathe;
-                zones[0].zone = AuraZone::One;
-                zones[0].colour1 = data.colour1;
-                zones[0].speed = data.speed;
-
-                zones[1].mode = AuraModeNum::Breathe;
-                zones[1].zone = AuraZone::Two;
-                zones[1].colour1 = data.colour2;
-                zones[1].speed = data.speed;
-
-                zones[2].mode = AuraModeNum::Breathe;
-                zones[2].zone = AuraZone::Three;
-                zones[2].colour1 = data.colour3;
-                zones[2].speed = data.speed;
-
-                zones[3].mode = AuraModeNum::Breathe;
-                zones[3].zone = AuraZone::Four;
-                zones[3].colour1 = data.colour4;
-                zones[3].speed = data.speed;
-            }
-            _ => {}
-        }
-        zones
-    }
-}

asusctl/src/cli_opts.rs

@@ -1,10 +1,9 @@
 use crate::{
     anime_cli::AnimeCommand,
-    aura_cli::{LedBrightness, SetAuraBuiltin},
+    aura_cli::{LedBrightness, LedPowerCommand, SetAuraBuiltin},
     profiles_cli::{FanCurveCommand, ProfileCommand},
 };
 use gumdrop::Options;
-use supergfxctl::gfx_vendors::GfxVendors;
 
 #[derive(Default, Options)]
 pub struct CliStart {
@@ -20,7 +19,7 @@ pub struct CliStart {
     pub next_kbd_bright: bool,
     #[options(help = "Toggle to previous keyboard brightness")]
     pub prev_kbd_bright: bool,
-    #[options(meta = "", help = "<20-100>")]
+    #[options(meta = "", help = "Set your battery charge limit <20-100>")]
     pub chg_limit: Option<u8>,
     #[options(command)]
     pub command: Option<CliCommand>,
@@ -30,11 +29,13 @@ pub struct CliStart {
 pub enum CliCommand {
     #[options(help = "Set the keyboard lighting from built-in modes")]
     LedMode(LedModeCommand),
+    #[options(help = "Set the keyboard lighting from built-in modes")]
+    LedPower(LedPowerCommand),
     #[options(help = "Set or select platform_profile")]
     Profile(ProfileCommand),
-    #[options(help = "Set, select, or modify fan curves if suported")]
+    #[options(help = "Set, select, or modify fan curves if supported")]
     FanCurve(FanCurveCommand),
-    #[options(help = "Set the graphics mode")]
+    #[options(help = "Set the graphics mode (obsoleted by supergfxctl)")]
     Graphics(GraphicsCommand),
     #[options(name = "anime", help = "Manage AniMe Matrix")]
     Anime(AnimeCommand),
@@ -50,16 +51,6 @@ pub struct LedModeCommand {
     pub next_mode: bool,
     #[options(help = "switch to previous aura mode")]
     pub prev_mode: bool,
-    #[options(
-        meta = "",
-        help = "set the keyboard LED to enabled while the device is awake"
-    )]
-    pub awake_enable: Option<bool>,
-    #[options(
-        meta = "",
-        help = "set the keyboard LED suspend animation to enabled while the device is suspended"
-    )]
-    pub sleep_enable: Option<bool>,
     #[options(command)]
     pub command: Option<SetAuraBuiltin>,
 }
@@ -68,17 +59,6 @@ pub struct LedModeCommand {
 pub struct GraphicsCommand {
     #[options(help = "print help message")]
     pub help: bool,
-    #[options(
-        meta = "",
-        help = "Set graphics mode: <nvidia, hybrid, compute, integrated>"
-    )]
-    pub mode: Option<GfxVendors>,
-    #[options(help = "Get the current mode")]
-    pub get: bool,
-    #[options(help = "Get the current power status")]
-    pub pow: bool,
-    #[options(help = "Do not ask for confirmation")]
-    pub force: bool,
 }
 
 #[derive(Options, Debug)]

asusctl/src/main.rs

@@ -1,29 +1,31 @@
-mod anime_cli;
-mod aura_cli;
-mod cli_opts;
-mod profiles_cli;
+use std::process::Command;
+use std::thread::sleep;
+use std::{env::args, path::Path};
 
-use crate::aura_cli::{LedBrightness, SetAuraBuiltin};
-use crate::cli_opts::*;
-use anime_cli::{AnimeActions, AnimeCommand};
+use aura_cli::LedPowerCommand;
 use gumdrop::{Opt, Options};
+
+use anime_cli::{AnimeActions, AnimeCommand};
 use profiles_cli::{FanCurveCommand, ProfileCommand};
-use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2, ANIME_DATA_LEN};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, Vec2};
+use rog_aura::usb::AuraControl;
 use rog_aura::{self, AuraEffect};
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
+use rog_profiles::error::ProfileError;
 use rog_supported::SupportedFunctions;
 use rog_supported::{
     AnimeSupportedFunctions, LedSupportedFunctions, PlatformProfileFunctions,
     RogBiosSupportedFunctions,
 };
-use std::process::Command;
-use std::{env::args, path::Path, sync::mpsc::channel};
-use supergfxctl::{
-    gfx_vendors::GfxRequiredUserAction,
-    special::{get_asus_gsync_gfx_mode, has_asus_gsync_gfx_mode},
-    zbus_proxy::GfxProxy,
-};
-use zbus::Connection;
+
+use crate::aura_cli::LedBrightness;
+use crate::cli_opts::*;
+
+mod anime_cli;
+mod aura_cli;
+mod cli_opts;
+mod profiles_cli;
 
 const CONFIG_ADVICE: &str = "A config file need to be removed so a new one can be generated";
 
@@ -48,7 +50,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
 
-    let (dbus, _) = RogDbusClient::new()
+    let (dbus, _) = RogDbusClientBlocking::new()
         .map_err(|e| {
             print_error_help(Box::new(e), None);
             std::process::exit(3);
@@ -58,7 +60,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let supported = dbus
         .proxies()
         .supported()
-        .get_supported_functions()
+        .supported_functions()
         .map_err(|e| {
             print_error_help(Box::new(e), None);
             std::process::exit(4);
@@ -102,7 +104,6 @@ fn print_versions() {
     println!("     rog-dbus v{}", rog_dbus::VERSION);
     println!(" rog-profiles v{}", rog_profiles::VERSION);
     println!("rog-supported v{}", rog_supported::VERSION);
-    println!("  supergfxctl v{}", supergfxctl::VERSION);
 }
 
 fn print_laptop_info() {
@@ -141,18 +142,16 @@ fn do_diagnose(name: &str) -> bool {
 fn do_parsed(
     parsed: &CliStart,
     supported: &SupportedFunctions,
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
 ) -> Result<(), Box<dyn std::error::Error>> {
     match &parsed.command {
         Some(CliCommand::LedMode(mode)) => handle_led_mode(dbus, &supported.keyboard_led, mode)?,
+        Some(CliCommand::LedPower(pow)) => handle_led_power(dbus, &supported.keyboard_led, pow)?,
         Some(CliCommand::Profile(cmd)) => handle_profile(dbus, &supported.platform_profile, cmd)?,
         Some(CliCommand::FanCurve(cmd)) => {
             handle_fan_curve(dbus, &supported.platform_profile, cmd)?
         }
-        Some(CliCommand::Graphics(cmd)) => do_gfx(cmd).map_err(|err| {
-            do_gfx_diagnose();
-            err
-        })?,
+        Some(CliCommand::Graphics(_)) => do_gfx()?,
         Some(CliCommand::Anime(cmd)) => handle_anime(dbus, &supported.anime_ctrl, cmd)?,
         Some(CliCommand::Bios(cmd)) => handle_bios_option(dbus, &supported.rog_bios_ctrl, cmd)?,
         None => {
@@ -175,13 +174,13 @@ fn do_parsed(
     if let Some(brightness) = &parsed.kbd_bright {
         match brightness.level() {
             None => {
-                let level = dbus.proxies().led().get_led_brightness()?;
-                println!("Current keyboard led brightness: {}", level.to_string());
+                let level = dbus.proxies().led().led_brightness()?;
+                println!("Current keyboard led brightness: {}", level);
             }
             Some(level) => dbus
                 .proxies()
                 .led()
-                .set_led_brightness(<rog_aura::LedBrightness>::from(level))?,
+                .set_brightness(<rog_aura::LedBrightness>::from(level))?,
         }
     }
 
@@ -198,107 +197,47 @@ fn do_parsed(
     }
 
     if let Some(chg_limit) = parsed.chg_limit {
-        dbus.proxies().charge().write_limit(chg_limit)?;
+        dbus.proxies().charge().set_limit(chg_limit)?;
     }
 
     Ok(())
 }
 
-fn do_gfx_diagnose() {
-    println!("\nGraphics mode change error.");
-    do_diagnose("supergfxd");
-    println!();
-}
-
-fn do_gfx(command: &GraphicsCommand) -> Result<(), Box<dyn std::error::Error>> {
-    if command.mode.is_none() && !command.get && !command.pow && !command.force || command.help {
-        println!("{}", command.self_usage());
-    }
-
-    let conn = Connection::new_system()?;
-    let proxy = GfxProxy::new(&conn)?;
-
-    let (tx, rx) = channel();
-    proxy.connect_notify_action(tx)?;
-
-    if let Some(mode) = command.mode {
-        if has_asus_gsync_gfx_mode() && get_asus_gsync_gfx_mode()? == 1 {
-            println!("You can not change modes until you turn dedicated/G-Sync off and reboot");
-            std::process::exit(-1);
-        }
-
-        println!(
-            "If anything fails check `journalctl -b -u asusd` and `journalctl -b -u supergfxd`\n"
-        );
-
-        proxy.gfx_write_mode(&mode)?;
-
-        loop {
-            proxy.next_signal()?;
-
-            if let Ok(res) = rx.try_recv() {
-                match res {
-                    GfxRequiredUserAction::Integrated => {
-                        println!(
-                            "You must change to Integrated before you can change to {}",
-                            <&str>::from(mode)
-                        );
-                    }
-                    GfxRequiredUserAction::Logout | GfxRequiredUserAction::Reboot => {
-                        println!(
-                            "Graphics mode changed to {}. User action required is: {}",
-                            <&str>::from(mode),
-                            <&str>::from(&res)
-                        );
-                    }
-                    GfxRequiredUserAction::None => {
-                        println!("Graphics mode changed to {}", <&str>::from(mode));
-                    }
-                }
-            }
-            std::process::exit(0)
-        }
-    }
-
-    if command.get {
-        let res = proxy.gfx_get_mode()?;
-        println!("Current graphics mode: {}", <&str>::from(res));
-    }
-    if command.pow {
-        let res = proxy.gfx_get_pwr()?;
-        println!("Current power status: {}", <&str>::from(&res));
-    }
-
+fn do_gfx() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Please use supergfxctl for graphics switching. supergfxctl is the result of making asusctl graphics switching generic so all laptops can use it");
+    println!("This command will be removed in future");
     Ok(())
 }
 
 fn handle_anime(
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
     _supported: &AnimeSupportedFunctions,
     cmd: &AnimeCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if (cmd.command.is_none() && cmd.boot.is_none() && cmd.turn.is_none()) || cmd.help {
+    if (cmd.command.is_none()
+        && cmd.enable.is_none()
+        && cmd.boot_enable.is_none()
+        && cmd.brightness.is_none())
+        || cmd.help
+    {
         println!("Missing arg or command\n\n{}", cmd.self_usage());
         if let Some(lst) = cmd.self_command_list() {
             println!("\n{}", lst);
         }
     }
-    if let Some(anime_turn) = cmd.turn {
-        dbus.proxies().anime().set_led_power(anime_turn.into())?
+    if let Some(anime_turn) = cmd.enable {
+        dbus.proxies().anime().set_on_off(anime_turn)?
     }
-    if let Some(anime_boot) = cmd.boot {
-        dbus.proxies()
-            .anime()
-            .set_system_animations(anime_boot.into())?
+    if let Some(anime_boot) = cmd.boot_enable {
+        dbus.proxies().anime().set_boot_on_off(anime_boot)?
+    }
+    if let Some(bright) = cmd.brightness {
+        verify_brightness(bright);
+        dbus.proxies().anime().set_brightness(bright)?
     }
     if let Some(action) = cmd.command.as_ref() {
+        let anime_type = get_anime_type()?;
         match action {
-            AnimeActions::Leds(anime_leds) => {
-                let data = AnimeDataBuffer::from_vec(
-                    [anime_leds.led_brightness(); ANIME_DATA_LEN].to_vec(),
-                );
-                dbus.proxies().anime().write(data)?;
-            }
             AnimeActions::Image(image) => {
                 if image.help_requested() || image.path.is_empty() {
                     println!("Missing arg or command\n\n{}", image.self_usage());
@@ -307,6 +246,7 @@ fn handle_anime(
                     }
                     std::process::exit(1);
                 }
+                verify_brightness(image.bright);
 
                 let matrix = AnimeImage::from_png(
                     Path::new(&image.path),
@@ -314,28 +254,120 @@ fn handle_anime(
                     image.angle,
                     Vec2::new(image.x_pos, image.y_pos),
                     image.bright,
+                    anime_type,
                 )?;
 
                 dbus.proxies()
                     .anime()
                     .write(<AnimeDataBuffer>::from(&matrix))?;
             }
+            AnimeActions::PixelImage(image) => {
+                if image.help_requested() || image.path.is_empty() {
+                    println!("Missing arg or command\n\n{}", image.self_usage());
+                    if let Some(lst) = image.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    std::process::exit(1);
+                }
+                verify_brightness(image.bright);
+
+                let matrix = AnimeDiagonal::from_png(
+                    Path::new(&image.path),
+                    None,
+                    image.bright,
+                    anime_type,
+                )?;
+
+                dbus.proxies()
+                    .anime()
+                    .write(matrix.into_data_buffer(anime_type))?;
+            }
+            AnimeActions::Gif(gif) => {
+                if gif.help_requested() || gif.path.is_empty() {
+                    println!("Missing arg or command\n\n{}", gif.self_usage());
+                    if let Some(lst) = gif.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    std::process::exit(1);
+                }
+                verify_brightness(gif.bright);
+
+                let matrix = AnimeGif::from_gif(
+                    Path::new(&gif.path),
+                    gif.scale,
+                    gif.angle,
+                    Vec2::new(gif.x_pos, gif.y_pos),
+                    AnimTime::Count(1),
+                    gif.bright,
+                    anime_type,
+                )?;
+
+                let mut loops = gif.loops as i32;
+                loop {
+                    for frame in matrix.frames() {
+                        dbus.proxies().anime().write(frame.frame().clone())?;
+                        sleep(frame.delay());
+                    }
+                    if loops >= 0 {
+                        loops -= 1;
+                    }
+                    if loops == 0 {
+                        break;
+                    }
+                }
+            }
+            AnimeActions::PixelGif(gif) => {
+                if gif.help_requested() || gif.path.is_empty() {
+                    println!("Missing arg or command\n\n{}", gif.self_usage());
+                    if let Some(lst) = gif.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    std::process::exit(1);
+                }
+                verify_brightness(gif.bright);
+
+                let matrix = AnimeGif::from_diagonal_gif(
+                    Path::new(&gif.path),
+                    AnimTime::Count(1),
+                    gif.bright,
+                    anime_type,
+                )?;
+
+                let mut loops = gif.loops as i32;
+                loop {
+                    for frame in matrix.frames() {
+                        dbus.proxies().anime().write(frame.frame().clone())?;
+                        sleep(frame.delay());
+                    }
+                    if loops >= 0 {
+                        loops -= 1;
+                    }
+                    if loops == 0 {
+                        break;
+                    }
+                }
+            }
         }
     }
     Ok(())
 }
 
+fn verify_brightness(brightness: f32) {
+    if brightness < 0.0 || brightness > 1.0 {
+        println!(
+            "Image and global brightness must be between 0.0 and 1.0 (inclusive), was {}",
+            brightness
+        );
+        std::process::exit(1);
+    }
+}
+
 fn handle_led_mode(
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
     supported: &LedSupportedFunctions,
     mode: &LedModeCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if mode.command.is_none()
-        && !mode.prev_mode
-        && !mode.next_mode
-        && mode.sleep_enable.is_none()
-        && mode.awake_enable.is_none()
-    {
+    if mode.command.is_none() && !mode.prev_mode && !mode.next_mode {
         if !mode.help {
             println!("Missing arg or command\n");
         }
@@ -346,11 +378,14 @@ fn handle_led_mode(
             let commands: Vec<String> = cmdlist.lines().map(|s| s.to_string()).collect();
             for command in commands.iter().filter(|command| {
                 for mode in &supported.stock_led_modes {
-                    if command.contains(&<&str>::from(mode).to_lowercase()) {
+                    if command
+                        .trim()
+                        .starts_with(&<&str>::from(mode).to_lowercase())
+                    {
                         return true;
                     }
                 }
-                if supported.multizone_led_mode {
+                if !supported.multizone_led_mode.is_empty() && command.trim().starts_with("multi") {
                     return true;
                 }
                 false
@@ -376,39 +411,186 @@ fn handle_led_mode(
             println!("{}", mode.self_usage());
             return Ok(());
         }
-        match mode {
-            SetAuraBuiltin::MultiStatic(_) | SetAuraBuiltin::MultiBreathe(_) => {
-                let zones = <Vec<AuraEffect>>::from(mode);
-                for eff in zones {
-                    dbus.proxies().led().set_led_mode(&eff)?
+        dbus.proxies()
+            .led()
+            .set_led_mode(&<AuraEffect>::from(mode))?;
+    }
+
+    Ok(())
+}
+
+fn handle_led_power(
+    dbus: &RogDbusClientBlocking,
+    _supported: &LedSupportedFunctions,
+    power: &LedPowerCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if power.command().is_none() {
+        if !power.help {
+            println!("Missing arg or command\n");
+        }
+        println!("{}\n", power.self_usage());
+        println!("Commands available");
+
+        if let Some(cmdlist) = LedPowerCommand::command_list() {
+            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_string()).collect();
+            for command in commands.iter() {
+                println!("{}", command);
+            }
+        }
+
+        println!("\nHelp can also be requested on commands, e.g: boot --help");
+        return Ok(());
+    }
+
+    if let Some(pow) = power.command.as_ref() {
+        if pow.help_requested() {
+            println!("{}", pow.self_usage());
+            return Ok(());
+        }
+
+        match pow {
+            // TODO: make this a macro or something
+            aura_cli::SetAuraEnabled::Boot(arg) => {
+                let mut enabled: Vec<AuraControl> = Vec::new();
+                let mut disabled: Vec<AuraControl> = Vec::new();
+                arg.keyboard.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::BootKeyb)
+                    } else {
+                        disabled.push(AuraControl::BootKeyb)
+                    }
+                });
+                arg.logo.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::BootLogo)
+                    } else {
+                        disabled.push(AuraControl::BootLogo)
+                    }
+                });
+                arg.lightbar.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::BootBar)
+                    } else {
+                        disabled.push(AuraControl::BootBar)
+                    }
+                });
+                if !enabled.is_empty() {
+                    dbus.proxies().led().set_leds_enabled(enabled)?;
+                }
+                if !disabled.is_empty() {
+                    dbus.proxies().led().set_leds_disabled(disabled)?;
+                }
+            }
+            aura_cli::SetAuraEnabled::Sleep(arg) => {
+                let mut enabled: Vec<AuraControl> = Vec::new();
+                let mut disabled: Vec<AuraControl> = Vec::new();
+                arg.keyboard.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::SleepKeyb)
+                    } else {
+                        disabled.push(AuraControl::SleepKeyb)
+                    }
+                });
+                arg.logo.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::SleepLogo)
+                    } else {
+                        disabled.push(AuraControl::SleepLogo)
+                    }
+                });
+                arg.lightbar.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::SleepBar)
+                    } else {
+                        disabled.push(AuraControl::SleepBar)
+                    }
+                });
+                if !enabled.is_empty() {
+                    dbus.proxies().led().set_leds_enabled(enabled)?;
+                }
+                if !disabled.is_empty() {
+                    dbus.proxies().led().set_leds_disabled(disabled)?;
+                }
+            }
+            aura_cli::SetAuraEnabled::Awake(arg) => {
+                let mut enabled: Vec<AuraControl> = Vec::new();
+                let mut disabled: Vec<AuraControl> = Vec::new();
+                arg.keyboard.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::AwakeKeyb)
+                    } else {
+                        disabled.push(AuraControl::AwakeKeyb)
+                    }
+                });
+                arg.logo.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::AwakeLogo)
+                    } else {
+                        disabled.push(AuraControl::AwakeLogo)
+                    }
+                });
+                arg.lightbar.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::AwakeBar)
+                    } else {
+                        disabled.push(AuraControl::AwakeBar)
+                    }
+                });
+                if !enabled.is_empty() {
+                    dbus.proxies().led().set_leds_enabled(enabled)?;
+                }
+                if !disabled.is_empty() {
+                    dbus.proxies().led().set_leds_disabled(disabled)?;
+                }
+            }
+            aura_cli::SetAuraEnabled::Shutdown(arg) => {
+                let mut enabled: Vec<AuraControl> = Vec::new();
+                let mut disabled: Vec<AuraControl> = Vec::new();
+                arg.keyboard.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::ShutdownKeyb)
+                    } else {
+                        disabled.push(AuraControl::ShutdownKeyb)
+                    }
+                });
+                arg.logo.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::ShutdownLogo)
+                    } else {
+                        disabled.push(AuraControl::ShutdownLogo)
+                    }
+                });
+                arg.lightbar.map(|v| {
+                    if v {
+                        enabled.push(AuraControl::ShutdownBar)
+                    } else {
+                        disabled.push(AuraControl::ShutdownBar)
+                    }
+                });
+                if !enabled.is_empty() {
+                    dbus.proxies().led().set_leds_enabled(enabled)?;
+                }
+                if !disabled.is_empty() {
+                    dbus.proxies().led().set_leds_disabled(disabled)?;
                 }
             }
-            _ => dbus
-                .proxies()
-                .led()
-                .set_led_mode(&<AuraEffect>::from(mode))?,
         }
     }
 
-    if let Some(enable) = mode.awake_enable {
-        dbus.proxies().led().set_awake_enabled(enable)?;
-    }
-
-    if let Some(enable) = mode.sleep_enable {
-        dbus.proxies().led().set_sleep_enabled(enable)?;
-    }
-
     Ok(())
 }
 
 fn handle_profile(
-    dbus: &RogDbusClient,
-    _supported: &PlatformProfileFunctions,
+    dbus: &RogDbusClientBlocking,
+    supported: &PlatformProfileFunctions,
     cmd: &ProfileCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    println!("Warning: Profiles now depend on power-profiles-daemon v0.9+");
-    println!("Warning: Fan-curve support is coming in a 4.1.x release");
-    if !cmd.next && !cmd.list {
+    if !supported.platform_profile {
+        println!("Profiles not supported by either this kernel or by the laptop.");
+        return Err(ProfileError::NotSupported.into());
+    }
+
+    if !cmd.next && !cmd.list && cmd.profile_set.is_none() && !cmd.profile_get {
         if !cmd.help {
             println!("Missing arg or command\n");
         }
@@ -417,28 +599,39 @@ fn handle_profile(
         if let Some(lst) = cmd.self_command_list() {
             println!("\n{}", lst);
         }
-
-        // println!("Note: turbo, frequency, fan preset and fan curve options will apply to");
-        // println!("      to the currently active profile unless a profile name is specified");
         std::process::exit(1);
     }
 
     if cmd.next {
         dbus.proxies().profile().next_profile()?;
+    } else if let Some(profile) = cmd.profile_set {
+        dbus.proxies().profile().set_active_profile(profile)?;
     }
 
     if cmd.list {
         let res = dbus.proxies().profile().profiles()?;
         res.iter().for_each(|p| println!("{:?}", p));
     }
+
+    if cmd.profile_get {
+        let res = dbus.proxies().profile().active_profile()?;
+        println!("Active profile is {:?}", res);
+    }
+
     Ok(())
 }
 
 fn handle_fan_curve(
-    dbus: &RogDbusClient,
-    _supported: &PlatformProfileFunctions,
+    dbus: &RogDbusClientBlocking,
+    supported: &PlatformProfileFunctions,
     cmd: &FanCurveCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
+    if !supported.fan_curves {
+        println!("Fan-curves not supported by either this kernel or by the laptop.");
+        println!("This requires kernel 5.17 or the fan curve patch listed in the readme.");
+        return Err(ProfileError::NotSupported.into());
+    }
+
     if !cmd.get_enabled && !cmd.default && cmd.mod_profile.is_none() {
         if !cmd.help {
             println!("Missing arg or command\n");
@@ -451,7 +644,8 @@ fn handle_fan_curve(
         std::process::exit(1);
     }
 
-    if (cmd.enabled.is_some() || cmd.fan.is_some() || cmd.data.is_some()) && cmd.mod_profile.is_none()
+    if (cmd.enabled.is_some() || cmd.fan.is_some() || cmd.data.is_some())
+        && cmd.mod_profile.is_none()
     {
         println!("--enabled, --fan, and --data options require --mod-profile");
         std::process::exit(666);
@@ -482,7 +676,7 @@ fn handle_fan_curve(
         if let Some(mut curve) = cmd.data.clone() {
             let fan = cmd.fan.unwrap_or_default();
             curve.set_fan(fan);
-            dbus.proxies().profile().set_fan_curve(curve, profile)?;
+            dbus.proxies().profile().set_fan_curve(profile, curve)?;
         }
     }
 
@@ -490,7 +684,7 @@ fn handle_fan_curve(
 }
 
 fn handle_bios_option(
-    dbus: &RogDbusClient,
+    dbus: &RogDbusClientBlocking,
     supported: &RogBiosSupportedFunctions,
     cmd: &BiosCommand,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -509,23 +703,23 @@ fn handle_bios_option(
                 .collect();
 
             for line in usage.iter().filter(|line| {
-                !line.contains("sound") && !supported.post_sound_toggle
-                    || !line.contains("GPU") && !supported.dedicated_gfx_toggle
+                line.contains("sound") && supported.post_sound_toggle
+                    || line.contains("GPU") && supported.dedicated_gfx_toggle
             }) {
                 println!("{}", line);
             }
         }
 
         if let Some(opt) = cmd.post_sound_set {
-            dbus.proxies().rog_bios().set_post_sound(opt)?;
+            dbus.proxies().rog_bios().set_post_boot_sound(opt)?;
         }
         if cmd.post_sound_get {
-            let res = dbus.proxies().rog_bios().get_post_sound()? == 1;
+            let res = dbus.proxies().rog_bios().post_boot_sound()? == 1;
             println!("Bios POST sound on: {}", res);
         }
         if let Some(opt) = cmd.dedicated_gfx_set {
             println!("Rebuilding initrd to include drivers");
-            dbus.proxies().rog_bios().set_dedicated_gfx(opt)?;
+            dbus.proxies().rog_bios().set_dedicated_graphic_mode(opt)?;
             println!("The mode change is not active until you reboot, on boot the bios will make the required change");
             if opt {
                 println!(
@@ -536,7 +730,7 @@ fn handle_bios_option(
             }
         }
         if cmd.dedicated_gfx_get {
-            let res = dbus.proxies().rog_bios().get_dedicated_gfx()? == 1;
+            let res = dbus.proxies().rog_bios().dedicated_graphic_mode()? == 1;
             println!("Bios dedicated GPU on: {}", res);
         }
     }

asusctl/src/profiles_cli.rs

@@ -12,7 +12,7 @@ pub struct ProfileCommand {
 
     #[options(help = "get profile")]
     pub profile_get: bool,
-    #[options(help = "set the active profile")]
+    #[options(meta = "", help = "set the active profile")]
     pub profile_set: Option<Profile>,
 }
 
@@ -44,7 +44,8 @@ pub struct FanCurveCommand {
 
     #[options(
         meta = "",
-        help = "data format = 30c:1%,49c:2%,59c:3%,69c:4%,79c:31%,89c:49%,99c:56%,109c:58%. `mod-profile` required"
+        help = "data format = 30c:1%,49c:2%,59c:3%,69c:4%,79c:31%,89c:49%,99c:56%,109c:58%.
+                      `--mod-profile` required. If '%' is omitted the fan range is 0-255"
     )]
     pub data: Option<CurveData>,
 }

daemon-user/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "daemon-user"
-version = "1.2.0"
+version = "1.3.0"
 authors = ["Luke D Jones <luke@ljones.dev>"]
 edition = "2018"
 description = "Usermode daemon for user settings, anime, per-key lighting"
@@ -23,8 +23,10 @@ rog_anime = { path = "../rog-anime" }
 rog_dbus = { path = "../rog-dbus" }
 rog_supported = { path = "../rog-supported" }
 
-dirs = "3.0.1"
+dirs = "^4.0"
 
-zbus = "^1.9.1"
-zvariant = "^2.6"
-zvariant_derive = "^2.6"
+zbus = "^2.2"
+zvariant = "^3.0"
+zvariant_derive = "^3.0"
+
+smol = "^1.2"

daemon-user/src/ctrl_anime.rs

@@ -1,6 +1,6 @@
 use rog_anime::error::AnimeError;
 use rog_anime::{ActionData, ActionLoader, AnimTime, Fade, Sequences, Vec2};
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 use serde_derive::{Deserialize, Serialize};
 use std::time::Duration;
 use std::{
@@ -66,14 +66,14 @@ pub enum TimeType {
 /// and a zbus server behind `Arc<Mutex<T>>`
 pub struct CtrlAnimeInner<'a> {
     sequences: Sequences,
-    client: RogDbusClient<'a>,
+    client: RogDbusClientBlocking<'a>,
     do_early_return: Arc<AtomicBool>,
 }
 
 impl<'a> CtrlAnimeInner<'static> {
     pub fn new(
         sequences: Sequences,
-        client: RogDbusClient<'static>,
+        client: RogDbusClientBlocking<'static>,
         do_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(Self {
@@ -91,12 +91,16 @@ impl<'a> CtrlAnimeInner<'static> {
         for action in self.sequences.iter() {
             match action {
                 ActionData::Animation(frames) => {
-                    rog_anime::run_animation(frames, self.do_early_return.clone(), &|output| {
+                    rog_anime::run_animation(frames, &|output| {
+                        if self.do_early_return.load(Ordering::Acquire) {
+                            return Ok(true); // Do safe exit
+                        }
                         self.client
                             .proxies()
                             .anime()
                             .write(output)
                             .map_err(|e| AnimeError::Dbus(format!("{}", e)))
+                            .map(|_| false)
                     })?;
                 }
                 ActionData::Image(image) => {
@@ -131,7 +135,7 @@ impl<'a> CtrlAnimeInner<'static> {
 
 pub struct CtrlAnime<'a> {
     config: Arc<Mutex<UserAnimeConfig>>,
-    client: RogDbusClient<'a>,
+    client: RogDbusClientBlocking<'a>,
     inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
     /// Must be the same Atomic as in CtrlAnimeInner
     inner_early_return: Arc<AtomicBool>,
@@ -141,7 +145,7 @@ impl<'a> CtrlAnime<'static> {
     pub fn new(
         config: Arc<Mutex<UserAnimeConfig>>,
         inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
-        client: RogDbusClient<'static>,
+        client: RogDbusClientBlocking<'static>,
         inner_early_return: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(CtrlAnime {
@@ -152,12 +156,14 @@ impl<'a> CtrlAnime<'static> {
         })
     }
 
-    pub fn add_to_server(self, server: &mut zbus::ObjectServer) {
+    pub async fn add_to_server(self, server: &mut zbus::Connection) {
         server
+            .object_server()
             .at(
                 &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
                 self,
             )
+            .await
             .map_err(|err| {
                 println!("CtrlAnime: add_to_server {}", err);
                 err
@@ -353,13 +359,13 @@ impl CtrlAnime<'static> {
     pub fn set_state(&mut self, on: bool) -> zbus::fdo::Result<()> {
         // Operations here need to be in specific order
         if on {
-            self.client.proxies().anime().set_led_power(on)?;
+            self.client.proxies().anime().set_on_off(on).ok();
             // Let the inner loop run
             self.inner_early_return.store(false, Ordering::SeqCst);
         } else {
             // Must make the inner run loop return early
             self.inner_early_return.store(true, Ordering::SeqCst);
-            self.client.proxies().anime().set_led_power(on)?;
+            self.client.proxies().anime().set_on_off(on).ok();
         }
         Ok(())
     }

daemon-user/src/daemon.rs

@@ -1,13 +1,14 @@
-use rog_dbus::RogDbusClient;
+use rog_anime::usb::get_anime_type;
+use rog_dbus::RogDbusClientBlocking;
 use rog_user::{
     ctrl_anime::{CtrlAnime, CtrlAnimeInner},
     user_config::*,
     DBUS_NAME,
 };
+use smol::Executor;
 use std::sync::Arc;
 use std::sync::Mutex;
-use std::thread;
-use zbus::{fdo, Connection};
+use zbus::Connection;
 
 use std::sync::atomic::AtomicBool;
 
@@ -17,51 +18,55 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("     rog-dbus v{}", rog_dbus::VERSION);
     println!("rog-supported v{}", rog_supported::VERSION);
 
-    let (client, _) = RogDbusClient::new()?;
-    let supported = client.proxies().supported().get_supported_functions()?;
+    let (client, _) = RogDbusClientBlocking::new()?;
+    let supported = client.proxies().supported().supported_functions()?;
 
     let mut config = UserConfig::new();
     config.load_config()?;
 
-    let anime_config = UserAnimeConfig::load_config(config.active_anime)?;
-    let anime = anime_config.create_anime()?;
-
-    let anime_config = Arc::new(Mutex::new(anime_config));
-
-    // Create server
-    let connection = Connection::new_session()?;
-    fdo::DBusProxy::new(&connection)?
-        .request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
-    let mut server = zbus::ObjectServer::new(&connection);
+    let executor = Executor::new();
 
+    let early_return = Arc::new(AtomicBool::new(false));
     // Set up the anime data and run loop/thread
     if supported.anime_ctrl.0 {
-        let early_return = Arc::new(AtomicBool::new(false));
-        // Inner behind mutex required for thread safety
-        let inner = Arc::new(Mutex::new(CtrlAnimeInner::new(
-            anime,
-            client,
-            early_return.clone(),
-        )?));
-        // Need new client object for dbus control part
-        let (client, _) = RogDbusClient::new()?;
-        let anime_control = CtrlAnime::new(anime_config, inner.clone(), client, early_return)?;
-        anime_control.add_to_server(&mut server);
-        // Thread using inner
-        let _anime_thread = thread::Builder::new()
-            .name("Anime User".into())
-            .spawn(move || loop {
-                if let Ok(inner) = inner.try_lock() {
-                    inner.run().ok();
+        let anime_type = get_anime_type()?;
+        let anime_config = UserAnimeConfig::load_config(config.active_anime)?;
+        let anime = anime_config.create_anime(anime_type)?;
+        let anime_config = Arc::new(Mutex::new(anime_config));
+
+        executor
+            .spawn(async move {
+                // Create server
+                let mut connection = Connection::session().await.unwrap();
+                connection.request_name(DBUS_NAME).await.unwrap();
+
+                // Inner behind mutex required for thread safety
+                let inner = Arc::new(Mutex::new(
+                    CtrlAnimeInner::new(anime, client, early_return.clone()).unwrap(),
+                ));
+                // Need new client object for dbus control part
+                let (client, _) = RogDbusClientBlocking::new().unwrap();
+                let anime_control =
+                    CtrlAnime::new(anime_config, inner.clone(), client, early_return).unwrap();
+                anime_control.add_to_server(&mut connection).await;
+                loop {
+                    if let Ok(inner) = inner.clone().try_lock() {
+                        inner.run().ok();
+                    }
                 }
-            })?;
+            })
+            .detach();
     }
 
-    if supported.keyboard_led.per_key_led_mode {}
+    // if supported.keyboard_led.per_key_led_mode {
+    //     executor
+    //         .spawn(async move {
+    //            //
+    //         })
+    //         .detach();
+    // }
 
     loop {
-        if let Err(err) = server.try_handle_next() {
-            println!("{}", err);
-        }
+        smol::block_on(executor.tick());
     }
 }

daemon-user/src/user_config.rs

@@ -4,7 +4,7 @@ use std::{
     time::Duration,
 };
 
-use rog_anime::{ActionLoader, AnimTime, Fade, Sequences, Vec2};
+use rog_anime::{ActionLoader, AnimTime, AnimeType, Fade, Sequences, Vec2};
 use serde_derive::{Deserialize, Serialize};
 
 use crate::error::Error;
@@ -16,8 +16,8 @@ pub struct UserAnimeConfig {
 }
 
 impl UserAnimeConfig {
-    pub fn create_anime(&self) -> Result<Sequences, Error> {
-        let mut seq = Sequences::new();
+    pub fn create_anime(&self, anime_type: AnimeType) -> Result<Sequences, Error> {
+        let mut seq = Sequences::new(anime_type);
 
         for (idx, action) in self.anime.iter().enumerate() {
             seq.insert(idx, action)?;

daemon/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "daemon"
-version = "4.0.3"
+version = "4.2.0"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -18,22 +18,25 @@ name = "asusd"
 path = "src/daemon.rs"
 
 [dependencies]
-rog_anime = { path = "../rog-anime" }
-rog_aura = { path = "../rog-aura" }
+rog_anime = { path = "../rog-anime", features = ["dbus"] }
+rog_aura = { path = "../rog-aura", features = ["dbus"] }
 rog_supported = { path = "../rog-supported" }
 rog_profiles = { path = "../rog-profiles" }
 rog_dbus = { path = "../rog-dbus" }
-rusb = "^0.8"
+
+async-trait = "^0.1"
+smol = "^1.2"
+
+rusb = "^0.9"
 udev = "^0.6"
 
 # cli and logging
 log = "^0.4"
-env_logger = "^0.8"
+env_logger = "^0.9"
 
-zbus = "^1.9.1"
-zvariant = "^2.6"
-zvariant_derive = { version = "^2.6" }
-logind-zbus = "^0.7.1"
+zbus = "^2.2"
+zvariant = "^3.2"
+logind-zbus = { version = "^3.0" } #, default-features = false, features = ["non_blocking"] }
 
 # serialisation
 serde = "^1.0"

daemon/src/config.rs

@@ -2,6 +2,7 @@ use log::{error, warn};
 use serde_derive::{Deserialize, Serialize};
 use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};
+use std::path::PathBuf;
 
 pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
 
@@ -24,8 +25,8 @@ impl Config {
             .read(true)
             .write(true)
             .create(true)
-            .open(&CONFIG_PATH)
-            .unwrap_or_else(|_| panic!("The directory /etc/asusd/ is missing")); // okay to cause panic here
+            .open(&PathBuf::from(CONFIG_PATH))
+            .unwrap_or_else(|e| panic!("Error opening {}, {}", CONFIG_PATH, e)); // okay to cause panic here
         let mut buf = String::new();
         let config;
         if let Ok(read_len) = file.read_to_string(&mut buf) {

daemon/src/ctrl_anime/config.rs

@@ -1,7 +1,7 @@
 use crate::VERSION;
 use log::{error, info, warn};
-use rog_anime::Fade;
 use rog_anime::{error::AnimeError, ActionData, ActionLoader, AnimTime, Vec2};
+use rog_anime::{AnimeType, Fade};
 use serde_derive::{Deserialize, Serialize};
 use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};
@@ -80,28 +80,32 @@ pub struct AnimeConfigCached {
 }
 
 impl AnimeConfigCached {
-    pub fn init_from_config(&mut self, config: &AnimeConfig) -> Result<(), AnimeError> {
+    pub fn init_from_config(
+        &mut self,
+        config: &AnimeConfig,
+        anime_type: AnimeType,
+    ) -> Result<(), AnimeError> {
         let mut sys = Vec::with_capacity(config.system.len());
         for ani in config.system.iter() {
-            sys.push(ActionData::from_anime_action(ani)?);
+            sys.push(ActionData::from_anime_action(anime_type, ani)?);
         }
         self.system = sys;
 
         let mut boot = Vec::with_capacity(config.boot.len());
         for ani in config.boot.iter() {
-            boot.push(ActionData::from_anime_action(ani)?);
+            boot.push(ActionData::from_anime_action(anime_type, ani)?);
         }
         self.boot = boot;
 
         let mut wake = Vec::with_capacity(config.wake.len());
         for ani in config.wake.iter() {
-            wake.push(ActionData::from_anime_action(ani)?);
+            wake.push(ActionData::from_anime_action(anime_type, ani)?);
         }
         self.wake = wake;
 
         let mut shutdown = Vec::with_capacity(config.shutdown.len());
         for ani in config.shutdown.iter() {
-            shutdown.push(ActionData::from_anime_action(ani)?);
+            shutdown.push(ActionData::from_anime_action(anime_type, ani)?);
         }
         self.shutdown = shutdown;
         Ok(())
@@ -153,17 +157,20 @@ impl AnimeConfig {
             if read_len == 0 {
                 return AnimeConfig::create_default(&mut file);
             } else {
-                if let Ok(data) = serde_json::from_str(&buf) {
+                if let Ok(mut data) = serde_json::from_str(&buf) {
+                    Self::clamp_config_brightness(&mut data);
                     return data;
                 } else if let Ok(data) = serde_json::from_str::<AnimeConfigV341>(&buf) {
-                    let config = data.into_current();
+                    let mut config = data.into_current();
                     config.write();
                     info!("Updated config version to: {}", VERSION);
+                    Self::clamp_config_brightness(&mut config);
                     return config;
                 } else if let Ok(data) = serde_json::from_str::<AnimeConfigV352>(&buf) {
-                    let config = data.into_current();
+                    let mut config = data.into_current();
                     config.write();
                     info!("Updated config version to: {}", VERSION);
+                    Self::clamp_config_brightness(&mut config);
                     return config;
                 }
                 warn!(
@@ -182,6 +189,16 @@ impl AnimeConfig {
         AnimeConfig::create_default(&mut file)
     }
 
+    fn clamp_config_brightness(mut config: &mut AnimeConfig) {
+        if config.brightness < 0.0 || config.brightness > 1.0 {
+            warn!(
+                "Clamped brightness to [0.0 ; 1.0], was {}",
+                config.brightness
+            );
+            config.brightness = f32::max(0.0, f32::min(1.0, config.brightness));
+        }
+    }
+
     fn create_default(file: &mut File) -> Self {
         // create a default config here
         let config = AnimeConfig {

daemon/src/ctrl_anime/mod.rs

@@ -2,22 +2,24 @@ pub mod config;
 pub mod zbus;
 
 use ::zbus::Connection;
+use async_trait::async_trait;
 use log::{error, info, warn};
-use logind_zbus::ManagerProxy;
+use logind_zbus::manager::ManagerProxy;
 use rog_anime::{
     error::AnimeError,
     usb::{
-        pkt_for_apply, pkt_for_flush, pkt_for_set_boot, pkt_for_set_on, pkts_for_init, PROD_ID,
-        VENDOR_ID,
+        find_node, get_anime_type, pkt_for_apply, pkt_for_flush, pkt_for_set_boot, pkt_for_set_on,
+        pkts_for_init, PROD_ID, VENDOR_ID,
     },
-    ActionData, AnimeDataBuffer, AnimePacketType, ANIME_DATA_LEN,
+    ActionData, AnimeDataBuffer, AnimePacketType, AnimeType,
 };
 use rog_supported::AnimeSupportedFunctions;
 use rusb::{Device, DeviceHandle};
+use smol::{stream::StreamExt, Executor};
 use std::{
     cell::RefCell,
     error::Error,
-    sync::{Arc, Mutex},
+    sync::{Arc, Mutex, MutexGuard},
     thread::sleep,
 };
 use std::{
@@ -39,6 +41,7 @@ impl GetSupported for CtrlAnime {
 
 pub struct CtrlAnime {
     _node: String,
+    anime_type: AnimeType,
     handle: RefCell<DeviceHandle<rusb::GlobalContext>>,
     cache: AnimeConfigCached,
     config: AnimeConfig,
@@ -51,15 +54,17 @@ pub struct CtrlAnime {
 impl CtrlAnime {
     #[inline]
     pub fn new(config: AnimeConfig) -> Result<CtrlAnime, Box<dyn Error>> {
-        let node = Self::find_node("193b")?;
+        let node = find_node("193b")?;
+        let anime_type = get_anime_type()?;
         let device = Self::get_dev_handle()?;
 
         info!("Device has an AniMe Matrix display");
         let mut cache = AnimeConfigCached::default();
-        cache.init_from_config(&config)?;
+        cache.init_from_config(&config, anime_type)?;
 
         let ctrl = CtrlAnime {
             _node: node,
+            anime_type,
             handle: RefCell::new(device),
             cache,
             config,
@@ -71,34 +76,6 @@ impl CtrlAnime {
         Ok(ctrl)
     }
 
-    fn find_node(id_product: &str) -> Result<String, RogError> {
-        let mut enumerator = udev::Enumerator::new().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("enumerator failed".into(), err)
-        })?;
-        enumerator.match_subsystem("usb").map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("match_subsystem failed".into(), err)
-        })?;
-
-        for device in enumerator.scan_devices().map_err(|err| {
-            warn!("{}", err);
-            RogError::Udev("scan_devices failed".into(), err)
-        })? {
-            if let Some(attr) = device.attribute_value("idProduct") {
-                if attr == id_product {
-                    if let Some(dev_node) = device.devnode() {
-                        info!("Using device at: {:?} for AniMe control", dev_node);
-                        return Ok(dev_node.to_string_lossy().to_string());
-                    }
-                }
-            }
-        }
-        Err(RogError::MissingFunction(
-            "ASUS AniMe device node not found".into(),
-        ))
-    }
-
     fn get_dev_handle() -> Result<DeviceHandle<rusb::GlobalContext>, Box<dyn Error>> {
         // We don't expect this ID to ever change
         let device = CtrlAnime::get_device(0x0b05, 0x193b)?;
@@ -139,6 +116,7 @@ impl CtrlAnime {
             warn!("AniMe system actions was empty");
             return;
         }
+
         // Loop rules:
         // - Lock the mutex **only when required**. That is, the lock must be held for the shortest duration possible.
         // - An AtomicBool used for thread exit should be checked in every loop, including nested
@@ -148,60 +126,58 @@ impl CtrlAnime {
         std::thread::Builder::new()
             .name("AniMe system thread start".into())
             .spawn(move || {
-                info!("AniMe system thread started");
+                info!("AniMe new system thread started");
                 // Getting copies of these Atomics is done *in* the thread to ensure
                 // we don't block other threads/main
                 let thread_exit;
                 let thread_running;
-                // First two loops are to ensure we *do* aquire a lock on the mutex
-                // The reason the loop is required is because the USB writes can block
-                // for up to 10ms. We can't fail to get the atomics.
+                let anime_type;
                 loop {
                     if let Ok(lock) = inner.try_lock() {
                         thread_exit = lock.thread_exit.clone();
                         thread_running = lock.thread_running.clone();
-                        // Make any running loop exit first
-                        thread_exit.store(true, Ordering::SeqCst);
+                        anime_type = lock.anime_type;
                         break;
                     }
                 }
+                // First two loops are to ensure we *do* aquire a lock on the mutex
+                // The reason the loop is required is because the USB writes can block
+                // for up to 10ms. We can't fail to get the atomics.
+                while thread_running.load(Ordering::SeqCst) {
+                    // Make any running loop exit first
+                    thread_exit.store(true, Ordering::SeqCst);
+                }
 
-                loop {
-                    // wait for other threads to set not running so we know they exited
-                    if !thread_running.load(Ordering::SeqCst) {
-                        thread_exit.store(false, Ordering::SeqCst);
-                        info!("AniMe forced a thread to exit");
-                        break;
-                    }
-                }
+                info!("AniMe no previous system thread running (now)");
+                thread_exit.store(false, Ordering::SeqCst);
 
                 'main: loop {
-                    if thread_exit.load(Ordering::SeqCst) {
-                        break 'main;
-                    }
+                    thread_running.store(true, Ordering::SeqCst);
                     for action in actions.iter() {
+                        if thread_exit.load(Ordering::SeqCst) {
+                            break 'main;
+                        }
                         match action {
                             ActionData::Animation(frames) => {
-                                if let Err(err) = rog_anime::run_animation(
-                                    frames,
-                                    thread_exit.clone(),
-                                    &|frame| {
-                                        inner
-                                            .try_lock()
-                                            .map(|lock| lock.write_data_buffer(frame))
-                                            .map_err(|err| {
-                                                warn!("rog_anime::run_animation: {}", err);
-                                                AnimeError::NoFrames
-                                            })
-                                    },
-                                ) {
-                                    warn!("rog_anime::run_animation: {}", err);
+                                if let Err(err) = rog_anime::run_animation(frames, &|frame| {
+                                    if thread_exit.load(Ordering::Acquire) {
+                                        info!("rog-anime: frame-loop was asked to exit");
+                                        return Ok(true); // Do safe exit
+                                    }
+                                    inner
+                                        .try_lock()
+                                        .map(|lock| {
+                                            lock.write_data_buffer(frame);
+                                            false // Don't exit yet
+                                        })
+                                        .map_err(|err| {
+                                            warn!("rog_anime::run_animation:callback {}", err);
+                                            AnimeError::NoFrames
+                                        })
+                                }) {
+                                    warn!("rog_anime::run_animation:Animation {}", err);
                                     break 'main;
                                 };
-
-                                if thread_exit.load(Ordering::SeqCst) {
-                                    break 'main;
-                                }
                             }
                             ActionData::Image(image) => {
                                 once = false;
@@ -216,17 +192,20 @@ impl CtrlAnime {
                             ActionData::Matrix => {}
                         }
                     }
+                    if thread_exit.load(Ordering::SeqCst) {
+                        break 'main;
+                    }
                     if once || actions.is_empty() {
                         break 'main;
                     }
                 }
                 // Clear the display on exit
                 if let Ok(lock) = inner.try_lock() {
-                    let data = AnimeDataBuffer::from_vec([0u8; ANIME_DATA_LEN].to_vec());
+                    let data =
+                        AnimeDataBuffer::from_vec(anime_type, vec![0u8; anime_type.data_length()]);
                     lock.write_data_buffer(data);
                 }
                 // Loop ended, set the atmonics
-                thread_exit.store(false, Ordering::SeqCst);
                 thread_running.store(false, Ordering::SeqCst);
                 info!("AniMe system thread exited");
             })
@@ -276,7 +255,7 @@ impl CtrlAnime {
     /// Write only a data packet. This will modify the leds brightness using the
     /// global brightness set in config.
     fn write_data_buffer(&self, mut buffer: AnimeDataBuffer) {
-        for led in buffer.get_mut()[7..].iter_mut() {
+        for led in buffer.data_mut()[7..].iter_mut() {
             let mut bright = *led as f32 * self.config.brightness;
             if bright > 254.0 {
                 bright = 254.0;
@@ -297,89 +276,83 @@ impl CtrlAnime {
     }
 }
 
-pub struct CtrlAnimeTask<'a> {
+pub struct CtrlAnimeTask {
     inner: Arc<Mutex<CtrlAnime>>,
-    _c: Connection,
-    manager: ManagerProxy<'a>,
 }
 
-impl<'a> CtrlAnimeTask<'a> {
-    pub fn new(inner: Arc<Mutex<CtrlAnime>>) -> Self {
-        let connection =
-            Connection::new_system().expect("CtrlAnimeTask could not create dbus connection");
-
-        let manager =
-            ManagerProxy::new(&connection).expect("CtrlAnimeTask could not create ManagerProxy");
-
-        let c1 = inner.clone();
-        // Run this action when the system starts shutting down
-        manager
-            .connect_prepare_for_shutdown(move |shutdown| {
-                if shutdown {
-                    'outer: loop {
-                        if let Ok(lock) = c1.try_lock() {
-                            lock.thread_exit.store(true, Ordering::SeqCst);
-                            CtrlAnime::run_thread(c1.clone(), lock.cache.shutdown.clone(), false);
-                            break 'outer;
-                        }
-                    }
-                }
-                Ok(())
-            })
-            .map_err(|err| {
-                warn!("CtrlAnimeTask: new() {}", err);
-                err
-            })
-            .ok();
-
-        let c1 = inner.clone();
-        // Run this action when the system wakes up from sleep
-        manager
-            .connect_prepare_for_sleep(move |sleep| {
-                if !sleep {
-                    // wait a fraction for things to wake up properly
-                    std::thread::sleep(Duration::from_millis(100));
-                    'outer: loop {
-                        if let Ok(lock) = c1.try_lock() {
-                            lock.thread_exit.store(true, Ordering::SeqCst);
-                            CtrlAnime::run_thread(c1.clone(), lock.cache.wake.clone(), true);
-                            break 'outer;
-                        }
-                    }
-                }
-                Ok(())
-            })
-            .map_err(|err| {
-                warn!("CtrlAnimeTask: new() {}", err);
-                err
-            })
-            .ok();
-
-        Self {
-            inner,
-            _c: connection,
-            manager,
-        }
+impl CtrlAnimeTask {
+    pub async fn new(inner: Arc<Mutex<CtrlAnime>>) -> CtrlAnimeTask {
+        Self { inner }
     }
 }
 
-impl<'a> crate::CtrlTask for CtrlAnimeTask<'a> {
-    fn do_task(&self) -> Result<(), RogError> {
-        if let Ok(mut lock) = self.inner.try_lock() {
-            // Refresh the config and cache incase the user has edited it
-            let config = AnimeConfig::load();
-            lock.cache
-                .init_from_config(&config)
-                .map_err(|err| {
-                    warn!("CtrlAnimeTask: do_task {}", err);
-                    err
-                })
-                .ok();
-        }
+#[async_trait]
+impl crate::CtrlTask for CtrlAnimeTask {
+    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let connection = Connection::system()
+            .await
+            .expect("CtrlAnimeTask could not create dbus connection");
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("CtrlAnimeTask could not create ManagerProxy");
+
+        let run_action =
+            |start: bool, lock: MutexGuard<CtrlAnime>, inner: Arc<Mutex<CtrlAnime>>| {
+                if start {
+                    info!("CtrlAnimeTask running sleep animation");
+                    CtrlAnime::run_thread(inner.clone(), lock.cache.shutdown.clone(), true);
+                } else {
+                    info!("CtrlAnimeTask running wake animation");
+                    CtrlAnime::run_thread(inner.clone(), lock.cache.wake.clone(), true);
+                }
+            };
+
+        let inner = self.inner.clone();
+        executor
+            .spawn(async move {
+                if let Ok(notif) = manager.receive_prepare_for_sleep().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                // Loop is required to try an attempt to get the mutex *without* blocking
+                                // other threads - it is possible to end up with deadlocks otherwise.
+                                loop {
+                                    if let Ok(lock) = inner.clone().try_lock() {
+                                        run_action(args.start, lock, inner.clone());
+                                        break;
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+            })
+            .detach();
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("CtrlAnimeTask could not create ManagerProxy");
+
+        let inner = self.inner.clone();
+        executor
+            .spawn(async move {
+                if let Ok(notif) = manager.receive_prepare_for_shutdown().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                loop {
+                                    if let Ok(lock) = inner.clone().try_lock() {
+                                        run_action(args.start, lock, inner.clone());
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+            })
+            .detach();
 
-        // Check for signals on each task iteration, this will run the callbacks
-        // if any signal is recieved
-        self.manager.next_signal()?;
         Ok(())
     }
 }

daemon/src/ctrl_anime/zbus.rs

@@ -1,12 +1,11 @@
 use std::sync::{Arc, Mutex};
 
-use log::warn;
+use async_trait::async_trait;
 use rog_anime::{
     usb::{pkt_for_apply, pkt_for_set_boot, pkt_for_set_on},
     AnimeDataBuffer, AnimePowerStates,
 };
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
+use zbus::{dbus_interface, Connection, SignalContext};
 
 use std::sync::atomic::Ordering;
 
@@ -15,18 +14,10 @@ use super::CtrlAnime;
 pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
 
 /// The struct with the main dbus methods requires this trait
+#[async_trait]
 impl crate::ZbusAdd for CtrlAnimeZbus {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlAnimeDisplay: add_to_server {}", err);
-                err
-            })
-            .ok();
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Anime", server).await;
     }
 }
 
@@ -53,8 +44,8 @@ impl CtrlAnimeZbus {
                 let mut bright = bright;
                 if bright < 0.0 {
                     bright = 0.0
-                } else if bright > 254.0 {
-                    bright = 254.0;
+                } else if bright > 1.0 {
+                    bright = 1.0;
                 }
                 lock.config.brightness = bright;
                 lock.config.write();
@@ -64,26 +55,30 @@ impl CtrlAnimeZbus {
     }
 
     /// Set whether the AniMe is displaying images/data
-    fn set_on_off(&self, status: bool) {
+    async fn set_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, status: bool) {
+        let states;
         'outer: loop {
             if let Ok(mut lock) = self.0.try_lock() {
                 lock.write_bytes(&pkt_for_set_on(status));
                 lock.config.awake_enabled = status;
                 lock.config.write();
 
-                let states = AnimePowerStates {
+                states = Some(AnimePowerStates {
+                    brightness: lock.config.brightness.floor() as u8,
                     enabled: lock.config.awake_enabled,
                     boot_anim_enabled: lock.config.boot_anim_enabled,
-                };
-                self.notify_power_states(&states)
-                    .unwrap_or_else(|err| warn!("{}", err));
+                });
                 break 'outer;
             }
         }
+        if let Some(state) = states {
+            Self::notify_power_states(&ctxt, state).await.ok();
+        }
     }
 
     /// Set whether the AniMe will show boot, suspend, or off animations
-    fn set_boot_on_off(&self, on: bool) {
+    async fn set_boot_on_off(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>, on: bool) {
+        let states;
         'outer: loop {
             if let Ok(mut lock) = self.0.try_lock() {
                 lock.write_bytes(&pkt_for_set_boot(on));
@@ -91,15 +86,17 @@ impl CtrlAnimeZbus {
                 lock.config.boot_anim_enabled = on;
                 lock.config.write();
 
-                let states = AnimePowerStates {
+                states = Some(AnimePowerStates {
+                    brightness: lock.config.brightness.floor() as u8,
                     enabled: lock.config.awake_enabled,
                     boot_anim_enabled: lock.config.boot_anim_enabled,
-                };
-                self.notify_power_states(&states)
-                    .unwrap_or_else(|err| warn!("{}", err));
+                });
                 break 'outer;
             }
         }
+        if let Some(state) = states {
+            Self::notify_power_states(&ctxt, state).await.ok();
+        }
     }
 
     /// The main loop is the base system set action if the user isn't running
@@ -116,7 +113,7 @@ impl CtrlAnimeZbus {
         }
     }
 
-    /// Get status of if the AniMe LEDs are on
+    /// Get status of if the AniMe LEDs are on/displaying while system is awake
     #[dbus_interface(property)]
     fn awake_enabled(&self) -> bool {
         if let Ok(ctrl) = self.0.try_lock() {
@@ -136,5 +133,8 @@ impl CtrlAnimeZbus {
 
     /// Notify listeners of the status of AniMe LED power and factory system-status animations
     #[dbus_interface(signal)]
-    fn notify_power_states(&self, data: &AnimePowerStates) -> zbus::Result<()>;
+    async fn notify_power_states(
+        ctxt: &SignalContext<'_>,
+        data: AnimePowerStates,
+    ) -> zbus::Result<()>;
 }

daemon/src/ctrl_aura/config.rs

@@ -1,63 +1,22 @@
 use crate::laptops::LaptopLedData;
-use log::{error, info, warn};
+use log::{error, warn};
+use rog_aura::usb::AuraControl;
 use rog_aura::{AuraEffect, AuraModeNum, AuraZone, LedBrightness};
 use serde_derive::{Deserialize, Serialize};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashSet};
 use std::fs::{File, OpenOptions};
 use std::io::{Read, Write};
 
 pub static AURA_CONFIG_PATH: &str = "/etc/asusd/aura.conf";
 
 #[derive(Deserialize, Serialize)]
-pub struct AuraConfigV320 {
-    pub brightness: u32,
-    pub current_mode: AuraModeNum,
-    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
-    pub multizone: Option<AuraMultiZone>,
-}
-
-impl AuraConfigV320 {
-    pub(crate) fn into_current(self) -> AuraConfig {
-        AuraConfig {
-            brightness: <LedBrightness>::from(self.brightness),
-            current_mode: self.current_mode,
-            builtins: self.builtins,
-            multizone: self.multizone,
-            awake_enabled: true,
-            sleep_anim_enabled: true,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct AuraConfigV352 {
-    pub brightness: LedBrightness,
-    pub current_mode: AuraModeNum,
-    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
-    pub multizone: Option<AuraMultiZone>,
-}
-
-impl AuraConfigV352 {
-    pub(crate) fn into_current(self) -> AuraConfig {
-        AuraConfig {
-            brightness: self.brightness,
-            current_mode: self.current_mode,
-            builtins: self.builtins,
-            multizone: self.multizone,
-            awake_enabled: true,
-            sleep_anim_enabled: true,
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
+#[serde(default)]
 pub struct AuraConfig {
     pub brightness: LedBrightness,
     pub current_mode: AuraModeNum,
     pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
-    pub multizone: Option<AuraMultiZone>,
-    pub awake_enabled: bool,
-    pub sleep_anim_enabled: bool,
+    pub multizone: Option<BTreeMap<AuraModeNum, Vec<AuraEffect>>>,
+    pub enabled: HashSet<AuraControl>,
 }
 
 impl Default for AuraConfig {
@@ -67,8 +26,20 @@ impl Default for AuraConfig {
             current_mode: AuraModeNum::Static,
             builtins: BTreeMap::new(),
             multizone: None,
-            awake_enabled: true,
-            sleep_anim_enabled: true,
+            enabled: HashSet::from([
+                AuraControl::BootLogo,
+                AuraControl::BootKeyb,
+                AuraControl::SleepLogo,
+                AuraControl::SleepKeyb,
+                AuraControl::AwakeLogo,
+                AuraControl::AwakeKeyb,
+                AuraControl::ShutdownLogo,
+                AuraControl::ShutdownKeyb,
+                AuraControl::AwakeBar,
+                AuraControl::BootBar,
+                AuraControl::SleepBar,
+                AuraControl::ShutdownBar,
+            ]),
         }
     }
 }
@@ -94,16 +65,6 @@ impl AuraConfig {
             } else {
                 if let Ok(data) = serde_json::from_str(&buf) {
                     return data;
-                } else if let Ok(data) = serde_json::from_str::<AuraConfigV320>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated AuraConfig version");
-                    return config;
-                } else if let Ok(data) = serde_json::from_str::<AuraConfigV352>(&buf) {
-                    let config = data.into_current();
-                    config.write();
-                    info!("Updated AuraConfig version");
-                    return config;
                 }
                 warn!(
                     "Could not deserialise {}.\nWill rename to {}-old and recreate config",
@@ -170,107 +131,27 @@ impl AuraConfig {
             }
             _ => {
                 if let Some(multi) = self.multizone.as_mut() {
-                    multi.set(effect)
+                    if let Some(fx) = multi.get_mut(effect.mode()) {
+                        for fx in fx.iter_mut() {
+                            if fx.mode == effect.mode {
+                                *fx = effect;
+                                break;
+                            }
+                        }
+                    } else {
+                        let mut tmp = BTreeMap::new();
+                        tmp.insert(*effect.mode(), vec![effect]);
+                        self.multizone = Some(tmp);
+                    }
                 }
             }
         }
     }
 
-    pub fn get_multizone(&self, aura_type: AuraModeNum) -> Option<&[AuraEffect; 4]> {
+    pub fn get_multizone(&self, aura_type: AuraModeNum) -> Option<&[AuraEffect]> {
         if let Some(multi) = &self.multizone {
-            if aura_type == AuraModeNum::Static {
-                return Some(multi.static_());
-            } else if aura_type == AuraModeNum::Breathe {
-                return Some(multi.breathe());
-            }
+            return multi.get(&aura_type).map(|v| v.as_slice());
         }
         None
     }
 }
-
-#[derive(Deserialize, Serialize)]
-pub struct AuraMultiZone {
-    static_: [AuraEffect; 4],
-    breathe: [AuraEffect; 4],
-}
-
-impl AuraMultiZone {
-    pub fn set(&mut self, effect: AuraEffect) {
-        if effect.mode == AuraModeNum::Static {
-            match effect.zone {
-                AuraZone::None => {}
-                AuraZone::One => self.static_[0] = effect,
-                AuraZone::Two => self.static_[1] = effect,
-                AuraZone::Three => self.static_[2] = effect,
-                AuraZone::Four => self.static_[3] = effect,
-            }
-        } else if effect.mode == AuraModeNum::Breathe {
-            match effect.zone {
-                AuraZone::None => {}
-                AuraZone::One => self.breathe[0] = effect,
-                AuraZone::Two => self.breathe[1] = effect,
-                AuraZone::Three => self.breathe[2] = effect,
-                AuraZone::Four => self.breathe[3] = effect,
-            }
-        }
-    }
-
-    pub fn static_(&self) -> &[AuraEffect; 4] {
-        &self.static_
-    }
-
-    pub fn breathe(&self) -> &[AuraEffect; 4] {
-        &self.breathe
-    }
-}
-
-impl Default for AuraMultiZone {
-    fn default() -> Self {
-        Self {
-            static_: [
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::One,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::Two,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::Three,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Static,
-                    zone: AuraZone::Four,
-                    ..Default::default()
-                },
-            ],
-            breathe: [
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::One,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::Two,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::Three,
-                    ..Default::default()
-                },
-                AuraEffect {
-                    mode: AuraModeNum::Breathe,
-                    zone: AuraZone::Four,
-                    ..Default::default()
-                },
-            ],
-        }
-    }
-}

daemon/src/ctrl_aura/controller.rs

@@ -6,21 +6,21 @@ use crate::{
     laptops::{LaptopLedData, ASUS_KEYBOARD_DEVICES},
     CtrlTask,
 };
-use log::{info, warn};
-use logind_zbus::ManagerProxy;
+use async_trait::async_trait;
+use log::{error, info, warn};
+use logind_zbus::manager::ManagerProxy;
+use rog_aura::usb::AuraControl;
 use rog_aura::{
-    usb::{
-        LED_APPLY, LED_AWAKE_OFF_SLEEP_OFF, LED_AWAKE_OFF_SLEEP_ON, LED_AWAKE_ON_SLEEP_OFF,
-        LED_AWAKE_ON_SLEEP_ON, LED_SET,
-    },
+    usb::{LED_APPLY, LED_SET},
     AuraEffect, LedBrightness, LED_MSG_LEN,
 };
 use rog_supported::LedSupportedFunctions;
+use smol::{stream::StreamExt, Executor};
 use std::io::{Read, Write};
 use std::path::Path;
 use std::sync::Arc;
 use std::sync::Mutex;
-use std::{fs::OpenOptions, thread::spawn};
+use std::{fs::OpenOptions, sync::MutexGuard};
 use zbus::Connection;
 
 use crate::GetSupported;
@@ -32,10 +32,10 @@ impl GetSupported for CtrlKbdLed {
 
     fn get_supported() -> Self::A {
         // let mode = <&str>::from(&<AuraModes>::from(*mode));
-        let multizone_led_mode = false;
-        let per_key_led_mode = false;
         let laptop = LaptopLedData::get_data();
         let stock_led_modes = laptop.standard;
+        let multizone_led_mode = laptop.multizone;
+        let per_key_led_mode = laptop.per_key;
 
         LedSupportedFunctions {
             brightness_set: CtrlKbdLed::get_kbd_bright_path().is_some(),
@@ -54,50 +54,13 @@ pub struct CtrlKbdLed {
     pub config: AuraConfig,
 }
 
-pub struct CtrlKbdLedTask<'a> {
+pub struct CtrlKbdLedTask {
     inner: Arc<Mutex<CtrlKbdLed>>,
-    _c: Connection,
-    manager: ManagerProxy<'a>,
 }
 
-impl<'a> CtrlKbdLedTask<'a> {
+impl CtrlKbdLedTask {
     pub fn new(inner: Arc<Mutex<CtrlKbdLed>>) -> Self {
-        let connection =
-            Connection::new_system().expect("CtrlKbdLedTask could not create dbus connection");
-
-        let manager =
-            ManagerProxy::new(&connection).expect("CtrlKbdLedTask could not create ManagerProxy");
-
-        let c1 = inner.clone();
-        // Run this action when the system wakes up from sleep
-        manager
-            .connect_prepare_for_sleep(move |sleep| {
-                if !sleep {
-                    let c1 = c1.clone();
-                    spawn(move || {
-                        // wait a fraction for things to wake up properly
-                        //std::thread::sleep(Duration::from_millis(100));
-                        loop {
-                            if let Ok(ref mut lock) = c1.try_lock() {
-                                lock.set_brightness(lock.config.brightness).ok();
-                                break;
-                            }
-                        }
-                    });
-                }
-                Ok(())
-            })
-            .map_err(|err| {
-                warn!("CtrlAnimeTask: new() {}", err);
-                err
-            })
-            .ok();
-
-        Self {
-            inner,
-            _c: connection,
-            manager,
-        }
+        Self { inner }
     }
 
     fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
@@ -125,12 +88,81 @@ impl<'a> CtrlKbdLedTask<'a> {
     }
 }
 
-impl<'a> CtrlTask for CtrlKbdLedTask<'a> {
-    fn do_task(&self) -> Result<(), RogError> {
-        self.manager.next_signal()?;
-        if let Ok(ref mut lock) = self.inner.try_lock() {
-            return Self::update_config(lock);
-        }
+#[async_trait]
+impl CtrlTask for CtrlKbdLedTask {
+    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let connection = Connection::system()
+            .await
+            .expect("CtrlKbdLedTask could not create dbus connection");
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("CtrlKbdLedTask could not create ManagerProxy");
+
+        let load_save = |start: bool, mut lock: MutexGuard<CtrlKbdLed>| {
+            // If waking up
+            if !start {
+                info!("CtrlKbdLedTask reloading brightness and modes");
+                lock.set_brightness(lock.config.brightness)
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+                if let Some(mode) = lock.config.builtins.get(&lock.config.current_mode) {
+                    lock.write_mode(mode)
+                        .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                        .ok();
+                }
+            } else if start {
+                info!("CtrlKbdLedTask saving last brightness");
+                Self::update_config(&mut lock)
+                    .map_err(|e| error!("CtrlKbdLedTask: {e}"))
+                    .ok();
+            }
+        };
+
+        let inner = self.inner.clone();
+        executor
+            .spawn(async move {
+                if let Ok(notif) = manager.receive_prepare_for_sleep().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                loop {
+                                    // Loop so that we do aquire the lock but also don't block other
+                                    // threads (prevents potential deadlocks)
+                                    if let Ok(lock) = inner.clone().try_lock() {
+                                        load_save(args.start, lock);
+                                        break;
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+                if let Ok(notif) = manager.receive_prepare_for_shutdown().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                loop {
+                                    if let Ok(lock) = inner.clone().try_lock() {
+                                        load_save(args.start, lock);
+                                        break;
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+            })
+            .detach();
+
+        // let inner = self.inner.clone();
+        // self.repeating_task(500, executor, move || loop {
+        //     if let Ok(ref mut lock) = inner.try_lock() {
+        //         Self::update_config(lock).unwrap();
+        //         break;
+        //     }
+        // })
+        // .await;
         Ok(())
     }
 }
@@ -145,8 +177,8 @@ impl crate::Reloadable for CtrlKbdLedReloader {
                 ctrl.do_command(mode).ok();
             }
 
-            ctrl.set_states_enabled(ctrl.config.awake_enabled, ctrl.config.sleep_anim_enabled)
-                .map_err(|err| warn!("{}", err))
+            ctrl.set_power_states(&ctrl.config)
+                .map_err(|err| warn!("{err}"))
                 .ok();
         }
         Ok(())
@@ -170,9 +202,10 @@ impl CtrlKbdLed {
             match Self::find_led_node(prod) {
                 Ok(node) => {
                     led_node = Some(node);
+                    info!("Looked for keyboard controller 0x{prod}: Found");
                     break;
                 }
-                Err(err) => warn!("led_node: {}", err),
+                Err(err) => info!("Looked for keyboard controller 0x{prod}: {err}"),
             }
         }
 
@@ -263,20 +296,17 @@ impl CtrlKbdLed {
         self.set_brightness(self.config.brightness)
     }
 
-    /// Set if awake/on LED active, and/or sleep animation active
-    pub(super) fn set_states_enabled(&self, awake: bool, sleep: bool) -> Result<(), RogError> {
-        let bytes = if awake && sleep {
-            LED_AWAKE_ON_SLEEP_ON
-        } else if awake && !sleep {
-            LED_AWAKE_ON_SLEEP_OFF
-        } else if !awake && sleep {
-            LED_AWAKE_OFF_SLEEP_ON
-        } else if !awake && !sleep {
-            LED_AWAKE_OFF_SLEEP_OFF
-        } else {
-            LED_AWAKE_ON_SLEEP_ON
-        };
-        self.write_bytes(&bytes)?;
+    /// Set combination state for boot animation/sleep animation/all leds/keys leds/side leds LED active
+    pub(super) fn set_power_states(&self, config: &AuraConfig) -> Result<(), RogError> {
+        let set: Vec<AuraControl> = config.enabled.iter().map(|v| *v).collect();
+        let bytes = AuraControl::to_bytes(&set);
+
+        // Quite ugly, must be a more idiomatic way to do
+        let message = [
+            0x5d, 0xbd, 0x01, bytes[0], bytes[1], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ];
+
+        self.write_bytes(&message)?;
         self.write_bytes(&LED_SET)?;
         // Changes won't persist unless apply is set
         self.write_bytes(&LED_APPLY)?;

daemon/src/ctrl_aura/zbus.rs

@@ -1,18 +1,14 @@
-use log::{error, warn};
-use rog_aura::{AuraEffect, LedBrightness, LedPowerStates};
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
+use async_trait::async_trait;
+use log::warn;
+use rog_aura::{usb::AuraControl, AuraEffect, LedBrightness};
+use zbus::{dbus_interface, Connection, SignalContext};
 
 use super::controller::CtrlKbdLedZbus;
 
+#[async_trait]
 impl crate::ZbusAdd for CtrlKbdLedZbus {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(&ObjectPath::from_str_unchecked("/org/asuslinux/Led"), self)
-            .map_err(|err| {
-                error!("DbusKbdLed: add_to_server {}", err);
-            })
-            .ok();
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Led", server).await;
     }
 }
 
@@ -22,7 +18,7 @@ impl crate::ZbusAdd for CtrlKbdLedZbus {
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlKbdLedZbus {
     /// Set the keyboard brightness level (0-3)
-    fn set_brightness(&mut self, brightness: LedBrightness) {
+    async fn set_brightness(&mut self, brightness: LedBrightness) {
         if let Ok(ctrl) = self.0.try_lock() {
             ctrl.set_brightness(brightness)
                 .map_err(|err| warn!("{}", err))
@@ -30,48 +26,87 @@ impl CtrlKbdLedZbus {
         }
     }
 
-    /// Set the keyboard LED to enabled while the device is awake
-    fn set_awake_enabled(&mut self, enabled: bool) {
+    /// Set a variety of states, input is array of enum.
+    ///
+    /// enum AuraControl {
+    ///     BootLogo,
+    ///     BootKeyb,
+    ///     AwakeLogo,
+    ///     AwakeKeyb,
+    ///     SleepLogo,
+    ///     SleepKeyb,
+    ///     ShutdownLogo,
+    ///     ShutdownKeyb,
+    ///     AwakeBar,
+    ///     BootBar,
+    ///     SleepBar,
+    ///     ShutdownBar,
+    /// }
+    async fn set_leds_enabled(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        enabled: Vec<AuraControl>,
+    ) {
+        let mut states = None;
         if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.set_states_enabled(enabled, ctrl.config.sleep_anim_enabled)
-                .map_err(|err| warn!("{}", err))
-                .ok();
-            ctrl.config.awake_enabled = enabled;
+            for s in enabled {
+                ctrl.config.enabled.insert(s);
+            }
             ctrl.config.write();
 
-            let states = LedPowerStates {
-                enabled: ctrl.config.awake_enabled,
-                sleep_anim_enabled: ctrl.config.sleep_anim_enabled,
-            };
-            self.notify_power_states(&states)
+            ctrl.set_power_states(&ctrl.config)
+                .map_err(|err| warn!("{}", err))
+                .ok();
+
+            let set: Vec<AuraControl> = ctrl.config.enabled.iter().map(|v| *v).collect();
+            states = Some(set);
+        }
+        // Need to pull state out like this due to MutexGuard
+        if let Some(states) = states {
+            Self::notify_power_states(&ctxt, &states)
+                .await
                 .unwrap_or_else(|err| warn!("{}", err));
         }
     }
 
-    /// Set the keyboard LED suspend animation to enabled while the device is suspended
-    fn set_sleep_enabled(&mut self, enabled: bool) {
+    async fn set_leds_disabled(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        disabled: Vec<AuraControl>,
+    ) {
+        let mut states = None;
         if let Ok(mut ctrl) = self.0.try_lock() {
-            ctrl.set_states_enabled(ctrl.config.awake_enabled, enabled)
+            for s in disabled {
+                ctrl.config.enabled.remove(&s);
+            }
+            ctrl.config.write();
+
+            ctrl.set_power_states(&ctrl.config)
                 .map_err(|err| warn!("{}", err))
                 .ok();
-            ctrl.config.sleep_anim_enabled = enabled;
-            ctrl.config.write();
-            let states = LedPowerStates {
-                enabled: ctrl.config.awake_enabled,
-                sleep_anim_enabled: ctrl.config.sleep_anim_enabled,
-            };
-            self.notify_power_states(&states)
+
+            let set: Vec<AuraControl> = ctrl.config.enabled.iter().map(|v| *v).collect();
+            states = Some(set);
+        }
+        // Need to pull state out like this due to MutexGuard
+        if let Some(states) = states {
+            Self::notify_power_states(&ctxt, &states)
+                .await
                 .unwrap_or_else(|err| warn!("{}", err));
         }
     }
 
-    fn set_led_mode(&mut self, effect: AuraEffect) {
+    async fn set_led_mode(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        effect: AuraEffect,
+    ) {
+        let mut led = None;
         if let Ok(mut ctrl) = self.0.try_lock() {
             match ctrl.do_command(effect) {
                 Ok(_) => {
                     if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                        self.notify_led(mode.clone())
-                            .unwrap_or_else(|err| warn!("{}", err));
+                        led = Some(mode.clone());
                     }
                 }
                 Err(err) => {
@@ -79,40 +114,55 @@ impl CtrlKbdLedZbus {
                 }
             }
         }
+        if let Some(led) = led {
+            Self::notify_led(&ctxt, led)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
     }
 
-    fn next_led_mode(&self) {
-        if let Ok(mut ctrl) = self.0.try_lock() {
+    async fn next_led_mode(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+        let mut led = None;
+        if let Ok(mut ctrl) = self.0.lock() {
             ctrl.toggle_mode(false)
                 .unwrap_or_else(|err| warn!("{}", err));
 
             if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                self.notify_led(mode.clone())
-                    .unwrap_or_else(|err| warn!("{}", err));
+                led = Some(mode.clone());
             }
         }
+        if let Some(led) = led {
+            Self::notify_led(&ctxt, led)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
     }
 
-    fn prev_led_mode(&self) {
-        if let Ok(mut ctrl) = self.0.try_lock() {
+    async fn prev_led_mode(&self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+        let mut led = None;
+        if let Ok(mut ctrl) = self.0.lock() {
             ctrl.toggle_mode(true)
                 .unwrap_or_else(|err| warn!("{}", err));
 
             if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
-                self.notify_led(mode.clone())
-                    .unwrap_or_else(|err| warn!("{}", err));
+                led = Some(mode.clone());
             }
         }
+        if let Some(led) = led {
+            Self::notify_led(&ctxt, led)
+                .await
+                .unwrap_or_else(|err| warn!("{}", err));
+        }
     }
 
-    fn next_led_brightness(&self) {
+    async fn next_led_brightness(&self) {
         if let Ok(mut ctrl) = self.0.try_lock() {
             ctrl.next_brightness()
                 .unwrap_or_else(|err| warn!("{}", err));
         }
     }
 
-    fn prev_led_brightness(&self) {
+    async fn prev_led_brightness(&self) {
         if let Ok(mut ctrl) = self.0.try_lock() {
             ctrl.prev_brightness()
                 .unwrap_or_else(|err| warn!("{}", err));
@@ -120,24 +170,17 @@ impl CtrlKbdLedZbus {
     }
 
     #[dbus_interface(property)]
-    fn awake_enabled(&self) -> bool {
+    async fn leds_enabled(&self) -> Vec<u8> {
         if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.awake_enabled;
+            let set: Vec<AuraControl> = ctrl.config.enabled.iter().map(|v| *v).collect();
+            return AuraControl::to_bytes(&set).to_vec();
         }
-        true
-    }
-
-    #[dbus_interface(property)]
-    fn sleep_enabled(&self) -> bool {
-        if let Ok(ctrl) = self.0.try_lock() {
-            return ctrl.config.sleep_anim_enabled;
-        }
-        true
+        vec![0, 0]
     }
 
     /// Return the current mode data
     #[dbus_interface(property)]
-    fn led_mode(&self) -> String {
+    async fn led_mode(&self) -> String {
         if let Ok(ctrl) = self.0.try_lock() {
             if let Some(mode) = ctrl.config.builtins.get(&ctrl.config.current_mode) {
                 if let Ok(json) = serde_json::to_string(&mode) {
@@ -151,7 +194,7 @@ impl CtrlKbdLedZbus {
 
     /// Return a list of available modes
     #[dbus_interface(property)]
-    fn led_modes(&self) -> String {
+    async fn led_modes(&self) -> String {
         if let Ok(ctrl) = self.0.try_lock() {
             if let Ok(json) = serde_json::to_string(&ctrl.config.builtins) {
                 return json;
@@ -163,7 +206,7 @@ impl CtrlKbdLedZbus {
 
     /// Return the current LED brightness
     #[dbus_interface(property)]
-    fn led_brightness(&self) -> i8 {
+    async fn led_brightness(&self) -> i8 {
         if let Ok(ctrl) = self.0.try_lock() {
             return ctrl.get_brightness().map(|n| n as i8).unwrap_or(-1);
         }
@@ -172,8 +215,11 @@ impl CtrlKbdLedZbus {
     }
 
     #[dbus_interface(signal)]
-    fn notify_led(&self, data: AuraEffect) -> zbus::Result<()>;
+    async fn notify_led(signal_ctxt: &SignalContext<'_>, data: AuraEffect) -> zbus::Result<()>;
 
     #[dbus_interface(signal)]
-    fn notify_power_states(&self, data: &LedPowerStates) -> zbus::Result<()>;
+    async fn notify_power_states(
+        signal_ctxt: &SignalContext<'_>,
+        data: &[AuraControl],
+    ) -> zbus::Result<()>;
 }

daemon/src/ctrl_charge.rs

@@ -1,14 +1,19 @@
+use crate::CtrlTask;
 use crate::{config::Config, error::RogError, GetSupported};
-//use crate::dbus::DbusEvents;
+use async_trait::async_trait;
 use log::{info, warn};
+use logind_zbus::manager::ManagerProxy;
 use rog_supported::ChargeSupportedFunctions;
+use smol::stream::StreamExt;
+use smol::Executor;
 use std::fs::OpenOptions;
 use std::io::Write;
 use std::path::Path;
 use std::sync::Arc;
 use std::sync::Mutex;
 use zbus::dbus_interface;
-use zvariant::ObjectPath;
+use zbus::Connection;
+use zbus::SignalContext;
 
 static BAT_CHARGE_PATH0: &str = "/sys/class/power_supply/BAT0/charge_control_end_threshold";
 static BAT_CHARGE_PATH1: &str = "/sys/class/power_supply/BAT1/charge_control_end_threshold";
@@ -30,24 +35,27 @@ pub struct CtrlCharge {
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlCharge {
-    pub fn set_limit(&mut self, limit: u8) {
+    async fn set_limit(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        limit: u8,
+    ) -> zbus::fdo::Result<()> {
+        if !(20..=100).contains(&limit) {
+            return Err(RogError::ChargeLimit(limit))?;
+        }
         if let Ok(mut config) = self.config.try_lock() {
-            self.set(limit, &mut config)
-                .map_err(|err| {
-                    warn!("CtrlCharge: set_limit {}", err);
-                    err
-                })
-                .ok();
-            self.notify_charge(limit)
+            Self::set(limit, &mut config)
                 .map_err(|err| {
                     warn!("CtrlCharge: set_limit {}", err);
                     err
                 })
                 .ok();
         }
+        Self::notify_charge(&ctxt, limit).await?;
+        Ok(())
     }
 
-    pub fn limit(&self) -> i8 {
+    fn limit(&self) -> i8 {
         if let Ok(config) = self.config.try_lock() {
             return config.bat_charge_limit as i8;
         }
@@ -55,21 +63,13 @@ impl CtrlCharge {
     }
 
     #[dbus_interface(signal)]
-    pub fn notify_charge(&self, limit: u8) -> zbus::Result<()> {}
+    async fn notify_charge(ctxt: &SignalContext<'_>, limit: u8) -> zbus::Result<()>;
 }
 
+#[async_trait]
 impl crate::ZbusAdd for CtrlCharge {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Charge"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlCharge: add_to_server {}", err);
-                err
-            })
-            .ok();
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Charge", server).await;
     }
 }
 
@@ -77,7 +77,7 @@ impl crate::Reloadable for CtrlCharge {
     fn reload(&mut self) -> Result<(), RogError> {
         if let Ok(mut config) = self.config.try_lock() {
             config.read();
-            self.set(config.bat_charge_limit, &mut config)?;
+            Self::set(config.bat_charge_limit, &mut config)?;
         }
         Ok(())
     }
@@ -104,12 +104,9 @@ impl CtrlCharge {
         }
     }
 
-    pub(super) fn set(&self, limit: u8, config: &mut Config) -> Result<(), RogError> {
+    pub(super) fn set(limit: u8, config: &mut Config) -> Result<(), RogError> {
         if !(20..=100).contains(&limit) {
-            warn!(
-                "Unable to set battery charge limit, must be between 20-100: requested {}",
-                limit
-            );
+            return Err(RogError::ChargeLimit(limit));
         }
 
         let path = Self::get_battery_path()?;
@@ -129,3 +126,76 @@ impl CtrlCharge {
         Ok(())
     }
 }
+
+#[async_trait]
+impl CtrlTask for CtrlCharge {
+    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let connection = Connection::system()
+            .await
+            .expect("CtrlCharge could not create dbus connection");
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("CtrlCharge could not create ManagerProxy");
+
+        let config1 = self.config.clone();
+        executor
+            .spawn(async move {
+                if let Ok(notif) = manager.receive_prepare_for_sleep().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                // If waking up
+                                if !args.start {
+                                    info!("CtrlCharge reloading charge limit");
+                                    if let Ok(mut lock) = config1.try_lock() {
+                                        Self::set(lock.bat_charge_limit, &mut lock)
+                                            .map_err(|err| {
+                                                warn!("CtrlCharge: set_limit {}", err);
+                                                err
+                                            })
+                                            .ok();
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+            })
+            .detach();
+
+        let manager = ManagerProxy::new(&connection)
+            .await
+            .expect("CtrlCharge could not create ManagerProxy");
+
+        let config = self.config.clone();
+        executor
+            .spawn(async move {
+                if let Ok(notif) = manager.receive_prepare_for_shutdown().await {
+                    notif
+                        .for_each(|event| {
+                            if let Ok(args) = event.args() {
+                                // If waking up - intention is to catch hibernation event
+                                if !args.start {
+                                    info!("CtrlCharge reloading charge limit");
+                                    loop {
+                                        if let Ok(mut lock) = config.clone().try_lock() {
+                                            Self::set(lock.bat_charge_limit, &mut lock)
+                                                .map_err(|err| {
+                                                    warn!("CtrlCharge: set_limit {}", err);
+                                                    err
+                                                })
+                                                .ok();
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        })
+                        .await;
+                }
+            })
+            .detach();
+        Ok(())
+    }
+}

daemon/src/ctrl_profiles/controller.rs

@@ -2,10 +2,12 @@ use std::sync::{Arc, Mutex};
 
 use crate::error::RogError;
 use crate::{CtrlTask, GetSupported};
+use async_trait::async_trait;
 use log::{info, warn};
 use rog_profiles::error::ProfileError;
 use rog_profiles::{FanCurveProfiles, Profile};
 use rog_supported::PlatformProfileFunctions;
+use smol::Executor;
 
 use super::config::ProfileConfig;
 
@@ -21,8 +23,7 @@ impl GetSupported for CtrlPlatformProfile {
             warn!(
                 r#"
 platform_profile kernel interface not found, your laptop does not support this, or the interface is missing.
-To enable profile support you require a kernel with the following patch applied:
-https://lkml.org/lkml/2021/8/18/1022
+To enable profile support you require a kernel version 5.15.2 minimum.
 "#
             );
         }
@@ -38,8 +39,8 @@ https://lkml.org/lkml/2021/8/18/1022
                 r#"
 fan curves kernel interface not found, your laptop does not support this, or the interface is missing.
 To enable fan-curve support you require a kernel with the following patch applied:
-https://lkml.org/lkml/2021/8/20/232
-Please note that as of 24/08/2021 this is not final.
+https://lkml.org/lkml/2021/10/23/250
+This patch has been accepted upstream for 5.17 kernel release.
 "#
             );
         }
@@ -56,7 +57,10 @@ impl crate::Reloadable for CtrlPlatformProfile {
     fn reload(&mut self) -> Result<(), RogError> {
         if let Some(curves) = &mut self.config.fan_curves {
             if let Ok(mut device) = FanCurveProfiles::get_device() {
+                // There is a possibility that the curve was default zeroed, so this call initialises
+                // the data from system read and we need to save it after
                 curves.write_profile_curve_to_platform(self.config.active_profile, &mut device)?;
+                self.config.write();
             }
         }
         Ok(())
@@ -64,17 +68,13 @@ impl crate::Reloadable for CtrlPlatformProfile {
 }
 
 impl CtrlPlatformProfile {
-    pub fn new(mut config: ProfileConfig) -> Result<Self, RogError> {
+    pub fn new(config: ProfileConfig) -> Result<Self, RogError> {
         if Profile::is_platform_profile_supported() {
             info!("Device has profile control available");
 
-            if let Ok(ref device) = FanCurveProfiles::get_device() {
-                let profile = config.active_profile;
-                if let Some(curve) = config.fan_curves.as_mut() {
-                    curve.read_from_dev_profile(profile, device);
-                }
+            if FanCurveProfiles::get_device().is_ok() {
+                info!("Device has fan curves available");
             }
-            config.write();
 
             return Ok(CtrlPlatformProfile { config });
         }
@@ -137,15 +137,21 @@ impl CtrlProfileTask {
     }
 }
 
+#[async_trait]
 impl CtrlTask for CtrlProfileTask {
-    fn do_task(&self) -> Result<(), RogError> {
-        if let Ok(ref mut lock) = self.ctrl.try_lock() {
-            let new_profile = Profile::get_active_profile().unwrap();
-            if new_profile != lock.config.active_profile {
-                lock.config.active_profile = new_profile;
-                lock.save_config();
+    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let ctrl = self.ctrl.clone();
+        self.repeating_task(666, executor, move || {
+            if let Ok(ref mut lock) = ctrl.try_lock() {
+                let new_profile = Profile::get_active_profile().unwrap();
+                if new_profile != lock.config.active_profile {
+                    lock.config.active_profile = new_profile;
+                    lock.write_profile_curve_to_platform().unwrap();
+                    lock.save_config();
+                }
             }
-        }
+        })
+        .await;
         Ok(())
     }
 }

daemon/src/ctrl_profiles/zbus.rs

@@ -1,12 +1,14 @@
+use async_trait::async_trait;
 use log::warn;
 use rog_profiles::fan_curve_set::CurveData;
 use rog_profiles::fan_curve_set::FanCurveSet;
 use rog_profiles::Profile;
+use zbus::Connection;
+use zbus::SignalContext;
 
 use std::sync::Arc;
 use std::sync::Mutex;
 use zbus::{dbus_interface, fdo::Error};
-use zvariant::ObjectPath;
 
 use super::controller::CtrlPlatformProfile;
 
@@ -37,13 +39,17 @@ impl ProfileZbus {
 
     /// Toggle to next platform_profile. Names provided by `Profiles`.
     /// If fan-curves are supported will also activate a fan curve for profile.
-    fn next_profile(&mut self) {
+    async fn next_profile(&mut self, #[zbus(signal_context)] ctxt: SignalContext<'_>) {
+        let mut profile = None;
         if let Ok(mut ctrl) = self.inner.try_lock() {
             ctrl.set_next_profile()
                 .unwrap_or_else(|err| warn!("{}", err));
             ctrl.save_config();
+            profile = Some(ctrl.config.active_profile);
+        }
+        if let Some(profile) = profile {
+            Self::notify_profile(&ctxt, profile).await.ok();
         }
-        self.do_notification();
     }
 
     /// Fetch the active profile name
@@ -58,7 +64,12 @@ impl ProfileZbus {
     }
 
     /// Set this platform_profile name as active
-    fn set_active_profile(&self, profile: Profile) {
+    async fn set_active_profile(
+        &self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        profile: Profile,
+    ) {
+        let mut tmp = None;
         if let Ok(mut ctrl) = self.inner.try_lock() {
             // Read first just incase the user has modified the config before calling this
             ctrl.config.read();
@@ -71,8 +82,11 @@ impl ProfileZbus {
                 .ok();
 
             ctrl.save_config();
+            tmp = Some(ctrl.config.active_profile);
+        }
+        if let Some(profile) = tmp {
+            Self::notify_profile(&ctxt, profile).await.ok();
         }
-        self.do_notification();
     }
 
     /// Get a list of profiles that have fan-curves enabled.
@@ -94,7 +108,7 @@ impl ProfileZbus {
     fn set_fan_curve_enabled(&mut self, profile: Profile, enabled: bool) -> zbus::fdo::Result<()> {
         if let Ok(mut ctrl) = self.inner.try_lock() {
             ctrl.config.read();
-            if let Some(curves) = &mut ctrl.config.fan_curves {
+            return if let Some(curves) = &mut ctrl.config.fan_curves {
                 curves.set_profile_curve_enabled(profile, enabled);
 
                 ctrl.write_profile_curve_to_platform()
@@ -102,10 +116,10 @@ impl ProfileZbus {
                     .ok();
 
                 ctrl.save_config();
-                return Ok(());
+                Ok(())
             } else {
-                return Err(Error::Failed(UNSUPPORTED_MSG.to_string()));
-            }
+                Err(Error::Failed(UNSUPPORTED_MSG.to_string()))
+            };
         }
         Err(Error::Failed(
             "Failed to get enabled fan curve names".to_string(),
@@ -161,29 +175,13 @@ impl ProfileZbus {
     }
 
     #[dbus_interface(signal)]
-    fn notify_profile(&self, profile: &Profile) -> zbus::Result<()> {}
-}
-
-impl ProfileZbus {
-    fn do_notification(&self) {
-        if let Ok(ctrl) = self.inner.try_lock() {
-            self.notify_profile(&ctrl.config.active_profile)
-                .unwrap_or_else(|err| warn!("{}", err));
-        }
+    async fn notify_profile(signal_ctxt: &SignalContext<'_>, profile: Profile) -> zbus::Result<()> {
     }
 }
 
+#[async_trait]
 impl crate::ZbusAdd for ProfileZbus {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Profile"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("DbusFanAndCpu: add_to_server {}", err);
-                err
-            })
-            .ok();
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Profile", server).await;
     }
 }

daemon/src/ctrl_rog_bios.rs

@@ -1,4 +1,5 @@
 use crate::{config::Config, error::RogError, GetSupported};
+use async_trait::async_trait;
 use log::{error, info, warn};
 use rog_supported::RogBiosSupportedFunctions;
 use std::fs::OpenOptions;
@@ -8,8 +9,8 @@ use std::path::Path;
 use std::process::Command;
 use std::sync::Arc;
 use std::sync::Mutex;
-use zbus::dbus_interface;
-use zvariant::ObjectPath;
+use zbus::Connection;
+use zbus::{dbus_interface, SignalContext};
 
 const INITRAMFS_PATH: &str = "/usr/sbin/update-initramfs";
 const DRACUT_PATH: &str = "/usr/bin/dracut";
@@ -36,22 +37,23 @@ impl GetSupported for CtrlRogBios {
 
 #[dbus_interface(name = "org.asuslinux.Daemon")]
 impl CtrlRogBios {
-    pub fn set_dedicated_graphic_mode(&mut self, dedicated: bool) {
+    async fn set_dedicated_graphic_mode(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        dedicated: bool,
+    ) {
         self.set_gfx_mode(dedicated)
             .map_err(|err| {
                 warn!("CtrlRogBios: set_asus_switch_graphic_mode {}", err);
                 err
             })
             .ok();
-        self.notify_dedicated_graphic_mode(dedicated)
-            .map_err(|err| {
-                warn!("CtrlRogBios: notify_asus_switch_graphic_mode {}", err);
-                err
-            })
+        Self::notify_dedicated_graphic_mode(&ctxt, dedicated)
+            .await
             .ok();
     }
 
-    pub fn dedicated_graphic_mode(&self) -> i8 {
+    fn dedicated_graphic_mode(&self) -> i8 {
         Self::get_gfx_mode()
             .map_err(|err| {
                 warn!("CtrlRogBios: get_gfx_mode {}", err);
@@ -61,24 +63,27 @@ impl CtrlRogBios {
     }
 
     #[dbus_interface(signal)]
-    pub fn notify_dedicated_graphic_mode(&self, dedicated: bool) -> zbus::Result<()> {}
+    async fn notify_dedicated_graphic_mode(
+        signal_ctxt: &SignalContext<'_>,
+        dedicated: bool,
+    ) -> zbus::Result<()> {
+    }
 
-    pub fn set_post_boot_sound(&mut self, on: bool) {
+    async fn set_post_boot_sound(
+        &mut self,
+        #[zbus(signal_context)] ctxt: SignalContext<'_>,
+        on: bool,
+    ) {
         Self::set_boot_sound(on)
             .map_err(|err| {
                 warn!("CtrlRogBios: set_post_boot_sound {}", err);
                 err
             })
             .ok();
-        self.notify_post_boot_sound(on)
-            .map_err(|err| {
-                warn!("CtrlRogBios: notify_post_boot_sound {}", err);
-                err
-            })
-            .ok();
+        Self::notify_post_boot_sound(&ctxt, on).await.ok();
     }
 
-    pub fn post_boot_sound(&self) -> i8 {
+    fn post_boot_sound(&self) -> i8 {
         Self::get_boot_sound()
             .map_err(|err| {
                 warn!("CtrlRogBios: get_boot_sound {}", err);
@@ -88,21 +93,13 @@ impl CtrlRogBios {
     }
 
     #[dbus_interface(signal)]
-    pub fn notify_post_boot_sound(&self, dedicated: bool) -> zbus::Result<()> {}
+    async fn notify_post_boot_sound(ctxt: &SignalContext<'_>, on: bool) -> zbus::Result<()> {}
 }
 
+#[async_trait]
 impl crate::ZbusAdd for CtrlRogBios {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/RogBios"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlRogBios: add_to_server {}", err);
-                err
-            })
-            .ok();
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/RogBios", server).await;
     }
 }
 

daemon/src/ctrl_supported.rs

@@ -1,8 +1,8 @@
-use log::warn;
+use async_trait::async_trait;
 use serde_derive::{Deserialize, Serialize};
 use zbus::dbus_interface;
-use zvariant::ObjectPath;
-use zvariant_derive::Type;
+use zbus::Connection;
+use zvariant::Type;
 
 use crate::{
     ctrl_anime::CtrlAnime, ctrl_aura::controller::CtrlKbdLed, ctrl_charge::CtrlCharge,
@@ -30,18 +30,10 @@ impl SupportedFunctions {
     }
 }
 
+#[async_trait]
 impl crate::ZbusAdd for SupportedFunctions {
-    fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Supported"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("SupportedFunctions: add_to_server {}", err);
-                err
-            })
-            .ok();
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, "/org/asuslinux/Supported", server).await;
     }
 }
 

daemon/src/daemon.rs

@@ -1,3 +1,14 @@
+use std::env;
+use std::error::Error;
+use std::io::Write;
+use std::sync::{Arc, Mutex};
+
+use ::zbus::Connection;
+use daemon::ctrl_profiles::controller::CtrlProfileTask;
+use log::LevelFilter;
+use log::{error, info, warn};
+use smol::Executor;
+
 use daemon::ctrl_anime::config::AnimeConfig;
 use daemon::ctrl_anime::zbus::CtrlAnimeZbus;
 use daemon::ctrl_anime::*;
@@ -7,7 +18,7 @@ use daemon::ctrl_aura::controller::{
 };
 use daemon::ctrl_charge::CtrlCharge;
 use daemon::ctrl_profiles::config::ProfileConfig;
-use daemon::ctrl_profiles::controller::CtrlProfileTask;
+use daemon::ctrl_rog_bios::CtrlRogBios;
 use daemon::{
     config::Config, ctrl_supported::SupportedFunctions, laptops::print_board_info, GetSupported,
 };
@@ -15,20 +26,9 @@ use daemon::{
     ctrl_profiles::{controller::CtrlPlatformProfile, zbus::ProfileZbus},
     laptops::LaptopLedData,
 };
-
-use ::zbus::{fdo, Connection, ObjectServer};
 use daemon::{CtrlTask, Reloadable, ZbusAdd};
-use log::LevelFilter;
-use log::{error, info, warn};
 use rog_dbus::DBUS_NAME;
 use rog_profiles::Profile;
-use std::env;
-use std::error::Error;
-use std::io::Write;
-use std::sync::Arc;
-use std::sync::Mutex;
-
-use daemon::ctrl_rog_bios::CtrlRogBios;
 
 static PROFILE_CONFIG_PATH: &str = "/etc/asusd/profile.conf";
 
@@ -61,27 +61,25 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     info!(" rog-profiles v{}", rog_profiles::VERSION);
     info!("rog-supported v{}", rog_supported::VERSION);
 
-    start_daemon()?;
+    let mut executor = Executor::new();
+
+    smol::block_on(start_daemon(&mut executor))?;
     Ok(())
 }
 
 /// The actual main loop for the daemon
-fn start_daemon() -> Result<(), Box<dyn Error>> {
+async fn start_daemon(executor: &mut Executor<'_>) -> Result<(), Box<dyn Error>> {
     let supported = SupportedFunctions::get_supported();
     print_board_info();
     println!("{}", serde_json::to_string_pretty(&supported)?);
 
-    // Collect tasks for task thread
-    let mut tasks: Vec<Box<dyn CtrlTask + Send>> = Vec::new();
     // Start zbus server
-    let connection = Connection::new_system()?;
-    let fdo_connection = fdo::DBusProxy::new(&connection)?;
-    let mut object_server = ObjectServer::new(&connection);
+    let mut connection = Connection::system().await?;
 
     let config = Config::load();
     let config = Arc::new(Mutex::new(config));
 
-    supported.add_to_server(&mut object_server);
+    supported.add_to_server(&mut connection).await;
 
     match CtrlRogBios::new(config.clone()) {
         Ok(mut ctrl) => {
@@ -89,20 +87,23 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
             ctrl.reload()
                 .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
             // Then register to dbus server
-            ctrl.add_to_server(&mut object_server);
+            ctrl.add_to_server(&mut connection).await;
         }
         Err(err) => {
             error!("rog_bios_control: {}", err);
         }
     }
 
-    match CtrlCharge::new(config) {
+    match CtrlCharge::new(config.clone()) {
         Ok(mut ctrl) => {
             // Do a reload of any settings
             ctrl.reload()
                 .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
             // Then register to dbus server
-            ctrl.add_to_server(&mut object_server);
+            ctrl.add_to_server(&mut connection).await;
+
+            let task = CtrlCharge::new(config)?;
+            task.create_tasks(executor).await.ok();
         }
         Err(err) => {
             error!("charge_control: {}", err);
@@ -117,9 +118,11 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
                     .unwrap_or_else(|err| warn!("Profile control: {}", err));
 
                 let tmp = Arc::new(Mutex::new(ctrl));
-                ProfileZbus::new(tmp.clone()).add_to_server(&mut object_server);
+                let task = CtrlProfileTask::new(tmp.clone());
+                task.create_tasks(executor).await.ok();
 
-                tasks.push(Box::new(CtrlProfileTask::new(tmp)));
+                let task = ProfileZbus::new(tmp.clone());
+                task.add_to_server(&mut connection).await;
             }
             Err(err) => {
                 error!("Profile control: {}", err);
@@ -139,9 +142,10 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
                 .unwrap_or_else(|err| warn!("AniMe: {}", err));
 
             let zbus = CtrlAnimeZbus(inner.clone());
-            zbus.add_to_server(&mut object_server);
+            zbus.add_to_server(&mut connection).await;
 
-            tasks.push(Box::new(CtrlAnimeTask::new(inner)));
+            let task = CtrlAnimeTask::new(inner).await;
+            task.create_tasks(executor).await.ok();
         }
         Err(err) => {
             error!("AniMe control: {}", err);
@@ -159,42 +163,21 @@ fn start_daemon() -> Result<(), Box<dyn Error>> {
                 .reload()
                 .unwrap_or_else(|err| warn!("Keyboard LED control: {}", err));
 
-            CtrlKbdLedZbus::new(inner.clone()).add_to_server(&mut object_server);
+            CtrlKbdLedZbus::new(inner.clone())
+                .add_to_server(&mut connection)
+                .await;
+
             let task = CtrlKbdLedTask::new(inner);
-            tasks.push(Box::new(task));
+            task.create_tasks(executor).await.ok();
         }
         Err(err) => {
             error!("Keyboard control: {}", err);
         }
     }
 
-    // TODO: implement messaging between threads to check fails
-
-    // Run tasks
-    let handle = std::thread::Builder::new()
-        .name("asusd watch".to_string())
-        .spawn(move || loop {
-            std::thread::sleep(std::time::Duration::from_millis(100));
-
-            for ctrl in tasks.iter() {
-                ctrl.do_task()
-                    .map_err(|err| {
-                        warn!("do_task error: {}", err);
-                    })
-                    .ok();
-            }
-        });
-
     // Request dbus name after finishing initalizing all functions
-    fdo_connection.request_name(DBUS_NAME, fdo::RequestNameFlags::ReplaceExisting.into())?;
-
-    // Loop to check errors and iterate zbus server
+    connection.request_name(DBUS_NAME).await?;
     loop {
-        if let Err(err) = &handle {
-            error!("{}", err);
-        }
-        if let Err(err) = object_server.try_handle_next() {
-            error!("{}", err);
-        }
+        smol::block_on(executor.tick());
     }
 }

daemon/src/error.rs

@@ -22,6 +22,7 @@ pub enum RogError {
     Modprobe(String),
     Io(std::io::Error),
     Zbus(zbus::Error),
+    ChargeLimit(u8),
 }
 
 impl fmt::Display for RogError {
@@ -46,6 +47,7 @@ impl fmt::Display for RogError {
             RogError::Modprobe(detail) => write!(f, "Modprobe error: {}", detail),
             RogError::Io(detail) => write!(f, "std::io error: {}", detail),
             RogError::Zbus(detail) => write!(f, "Zbus error: {}", detail),
+            RogError::ChargeLimit(value) => write!(f, "Invalid charging limit, not in range 20-100%: {}", value),
         }
     }
 }

daemon/src/laptops.rs

@@ -1,10 +1,11 @@
 use log::{info, warn};
-use rog_aura::AuraModeNum;
+use rog_aura::{AuraModeNum, AuraZone};
 use serde_derive::{Deserialize, Serialize};
 use std::fs::OpenOptions;
 use std::io::Read;
 
 pub const ASUS_LED_MODE_CONF: &str = "/etc/asusd/asusd-ledmodes.toml";
+pub const ASUS_LED_MODE_USER_CONF: &str = "/etc/asusd/asusd-user-ledmodes.toml";
 pub const ASUS_KEYBOARD_DEVICES: [&str; 4] = ["1866", "1869", "1854", "19b6"];
 
 pub fn print_board_info() {
@@ -32,17 +33,18 @@ pub fn print_modes(supported_modes: &[u8]) {
     }
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Default, Deserialize, Serialize)]
 struct LedSupportFile {
     led_data: Vec<LaptopLedData>,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
+#[serde(default)]
 pub struct LaptopLedData {
     pub prod_family: String,
     pub board_names: Vec<String>,
     pub standard: Vec<AuraModeNum>,
-    pub multizone: bool,
+    pub multizone: Vec<AuraZone>,
     pub per_key: bool,
 }
 
@@ -62,7 +64,7 @@ impl LaptopLedData {
             prod_family,
             board_names: vec![board_name],
             standard: vec![],
-            multizone: false,
+            multizone: vec![],
             per_key: false,
         }
     }
@@ -85,19 +87,81 @@ impl LedSupportFile {
     }
 
     fn load_from_config() -> Option<Self> {
+        let mut loaded = false;
+        let mut data = LedSupportFile::default();
+        // Load user configs first so they are first to be checked
+        if let Ok(mut file) = OpenOptions::new().read(true).open(&ASUS_LED_MODE_USER_CONF) {
+            let mut buf = String::new();
+            if let Ok(l) = file.read_to_string(&mut buf) {
+                if l == 0 {
+                    warn!("{} is empty", ASUS_LED_MODE_USER_CONF);
+                } else {
+                    if let Ok(mut tmp) = toml::from_str::<LedSupportFile>(&buf) {
+                        data.led_data.append(&mut tmp.led_data);
+                    }
+                    info!(
+                        "Loaded user-defined LED support data from {}",
+                        ASUS_LED_MODE_USER_CONF
+                    );
+                }
+            }
+        }
+        // Load and append the default LED support data
         if let Ok(mut file) = OpenOptions::new().read(true).open(&ASUS_LED_MODE_CONF) {
             let mut buf = String::new();
             if let Ok(l) = file.read_to_string(&mut buf) {
                 if l == 0 {
                     warn!("{} is empty", ASUS_LED_MODE_CONF);
                 } else {
-                    return Some(toml::from_str(&buf).unwrap_or_else(|_| {
-                        panic!("Could not deserialise {}", ASUS_LED_MODE_CONF)
-                    }));
+                    let mut tmp: LedSupportFile = toml::from_str(&buf)
+                        .unwrap_or_else(|_| panic!("Could not deserialise {}", ASUS_LED_MODE_CONF));
+                    data.led_data.append(&mut tmp.led_data);
+                    loaded = true;
+                    info!(
+                        "Loaded default LED support data from {}",
+                        ASUS_LED_MODE_CONF
+                    );
                 }
             }
         }
-        warn!("Does {} exist?", ASUS_LED_MODE_CONF);
+
+        if loaded {
+            return Some(data);
+        }
+
+        warn!("Does {} exist?", ASUS_LED_MODE_USER_CONF);
         None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{fs::OpenOptions, io::Read, path::PathBuf};
+
+    use super::LaptopLedData;
+    use rog_aura::{AuraModeNum, AuraZone};
+
+    #[test]
+    fn check_data_parse() {
+        let led = LaptopLedData {
+            prod_family: "Test".to_owned(),
+            board_names: vec!["Test".to_owned()],
+            standard: vec![AuraModeNum::Static],
+            multizone: vec![AuraZone::Key1, AuraZone::Logo, AuraZone::BarLeft],
+            per_key: false,
+        };
+
+        let toml = toml::to_string_pretty(&led).unwrap();
+        println!("{toml}");
+
+        let mut data = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        data.push("../data/asusd-ledmodes.toml");
+
+        let mut file = OpenOptions::new().read(true).open(&data).unwrap();
+        let mut buf = String::new();
+        file.read_to_string(&mut buf).unwrap();
+
+        let x = toml::to_string_pretty(&buf).unwrap();
+        println!("{x}");
+    }
+}

daemon/src/lib.rs

@@ -27,11 +27,17 @@ pub mod laptops;
 /// Fetch all supported functions for the laptop
 pub mod ctrl_supported;
 
-mod error;
+pub mod error;
+
+use std::time::Duration;
 
 use crate::error::RogError;
+use async_trait::async_trait;
 use config::Config;
-use zbus::ObjectServer;
+use log::warn;
+use smol::{stream::StreamExt, Executor, Timer};
+use zbus::Connection;
+use zvariant::ObjectPath;
 
 pub static VERSION: &str = env!("CARGO_PKG_VERSION");
 
@@ -39,12 +45,48 @@ pub trait Reloadable {
     fn reload(&mut self) -> Result<(), RogError>;
 }
 
+#[async_trait]
 pub trait ZbusAdd {
-    fn add_to_server(self, server: &mut ObjectServer);
+    async fn add_to_server(self, server: &mut Connection);
+
+    async fn add_to_server_helper(
+        iface: impl zbus::Interface,
+        path: &str,
+        server: &mut Connection,
+    ) {
+        server
+            .object_server()
+            .at(&ObjectPath::from_str_unchecked(path), iface)
+            .await
+            .map_err(|err| {
+                warn!("{}: add_to_server {}", path, err);
+                err
+            })
+            .ok();
+    }
 }
 
+/// Set up a task to run on the async executor
+#[async_trait]
 pub trait CtrlTask {
-    fn do_task(&self) -> Result<(), RogError>;
+    /// Implement to set up various tasks that may be required, using the `Executor`.
+    /// No blocking loops are allowed, or they must be run on a separate thread.
+    async fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError>;
+
+    /// Create a timed repeating task
+    async fn repeating_task(
+        &self,
+        millis: u64,
+        executor: &mut Executor,
+        mut task: impl FnMut() + Send + 'static,
+    ) {
+        let timer = Timer::interval(Duration::from_millis(millis));
+        executor
+            .spawn(async move {
+                timer.for_each(|_| task()).await;
+            })
+            .detach();
+    }
 }
 
 pub trait CtrlTaskComplex {

data/asusd-ledmodes.toml

@@ -2,98 +2,127 @@
 prod_family = "Zephyrus S"
 board_names = ["GX502", "GX701", "G531", "GL531", "G532"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = false
+multizone = []
 per_key = true
 
 [[led_data]]
 prod_family = "Zephyrus M"
 board_names = ["GU502GV"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = false
+multizone = []
 per_key = true
 
 [[led_data]]
 prod_family = "Zephyrus M"
 board_names = ["GM501GS"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = true
+multizone = ["Key1", "Key2", "Key3", "Key4"]
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Zephyrus M15"
-board_names = ["GU502LW"]
+board_names = ["GU502LW", "GU502LV"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = false
+multizone = []
 per_key = true
 
 [[led_data]]
 prod_family = "ROG Zephyrus M15"
 board_names = ["GU502LU"]
 standard = ["Static", "Breathe", "Strobe", "Pulse"]
-multizone = false
+multizone = []
 per_key = false
 
+[[led_data]]
+prod_family = "ROG Zephyrus S17"
+board_names = ["GX703HS"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
+multizone = []
+per_key = false
+
+
 [[led_data]]
 prod_family = "Zephyrus"
 board_names = ["GM501GM", "GX531"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = true
+multizone = ["Key1", "Key2", "Key3", "Key4"]
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Strix"
-board_names = ["G531GW", "G533QR", "G533QS", "G733QS", "G733QR", "G713QR"]
+board_names = ["G531GW", "G533QR", "G533QS", "G733QS", "G733QR", "G513QR", "G713QR", "G513QM"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = false
+multizone = []
 per_key = true
 
 [[led_data]]
 prod_family = "ROG Strix"
-board_names = ["GX531", "G512LV", "G712LV", "G712LW", "G513IH", "G513QY"]
+board_names = ["G513QE", "GX531", "G512LV", "G712LV", "G712LW", "G513IH", "G513QY", "G713QM", "G512"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = true
+multizone = ["Key1", "Key2", "Key3", "Key4"]
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Strix"
 board_names = ["G512LI", "G712LI", "G531GD"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = false
+multizone = []
 per_key = false
 
+[[led_data]]
+prod_family = "ROG Strix"
+board_names = ["G513IM"]
+standard = ["Flash", "Static", "Breathe", "Strobe", "Rainbow"]
+multizone = []
+per_key = true
+
 [[led_data]]
 prod_family = "Strix"
 board_names = ["G731GV", "G731GW", "G531GV"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow"]
-multizone = true
+multizone = ["Key1", "Key2", "Key3", "Key4"]
+per_key = false
+
+[[led_data]]
+prod_family = "Strix"
+board_names = ["GL504G"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = ["Key1", "Key2", "Key3", "Key4", "Logo", "BarLeft", "BarRight"]
 per_key = false
 
 [[led_data]]
 prod_family = "Strix"
 board_names = ["G731GT", "G731GU", "G531GT", "G531GU"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow"]
-multizone = false
+multizone = []
 per_key = false
 
 [[led_data]]
 prod_family = "Strix Scar"
 board_names = ["G531", "G731"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = true
+multizone = ["Key1", "Key2", "Key3", "Key4"]
 per_key = true
 
 [[led_data]]
 prod_family = "ROG"
 board_names = ["GL553VE"]
 standard = ["Static", "Breathe", "Strobe"]
-multizone = true
+multizone = ["Key1", "Key2", "Key3", "Key4"]
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Zephyrus G14"
 board_names = ["GA401Q"]
 standard = ["Static", "Breathe", "Pulse"]
-multizone = false
+multizone = []
+per_key = false
+
+[[led_data]]
+prod_family = "ROG Zephyrus G14"
+board_names = ["GA402R"]
+standard = ["Static", "Breathe", "Pulse", "Rainbow"]
+multizone = []
 per_key = false
 
 # GA503QE at higher priority (first match) than GA503Q
@@ -101,33 +130,40 @@ per_key = false
 prod_family = "ROG Zephyrus G15"
 board_names = ["GA503QE"]
 standard = ["Static", "Breathe", "Pulse"]
-multizone = false
+multizone = []
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Zephyrus G15"
-board_names = ["GA503Q"]
+board_names = ["GA503Q", "GA503R"]
 standard = ["Static", "Breathe", "Pulse", "Rainbow", "Strobe"]
-multizone = false
+multizone = []
 per_key = false
 
 [[led_data]]
 prod_family = "ROG Zephyrus"
 board_names = ["GX550L"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Star", "Rain", "Highlight", "Laser", "Ripple", "Pulse", "Comet", "Flash"]
-multizone = false
+multizone = []
 per_key = true
 
 [[led_data]]
 prod_family = "ROG Zephyrus Duo 15 SE"
 board_names = ["GX551Q"]
 standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
-multizone = false
+multizone = []
 per_key = true
 
 [[led_data]]
 prod_family = "ROG Flow X13"
 board_names = ["GV301QH", "GV301QE"]
 standard = ["Static", "Breathe", "Pulse"]
-multizone = false
+multizone = []
+per_key = false
+
+[[led_data]]
+prod_family = "ROG Strix" 
+board_names = ["G513IC"]
+standard = ["Static", "Breathe", "Strobe", "Rainbow", "Pulse"]
+multizone = []
 per_key = false

design-patterns.md

@@ -28,18 +28,53 @@ impl CtrlAnime {
 }
 ```
 
-The task trait:
+The task trait. There are three ways to implement this:
 
 ```rust
 pub struct CtrlAnimeTask(Arc<Mutex<CtrlAnime>>);
 
 impl crate::CtrlTask for CtrlAnimeTask {
-    fn do_task(&self) -> Result<(), RogError> {
+    // This will run once only
+    fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
        if let Ok(lock) = self.inner.try_lock() {
             <some action>
         }
         Ok(())
     }
+
+    // This will run until the notification stream closes (which in most cases will be never)
+    fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let connection = Connection::system().await.unwrap();
+        let manager = ManagerProxy::new(&connection).await.unwrap();
+
+        let inner = self.inner.clone();
+        executor
+            .spawn(async move {
+                // A notification from logind dbus interface
+                if let Ok(p) = manager.receive_prepare_for_sleep().await {
+                    // A stream that will continuously output events
+                    p.for_each(|_| {
+                        if let Ok(lock) = inner.try_lock() {
+                            // Do stuff here
+                        }
+                    })
+                    .await;
+                }
+            })
+            .detach();
+    }
+
+    // This task will run every 500 milliseconds
+    fn create_tasks(&self, executor: &mut Executor) -> Result<(), RogError> {
+        let inner = self.inner.clone();
+        // This is a provided free trait to help set up a repeating task
+        self.repeating_task(500, executor, move || {
+            if let Ok(lock) = inner.try_lock() {
+                // Do stuff here
+            }
+        })
+        .await;
+    }
 }
 ```
 
@@ -61,18 +96,11 @@ The Zbus requirements:
 ```rust
 pub struct CtrlAnimeZbus(Arc<Mutex<CtrlAnime>>);
 
+#[async_trait]
 impl crate::ZbusAdd for CtrlAnimeZbus {
     fn add_to_server(self, server: &mut zbus::ObjectServer) {
-        server
-            .at(
-                &ObjectPath::from_str_unchecked("/org/asuslinux/Anime"),
-                self,
-            )
-            .map_err(|err| {
-                warn!("CtrlAnimeDisplay: add_to_server {}", err);
-                err
-            })
-            .ok();
+        // This is a provided free helper trait with pre-set body. It will move self in-to.
+        Self::add_to_server_helper(self, "/org/asuslinux/Anime", server).await;
     }
 }
 

rog-anime/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rog_anime"
-version = "1.1.0"
+version = "1.3.4"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -13,18 +13,22 @@ edition = "2018"
 exclude = ["data"]
 
 [features]
-default = ["dbus"]
-dbus = ["zvariant", "zvariant_derive"]
+default = ["dbus", "detect"]
+dbus = ["zvariant"]
+detect = ["udev", "sysfs-class"]
 
 [dependencies]
 png_pong = "^0.8.0"
 pix = "0.13"
 gif = "^0.11.2"
+log = "*"
 
 serde = "^1.0"
 serde_derive = "^1.0"
 
-glam = { version = "0.14.0", features = ["serde"] }
+glam = { version = "0.20.5", features = ["serde"] }
 
-zvariant = { version = "^2.6", optional = true }
-zvariant_derive = { version = "^2.6", optional = true }
+zvariant = { version = "^3.0", optional = true }
+
+udev = { version = "^0.6", optional = true }
+sysfs-class = { version = "^0.1", optional = true }

rog-anime/src/data.rs

@@ -1,15 +1,12 @@
 use std::{
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
     thread::sleep,
     time::{Duration, Instant},
 };
 
+use log::info;
 use serde_derive::{Deserialize, Serialize};
 #[cfg(feature = "dbus")]
-use zvariant_derive::Type;
+use zvariant::Type;
 
 use crate::{error::AnimeError, AnimTime, AnimeGif};
 
@@ -19,48 +16,85 @@ const BLOCK_START: usize = 7;
 const BLOCK_END: usize = 634;
 /// Individual usable data length of each USB packet
 const PANE_LEN: usize = BLOCK_END - BLOCK_START;
-/// The length of usable data
-pub const ANIME_DATA_LEN: usize = PANE_LEN * 2;
 
+/// First packet is for GA401 + GA402
 const USB_PREFIX1: [u8; 7] = [0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02];
+/// Second packet is for GA401 + GA402
 const USB_PREFIX2: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
+/// Third packet is for GA402 matrix
+const USB_PREFIX3: [u8; 7] = [0x5e, 0xc0, 0x02, 0xe7, 0x04, 0x73, 0x02];
 
 #[cfg_attr(feature = "dbus", derive(Type))]
 #[derive(Debug, PartialEq, Copy, Clone, Deserialize, Serialize)]
-
 pub struct AnimePowerStates {
+    pub brightness: u8,
     pub enabled: bool,
     pub boot_anim_enabled: bool,
 }
 
+#[cfg_attr(feature = "dbus", derive(Type))]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
+pub enum AnimeType {
+    GA401,
+    GA402,
+}
+
+impl AnimeType {
+    /// The width of diagonal images
+    pub fn width(&self) -> usize {
+        match self {
+            AnimeType::GA401 => 74,
+            AnimeType::GA402 => 74,
+        }
+    }
+
+    /// The height of diagonal images
+    pub fn height(&self) -> usize {
+        match self {
+            AnimeType::GA401 => 36,
+            AnimeType::GA402 => 39,
+        }
+    }
+
+    /// The length of usable data for this type
+    pub fn data_length(&self) -> usize {
+        match self {
+            AnimeType::GA401 => PANE_LEN * 2,
+            AnimeType::GA402 => PANE_LEN * 3,
+        }
+    }
+}
+
 /// The minimal serializable data that can be transferred over wire types.
 /// Other data structures in `rog_anime` will convert to this.
 #[cfg_attr(feature = "dbus", derive(Type))]
 #[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct AnimeDataBuffer(Vec<u8>);
-
-impl Default for AnimeDataBuffer {
-    fn default() -> Self {
-        Self::new()
-    }
+pub struct AnimeDataBuffer {
+    data: Vec<u8>,
+    anime: AnimeType,
 }
 
 impl AnimeDataBuffer {
     #[inline]
-    pub fn new() -> Self {
-        AnimeDataBuffer(vec![0u8; ANIME_DATA_LEN])
+    pub fn new(anime: AnimeType) -> Self {
+        let len = anime.data_length();
+
+        AnimeDataBuffer {
+            data: vec![0u8; len],
+            anime,
+        }
     }
 
     /// Get the inner data buffer
     #[inline]
-    pub fn get(&self) -> &[u8] {
-        &self.0
+    pub fn data(&self) -> &[u8] {
+        &self.data
     }
 
     /// Get a mutable slice of the inner buffer
     #[inline]
-    pub fn get_mut(&mut self) -> &mut [u8] {
-        &mut self.0
+    pub fn data_mut(&mut self) -> &mut [u8] {
+        &mut self.data
     }
 
     /// Create from a vector of bytes
@@ -68,34 +102,45 @@ impl AnimeDataBuffer {
     /// # Panics
     /// Will panic if the vector length is not `ANIME_DATA_LEN`
     #[inline]
-    pub fn from_vec(input: Vec<u8>) -> Self {
-        assert_eq!(input.len(), ANIME_DATA_LEN);
-        Self(input)
+    pub fn from_vec(anime: AnimeType, data: Vec<u8>) -> Self {
+        assert_eq!(data.len(), anime.data_length());
+
+        Self { data, anime }
     }
 }
 
 /// The two packets to be written to USB
-pub type AnimePacketType = [[u8; 640]; 2];
+pub type AnimePacketType = Vec<[u8; 640]>;
 
 impl From<AnimeDataBuffer> for AnimePacketType {
     #[inline]
     fn from(anime: AnimeDataBuffer) -> Self {
-        assert!(anime.0.len() == ANIME_DATA_LEN);
-        let mut buffers = [[0; 640]; 2];
-        for (idx, chunk) in anime.0.as_slice().chunks(PANE_LEN).enumerate() {
+        assert_eq!(anime.data.len(), anime.anime.data_length());
+
+        let mut buffers = match anime.anime {
+            AnimeType::GA401 => vec![[0; 640]; 2],
+            AnimeType::GA402 => vec![[0; 640]; 3],
+        };
+
+        for (idx, chunk) in anime.data.as_slice().chunks(PANE_LEN).enumerate() {
             buffers[idx][BLOCK_START..BLOCK_END].copy_from_slice(chunk);
         }
         buffers[0][..7].copy_from_slice(&USB_PREFIX1);
         buffers[1][..7].copy_from_slice(&USB_PREFIX2);
+
+        if matches!(anime.anime, AnimeType::GA402) {
+            buffers[2][..7].copy_from_slice(&USB_PREFIX3);
+        }
         buffers
     }
 }
 
 /// This runs the animations as a blocking loop by using the `callback` to write data
+///
+/// If `callback` is `Ok(true)` then `run_animation` will exit the animation loop early.
 pub fn run_animation(
     frames: &AnimeGif,
-    do_early_return: Arc<AtomicBool>,
-    callback: &dyn Fn(AnimeDataBuffer) -> Result<(), AnimeError>,
+    callback: &dyn Fn(AnimeDataBuffer) -> Result<bool, AnimeError>,
 ) -> Result<(), AnimeError> {
     let mut count = 0;
     let start = Instant::now();
@@ -140,14 +185,11 @@ pub fn run_animation(
     'animation: loop {
         for frame in frames.frames() {
             let frame_start = Instant::now();
-            if do_early_return.load(Ordering::SeqCst) {
-                return Ok(());
-            }
             let mut output = frame.frame().clone();
 
             if let AnimTime::Fade(_) = frames.duration() {
                 if frame_start <= start + fade_in {
-                    for pixel in output.get_mut() {
+                    for pixel in output.data_mut() {
                         *pixel = (*pixel as f32 * fade_in_accum) as u8;
                     }
                     fade_in_accum = fade_in_step * (frame_start - start).as_secs_f32();
@@ -158,18 +200,20 @@ pub fn run_animation(
                     } else {
                         fade_out_accum = 0.0;
                     }
-                    for pixel in output.get_mut() {
+                    for pixel in output.data_mut() {
                         *pixel = (*pixel as f32 * fade_out_accum) as u8;
                     }
                 }
             }
 
-            callback(output)?;
+            if matches!(callback(output), Ok(true)) {
+                info!("rog-anime: frame-loop callback asked to exit early");
+                return Ok(());
+            }
 
             if timed && Instant::now().duration_since(start) > run_time {
                 break 'animation;
             }
-
             sleep(frame.delay());
         }
         if let AnimTime::Count(times) = frames.duration() {

rog-anime/src/diagonal.rs

@@ -1,40 +1,32 @@
 use std::{path::Path, time::Duration};
 
-use crate::{
-    data::{AnimeDataBuffer, ANIME_DATA_LEN},
-    error::AnimeError,
-};
-
-const WIDTH: usize = 74;
-const HEIGHT: usize = 36;
+use crate::{data::AnimeDataBuffer, error::AnimeError, AnimeType};
 
 /// Mostly intended to be used with ASUS gifs, but can be used for other purposes (like images)
 #[derive(Debug, Clone)]
-pub struct AnimeDiagonal([[u8; WIDTH]; HEIGHT], Option<Duration>);
-
-impl Default for AnimeDiagonal {
-    #[inline]
-    fn default() -> Self {
-        Self::new(None)
-    }
-}
+pub struct AnimeDiagonal(AnimeType, Vec<Vec<u8>>, Option<Duration>);
 
 impl AnimeDiagonal {
     #[inline]
-    pub fn new(duration: Option<Duration>) -> Self {
-        Self([[0u8; WIDTH]; HEIGHT], duration)
+    pub fn new(anime_type: AnimeType, duration: Option<Duration>) -> Self {
+        Self(
+            anime_type,
+            vec![vec![0; anime_type.width()]; anime_type.height()],
+            duration,
+        )
     }
 
     #[inline]
-    pub fn get_mut(&mut self) -> &mut [[u8; WIDTH]; HEIGHT] {
-        &mut self.0
+    pub fn get_mut(&mut self) -> &mut Vec<Vec<u8>> {
+        &mut self.1
     }
 
     /// Get a full diagonal row where `x` `y` is the starting point  and `len` is the length of data.
     fn get_row(&self, x: usize, y: usize, len: usize) -> Vec<u8> {
         let mut buf = Vec::with_capacity(len);
         for i in 0..len {
-            let val = self.0[HEIGHT - y - i - 1][x + i];
+            let y = self.0.height() - y - i - 1;
+            let val = self.1[y][x + i];
             buf.push(val);
         }
         buf
@@ -47,13 +39,14 @@ impl AnimeDiagonal {
         path: &Path,
         duration: Option<Duration>,
         bright: f32,
+        anime_type: AnimeType,
     ) -> Result<Self, AnimeError> {
         let data = std::fs::read(path)?;
         let data = std::io::Cursor::new(data);
         let decoder = png_pong::Decoder::new(data)?.into_steps();
         let png_pong::Step { raster, delay: _ } = decoder.last().ok_or(AnimeError::NoFrames)??;
 
-        let mut matrix = AnimeDiagonal::new(duration);
+        let mut matrix = AnimeDiagonal::new(anime_type, duration);
 
         match raster {
             png_pong::PngRaster::Gray8(ras) => {
@@ -100,7 +93,9 @@ impl AnimeDiagonal {
                         + (<u8>::from(px.two()) / 3) as f32
                         + (<u8>::from(px.three()) / 3) as f32
                 };
-                matrix.0[y][x] = (v * bright) as u8;
+                if y < matrix.1.len() && x < matrix.1[y].len() {
+                    matrix.1[y][x] = (v * bright) as u8;
+                }
             }
         }
     }
@@ -123,75 +118,547 @@ impl AnimeDiagonal {
                         + ((<u16>::from(px.two()) / 3) >> 8) as f32
                         + ((<u16>::from(px.three()) / 3) >> 8) as f32
                 };
-                matrix.0[y][x] = (v * bright) as u8;
+                matrix.1[y][x] = (v * bright) as u8;
             }
         }
     }
-}
 
-impl From<&AnimeDiagonal> for AnimeDataBuffer {
+    /// Convert to a data buffer that can be sent over dbus
+    #[inline]
+    pub fn into_data_buffer(&self, anime_type: AnimeType) -> AnimeDataBuffer {
+        match anime_type {
+            AnimeType::GA401 => self.into_ga401_packets(),
+            AnimeType::GA402 => self.into_ga402_packets(),
+        }
+    }
+
     /// Do conversion from the nested Vec in AnimeMatrix to the two required
     /// packets suitable for sending over USB
-    #[inline]
-    fn from(anime: &AnimeDiagonal) -> Self {
-        let mut buf = vec![0u8; ANIME_DATA_LEN];
+    fn into_ga401_packets(&self) -> AnimeDataBuffer {
+        let mut buf = vec![0u8; AnimeType::GA401.data_length()];
 
-        buf[1..=32].copy_from_slice(&anime.get_row(0, 3, 32));
-        buf[34..=66].copy_from_slice(&anime.get_row(0, 2, 33));
-        buf[69..=101].copy_from_slice(&anime.get_row(1, 2, 33)); // ?!
-        buf[102..=134].copy_from_slice(&anime.get_row(1, 1, 33));
-        buf[137..=169].copy_from_slice(&anime.get_row(2, 1, 33));
-        buf[170..=202].copy_from_slice(&anime.get_row(2, 0, 33));
-        buf[204..=236].copy_from_slice(&anime.get_row(3, 0, 33));
-        buf[237..=268].copy_from_slice(&anime.get_row(4, 0, 32));
-        buf[270..=301].copy_from_slice(&anime.get_row(5, 0, 32));
-        buf[302..=332].copy_from_slice(&anime.get_row(6, 0, 31));
-        buf[334..=364].copy_from_slice(&anime.get_row(7, 0, 31));
-        buf[365..=394].copy_from_slice(&anime.get_row(8, 0, 30));
-        buf[396..=425].copy_from_slice(&anime.get_row(9, 0, 30));
-        buf[426..=454].copy_from_slice(&anime.get_row(10, 0, 29));
-        buf[456..=484].copy_from_slice(&anime.get_row(11, 0, 29));
-        buf[485..=512].copy_from_slice(&anime.get_row(12, 0, 28));
-        buf[514..=541].copy_from_slice(&anime.get_row(13, 0, 28));
-        buf[542..=568].copy_from_slice(&anime.get_row(14, 0, 27));
-        buf[570..=596].copy_from_slice(&anime.get_row(15, 0, 27));
-        buf[597..=622].copy_from_slice(&anime.get_row(16, 0, 26));
-        buf[624..=649].copy_from_slice(&anime.get_row(17, 0, 26));
-        buf[650..=674].copy_from_slice(&anime.get_row(18, 0, 25));
-        buf[676..=700].copy_from_slice(&anime.get_row(19, 0, 25));
-        buf[701..=724].copy_from_slice(&anime.get_row(20, 0, 24));
-        buf[726..=749].copy_from_slice(&anime.get_row(21, 0, 24));
-        buf[750..=772].copy_from_slice(&anime.get_row(22, 0, 23));
-        buf[774..=796].copy_from_slice(&anime.get_row(23, 0, 23));
-        buf[797..=818].copy_from_slice(&anime.get_row(24, 0, 22));
-        buf[820..=841].copy_from_slice(&anime.get_row(25, 0, 22));
-        buf[842..=862].copy_from_slice(&anime.get_row(26, 0, 21));
-        buf[864..=884].copy_from_slice(&anime.get_row(27, 0, 21));
-        buf[885..=904].copy_from_slice(&anime.get_row(28, 0, 20));
-        buf[906..=925].copy_from_slice(&anime.get_row(29, 0, 20));
-        buf[926..=944].copy_from_slice(&anime.get_row(30, 0, 19));
-        buf[946..=964].copy_from_slice(&anime.get_row(31, 0, 19));
-        buf[965..=982].copy_from_slice(&anime.get_row(32, 0, 18));
-        buf[984..=1001].copy_from_slice(&anime.get_row(33, 0, 18));
-        buf[1002..=1018].copy_from_slice(&anime.get_row(34, 0, 17));
-        buf[1020..=1036].copy_from_slice(&anime.get_row(35, 0, 17));
-        buf[1037..=1052].copy_from_slice(&anime.get_row(36, 0, 16));
-        buf[1054..=1069].copy_from_slice(&anime.get_row(37, 0, 16));
-        buf[1070..=1084].copy_from_slice(&anime.get_row(38, 0, 15));
-        buf[1086..=1100].copy_from_slice(&anime.get_row(39, 0, 15));
-        buf[1101..=1114].copy_from_slice(&anime.get_row(40, 0, 14));
-        buf[1116..=1129].copy_from_slice(&anime.get_row(41, 0, 14));
-        buf[1130..=1142].copy_from_slice(&anime.get_row(42, 0, 13));
-        buf[1144..=1156].copy_from_slice(&anime.get_row(43, 0, 13));
-        buf[1157..=1168].copy_from_slice(&anime.get_row(44, 0, 12));
-        buf[1170..=1181].copy_from_slice(&anime.get_row(45, 0, 12));
-        buf[1182..=1192].copy_from_slice(&anime.get_row(46, 0, 11));
-        buf[1194..=1204].copy_from_slice(&anime.get_row(47, 0, 11));
-        buf[1205..=1214].copy_from_slice(&anime.get_row(48, 0, 10));
-        buf[1216..=1225].copy_from_slice(&anime.get_row(49, 0, 10));
-        buf[1226..=1234].copy_from_slice(&anime.get_row(50, 0, 9));
-        buf[1236..=1244].copy_from_slice(&anime.get_row(51, 0, 9));
+        buf[1..=32].copy_from_slice(&self.get_row(0, 3, 32));
+        buf[34..=66].copy_from_slice(&self.get_row(0, 2, 33));
+        buf[69..=101].copy_from_slice(&self.get_row(1, 2, 33)); // ?!
+        buf[102..=134].copy_from_slice(&self.get_row(1, 1, 33));
+        buf[137..=169].copy_from_slice(&self.get_row(2, 1, 33));
+        buf[170..=202].copy_from_slice(&self.get_row(2, 0, 33));
+        buf[204..=236].copy_from_slice(&self.get_row(3, 0, 33)); // This and above cause overflow?
+        buf[237..=268].copy_from_slice(&self.get_row(4, 0, 32));
+        buf[270..=301].copy_from_slice(&self.get_row(5, 0, 32));
+        buf[302..=332].copy_from_slice(&self.get_row(6, 0, 31));
+        buf[334..=364].copy_from_slice(&self.get_row(7, 0, 31));
+        buf[365..=394].copy_from_slice(&self.get_row(8, 0, 30));
+        buf[396..=425].copy_from_slice(&self.get_row(9, 0, 30));
+        buf[426..=454].copy_from_slice(&self.get_row(10, 0, 29));
+        buf[456..=484].copy_from_slice(&self.get_row(11, 0, 29));
+        buf[485..=512].copy_from_slice(&self.get_row(12, 0, 28));
+        buf[514..=541].copy_from_slice(&self.get_row(13, 0, 28));
+        buf[542..=568].copy_from_slice(&self.get_row(14, 0, 27));
+        buf[570..=596].copy_from_slice(&self.get_row(15, 0, 27));
+        buf[597..=622].copy_from_slice(&self.get_row(16, 0, 26));
+        buf[624..=649].copy_from_slice(&self.get_row(17, 0, 26));
+        buf[650..=674].copy_from_slice(&self.get_row(18, 0, 25));
+        buf[676..=700].copy_from_slice(&self.get_row(19, 0, 25));
+        buf[701..=724].copy_from_slice(&self.get_row(20, 0, 24));
+        buf[726..=749].copy_from_slice(&self.get_row(21, 0, 24));
+        buf[750..=772].copy_from_slice(&self.get_row(22, 0, 23));
+        buf[774..=796].copy_from_slice(&self.get_row(23, 0, 23));
+        buf[797..=818].copy_from_slice(&self.get_row(24, 0, 22));
+        buf[820..=841].copy_from_slice(&self.get_row(25, 0, 22));
+        buf[842..=862].copy_from_slice(&self.get_row(26, 0, 21));
+        buf[864..=884].copy_from_slice(&self.get_row(27, 0, 21));
+        buf[885..=904].copy_from_slice(&self.get_row(28, 0, 20));
+        buf[906..=925].copy_from_slice(&self.get_row(29, 0, 20));
+        buf[926..=944].copy_from_slice(&self.get_row(30, 0, 19));
+        buf[946..=964].copy_from_slice(&self.get_row(31, 0, 19));
+        buf[965..=982].copy_from_slice(&self.get_row(32, 0, 18));
+        buf[984..=1001].copy_from_slice(&self.get_row(33, 0, 18));
+        buf[1002..=1018].copy_from_slice(&self.get_row(34, 0, 17));
+        buf[1020..=1036].copy_from_slice(&self.get_row(35, 0, 17));
+        buf[1037..=1052].copy_from_slice(&self.get_row(36, 0, 16));
+        buf[1054..=1069].copy_from_slice(&self.get_row(37, 0, 16));
+        buf[1070..=1084].copy_from_slice(&self.get_row(38, 0, 15));
+        buf[1086..=1100].copy_from_slice(&self.get_row(39, 0, 15));
+        buf[1101..=1114].copy_from_slice(&self.get_row(40, 0, 14));
+        buf[1116..=1129].copy_from_slice(&self.get_row(41, 0, 14));
+        buf[1130..=1142].copy_from_slice(&self.get_row(42, 0, 13));
+        buf[1144..=1156].copy_from_slice(&self.get_row(43, 0, 13));
+        buf[1157..=1168].copy_from_slice(&self.get_row(44, 0, 12));
+        buf[1170..=1181].copy_from_slice(&self.get_row(45, 0, 12));
+        buf[1182..=1192].copy_from_slice(&self.get_row(46, 0, 11));
+        buf[1194..=1204].copy_from_slice(&self.get_row(47, 0, 11));
+        buf[1205..=1214].copy_from_slice(&self.get_row(48, 0, 10));
+        buf[1216..=1225].copy_from_slice(&self.get_row(49, 0, 10));
+        buf[1226..=1234].copy_from_slice(&self.get_row(50, 0, 9));
+        buf[1236..=1244].copy_from_slice(&self.get_row(51, 0, 9));
 
-        AnimeDataBuffer::from_vec(buf)
+        AnimeDataBuffer::from_vec(crate::AnimeType::GA401, buf)
+    }
+
+    fn into_ga402_packets(&self) -> AnimeDataBuffer {
+        let mut buf = vec![0u8; AnimeType::GA402.data_length()];
+        let mut start_index: usize = 0;
+
+        fn copy_slice(
+            buf: &mut Vec<u8>,
+            anime: &AnimeDiagonal,
+            x: usize,
+            y: usize,
+            start_index: &mut usize,
+            len: usize,
+        ) {
+            buf[*start_index..*start_index + len].copy_from_slice(&anime.get_row(x, y, len));
+            *start_index += len;
+        }
+
+        let b = &mut buf;
+        let a = &self;
+        copy_slice(b, a, 0, 5, &mut start_index, 34);
+        copy_slice(b, a, 1, 5, &mut start_index, 34);
+        copy_slice(b, a, 1, 4, &mut start_index, 34);
+        copy_slice(b, a, 2, 4, &mut start_index, 34);
+        copy_slice(b, a, 2, 3, &mut start_index, 34);
+        copy_slice(b, a, 3, 3, &mut start_index, 34);
+        copy_slice(b, a, 3, 2, &mut start_index, 34);
+        copy_slice(b, a, 4, 2, &mut start_index, 34);
+        copy_slice(b, a, 4, 1, &mut start_index, 34);
+        copy_slice(b, a, 5, 1, &mut start_index, 34);
+        copy_slice(b, a, 5, 0, &mut start_index, 34);
+        copy_slice(b, a, 6, 0, &mut start_index, 34);
+        copy_slice(b, a, 7, 0, &mut start_index, 33);
+        copy_slice(b, a, 8, 0, &mut start_index, 33);
+        copy_slice(b, a, 9, 0, &mut start_index, 32);
+        copy_slice(b, a, 10, 0, &mut start_index, 32);
+        copy_slice(b, a, 11, 0, &mut start_index, 31);
+        copy_slice(b, a, 12, 0, &mut start_index, 31);
+        copy_slice(b, a, 13, 0, &mut start_index, 30);
+        copy_slice(b, a, 14, 0, &mut start_index, 30);
+        copy_slice(b, a, 15, 0, &mut start_index, 29);
+        copy_slice(b, a, 16, 0, &mut start_index, 29);
+        copy_slice(b, a, 17, 0, &mut start_index, 28);
+        copy_slice(b, a, 18, 0, &mut start_index, 28);
+        copy_slice(b, a, 19, 0, &mut start_index, 27);
+        copy_slice(b, a, 20, 0, &mut start_index, 27);
+        copy_slice(b, a, 21, 0, &mut start_index, 26);
+        copy_slice(b, a, 22, 0, &mut start_index, 26);
+        copy_slice(b, a, 23, 0, &mut start_index, 25);
+        copy_slice(b, a, 24, 0, &mut start_index, 25);
+        copy_slice(b, a, 25, 0, &mut start_index, 24);
+        copy_slice(b, a, 26, 0, &mut start_index, 24);
+        copy_slice(b, a, 27, 0, &mut start_index, 23);
+        copy_slice(b, a, 28, 0, &mut start_index, 23);
+        copy_slice(b, a, 29, 0, &mut start_index, 22);
+        copy_slice(b, a, 30, 0, &mut start_index, 22);
+        copy_slice(b, a, 31, 0, &mut start_index, 21);
+        copy_slice(b, a, 32, 0, &mut start_index, 21);
+        copy_slice(b, a, 33, 0, &mut start_index, 20);
+        copy_slice(b, a, 34, 0, &mut start_index, 20);
+        copy_slice(b, a, 35, 0, &mut start_index, 19);
+        copy_slice(b, a, 36, 0, &mut start_index, 19);
+        copy_slice(b, a, 37, 0, &mut start_index, 18);
+        copy_slice(b, a, 38, 0, &mut start_index, 18);
+        copy_slice(b, a, 39, 0, &mut start_index, 17);
+        copy_slice(b, a, 40, 0, &mut start_index, 17);
+        copy_slice(b, a, 41, 0, &mut start_index, 16);
+        copy_slice(b, a, 42, 0, &mut start_index, 16);
+        copy_slice(b, a, 43, 0, &mut start_index, 15);
+        copy_slice(b, a, 44, 0, &mut start_index, 15);
+        copy_slice(b, a, 45, 0, &mut start_index, 14);
+        copy_slice(b, a, 46, 0, &mut start_index, 14);
+        copy_slice(b, a, 47, 0, &mut start_index, 13);
+        copy_slice(b, a, 48, 0, &mut start_index, 13);
+        copy_slice(b, a, 49, 0, &mut start_index, 12);
+        copy_slice(b, a, 50, 0, &mut start_index, 12);
+        copy_slice(b, a, 51, 0, &mut start_index, 11);
+        copy_slice(b, a, 52, 0, &mut start_index, 11);
+        copy_slice(b, a, 53, 0, &mut start_index, 10);
+        copy_slice(b, a, 54, 0, &mut start_index, 10);
+        copy_slice(b, a, 55, 0, &mut start_index, 9);
+
+        AnimeDataBuffer::from_vec(crate::AnimeType::GA402, buf)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use crate::{AnimeDiagonal, AnimePacketType, AnimeType};
+
+    #[test]
+    fn ga401_diagonal_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
+            0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("test/ga401-diagonal.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA401).unwrap();
+        let data = matrix.into_data_buffer(crate::AnimeType::GA401);
+        let pkt = AnimePacketType::from(data);
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+    }
+
+    #[test]
+    fn ga402_diagonal_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+        let pkt2_check = [
+            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
+            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
+            0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("test/ga402-diagonal.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA402).unwrap();
+        let data = matrix.into_data_buffer(crate::AnimeType::GA402);
+        let pkt = AnimePacketType::from(data);
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+        assert_eq!(pkt[2], pkt2_check);
+    }
+
+    #[test]
+    #[ignore = "Needs the packets verified with capture"]
+    fn ga402_diagonal_fullbright_packet_check() {
+        let pkt0_check = [
+            0x5e, 0xc0, 0x2, 0x1, 0x0, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x68, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x67, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+        let pkt1_check = [
+            0x5e, 0xc0, 0x2, 0x74, 0x2, 0x73, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+        let pkt2_check = [
+            0x5e, 0xc0, 0x2, 0xe7, 0x4, 0x73, 0x2, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+            0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+        ];
+
+        let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        path.push("test/ga402-diagonal-fullbright.png");
+
+        let matrix = AnimeDiagonal::from_png(&path, None, 255.0, AnimeType::GA402).unwrap();
+        let data = matrix.into_data_buffer(crate::AnimeType::GA402);
+        let pkt = AnimePacketType::from(data);
+
+        assert_eq!(pkt[0], pkt0_check);
+        assert_eq!(pkt[1], pkt1_check);
+        assert_eq!(pkt[2], pkt2_check);
     }
 }

rog-anime/src/error.rs

@@ -13,6 +13,10 @@ pub enum AnimeError {
     /// The input was incorrect size, expected size is `IncorrectSize(width, height)`
     IncorrectSize(u32, u32),
     Dbus(String),
+    Udev(String, std::io::Error),
+    NoDevice,
+    UnsupportedDevice,
+    InvalidBrightness(f32),
 }
 
 impl fmt::Display for AnimeError {
@@ -30,6 +34,14 @@ impl fmt::Display for AnimeError {
                 width, height
             ),
             AnimeError::Dbus(detail) => write!(f, "{}", detail),
+            AnimeError::Udev(deets, error) => write!(f, "udev {}: {}", deets, error),
+            AnimeError::NoDevice => write!(f, "No AniMe Matrix device found"),
+            AnimeError::UnsupportedDevice => write!(f, "Unsupported AniMe Matrix device found"),
+            AnimeError::InvalidBrightness(bright) => write!(
+                f,
+                "Image brightness must be between 0.0 and 1.0 (inclusive), was {}",
+                bright
+            ),
         }
     }
 }

rog-anime/src/gif.rs

@@ -2,7 +2,7 @@ use glam::Vec2;
 use serde_derive::{Deserialize, Serialize};
 use std::{fs::File, path::Path, time::Duration};
 
-use crate::{error::AnimeError, AnimeDataBuffer, AnimeDiagonal, AnimeImage, Pixel};
+use crate::{error::AnimeError, AnimeDataBuffer, AnimeDiagonal, AnimeImage, AnimeType, Pixel};
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct AnimeFrame {
@@ -88,12 +88,13 @@ pub struct AnimeGif(Vec<AnimeFrame>, AnimTime);
 impl AnimeGif {
     /// Create an animation using the 74x36 ASUS gif format
     #[inline]
-    pub fn create_diagonal_gif(
+    pub fn from_diagonal_gif(
         file_name: &Path,
         duration: AnimTime,
         brightness: f32,
+        anime_type: AnimeType,
     ) -> Result<Self, AnimeError> {
-        let mut matrix = AnimeDiagonal::new(None);
+        let mut matrix = AnimeDiagonal::new(anime_type, None);
 
         let mut decoder = gif::DecodeOptions::new();
         // Configure the decoder such that it will expand the image to RGBA.
@@ -121,7 +122,7 @@ impl AnimeGif {
             }
 
             frames.push(AnimeFrame {
-                data: <AnimeDataBuffer>::from(&matrix),
+                data: matrix.into_data_buffer(anime_type),
                 delay: Duration::from_millis(wait as u64),
             });
         }
@@ -130,12 +131,13 @@ impl AnimeGif {
 
     /// Create an animation using the 74x36 ASUS gif format from a png
     #[inline]
-    pub fn create_diagonal_png(
+    pub fn from_diagonal_png(
         file_name: &Path,
+        anime_type: AnimeType,
         duration: AnimTime,
         brightness: f32,
     ) -> Result<Self, AnimeError> {
-        let image = AnimeDiagonal::from_png(file_name, None, brightness)?;
+        let image = AnimeDiagonal::from_png(file_name, None, brightness, anime_type)?;
 
         let mut total = Duration::from_millis(1000);
         if let AnimTime::Fade(fade) = duration {
@@ -148,7 +150,7 @@ impl AnimeGif {
         let frame_count = total.as_millis() / 30;
 
         let single = AnimeFrame {
-            data: <AnimeDataBuffer>::from(&image),
+            data: image.into_data_buffer(anime_type),
             delay: Duration::from_millis(30),
         };
         let frames = vec![single; frame_count as usize];
@@ -159,13 +161,14 @@ impl AnimeGif {
     /// Create an animation using a gif of any size. This method must precompute the
     /// result.
     #[inline]
-    pub fn create_png_gif(
+    pub fn from_gif(
         file_name: &Path,
         scale: f32,
         angle: f32,
         translation: Vec2,
         duration: AnimTime,
         brightness: f32,
+        anime_type: AnimeType,
     ) -> Result<Self, AnimeError> {
         let mut frames = Vec::new();
 
@@ -187,7 +190,8 @@ impl AnimeGif {
             brightness,
             pixels,
             decoder.width() as u32,
-        );
+            anime_type,
+        )?;
 
         while let Some(frame) = decoder.read_next_frame()? {
             let wait = frame.delay * 10;
@@ -201,7 +205,8 @@ impl AnimeGif {
                     brightness,
                     pixels,
                     width as u32,
-                );
+                    anime_type,
+                )?;
             }
             for (y, row) in frame.buffer.chunks(frame.width as usize * 4).enumerate() {
                 for (x, px) in row.chunks(4).enumerate() {
@@ -231,15 +236,17 @@ impl AnimeGif {
     /// will be 1 second long. If `AnimTime::Cycles` is specified for `duration` then this can
     /// be considered how many seconds the image will show for.
     #[inline]
-    pub fn create_png_static(
+    pub fn from_png(
         file_name: &Path,
         scale: f32,
         angle: f32,
         translation: Vec2,
         duration: AnimTime,
         brightness: f32,
+        anime_type: AnimeType,
     ) -> Result<Self, AnimeError> {
-        let image = AnimeImage::from_png(file_name, scale, angle, translation, brightness)?;
+        let image =
+            AnimeImage::from_png(file_name, scale, angle, translation, brightness, anime_type)?;
 
         let mut total = Duration::from_millis(1000);
         if let AnimTime::Fade(fade) = duration {

rog-anime/src/grid.rs

@@ -1,8 +1,7 @@
-use std::time::Duration;
-
-use crate::data::{AnimeDataBuffer, ANIME_DATA_LEN};
-use crate::image::LED_IMAGE_POSITIONS;
+use crate::data::AnimeDataBuffer;
+use crate::{AnimeImage, AnimeType};
 
+// TODO: Adjust these sizes as WIDTH_GA401 WIDTH_GA402
 const WIDTH: usize = 33;
 const HEIGHT: usize = 55;
 
@@ -14,41 +13,40 @@ const HEIGHT: usize = 55;
 ///
 /// **Note:** the columns in each odd row are offset by half a pixel left
 #[derive(Debug, Clone)]
-pub struct AnimeGrid([[u8; WIDTH]; HEIGHT], Option<Duration>);
-
-impl Default for AnimeGrid {
-    #[inline]
-    fn default() -> Self {
-        Self::new(None)
-    }
+pub struct AnimeGrid {
+    anime_type: AnimeType,
+    data: [[u8; WIDTH]; HEIGHT],
 }
 
 impl AnimeGrid {
     #[inline]
-    pub fn new(duration: Option<Duration>) -> Self {
-        AnimeGrid([[0u8; WIDTH]; HEIGHT], duration)
+    pub fn new(anime_type: AnimeType) -> Self {
+        Self {
+            anime_type,
+            data: [[0u8; WIDTH]; HEIGHT],
+        }
     }
 
     /// Set a position in the grid with a brightness value
     #[inline]
     pub fn set(&mut self, x: usize, y: usize, b: u8) {
-        self.0[y][x] = b;
+        self.data[y][x] = b;
     }
 
     #[inline]
     pub fn get(&self) -> &[[u8; WIDTH]; HEIGHT] {
-        &self.0
+        &self.data
     }
 
     #[inline]
     pub fn get_mut(&mut self) -> &mut [[u8; WIDTH]; HEIGHT] {
-        &mut self.0
+        &mut self.data
     }
 
     /// Fill the grid with a value
     #[inline]
     pub fn fill_with(&mut self, fill: u8) {
-        for row in self.0.iter_mut() {
+        for row in self.data.iter_mut() {
             for x in row.iter_mut() {
                 *x = fill;
             }
@@ -94,16 +92,19 @@ impl From<AnimeGrid> for AnimeDataBuffer {
     /// packets suitable for sending over USB
     #[inline]
     fn from(anime: AnimeGrid) -> Self {
-        let mut buf = vec![0u8; ANIME_DATA_LEN];
+        let mut buf = vec![0u8; anime.anime_type.data_length()];
 
-        for (idx, pos) in LED_IMAGE_POSITIONS.iter().enumerate() {
+        for (idx, pos) in AnimeImage::generate_image_positioning(anime.anime_type)
+            .iter()
+            .enumerate()
+        {
             if let Some(pos) = pos {
                 let x = pos.x().ceil() as usize;
                 let y = pos.y().ceil() as usize;
-                buf[idx + 1] = anime.0[y][x];
+                buf[idx + 1] = anime.data[y][x];
             }
         }
-        AnimeDataBuffer::from_vec(buf)
+        AnimeDataBuffer::from_vec(anime.anime_type, buf)
     }
 }
 
@@ -113,7 +114,7 @@ mod tests {
 
     #[test]
     fn check_data_alignment() {
-        let mut matrix = AnimeGrid::new(None);
+        let mut matrix = AnimeGrid::new(AnimeType::GA401);
         {
             let tmp = matrix.get_mut();
             for row in tmp.iter_mut() {
@@ -171,6 +172,6 @@ mod tests {
             0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0,
             0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         ];
-        assert_eq!(matrix.get(), &data_cmp);
+        assert_eq!(matrix.data(), &data_cmp);
     }
 }

rog-anime/src/sequencer.rs

@@ -3,7 +3,9 @@ use std::{path::PathBuf, time::Duration};
 use glam::Vec2;
 use serde_derive::{Deserialize, Serialize};
 
-use crate::{error::AnimeError, AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage};
+use crate::{
+    error::AnimeError, AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType,
+};
 
 /// All the possible AniMe actions that can be used. This enum is intended to be
 /// a helper for loading up `ActionData`.
@@ -63,26 +65,37 @@ pub enum ActionData {
 }
 
 impl ActionData {
-    pub fn from_anime_action(action: &ActionLoader) -> Result<ActionData, AnimeError> {
+    pub fn from_anime_action(
+        anime_type: AnimeType,
+        action: &ActionLoader,
+    ) -> Result<ActionData, AnimeError> {
         let a = match action {
             ActionLoader::AsusAnimation {
                 file,
                 time,
                 brightness,
-            } => ActionData::Animation(AnimeGif::create_diagonal_gif(file, *time, *brightness)?),
+            } => ActionData::Animation(AnimeGif::from_diagonal_gif(
+                file,
+                *time,
+                *brightness,
+                anime_type,
+            )?),
             ActionLoader::AsusImage {
                 file,
                 time,
                 brightness,
             } => match time {
                 AnimTime::Infinite => {
-                    let image = AnimeDiagonal::from_png(file, None, *brightness)?;
-                    let data = <AnimeDataBuffer>::from(&image);
+                    let image = AnimeDiagonal::from_png(file, None, *brightness, anime_type)?;
+                    let data = image.into_data_buffer(anime_type);
                     ActionData::Image(Box::new(data))
                 }
-                _ => {
-                    ActionData::Animation(AnimeGif::create_diagonal_png(file, *time, *brightness)?)
-                }
+                _ => ActionData::Animation(AnimeGif::from_diagonal_png(
+                    file,
+                    anime_type,
+                    *time,
+                    *brightness,
+                )?),
             },
             ActionLoader::ImageAnimation {
                 file,
@@ -94,23 +107,25 @@ impl ActionData {
             } => {
                 if let Some(ext) = file.extension() {
                     if ext.to_string_lossy().to_lowercase() == "png" {
-                        return Ok(ActionData::Animation(AnimeGif::create_png_static(
+                        return Ok(ActionData::Animation(AnimeGif::from_png(
                             file,
                             *scale,
                             *angle,
                             *translation,
                             *time,
                             *brightness,
+                            anime_type,
                         )?));
                     }
                 }
-                ActionData::Animation(AnimeGif::create_png_gif(
+                ActionData::Animation(AnimeGif::from_gif(
                     file,
                     *scale,
                     *angle,
                     *translation,
                     *time,
                     *brightness,
+                    anime_type,
                 )?)
             }
             ActionLoader::Image {
@@ -124,18 +139,25 @@ impl ActionData {
                 match time {
                     AnimTime::Infinite => {
                         // If no time then create a plain static image
-                        let image =
-                            AnimeImage::from_png(file, *scale, *angle, *translation, *brightness)?;
+                        let image = AnimeImage::from_png(
+                            file,
+                            *scale,
+                            *angle,
+                            *translation,
+                            *brightness,
+                            anime_type,
+                        )?;
                         let data = <AnimeDataBuffer>::from(&image);
                         ActionData::Image(Box::new(data))
                     }
-                    _ => ActionData::Animation(AnimeGif::create_png_static(
+                    _ => ActionData::Animation(AnimeGif::from_png(
                         file,
                         *scale,
                         *angle,
                         *translation,
                         *time,
                         *brightness,
+                        anime_type,
                     )?),
                 }
             }
@@ -146,20 +168,21 @@ impl ActionData {
 }
 
 /// An optimised precomputed set of actions that the user can cycle through
-#[derive(Debug, Deserialize, Serialize, Default)]
-pub struct Sequences(Vec<ActionData>);
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Sequences(Vec<ActionData>, AnimeType);
 
 impl Sequences {
     #[inline]
-    pub fn new() -> Self {
-        Self(Vec::new())
+    pub fn new(anime_type: AnimeType) -> Self {
+        Self(Vec::new(), anime_type)
     }
 
     /// Use a base `AnimeAction` to generate the precomputed data and insert in to
     /// the run buffer
     #[inline]
     pub fn insert(&mut self, index: usize, action: &ActionLoader) -> Result<(), AnimeError> {
-        self.0.insert(index, ActionData::from_anime_action(action)?);
+        self.0
+            .insert(index, ActionData::from_anime_action(self.1, action)?);
         Ok(())
     }
 

rog-anime/src/usb.rs

@@ -7,6 +7,8 @@
 //!
 //! Step 1 need to applied only on fresh system boot.
 
+use crate::{error::AnimeError, AnimeType};
+
 const INIT_STR: [u8; 15] = [
     0x5e, b'A', b'S', b'U', b'S', b' ', b'T', b'e', b'c', b'h', b'.', b'I', b'n', b'c', b'.',
 ];
@@ -15,6 +17,47 @@ const DEV_PAGE: u8 = 0x5e;
 pub const VENDOR_ID: u16 = 0x0b05;
 pub const PROD_ID: u16 = 0x193b;
 
+/// `get_anime_type` is very broad, matching on part of the laptop board name only. For this
+/// reason `find_node()` must be used also to verify if the USB device is available.
+///
+/// The currently known USB device is `19b6`.
+#[inline]
+pub fn get_anime_type() -> Result<AnimeType, AnimeError> {
+    let dmi = sysfs_class::DmiId::default();
+    let board_name = dmi.board_name()?;
+
+    if board_name.contains("GA401Q") {
+        return Ok(AnimeType::GA401);
+    } else if board_name.contains("GA402R") {
+        return Ok(AnimeType::GA402);
+    }
+    Err(AnimeError::UnsupportedDevice)
+}
+
+/// Find the USB device node - known devices so far: `19b6`
+#[inline]
+pub fn find_node(id_product: &str) -> Result<String, AnimeError> {
+    let mut enumerator =
+        udev::Enumerator::new().map_err(|err| AnimeError::Udev("enumerator failed".into(), err))?;
+    enumerator
+        .match_subsystem("usb")
+        .map_err(|err| AnimeError::Udev("match_subsystem failed".into(), err))?;
+
+    for device in enumerator
+        .scan_devices()
+        .map_err(|err| AnimeError::Udev("scan_devices failed".into(), err))?
+    {
+        if let Some(attr) = device.attribute_value("idProduct") {
+            if attr == id_product {
+                if let Some(dev_node) = device.devnode() {
+                    return Ok(dev_node.to_string_lossy().to_string());
+                }
+            }
+        }
+    }
+    Err(AnimeError::NoDevice)
+}
+
 /// Get the two device initialization packets. These are required for device start
 /// after the laptop boots.
 #[inline]

rog-aura/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rog_aura"
-version = "1.1.0"
+version = "1.1.1"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -14,11 +14,10 @@ exclude = ["data"]
 
 [features]
 default = ["dbus"]
-dbus = ["zvariant", "zvariant_derive"]
+dbus = ["zvariant"]
 
 [dependencies]
 serde = "^1.0"
 serde_derive = "^1.0"
 
-zvariant = { version = "^2.6", optional = true }
-zvariant_derive = { version = "^2.6", optional = true }
+zvariant = { version = "^3.0", optional = true }

rog-aura/src/builtin_modes.rs

@@ -7,17 +7,10 @@ pub const LED_INIT5: [u8; 6] = [0x5e, 0x05, 0x20, 0x31, 0, 0x08];
 use serde_derive::{Deserialize, Serialize};
 use std::str::FromStr;
 #[cfg(feature = "dbus")]
-use zvariant_derive::Type;
+use zvariant::Type;
 
 use crate::{error::Error, LED_MSG_LEN};
 
-#[cfg_attr(feature = "dbus", derive(Type))]
-#[derive(Debug, PartialEq, Copy, Clone, Deserialize, Serialize)]
-pub struct LedPowerStates {
-    pub enabled: bool,
-    pub sleep_anim_enabled: bool,
-}
-
 #[cfg_attr(feature = "dbus", derive(Type))]
 #[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize)]
 pub enum LedBrightness {
@@ -145,18 +138,38 @@ pub enum AuraModeNum {
     Flash = 12,
 }
 
+impl From<AuraModeNum> for String {
+    fn from(mode: AuraModeNum) -> Self {
+        match mode {
+            AuraModeNum::Static => "Static",
+            AuraModeNum::Breathe => "Breathe",
+            AuraModeNum::Strobe => "Strobe",
+            AuraModeNum::Rainbow => "Rainbow",
+            AuraModeNum::Star => "Stars",
+            AuraModeNum::Rain => "Rain",
+            AuraModeNum::Highlight => "Highlight",
+            AuraModeNum::Laser => "Laser",
+            AuraModeNum::Ripple => "Ripple",
+            AuraModeNum::Pulse => "Pulse",
+            AuraModeNum::Comet => "Comet",
+            AuraModeNum::Flash => "Flash",
+        }
+        .to_string()
+    }
+}
+
 impl From<&AuraModeNum> for &str {
     fn from(mode: &AuraModeNum) -> Self {
         match mode {
             AuraModeNum::Static => "Static",
-            AuraModeNum::Breathe => "Breathing",
-            AuraModeNum::Strobe => "Strobing",
+            AuraModeNum::Breathe => "Breathe",
+            AuraModeNum::Strobe => "Strobe",
             AuraModeNum::Rainbow => "Rainbow",
             AuraModeNum::Star => "Stars",
             AuraModeNum::Rain => "Rain",
-            AuraModeNum::Highlight => "Keypress Highlight",
-            AuraModeNum::Laser => "Keypress Laser",
-            AuraModeNum::Ripple => "Keypress Ripple",
+            AuraModeNum::Highlight => "Highlight",
+            AuraModeNum::Laser => "Laser",
+            AuraModeNum::Ripple => "Ripple",
             AuraModeNum::Pulse => "Pulse",
             AuraModeNum::Comet => "Comet",
             AuraModeNum::Flash => "Flash",
@@ -167,14 +180,14 @@ impl From<&str> for AuraModeNum {
     fn from(mode: &str) -> Self {
         match mode {
             "Static" => AuraModeNum::Static,
-            "Breathing" => AuraModeNum::Breathe,
-            "Strobing" => AuraModeNum::Strobe,
+            "Breathe" => AuraModeNum::Breathe,
+            "Strobe" => AuraModeNum::Strobe,
             "Rainbow" => AuraModeNum::Rainbow,
             "Stars" => AuraModeNum::Star,
             "Rain" => AuraModeNum::Rain,
-            "Keypress Highlight" => AuraModeNum::Highlight,
-            "Keypress Laser" => AuraModeNum::Laser,
-            "Keypress Ripple" => AuraModeNum::Ripple,
+            "Highlight" => AuraModeNum::Highlight,
+            "Laser" => AuraModeNum::Laser,
+            "Ripple" => AuraModeNum::Ripple,
             "Pulse" => AuraModeNum::Pulse,
             "Comet" => AuraModeNum::Comet,
             "Flash" => AuraModeNum::Flash,
@@ -207,16 +220,60 @@ impl From<u8> for AuraModeNum {
 #[cfg_attr(feature = "dbus", derive(Type))]
 #[derive(Debug, Copy, Clone, PartialEq, Deserialize, Serialize)]
 pub enum AuraZone {
+    /// Used if keyboard has no zones, or if setting all
     None,
-    One,
-    Two,
-    Three,
-    Four,
+    /// Leftmost zone
+    Key1,
+    /// Zone after leftmost
+    Key2,
+    /// Zone second from right
+    Key3,
+    /// Rightmost zone
+    Key4,
+    /// Logo on the lid (or elsewhere?)
+    Logo,
+    /// The left part of a lightbar (typically on the front of laptop)
+    BarLeft,
+    /// The right part of a lightbar
+    BarRight,
+}
+
+impl Default for AuraZone {
+    fn default() -> Self {
+        AuraZone::None
+    }
+}
+
+impl FromStr for AuraZone {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_lowercase();
+        match s.to_ascii_lowercase().as_str() {
+            "0" => Ok(AuraZone::None),
+            "none" => Ok(AuraZone::None),
+            "1" => Ok(AuraZone::Key1),
+            "one" => Ok(AuraZone::Key1),
+            "2" => Ok(AuraZone::Key2),
+            "two" => Ok(AuraZone::Key2),
+            "3" => Ok(AuraZone::Key3),
+            "three" => Ok(AuraZone::Key3),
+            "4" => Ok(AuraZone::Key4),
+            "four" => Ok(AuraZone::Key4),
+            "5" => Ok(AuraZone::Logo),
+            "logo" => Ok(AuraZone::Logo),
+            "6" => Ok(AuraZone::BarLeft),
+            "lightbar-left" => Ok(AuraZone::BarLeft),
+            "7" => Ok(AuraZone::BarRight),
+            "lightbar-right" => Ok(AuraZone::BarRight),
+            _ => Err(Error::ParseSpeed),
+        }
+    }
 }
 
 /// Default factory modes structure. This easily converts to an USB HID packet with:
 /// ```rust
-/// let bytes: [u8; LED_MSG_LEN] = mode.into();
+/// // let bytes: [u8; LED_MSG_LEN] = mode.into();
 /// ```
 #[cfg_attr(feature = "dbus", derive(Type))]
 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -299,3 +356,100 @@ impl From<&AuraEffect> for [u8; LED_MSG_LEN] {
         msg
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed, LED_MSG_LEN};
+
+    #[test]
+    fn check_led_static_packet() {
+        let st = AuraEffect {
+            mode: AuraModeNum::Static,
+            zone: AuraZone::None,
+            colour1: Colour(0xff, 0x11, 0xdd),
+            colour2: Colour::default(),
+            speed: Speed::Med,
+            direction: Direction::Right,
+        };
+        let ar = <[u8; LED_MSG_LEN]>::from(&st);
+
+        println!("{:02x?}", ar);
+        let check = [
+            0x5d, 0xb3, 0x0, 0x0, 0xff, 0x11, 0xdd, 0xeb, 0x0, 0x0, 0xa6, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0,
+        ];
+        assert_eq!(ar, check);
+    }
+
+    #[test]
+    fn check_led_static_zone_packet() {
+        let mut st = AuraEffect {
+            mode: AuraModeNum::Static,
+            zone: AuraZone::Key1,
+            colour1: Colour(0xff, 0, 0),
+            colour2: Colour(0, 0, 0),
+            speed: Speed::Low,
+            direction: Direction::Left,
+        };
+        let capture = [
+            0x5d, 0xb3, 0x01, 0x00, 0xff, 0x00, 0x00, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::Key2;
+        st.colour1 = Colour(0xff, 0xff, 0);
+        let capture = [
+            0x5d, 0xb3, 0x02, 0x00, 0xff, 0xff, 0x00, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::Key3;
+        st.colour1 = Colour(0, 0xff, 0xff);
+        let capture = [
+            0x5d, 0xb3, 0x03, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::Key4;
+        st.colour1 = Colour(0xff, 0x00, 0xff);
+        let capture = [
+            0x5d, 0xb3, 0x04, 0x00, 0xff, 0x00, 0xff, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::Logo;
+        st.colour1 = Colour(0x2c, 0xff, 0x00);
+        let capture = [
+            0x5d, 0xb3, 0x05, 0x00, 0x2c, 0xff, 0x00, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::BarLeft;
+        st.colour1 = Colour(0xff, 0x00, 0x00);
+        let capture = [
+            0x5d, 0xb3, 0x06, 0x00, 0xff, 0x00, 0x00, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.zone = AuraZone::BarRight;
+        st.colour1 = Colour(0xff, 0x00, 0xcd);
+        let capture = [
+            0x5d, 0xb3, 0x07, 0x00, 0xff, 0x00, 0xcd, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+
+        st.mode = AuraModeNum::Rainbow;
+        let capture = [
+            0x5d, 0xb3, 0x07, 0x03, 0xff, 0x00, 0xcd, 0xe1, 0x01, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x0, 0x0,
+        ];
+        assert_eq!(<[u8; LED_MSG_LEN]>::from(&st)[..9], capture[..9]);
+    }
+}

rog-aura/src/usb.rs

@@ -1,3 +1,8 @@
+use serde::{Deserialize, Serialize};
+use std::ops::{BitAnd, BitOr};
+#[cfg(feature = "dbus")]
+use zvariant::Type;
+
 pub const LED_INIT1: [u8; 2] = [0x5d, 0xb9];
 pub const LED_INIT2: &str = "]ASUS Tech.Inc."; // ] == 0x5d
 pub const LED_INIT3: [u8; 6] = [0x5d, 0x05, 0x20, 0x31, 0, 0x08];
@@ -15,18 +20,179 @@ pub const fn aura_brightness_bytes(brightness: u8) -> [u8; 17] {
     ]
 }
 
-pub const LED_AWAKE_ON_SLEEP_OFF: [u8; 17] = [
-    0x5d, 0xbd, 0x01, 0xcf, 0x17, 0x0b, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-];
+/// Enable/disable LED control in various states such as
+/// when the device is awake, suspended, shutting down or
+/// booting.
+///
+/// ```text
+// byte 4 in the USB packet is for keyboard + logo power states
+// default is on, `ff`
+// Keyboard and logo use the full range of bits (almost)
+// | n1   | n2   | hex | action                | bit   |
+// |------|------|-----|-----------------------|-------|
+// | 0000 | 0000 | 00  | all off               |       |
+// | 0000 | 0001 | 01  | logo boot             | bit 1 |
+// | 0000 | 0010 | 02  | keyboard boot         | bit 2 |
+// | 0000 | 0100 | 04  | logo awake            | bit 3 |
+// | 0000 | 1000 | 08  | keyboard awake        | bit 4 |
+// | 0001 | 0000 | 10  | logo sleep off        | bit 5 |
+// | 0010 | 0000 | 20  | keyboard sleep        | bit 6 |
+// | 0100 | 0000 | 40  | logo shutdown off     | bit 7 |
+// | 1000 | 0000 | 80  | keyboard shutdown off | bit 8 |
 
-pub const LED_AWAKE_ON_SLEEP_ON: [u8; 17] = [
-    0x5d, 0xbd, 0x01, 0xff, 0x1f, 0x0f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-];
+// byte 5 = lightbar
+// |  1   |  2   | hex | action               | bit   |
+// |------|------|-----|----------------------|-------|
+// | 0000 | 0010 | 02  | lightbar off boot    | bit 2 |
+// | 0000 | 0100 | 04  | lightbar on          | bit 3 |
+// | 0000 | 1000 | 08  | lightbar off sleep   | bit 4 |
+// | 0001 | 0000 | 10  | lightbar shtdn off   | bit 5 |
+#[cfg_attr(feature = "dbus", derive(Type))]
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Serialize, Deserialize)]
+#[repr(u16)]
+pub enum AuraControl {
+    BootLogo = 1,
+    BootKeyb = 1 << 1,
+    AwakeLogo = 1 << 2,
+    AwakeKeyb = 1 << 3,
+    SleepLogo = 1 << 4,
+    SleepKeyb = 1 << 5,
+    ShutdownLogo = 1 << 6,
+    ShutdownKeyb = 1 << 7,
+    AwakeBar = 1 << 7 + 2,
+    BootBar = 1 << 7 + 3,
+    SleepBar = 1 << 7 + 4,
+    ShutdownBar = 1 << 7 + 5,
+}
 
-pub const LED_AWAKE_OFF_SLEEP_OFF: [u8; 17] = [
-    0x5d, 0xbd, 0x01, 0xc3, 0x13, 0x09, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-];
+impl From<AuraControl> for u16 {
+    fn from(a: AuraControl) -> Self {
+        a as u16
+    }
+}
 
-pub const LED_AWAKE_OFF_SLEEP_ON: [u8; 17] = [
-    0x5d, 0xbd, 0x01, 0xf3, 0x1b, 0x0d, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-];
+impl AuraControl {
+    pub fn to_bytes(control: &[Self]) -> [u8; 2] {
+        let mut a: u16 = 0;
+        control.iter().for_each(|n| {
+            a |= *n as u16;
+        });
+        [(a & 0xff) as u8, ((a & 0xff00) >> 8) as u8]
+    }
+}
+
+impl BitOr<AuraControl> for AuraControl {
+    type Output = u16;
+
+    fn bitor(self, rhs: AuraControl) -> Self::Output {
+        return self as u16 | rhs as u16;
+    }
+}
+
+impl BitAnd<AuraControl> for AuraControl {
+    type Output = u16;
+
+    fn bitand(self, rhs: AuraControl) -> Self::Output {
+        return self as u16 & rhs as u16;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::usb::AuraControl;
+
+    #[test]
+    fn check_led_control_bytes() {
+        // All on
+        let byte1 = [
+            AuraControl::BootLogo,
+            AuraControl::BootKeyb,
+            AuraControl::SleepLogo,
+            AuraControl::SleepKeyb,
+            AuraControl::AwakeLogo,
+            AuraControl::AwakeKeyb,
+            AuraControl::ShutdownLogo,
+            AuraControl::ShutdownKeyb,
+        ];
+        let bytes = AuraControl::to_bytes(&byte1);
+        println!("{:08b}", bytes[0]);
+        assert_eq!(bytes[0], 0xff);
+
+        //
+        let byte1 = [
+            // AuraControl::BootLogo,
+            AuraControl::BootKeyb,
+            AuraControl::SleepLogo,
+            AuraControl::SleepKeyb,
+            AuraControl::AwakeLogo,
+            AuraControl::AwakeKeyb,
+            AuraControl::ShutdownLogo,
+            AuraControl::ShutdownKeyb,
+        ];
+        let bytes = AuraControl::to_bytes(&byte1);
+        println!("{:08b}", bytes[0]);
+        assert_eq!(bytes[0], 0xfe);
+
+        let byte1 = [
+            AuraControl::BootLogo,
+            // AuraControl::BootKeyb,
+            AuraControl::SleepLogo,
+            AuraControl::SleepKeyb,
+            AuraControl::AwakeLogo,
+            AuraControl::AwakeKeyb,
+            AuraControl::ShutdownLogo,
+            AuraControl::ShutdownKeyb,
+        ];
+        let bytes = AuraControl::to_bytes(&byte1);
+        println!("{:08b}", bytes[0]);
+        assert_eq!(bytes[0], 0xfd);
+
+        let byte1 = [
+            AuraControl::BootLogo,
+            AuraControl::BootKeyb,
+            // AuraControl::SleepLogo,
+            AuraControl::SleepKeyb,
+            AuraControl::AwakeLogo,
+            AuraControl::AwakeKeyb,
+            AuraControl::ShutdownLogo,
+            AuraControl::ShutdownKeyb,
+        ];
+        let bytes = AuraControl::to_bytes(&byte1);
+        println!("{:08b}", bytes[0]);
+        assert_eq!(bytes[0], 0xef);
+
+        let byte1 = [
+            AuraControl::BootLogo,
+            AuraControl::BootKeyb,
+            AuraControl::SleepLogo,
+            // AuraControl::SleepKeyb,
+            AuraControl::AwakeLogo,
+            AuraControl::AwakeKeyb,
+            AuraControl::ShutdownLogo,
+            AuraControl::ShutdownKeyb,
+        ];
+        let bytes = AuraControl::to_bytes(&byte1);
+        println!("{:08b}", bytes[0]);
+        assert_eq!(bytes[0], 0xdf);
+
+        let byte2 = [
+            AuraControl::AwakeBar,
+            AuraControl::BootBar,
+            AuraControl::SleepBar,
+            AuraControl::ShutdownBar,
+        ];
+        let bytes = AuraControl::to_bytes(&byte2);
+        println!("{:08b}", bytes[1]);
+        assert_eq!(bytes[1], 0x1e);
+
+        let byte2 = [
+            AuraControl::AwakeBar,
+            AuraControl::BootBar,
+            // AuraControl::SleepBar,
+            AuraControl::ShutdownBar,
+        ];
+        let bytes = AuraControl::to_bytes(&byte2);
+        println!("{:08b}", bytes[1]);
+        assert_eq!(bytes[1], 0x16);
+    }
+}

rog-dbus/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rog_dbus"
-version = "4.0.2"
+version = "4.2.0"
 license = "MPL-2.0"
 readme = "README.md"
 authors = ["Luke <luke@ljones.dev>"]
@@ -14,7 +14,6 @@ rog_anime = { path = "../rog-anime" }
 rog_aura = { path = "../rog-aura" }
 rog_profiles = { path = "../rog-profiles" }
 rog_supported = { path = "../rog-supported" }
-supergfxctl = { git = "https://gitlab.com/asus-linux/supergfxctl.git", tag = "2.0.0" }
-zbus = "^1.9"
-zbus_macros = "^1.9"
-zvariant = "^2.8"
+zbus = "^2.2"
+zbus_macros = "^2.0"
+zvariant = "^3.0"

rog-dbus/src/lib.rs

@@ -1,5 +1,4 @@
 pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
-pub static DBUS_NAME_GFX: &str = "org.supergfxctl.Daemon";
 pub static DBUS_PATH: &str = "/org/asuslinux/Daemon";
 pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
 
@@ -10,51 +9,109 @@ pub mod zbus_profile;
 pub mod zbus_rogbios;
 pub mod zbus_supported;
 
-use rog_anime::AnimePowerStates;
-use rog_aura::{AuraEffect, LedPowerStates};
-use rog_profiles::Profile;
-use std::sync::mpsc::{channel, Receiver};
-use zbus::{Connection, Result, SignalReceiver};
+// use rog_anime::AnimePowerStates;
+// use rog_aura::{AuraEffect, LedPowerStates};
+// use rog_profiles::Profile;
+// use std::sync::mpsc::{channel, Receiver};
+use zbus::{blocking, Connection, Result};
 
 pub static VERSION: &str = env!("CARGO_PKG_VERSION");
+pub struct DbusProxiesBlocking<'a> {
+    anime: zbus_anime::AnimeProxyBlocking<'a>,
+    charge: zbus_charge::ChargeProxyBlocking<'a>,
+    led: zbus_led::LedProxyBlocking<'a>,
+    profile: zbus_profile::ProfileProxyBlocking<'a>,
+    rog_bios: zbus_rogbios::RogBiosProxyBlocking<'a>,
+    supported: zbus_supported::SupportedProxyBlocking<'a>,
+}
+
+impl<'a> DbusProxiesBlocking<'a> {
+    #[inline]
+    pub fn new() -> Result<(Self, blocking::Connection)> {
+        let conn = blocking::Connection::system()?;
+
+        Ok((
+            DbusProxiesBlocking {
+                anime: zbus_anime::AnimeProxyBlocking::new(&conn)?,
+                led: zbus_led::LedProxyBlocking::new(&conn)?,
+                charge: zbus_charge::ChargeProxyBlocking::new(&conn)?,
+                profile: zbus_profile::ProfileProxyBlocking::new(&conn)?,
+                rog_bios: zbus_rogbios::RogBiosProxyBlocking::new(&conn)?,
+                supported: zbus_supported::SupportedProxyBlocking::new(&conn)?,
+            },
+            conn,
+        ))
+    }
+
+    pub fn anime(&self) -> &zbus_anime::AnimeProxyBlocking<'a> {
+        &self.anime
+    }
+
+    pub fn charge(&self) -> &zbus_charge::ChargeProxyBlocking<'a> {
+        &self.charge
+    }
+
+    pub fn led(&self) -> &zbus_led::LedProxyBlocking<'a> {
+        &self.led
+    }
+
+    pub fn profile(&self) -> &zbus_profile::ProfileProxyBlocking<'a> {
+        &self.profile
+    }
+
+    pub fn rog_bios(&self) -> &zbus_rogbios::RogBiosProxyBlocking<'a> {
+        &self.rog_bios
+    }
+
+    pub fn supported(&self) -> &zbus_supported::SupportedProxyBlocking<'a> {
+        &self.supported
+    }
+}
+
+/// This is the main way to communicate with the DBUS interface
+pub struct RogDbusClientBlocking<'a> {
+    proxies: DbusProxiesBlocking<'a>,
+}
+
+impl<'a> RogDbusClientBlocking<'a> {
+    #[inline]
+    pub fn new() -> Result<(Self, blocking::Connection)> {
+        let (proxies, conn) = DbusProxiesBlocking::new()?;
+        Ok((RogDbusClientBlocking { proxies }, conn))
+    }
+
+    pub fn proxies(&self) -> &DbusProxiesBlocking {
+        &self.proxies
+    }
+}
+
 pub struct DbusProxies<'a> {
     anime: zbus_anime::AnimeProxy<'a>,
     charge: zbus_charge::ChargeProxy<'a>,
     led: zbus_led::LedProxy<'a>,
     profile: zbus_profile::ProfileProxy<'a>,
     rog_bios: zbus_rogbios::RogBiosProxy<'a>,
-    supported: zbus_supported::SupportProxy<'a>,
+    supported: zbus_supported::SupportedProxy<'a>,
 }
 
 impl<'a> DbusProxies<'a> {
     #[inline]
-    pub fn new() -> Result<(Self, Connection)> {
-        let conn = Connection::new_system()?;
+    pub async fn new() -> Result<(DbusProxies<'a>, Connection)> {
+        let conn = Connection::system().await?;
 
         Ok((
             DbusProxies {
-                anime: zbus_anime::AnimeProxy::new(&conn)?,
-                led: zbus_led::LedProxy::new(&conn)?,
-                charge: zbus_charge::ChargeProxy::new(&conn)?,
-                profile: zbus_profile::ProfileProxy::new(&conn)?,
-                rog_bios: zbus_rogbios::RogBiosProxy::new(&conn)?,
-                supported: zbus_supported::SupportProxy::new(&conn)?,
+                anime: zbus_anime::AnimeProxy::new(&conn).await?,
+                led: zbus_led::LedProxy::new(&conn).await?,
+                charge: zbus_charge::ChargeProxy::new(&conn).await?,
+                profile: zbus_profile::ProfileProxy::new(&conn).await?,
+                rog_bios: zbus_rogbios::RogBiosProxy::new(&conn).await?,
+                supported: zbus_supported::SupportedProxy::new(&conn).await?,
             },
             conn,
         ))
     }
 
-    pub fn setup_recv(&'a self, conn: Connection) -> SignalReceiver<'a, 'a> {
-        let mut recv = SignalReceiver::new(conn);
-        recv.receive_for(self.anime.proxy());
-        recv.receive_for(self.led.proxy());
-        recv.receive_for(self.charge.proxy());
-        recv.receive_for(self.profile.proxy());
-        recv.receive_for(self.rog_bios.proxy());
-        recv.receive_for(self.supported.proxy());
-        recv
-    }
-
     pub fn anime(&self) -> &zbus_anime::AnimeProxy<'a> {
         &self.anime
     }
@@ -75,96 +132,24 @@ impl<'a> DbusProxies<'a> {
         &self.rog_bios
     }
 
-    pub fn supported(&self) -> &zbus_supported::SupportProxy<'a> {
+    pub fn supported(&self) -> &zbus_supported::SupportedProxy<'a> {
         &self.supported
     }
 }
 
-// Signals separated out
-pub struct Signals {
-    pub profile: Receiver<Profile>,
-    pub led_mode: Receiver<AuraEffect>,
-    pub led_power_state: Receiver<LedPowerStates>,
-    pub anime_power_state: Receiver<AnimePowerStates>,
-    pub charge: Receiver<u8>,
-    pub bios_gsync: Receiver<bool>,
-    pub bios_sound: Receiver<bool>,
-}
-
-impl Signals {
-    #[inline]
-    pub fn new(proxies: &DbusProxies) -> Result<Self> {
-        Ok(Signals {
-            profile: {
-                let (tx, rx) = channel();
-                proxies.profile.connect_notify_profile(tx)?;
-                rx
-            },
-            charge: {
-                let (tx, rx) = channel();
-                proxies.charge.connect_notify_charge(tx)?;
-                rx
-            },
-            led_mode: {
-                let (tx, rx) = channel();
-                proxies.led.connect_notify_led(tx)?;
-                rx
-            },
-            led_power_state: {
-                let (tx, rx) = channel();
-                proxies.led.connect_notify_power_states(tx)?;
-                rx
-            },
-            anime_power_state: {
-                let (tx, rx) = channel();
-                proxies.anime.connect_notify_power_states(tx)?;
-                rx
-            },
-            bios_gsync: {
-                let (tx, rx) = channel();
-                proxies.rog_bios.connect_notify_dedicated_graphic_mode(tx)?;
-                rx
-            },
-            bios_sound: {
-                let (tx, rx) = channel();
-                proxies.rog_bios.connect_notify_post_boot_sound(tx)?;
-                rx
-            },
-        })
-    }
-}
-
 /// This is the main way to communicate with the DBUS interface
 pub struct RogDbusClient<'a> {
     proxies: DbusProxies<'a>,
-    signals: Signals,
 }
 
 impl<'a> RogDbusClient<'a> {
     #[inline]
-    pub fn new() -> Result<(Self, Connection)> {
-        let (proxies, conn) = DbusProxies::new()?;
-        let signals = Signals::new(&proxies)?;
-
-        Ok((RogDbusClient { proxies, signals }, conn))
+    pub async fn new() -> Result<(RogDbusClient<'a>, Connection)> {
+        let (proxies, conn) = DbusProxies::new().await?;
+        Ok((RogDbusClient { proxies }, conn))
     }
 
     pub fn proxies(&self) -> &DbusProxies {
         &self.proxies
     }
-
-    pub fn signals(&self) -> &Signals {
-        &self.signals
-    }
-
-    pub fn setup_recv(&'a self, conn: Connection) -> SignalReceiver<'a, 'a> {
-        let mut recv = SignalReceiver::new(conn);
-        recv.receive_for(self.proxies.anime.proxy());
-        recv.receive_for(self.proxies.led.proxy());
-        recv.receive_for(self.proxies.charge.proxy());
-        recv.receive_for(self.proxies.profile.proxy());
-        recv.receive_for(self.proxies.rog_bios.proxy());
-        recv.receive_for(self.proxies.supported.proxy());
-        recv
-    }
 }

rog-dbus/src/zbus_anime.rs

@@ -1,12 +1,11 @@
 use rog_anime::{AnimeDataBuffer, AnimePowerStates};
-use std::sync::mpsc::Sender;
-use zbus::{dbus_proxy, Connection, Result};
+use zbus_macros::dbus_proxy;
 
 #[dbus_proxy(
     interface = "org.asuslinux.Daemon",
     default_path = "/org/asuslinux/Anime"
 )]
-trait Daemon {
+trait Anime {
     /// Set whether the AniMe will show boot, suspend, or off animations
     fn set_boot_on_off(&self, status: bool) -> zbus::Result<()>;
 
@@ -17,7 +16,7 @@ trait Daemon {
     fn set_on_off(&self, status: bool) -> zbus::Result<()>;
 
     /// Writes a data stream of length. Will force system thread to exit until it is restarted
-    fn write(&self, input: &[u8]) -> zbus::Result<()>;
+    fn write(&self, input: AnimeDataBuffer) -> zbus::Result<()>;
 
     /// Get status of if the AniMe LEDs are on
     #[dbus_proxy(property)]
@@ -29,61 +28,5 @@ trait Daemon {
 
     /// Notify listeners of the status of AniMe LED power and factory system-status animations
     #[dbus_proxy(signal)]
-    fn notify_power_states(&self, data: AnimePowerStates) -> zbus::Result<()>;
-}
-
-pub struct AnimeProxy<'a>(DaemonProxy<'a>);
-
-impl<'a> AnimeProxy<'a> {
-    #[inline]
-    pub fn new(conn: &Connection) -> Result<Self> {
-        Ok(AnimeProxy(DaemonProxy::new(conn)?))
-    }
-
-    #[inline]
-    pub fn proxy(&self) -> &DaemonProxy<'a> {
-        &self.0
-    }
-
-    /// Set whether the AniMe will show boot, suspend, or off animations
-    #[inline]
-    pub fn set_system_animations(&self, on: bool) -> Result<()> {
-        self.0.set_boot_on_off(on)
-    }
-
-    /// Set whether the AniMe is displaying images/data
-    #[inline]
-    pub fn set_led_power(&self, on: bool) -> Result<()> {
-        self.0.set_on_off(on)
-    }
-
-    /// Writes a data stream of length. Will force system thread to exit until it is restarted
-    #[inline]
-    pub fn write(&self, input: AnimeDataBuffer) -> Result<()> {
-        self.0.write(input.get())
-    }
-
-    /// Get status of if the AniMe LEDs are on
-    #[inline]
-    pub fn awake_enabled(&self) -> Result<bool> {
-        self.0.awake_enabled()
-    }
-
-    /// Get the status of if factory system-status animations are enabled
-    #[inline]
-    pub fn boot_enabled(&self) -> Result<bool> {
-        self.0.boot_enabled()
-    }
-
-    #[inline]
-    pub fn connect_notify_power_states(
-        &self,
-        send: Sender<AnimePowerStates>,
-    ) -> zbus::fdo::Result<()> {
-        self.0.connect_notify_power_states(move |data| {
-            send.send(data)
-                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-            Ok(())
-        })
-    }
+    fn power_states(&self, data: AnimePowerStates) -> zbus::Result<()>;
 }

rog-dbus/src/zbus_charge.rs

@@ -19,15 +19,13 @@
 //!
 //! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
 
-use std::sync::mpsc::Sender;
-
-use zbus::{dbus_proxy, Connection, Result};
+use zbus_macros::dbus_proxy;
 
 #[dbus_proxy(
     interface = "org.asuslinux.Daemon",
     default_path = "/org/asuslinux/Charge"
 )]
-trait Daemon {
+trait Charge {
     /// Limit method
     fn limit(&self) -> zbus::Result<i16>;
 
@@ -36,38 +34,5 @@ trait Daemon {
 
     /// NotifyCharge signal
     #[dbus_proxy(signal)]
-    fn notify_charge(&self, limit: u8) -> zbus::Result<()>;
-}
-
-pub struct ChargeProxy<'a>(DaemonProxy<'a>);
-
-impl<'a> ChargeProxy<'a> {
-    #[inline]
-    pub fn new(conn: &Connection) -> Result<Self> {
-        Ok(ChargeProxy(DaemonProxy::new(conn)?))
-    }
-
-    #[inline]
-    pub fn proxy(&self) -> &DaemonProxy<'a> {
-        &self.0
-    }
-
-    #[inline]
-    pub fn write_limit(&self, level: u8) -> Result<()> {
-        self.0.set_limit(level)
-    }
-
-    #[inline]
-    pub fn get_limit(&self) -> Result<i16> {
-        self.0.limit()
-    }
-
-    #[inline]
-    pub fn connect_notify_charge(&self, send: Sender<u8>) -> zbus::fdo::Result<()> {
-        self.0.connect_notify_charge(move |data| {
-            send.send(data)
-                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-            Ok(())
-        })
-    }
+    fn notify_charge(&self, limit: u8) -> zbus::Result<u8>;
 }

rog-dbus/src/zbus_led.rs

@@ -19,11 +19,10 @@
 //!
 //! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
 
-use std::sync::mpsc::Sender;
+use zbus::{blocking::Connection, Result};
+use zbus_macros::dbus_proxy;
 
-use zbus::{dbus_proxy, Connection, Result};
-
-use rog_aura::{AuraEffect, KeyColourArray, LedBrightness, LedPowerStates};
+use rog_aura::{usb::AuraControl, AuraEffect, KeyColourArray, LedBrightness};
 
 const BLOCKING_TIME: u64 = 40; // 100ms = 10 FPS, max 50ms = 20 FPS, 40ms = 25 FPS
 
@@ -31,7 +30,7 @@ const BLOCKING_TIME: u64 = 40; // 100ms = 10 FPS, max 50ms = 20 FPS, 40ms = 25 F
     interface = "org.asuslinux.Daemon",
     default_path = "/org/asuslinux/Led"
 )]
-trait Daemon {
+trait Led {
     /// NextLedMode method
     fn next_led_mode(&self) -> zbus::Result<()>;
 
@@ -50,18 +49,16 @@ trait Daemon {
     /// SetLedMode method
     fn set_led_mode(&self, effect: &AuraEffect) -> zbus::Result<()>;
 
-    /// SetAwakeEnabled method
-    fn set_awake_enabled(&self, enabled: bool) -> zbus::Result<()>;
+    fn set_leds_enabled(&self, enabled: Vec<AuraControl>) -> zbus::Result<()>;
 
-    /// SetSleepEnabled method
-    fn set_sleep_enabled(&self, enabled: bool) -> zbus::Result<()>;
+    fn set_leds_disabled(&self, disabled: Vec<AuraControl>) -> zbus::Result<()>;
 
     /// NotifyLed signal
     #[dbus_proxy(signal)]
     fn notify_led(&self, data: AuraEffect) -> zbus::Result<()>;
 
     #[dbus_proxy(signal)]
-    fn notify_power_states(&self, data: LedPowerStates) -> zbus::Result<()>;
+    fn notify_power_states(&self, data: Vec<AuraControl>) -> zbus::Result<()>;
 
     /// LedBrightness property
     #[dbus_proxy(property)]
@@ -76,85 +73,22 @@ trait Daemon {
     fn led_modes(&self) -> zbus::Result<String>;
 
     #[dbus_proxy(property)]
-    fn awake_enabled(&self) -> zbus::Result<bool>;
-
-    #[dbus_proxy(property)]
-    fn sleep_enabled(&self) -> zbus::Result<bool>;
+    fn leds_enabled(&self) -> zbus::Result<Vec<u8>>;
 }
 
-pub struct LedProxy<'a>(DaemonProxy<'a>);
+pub struct LedProxyPerkey<'a>(LedProxyBlocking<'a>);
 
-impl<'a> LedProxy<'a> {
+impl<'a> LedProxyPerkey<'a> {
     #[inline]
     pub fn new(conn: &Connection) -> Result<Self> {
-        Ok(LedProxy(DaemonProxy::new(conn)?))
+        Ok(LedProxyPerkey(LedProxyBlocking::new(conn)?))
     }
 
     #[inline]
-    pub fn proxy(&self) -> &DaemonProxy<'a> {
+    pub fn proxy(&self) -> &LedProxyBlocking<'a> {
         &self.0
     }
 
-    #[inline]
-    pub fn get_led_brightness(&self) -> Result<i16> {
-        self.0.led_brightness()
-    }
-
-    #[inline]
-    pub fn set_led_brightness(&self, level: LedBrightness) -> Result<()> {
-        self.0.set_brightness(level)?;
-        Ok(())
-    }
-
-    /// Set the keyboard LED to enabled while the device is awake
-    #[inline]
-    pub fn set_awake_enabled(&self, enabled: bool) -> Result<()> {
-        self.0.set_awake_enabled(enabled)?;
-        Ok(())
-    }
-
-    /// Set the keyboard LED suspend animation to enabled while the device is suspended
-    #[inline]
-    pub fn set_sleep_enabled(&self, enabled: bool) -> Result<()> {
-        self.0.set_sleep_enabled(enabled)?;
-        Ok(())
-    }
-
-    #[inline]
-    pub fn next_led_mode(&self) -> Result<()> {
-        self.0.next_led_mode()
-    }
-
-    #[inline]
-    pub fn prev_led_mode(&self) -> Result<()> {
-        self.0.prev_led_mode()
-    }
-
-    #[inline]
-    pub fn next_led_brightness(&self) -> Result<()> {
-        self.0.next_led_brightness()
-    }
-
-    #[inline]
-    pub fn prev_led_brightness(&self) -> Result<()> {
-        self.0.prev_led_brightness()
-    }
-
-    #[inline]
-    pub fn set_led_mode(&self, mode: &AuraEffect) -> Result<()> {
-        self.0.set_led_mode(mode)
-    }
-
-    #[inline]
-    pub fn awake_enabled(&self) -> Result<bool> {
-        self.0.awake_enabled()
-    }
-
-    #[inline]
-    pub fn sleep_enabled(&self) -> Result<bool> {
-        self.0.sleep_enabled()
-    }
-
     /// Write a single colour block.
     ///
     /// Intentionally blocks for 10ms after sending to allow the block to
@@ -186,25 +120,4 @@ impl<'a> LedProxy<'a> {
         // self.0.set_led_mode(&serde_json::to_string(&mode).unwrap())
         Ok(())
     }
-
-    #[inline]
-    pub fn connect_notify_led(&self, send: Sender<AuraEffect>) -> zbus::fdo::Result<()> {
-        self.0.connect_notify_led(move |data| {
-            send.send(data)
-                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-            Ok(())
-        })
-    }
-
-    #[inline]
-    pub fn connect_notify_power_states(
-        &self,
-        send: Sender<LedPowerStates>,
-    ) -> zbus::fdo::Result<()> {
-        self.0.connect_notify_power_states(move |data| {
-            send.send(data)
-                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-            Ok(())
-        })
-    }
 }

rog-dbus/src/zbus_profile.rs

@@ -19,19 +19,17 @@
 //!
 //! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
 
-use std::sync::mpsc::Sender;
-
 use rog_profiles::{
     fan_curve_set::{CurveData, FanCurveSet},
     Profile,
 };
-use zbus::{dbus_proxy, Connection, Result};
+use zbus_macros::dbus_proxy;
 
 #[dbus_proxy(
     interface = "org.asuslinux.Daemon",
     default_path = "/org/asuslinux/Profile"
 )]
-trait Daemon {
+trait Profile {
     /// Get the fan-curve data for the currently active Profile
     fn fan_curve_data(&self, profile: Profile) -> zbus::Result<FanCurveSet>;
 
@@ -66,73 +64,5 @@ trait Daemon {
 
     /// NotifyProfile signal
     #[dbus_proxy(signal)]
-    fn notify_profile(&self, profile: Profile) -> zbus::Result<()>;
-}
-
-pub struct ProfileProxy<'a>(DaemonProxy<'a>);
-
-impl<'a> ProfileProxy<'a> {
-    #[inline]
-    pub fn new(conn: &Connection) -> Result<Self> {
-        Ok(ProfileProxy(DaemonProxy::new(conn)?))
-    }
-
-    #[inline]
-    pub fn proxy(&self) -> &DaemonProxy<'a> {
-        &self.0
-    }
-
-    #[inline]
-    pub fn active_profile(&self) -> zbus::Result<Profile> {
-        self.0.active_profile()
-    }
-
-    #[inline]
-    pub fn enabled_fan_profiles(&self) -> zbus::Result<Vec<Profile>> {
-        self.0.enabled_fan_profiles()
-    }
-
-    #[inline]
-    pub fn fan_curve_data(&self, profile: Profile) -> zbus::Result<FanCurveSet> {
-        self.0.fan_curve_data(profile)
-    }
-
-    #[inline]
-    pub fn next_profile(&self) -> Result<()> {
-        self.0.next_profile()
-    }
-
-    #[inline]
-    pub fn profiles(&self) -> Result<Vec<Profile>> {
-        self.0.profiles()
-    }
-
-    #[inline]
-    pub fn set_active_profile(&self, profile: Profile) -> zbus::Result<()> {
-        self.0.set_active_profile(profile)
-    }
-
-    #[inline]
-    pub fn set_fan_curve_enabled(&self, profile: Profile, enabled: bool) -> zbus::Result<()> {
-        self.0.set_fan_curve_enabled(profile, enabled)
-    }
-
-    #[inline]
-    pub fn set_fan_curve(&self, curve: CurveData, profile: Profile) -> zbus::Result<()> {
-        self.0.set_fan_curve(profile, curve)
-    }
-
-    #[inline]
-    pub fn set_active_curve_to_defaults(&self) -> zbus::Result<()> {
-        self.0.set_active_curve_to_defaults()
-    }
-
-    #[inline]
-    pub fn connect_notify_profile(&self, send: Sender<Profile>) -> zbus::fdo::Result<()> {
-        self.0.connect_notify_profile(move |data| {
-            send.send(data)
-                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-            Ok(())
-        })
-    }
+    fn notify_profile(&self, profile: Profile) -> zbus::Result<Profile>;
 }

rog-dbus/src/zbus_rogbios.rs

@@ -19,15 +19,13 @@
 //!
 //! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
 
-use std::sync::mpsc::Sender;
-
-use zbus::{dbus_proxy, Connection, Result};
+use zbus_macros::dbus_proxy;
 
 #[dbus_proxy(
     interface = "org.asuslinux.Daemon",
     default_path = "/org/asuslinux/RogBios"
 )]
-trait Daemon {
+trait RogBios {
     /// DedicatedGraphicMode method
     fn dedicated_graphic_mode(&self) -> zbus::Result<i16>;
 
@@ -46,60 +44,5 @@ trait Daemon {
 
     /// NotifyPostBootSound signal
     #[dbus_proxy(signal)]
-    fn notify_post_boot_sound(&self, dedicated: bool) -> zbus::Result<()>;
-}
-
-pub struct RogBiosProxy<'a>(DaemonProxy<'a>);
-
-impl<'a> RogBiosProxy<'a> {
-    #[inline]
-    pub fn new(conn: &Connection) -> Result<Self> {
-        Ok(RogBiosProxy(DaemonProxy::new(conn)?))
-    }
-
-    #[inline]
-    pub fn proxy(&self) -> &DaemonProxy<'a> {
-        &self.0
-    }
-
-    #[inline]
-    pub fn get_dedicated_gfx(&self) -> Result<i16> {
-        self.0.dedicated_graphic_mode()
-    }
-
-    #[inline]
-    pub fn set_dedicated_gfx(&self, on: bool) -> Result<()> {
-        self.0.set_dedicated_graphic_mode(on)
-    }
-
-    #[inline]
-    pub fn get_post_sound(&self) -> Result<i16> {
-        self.0.post_boot_sound()
-    }
-
-    #[inline]
-    pub fn set_post_sound(&self, on: bool) -> Result<()> {
-        self.0.set_post_boot_sound(on)
-    }
-
-    #[inline]
-    pub fn connect_notify_dedicated_graphic_mode(
-        &self,
-        send: Sender<bool>,
-    ) -> zbus::fdo::Result<()> {
-        self.0.connect_notify_dedicated_graphic_mode(move |data| {
-            send.send(data)
-                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-            Ok(())
-        })
-    }
-
-    #[inline]
-    pub fn connect_notify_post_boot_sound(&self, send: Sender<bool>) -> zbus::fdo::Result<()> {
-        self.0.connect_notify_post_boot_sound(move |data| {
-            send.send(data)
-                .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
-            Ok(())
-        })
-    }
+    fn notify_post_boot_sound(&self, sound: bool) -> zbus::Result<()>;
 }

rog-dbus/src/zbus_supported.rs

@@ -20,32 +20,13 @@
 //! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
 
 use rog_supported::SupportedFunctions;
-use zbus::{dbus_proxy, Connection, Result};
+use zbus_macros::dbus_proxy;
 
 #[dbus_proxy(
     interface = "org.asuslinux.Daemon",
     default_path = "/org/asuslinux/Supported"
 )]
-trait Daemon {
+trait Supported {
     /// SupportedFunctions method
     fn supported_functions(&self) -> zbus::Result<SupportedFunctions>;
 }
-
-pub struct SupportProxy<'a>(DaemonProxy<'a>);
-
-impl<'a> SupportProxy<'a> {
-    #[inline]
-    pub fn new(conn: &Connection) -> Result<Self> {
-        Ok(SupportProxy(DaemonProxy::new(conn)?))
-    }
-
-    #[inline]
-    pub fn proxy(&self) -> &DaemonProxy<'a> {
-        &self.0
-    }
-
-    #[inline]
-    pub fn get_supported_functions(&self) -> Result<SupportedFunctions> {
-        self.0.supported_functions()
-    }
-}

rog-profiles/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rog_profiles"
-version = "1.1.2"
+version = "1.1.3"
 authors = ["Luke D. Jones <luke@ljones.dev>"]
 edition = "2018"
 
@@ -13,5 +13,5 @@ udev = "^0.6"
 serde = "^1.0"
 serde_derive = "^1.0"
 
-zvariant = { version = "^2.6", optional = true }
-zvariant_derive = { version = "^2.6", optional = true }
+zvariant = { version = "^3.0", optional = true }
+zvariant_derive = { version = "^3.0", optional = true }

rog-profiles/src/error.rs

@@ -12,6 +12,7 @@ pub enum ProfileError {
     ParseFanCurveDigit(std::num::ParseIntError),
     /// (pwm/temp, prev, next)
     ParseFanCurvePrevHigher(&'static str, u8, u8),
+    ParseFanCurvePercentOver100(u8),
     // Zbus(zbus::Error),
 }
 
@@ -34,7 +35,9 @@ impl fmt::Display for ProfileError {
                 "Invalid {}, previous value {} is higher than next value {}",
                 part, prev, next
             ),
-            // Error::Zbus(detail) => write!(f, "Zbus error: {}", detail),
+            ProfileError::ParseFanCurvePercentOver100(value) => {
+                write!(f, "Invalid percentage, {} is higher than 100", value)
+            } // Error::Zbus(detail) => write!(f, "Zbus error: {}", detail),
         }
     }
 }

rog-profiles/src/fan_curve_set.rs

@@ -37,14 +37,24 @@ pub struct CurveData {
 impl std::str::FromStr for CurveData {
     type Err = ProfileError;
 
+    /// Parse a string to the correct values that the fan curve kernel driver expects
+    ///
+    /// If the fan curve is given with percentage char '%' then the fan power values are converted
+    /// otherwise the expected fan power range is 0-255.
+    ///
+    /// Temperature range is 0-255 in degrees C. You don't want to be setting over 100.
     fn from_str(input: &str) -> Result<Self, Self::Err> {
         let mut temp = [0u8; 8];
         let mut pwm = [0u8; 8];
         let mut temp_prev = 0;
         let mut pwm_prev = 0;
+        let mut percentages = false;
 
         for (index, value) in input.split(',').enumerate() {
             for (select, num) in value.splitn(2, |c| c == 'c' || c == ':').enumerate() {
+                if num.contains('%') {
+                    percentages = true;
+                }
                 let r = num.trim_matches(|c| c == 'c' || c == ':' || c == '%');
                 let r = r.parse::<u8>().map_err(ProfileError::ParseFanCurveDigit)?;
 
@@ -59,15 +69,22 @@ impl std::str::FromStr for CurveData {
                     temp_prev = r;
                     temp[index] = r;
                 } else {
-                    if pwm_prev > r {
+                    let mut p = r;
+                    if percentages {
+                        if r > 100 {
+                            return Err(ProfileError::ParseFanCurvePercentOver100(r));
+                        }
+                        p = (p as f32 * 2.55).round() as u8;
+                    }
+                    if pwm_prev > p {
                         return Err(ProfileError::ParseFanCurvePrevHigher(
                             "percentage",
                             pwm_prev,
-                            r,
+                            p,
                         ));
                     }
-                    pwm_prev = r;
-                    pwm[index] = r;
+                    pwm_prev = p;
+                    pwm[index] = p;
                 }
             }
         }
@@ -205,7 +222,7 @@ mod tests {
                 .unwrap();
         assert_eq!(curve.fan, FanCurvePU::CPU);
         assert_eq!(curve.temp, [30, 49, 59, 69, 79, 89, 99, 109]);
-        assert_eq!(curve.pwm, [1, 2, 3, 4, 31, 49, 56, 58]);
+        assert_eq!(curve.pwm, [3, 5, 8, 10, 79, 125, 143, 148]);
     }
 
     #[test]

rog-profiles/src/lib.rs

@@ -219,7 +219,9 @@ impl FanCurveProfiles {
     }
 
     /// Write the curves for the selected profile to the device. If the curve is
-    /// in the enabled list it will become active.
+    /// in the enabled list it will become active. If the curve is zeroed it will be initialised
+    /// to a default read from the system.
+    // TODO: Make this return an error if curve is zeroed
     pub fn write_profile_curve_to_platform(
         &mut self,
         profile: Profile,

rog-supported/Cargo.toml

@@ -13,5 +13,5 @@ edition = "2018"
 rog_aura = { path = "../rog-aura" }
 serde = "^1.0"
 serde_derive = "^1.0"
-zvariant = "^2.6"
-zvariant_derive = "^2.6"
+zvariant = "^3.0"
+zvariant_derive = "^3.0"

rog-supported/src/lib.rs

@@ -1,6 +1,6 @@
 pub static VERSION: &str = env!("CARGO_PKG_VERSION");
 
-use rog_aura::AuraModeNum;
+use rog_aura::{AuraModeNum, AuraZone};
 use serde_derive::{Deserialize, Serialize};
 use std::fmt;
 use zvariant_derive::Type;
@@ -32,7 +32,7 @@ pub struct PlatformProfileFunctions {
 pub struct LedSupportedFunctions {
     pub brightness_set: bool,
     pub stock_led_modes: Vec<AuraModeNum>,
-    pub multizone_led_mode: bool,
+    pub multizone_led_mode: Vec<AuraZone>,
     pub per_key_led_mode: bool,
 }
 
@@ -80,7 +80,7 @@ impl fmt::Display for LedSupportedFunctions {
         writeln!(f, "LED:")?;
         writeln!(f, "\tBrightness control: {}", self.brightness_set)?;
         writeln!(f, "\tStock LED modes: {:?}", self.stock_led_modes)?;
-        writeln!(f, "\tMultizone LED mode: {}", self.multizone_led_mode)?;
+        writeln!(f, "\tMultizone LED mode: {:?}", self.multizone_led_mode)?;
         writeln!(f, "\tPer key LED mode: {}", self.per_key_led_mode)
     }
 }

tmp-aura-examples/aura-rgb-ball.rs

@@ -1,5 +1,5 @@
 use rog_aura::{GX502Layout, Key, KeyColourArray, KeyLayout};
-use rog_dbus::RogDbusClient;
+use rog_dbus::RogDbusClientBlocking;
 use std::collections::LinkedList;
 
 #[derive(Debug, Clone)]
@@ -52,7 +52,7 @@ impl Ball {
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let (dbus, _) = RogDbusClient::new()?;
+    let (dbus, _) = RogDbusClientBlocking::new()?;
 
     let mut colours = KeyColourArray::new();
 
@@ -60,8 +60,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let mut balls = [Ball::new(2, 1, 12), Ball::new(4, 6, 12)];
 
-    dbus.proxies().led().init_effect()?;
-
     let rows = layout.get_rows();
     loop {
         for (n, ball) in balls.iter_mut().enumerate() {