Fix up colour sliders

- Fixup colour sliders for UI
- Correctly drop tokio runtime

.cargo-husky/hooks/pre-commit

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+set -e
+
+echo 'find -name \*.slint | xargs slint-tr-extractor -o rog-control-center/translations/en/rog-control-center.po'
+find -name \*.slint | xargs slint-tr-extractor -o rog-control-center/translations/en/rog-control-center.po
+
+echo '+cargo +nightly fmt --all -- --check'
+cargo +nightly fmt --all -- --check
+
+echo '+cargo clippy --all -- -D warnings'
+cargo clippy --all -- -D warnings
+
+echo '+cargo test --all'
+cargo test --all
+
+echo '+cargo cranky'
+cargo cranky

.cargo-husky/hooks/pre-push

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -e
+
+echo '+cargo +nightly fmt --all -- --check'
+cargo +nightly fmt --all -- --check
+echo '+cargo clippy --all -- -D warnings'
+cargo clippy --all -- -D warnings
+echo '+cargo cranky'
+cargo cranky

.editorconfig

@@ -0,0 +1,23 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.rs]
+indent_size = 4
+
+[tests/**/*.rs]
+charset = utf-8
+end_of_line = unset
+indent_size = unset
+indent_style = unset
+trim_trailing_whitespace = unset
+insert_final_newline = unset

.gitignore

@@ -1,2 +1,21 @@
 /target
-vendor.tar.xz
+vendor.tar.xz
+cargo-config
+.idea
+vendor
+vendor-*
+vendor_*
+.vscode-ctags
+.vscode
+.~lock.*
+*.ods#
+
+# gnome extension
+node-modules
+bindings/ts/*.d.ts
+bindings/ts/*.js.map
+desktop-extensions/gnome*/dist
+desktop-extensions/gnome*/@types/gir-generated
+desktop-extensions/gnome*/node_modules
+desktop-extensions/gnome*/schemas/gschemas.compiled
+desktop-extensions/gnome*/*.zip

.gitlab-ci.yml

@@ -1,26 +1,85 @@
-image: rustdocker/rust:stable
+image: rust:latest
+
+.rust_cache: &rust_cache
+  cache:
+    # key: $CI_COMMIT_REF_SLUG
+    paths:
+      # Don't include `incremental` to save space
+      # Debug
+      - target/debug/build/
+      - target/debug/deps/
+      - target/debug/.fingerprint/
+      - target/debug/.cargo-lock
+      # Release
+      - target/release/build/
+      - target/release/deps/
+      - target/release/.fingerprint/
+      - target/release/.cargo-lock
 
 before_script:
-  - apt-get update -qq && apt-get install -y -qq libdbus-1-dev libclang-dev libudev-dev
+  - apt-get update -qq && apt-get install -y -qq libinput-dev libseat-dev libudev-dev libgtk-3-dev grep llvm clang libclang-dev libsdl2-dev libsdl2-gfx-dev
 
 stages:
-    - test
-    - build
+  - format
+  - check
+  - test
+  - release
+  - deploy
+
+format:
+  except:
+    - tags
+  <<: *rust_cache
+  script:
+    - echo "nightly" > rust-toolchain
+    - rustup component add rustfmt
+    - cargo fmt --check
+
+check:
+  except:
+    - tags
+  <<: *rust_cache
+  script:
+    - rustup component add clippy
+    - cargo check
+    # deny currently catches too much
+    #- cargo install cargo-deny && cargo deny
+    - cargo install cargo-cranky && cargo cranky
 
 test:
+  except:
+    - tags
+  <<: *rust_cache
   script:
-    - cargo check #+nightly check --features "clippy"
+    - mkdir -p .git/hooks > /dev/null
+    - cargo test --all
 
-build:
+release:
   only:
-    - next
+    - tags
+  <<: *rust_cache
   script:
+    - cargo install cargo-vendor-filterer
     - make && make vendor
   artifacts:
     paths:
-    - vendor-$(grep -P 'version = "(\d.\d.\d)"' asus-nb-ctrl/Cargo.toml | cut -d'"' -f2).tar.xz
-    - cargo-config
+      - vendor_asusctl*.tar.xz
+      - cargo-config
+
+pages:
+  stage: deploy
+  only:
+    - tags
+  <<: *rust_cache
+  script:
+    - cargo doc --document-private-items --no-deps --workspace
+    - rm -rf public
+    - mkdir public
+    - cp -R target/doc/* public
+    - cp extra/index.html public
+  artifacts:
+    paths:
+      - public
 
 variables:
   GIT_SUBMODULE_STRATEGY: normal
-

.gitlab/issue_templates/default.md

@@ -0,0 +1,32 @@
+## Issue description
+
+(** I can not support distros which are outdated by default. This includes Ubuntu at least 50% of the time, and definitely includes Mint. **)
+(Summarize the bug encountered)
+
+## Steps to reproduce
+
+(How can the issue be reproduced)
+
+## What is the current bug behavior?
+
+(What actually happens)
+
+## What is the expected correct behavior?
+
+(What you should see instead)
+
+## Relevant logs and/or screenshots
+
+(run `journalctl -b -u asusd > ~/asusd.log` and attach `~/asusd.log`)
+
+(Paste any relevant logs - use code blocks (```) to format console output, logs, and code, as
+it's very hard to read otherwise.)
+
+## System details
+
+- Distro:
+- Kernel: (`uname -r`)
+- Desktop:
+- Xorg or wayland: ??
+
+/label ~bug ~reproducable ~needs-investigation

Cargo.toml

@@ -1,16 +1,102 @@
 [workspace]
-members = ["asus-nb-ctrl", "asus-nb"]
+members = [
+    "asusctl",
+    "asusd",
+    "asusd-user",
+    "config-traits",
+    "cpuctl",
+    "dmi-id",
+    "rog-platform",
+    "rog-dbus",
+    "rog-anime",
+    "rog-aura",
+    "rog-profiles",
+    "rog-control-center",
+    "rog-slash",
+    "simulators",
+]
+default-members = [
+    "asusctl",
+    "asusd",
+    "asusd-user",
+    "cpuctl",
+    "rog-control-center",
+]
+resolver = "2"
+
+[workspace.package]
+version = "6.0.3"
+rust-version = "1.77"
+license = "MPL-2.0"
+readme = "README.md"
+authors = ["Luke <luke@ljones.dev>"]
+repository = "https://gitlab.com/asus-linux/asusctl"
+homepage = "https://gitlab.com/asus-linux/asusctl"
+description = "Laptop feature control for ASUS ROG laptops and others"
+edition = "2021"
+
+[workspace.dependencies]
+tokio = { version = "^1.36.0", default-features = false, features = [
+    "macros",
+    "sync",
+    "time",
+    "rt-multi-thread",
+] }
+concat-idents = "^1.1"
+dirs = "^4.0"
+smol = "^1.3"
+mio = "0.8.11"
+
+zbus = "4.1"
+logind-zbus = { version = "4.0.2" } #, default-features = false, features = ["non_blocking"] }
+
+serde = "^1.0"
+serde_derive = "^1.0"
+ron = "*"
+typeshare = "1.0.0"
+
+log = "^0.4"
+env_logger = "^0.10.0"
+
+glam = { version = "^0.22", features = ["serde"] }
+gumdrop = "^0.8"
+udev = { version = "^0.8", features = ["mio"] }
+rusb = "^0.9"
+inotify = "^0.10.0"
+
+png_pong = "^0.8"
+pix = "^0.13"
+tinybmp = "^0.4.0"
+gif = "^0.12.0"
+
+versions = "6.2"
+
+notify-rust = { git = "https://github.com/flukejones/notify-rust.git", rev = "54176413b81189a3e4edbdc20a0b4f7e2e35c063", default-features = false, features = [
+    "z",
+] }
 
 [profile.release]
-lto = true
+# thin = 57s, asusd = 9.0M
+# fat = 72s, asusd = 6.4M
+lto = "fat"
 debug = false
 opt-level = 3
 panic = "abort"
+codegen-units = 1
 
 [profile.dev]
-debug = false
 opt-level = 1
+codegen-units = 16
+
+[profile.dev.package."*"]
+opt-level = 1
+codegen-units = 16
 
 [profile.bench]
 debug = false
-opt-level = 3
+opt-level = 3
+
+[workspace.dependencies.cargo-husky]
+version = "1"
+default-features = false
+features = ["user-hooks"]

Cranky.toml

@@ -0,0 +1,121 @@
+# https://github.com/ericseppanen/cargo-cranky
+# cargo install cargo-cranky && cargo cranky
+
+error = [
+  "clippy::all",
+  "clippy::await_holding_lock",
+  "clippy::bool_to_int_with_if",
+  "clippy::char_lit_as_u8",
+  "clippy::checked_conversions",
+  "clippy::dbg_macro",
+  "clippy::debug_assert_with_mut_call",
+  "clippy::disallowed_methods",
+  "clippy::disallowed_script_idents",
+  "clippy::doc_link_with_quotes",
+  "clippy::doc_markdown",
+  "clippy::empty_enum",
+  "clippy::enum_glob_use",
+  "clippy::equatable_if_let",
+  "clippy::exit",
+  "clippy::expl_impl_clone_on_copy",
+  "clippy::explicit_deref_methods",
+  "clippy::explicit_into_iter_loop",
+  "clippy::explicit_iter_loop",
+  "clippy::fallible_impl_from",
+  "clippy::filter_map_next",
+  "clippy::flat_map_option",
+  "clippy::float_cmp_const",
+  "clippy::fn_params_excessive_bools",
+  "clippy::fn_to_numeric_cast_any",
+  "clippy::from_iter_instead_of_collect",
+  "clippy::if_let_mutex",
+  "clippy::implicit_clone",
+  "clippy::imprecise_flops",
+  "clippy::index_refutable_slice",
+  "clippy::inefficient_to_string",
+  "clippy::invalid_upcast_comparisons",
+  "clippy::iter_not_returning_iterator",
+  "clippy::iter_on_empty_collections",
+  "clippy::iter_on_single_items",
+  "clippy::large_digit_groups",
+  "clippy::large_stack_arrays",
+  "clippy::large_types_passed_by_value",
+  "clippy::let_unit_value",
+  "clippy::linkedlist",
+  "clippy::lossy_float_literal",
+  "clippy::macro_use_imports",
+  "clippy::manual_assert",
+  "clippy::manual_instant_elapsed",
+  "clippy::manual_ok_or",
+  "clippy::manual_string_new",
+  "clippy::map_err_ignore",
+  "clippy::map_flatten",
+  "clippy::map_unwrap_or",
+  "clippy::match_on_vec_items",
+  "clippy::match_same_arms",
+  "clippy::match_wild_err_arm",
+  "clippy::match_wildcard_for_single_variants",
+  "clippy::mem_forget",
+  "clippy::mismatched_target_os",
+  "clippy::mismatching_type_param_order",
+  "clippy::missing_enforced_import_renames",
+  # "clippy::missing_errors_doc",
+  "clippy::missing_safety_doc",
+  "clippy::mut_mut",
+  "clippy::mutex_integer",
+  "clippy::needless_borrow",
+  "clippy::needless_continue",
+  "clippy::needless_for_each",
+  "clippy::needless_pass_by_value",
+  "clippy::negative_feature_names",
+  "clippy::nonstandard_macro_braces",
+  "clippy::option_option",
+  "clippy::path_buf_push_overwrite",
+  "clippy::ptr_as_ptr",
+  "clippy::rc_mutex",
+  "clippy::ref_option_ref",
+  "clippy::rest_pat_in_fully_bound_structs",
+  "clippy::same_functions_in_if_condition",
+  "clippy::semicolon_if_nothing_returned",
+  "clippy::single_match_else",
+  "clippy::str_to_string",
+  "clippy::string_add_assign",
+  "clippy::string_add",
+  "clippy::string_lit_as_bytes",
+  "clippy::string_to_string",
+  "clippy::todo",
+  "clippy::trailing_empty_array",
+  "clippy::trait_duplication_in_bounds",
+  "clippy::unimplemented",
+  "clippy::unnecessary_wraps",
+  "clippy::unnested_or_patterns",
+  "clippy::unused_peekable",
+  "clippy::unused_rounding",
+  # "clippy::unused_self",
+  "clippy::useless_transmute",
+  "clippy::verbose_file_reads",
+  "clippy::zero_sized_map_values",
+  "elided_lifetimes_in_paths",
+  "future_incompatible",
+  "nonstandard_style",
+  "rust_2018_idioms",
+  "rust_2021_prelude_collisions",
+  "rustdoc::missing_crate_level_docs",
+  "semicolon_in_expressions_from_macros",
+  "trivial_numeric_casts",
+  "unused_extern_crates",
+  "unused_import_braces",
+  "unused_lifetimes",
+]
+
+allow = [
+  # TODO(emilk): enable more lints
+  "clippy::cloned_instead_of_copied",
+  "clippy::derive_partial_eq_without_eq",
+  "clippy::type_complexity",
+  "clippy::undocumented_unsafe_blocks",
+  "trivial_casts",
+  "unsafe_op_in_unsafe_fn",               # `unsafe_op_in_unsafe_fn` may become the default in future Rust versions: https://github.com/rust-lang/rust/issues/71668
+  "unused_qualifications",
+]
+

MANUAL.md

@@ -0,0 +1,446 @@
+# asusctrl manual
+
+**NOTE:** this manual is in need of an update in some places. If you find issues please file issue reports.
+
+`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.
+
+## Programs Available
+
+- `asusd`: The main system daemon. It is autostarted by a udev rule and systemd unit.
+- `asusd-user`: The user level daemon. Currently will run an anime sequence, with RGB keyboard sequences soon.
+- `asusctl`: The CLI for interacting with the system daemon
+
+## `asusd`
+
+`asusd` is the main system-level daemon which will control/load/save various settings in a safe way for the user, along with exposing a _safe_ dbus interface for these interactions. This section covers only the daemon plus the various configuration file options.
+
+The functionality that `asusd` exposes is:
+
+- anime control
+- led keyboard control (aura)
+- charge limiting
+- bios/efivar control
+- power profile switching
+- fan curves (if supported, this is auto-detected)
+
+each of these will be detailed in sections.
+
+### AniMe control
+
+Controller for the fancy AniMe matrix display on the lid of some machines. This controller is a work in progress.
+
+#### Config options
+
+If you have an AniMe device a few system-level config options are enabled for you in `/etc/asusd/anime.conf`;
+
+1. `"system": [],`: currently unused, is intended to be a default continuous sequence in future versions
+2. `"boot": [],`: a sequence that plays on system boot (when asusd is loaded)
+3. `"wake": [],`: a sequence that plays when waking from suspend
+4. `"shutdown": [],`: a sequence that plays when shutdown begins
+5. `"brightness": <FLOAT>`: global brightness control, where `<FLOAT> is 0.0-1.0
+
+Some default examples are provided but are minimal. The full range of configuration options will be covered in another section of this manual.
+
+### Led keyboard control
+
+The LED controller (e.g, aura) enables setting many of the factory modes available if a laptop supports them. It also enables per-key RGB settings but this is a WIP and will likely be similar to how AniMe sequences can be created.
+
+#### Supported laptops
+
+There are over 60 supported laptops as of 01-01-2023. Please see [the rog-aura crate readme for further details](/rog-aura/README.md).
+
+### Charge control
+
+Almost all modern ASUS laptops have charging limit control now. This can be controlled in `/etc/asusd/asusd.conf`.
+
+```json
+"bat_charge_limit": 80,
+```
+
+where the number is a percentage.
+
+### Bios control
+
+Some options that you find in Armory Crate are available under this controller, so far there is:
+
+- POST sound: this is the sound you hear on bios boot post
+- GPU MUX: this controls if the dGPU is the _only_ GPU, making it the main GPU and disabling the iGPU
+
+These options are not written to the config file as they are stored in efivars. The only way to change these is to use the exposed safe dbus methods, or use the `asusctl` CLI tool.
+
+### 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.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
+2. Performance
+3. Quiet
+
+#### 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/10/23/250) which is accepted for the 5.17 kernel release .
+
+The fan curve format can be of varying formats:
+
+- `30c:0%,40c:5%,50c:10%,60c:20%,70c:35%,80c:55%,90c:65%,100c:65%"`
+- `30:0,40:5,50:10,60:20,70:35,80:55,90:65,100:65"`
+- `30 0,40 5,50 10,60 20,70 35,80 55,90 65,100 65"`
+- `30 0 40 5 50 10 60 20 70 35 80 55 90 65 100 65"`
+
+the order must always be the same "temperature:percentage", lowest from left to rigth being highest.
+
+The config file is located at `/etc/asusd/profile.conf` and is self-descriptive. On first run it is populated with the system EC defaults.
+
+### Support controller
+
+There is one more controller; the support controller. The sole pupose of this controller is to querie all the other controllers for information about their support level for the host laptop. Returns a json string.
+
+## asusd-user
+
+`asusd-user` is a usermode daemon. The intended purpose is to provide a method for users to run there own custom per-key keyboard effects and modes, AniMe sequences, and possibly their own profiles - all without overwriting the _base_ system config. As such some parts of the system daemon will migrate to the user daemon over time with the expectation that the Linux system runs both.
+
+As of now only AniMe is active in this with configuration in `~/.config/rog/`. On first run defaults are created that are intended to work as examples.
+
+The main config is `~/.config/rog/rog-user.cfg`
+
+#### Config options: Aura, per-key and zoned
+
+I'm unsure of how many laptops this works on, so please try it.
+
+`led_type: Key` works only on actual per-key RGB keyboards.
+
+`led_type: Zone` works on zoned laptops.
+
+`led_type: Zone` set to `None` works on zoned ROG laptops, unzoned ROG laptops, and TUF laptops (and yes this does mean an audio EQ can be done now).
+
+`~/.config/rog/rog-user.cfg` contains a setting `"active_aura": "<FILENAME>"` where `<FILENAME>` is the name of the Aura config to use, located in the same directory and without the file postfix, e.g, `"active_anime": "aura-default"`
+
+An Aura config itself is a file with contents:
+
+```ron
+(
+    name: "aura-default",
+    aura: (
+        effects: [
+            Breathe((
+                led: W,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: A,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: S,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: D,
+                start_colour1: (255, 0, 20),
+                start_colour2: (20, 255, 0),
+                speed: Low,
+            )),
+            Breathe((
+                led: F,
+                start_colour1: (255, 0, 0),
+                start_colour2: (255, 0, 0),
+                speed: High,
+            )),
+            Static((
+                led: RCtrl,
+                colour: (0, 0, 255),
+            )),
+            Static((
+                led: LCtrl,
+                colour: (0, 0, 255),
+            )),
+            Static((
+                led: Esc,
+                colour: (0, 0, 255),
+            )),
+            DoomFlicker((
+                led: N9,
+                start_colour: (0, 0, 255),
+                max_percentage: 80,
+                min_percentage: 40,
+            )),
+        ],
+        zoned: false,
+    ),
+)
+```
+
+If your laptop supports multizone, `"led"` can also be `"Zone": <one of the following>`
+
+- `SingleZone` // Keyboards with only one zone
+- `ZonedKbLeft` // keyboard left
+- `ZonedKbLeftMid` // keyboard left-middle
+- `ZonedKbRightMid` // etc
+- `ZonedKbRight`
+- `LightbarRight`
+- `LightbarRightCorner`
+- `LightbarRightBottom`
+- `LightbarLeftBottom`
+- `LightbarLeftCorner`
+- `LightbarLeft`
+
+Single zone example:
+
+```ron
+(
+    name: "aura-default",
+    aura: (
+        effects: [
+            DoomFlicker((
+                led: SingleZone,
+                start_colour: (200, 40, 5),
+                max_percentage: 80,
+                min_percentage: 40,
+            )),
+        ],
+        zoned: true,
+    ),
+)
+```
+
+At the moment there are only three effects available as shown in the example. More will come in the future
+but this may take me some time.
+
+#### Config options: AniMe
+
+`~/.config/rog/rog-user.cfg` contains a setting `"active_anime": "<FILENAME>"` where `<FILENAME>` is the name of the AniMe config to use, located in the same directory and without the file postfix, e.g, `"active_anime": "anime-doom"`
+
+An AniMe config itself is a file with contents:
+
+```json
+{
+  "name": "<FILENAME>",
+  "anime": []
+}
+```
+
+`<FILENAME>` is used as a reference internally. `"anime": []` is an array of sequences (WIP).
+
+##### "anime" array options
+
+Each object in the array can be one of:
+
+1. AsusAnimation
+2. ImageAnimation
+3. Image
+4. Pause
+
+##### AsusAnimation
+
+`AsusAnimation` is specifically for running the gif files that Armory Crate comes with. `asusctl` includes all of these in `/usr/share/asusd/anime/asus/`
+
+```json
+      "AsusAnimation": {
+        "file": "<FILE_PATH>",
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+```
+
+##### AsusImage
+
+Virtually the same as `AsusAnimation` but for png files, typically created in the same "slanted" style using a template (`diagonal-template.png`) as the ASUS gifs for pixel perfection.
+
+```json
+      "AsusImage": {
+        "file": "<FILE_PATH>",
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+```
+
+##### ImageAnimation
+
+`ImageAnimation` can play _any_ gif of any size.
+
+```json
+      "ImageAnimation": {
+        "file": "<FILE_PATH>",
+        "scale": <FLOAT>,
+        "angle": <FLOAT>,
+        "translation": [
+          <FLOAT>,
+          <FLOAT>
+        ],
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+    },
+```
+
+##### Image
+
+`Image` currently requires 8bit greyscale png. It will be able to use most in future.
+
+```json
+    {
+      "Image": {
+        "file": "<FILE_PATH>",
+        "scale": <FLOAT>,
+        "angle": <FLOAT>,
+        "translation": [
+          <FLOAT>,
+          <FLOAT>
+        ],
+        "time": <TIME>,
+        "brightness": <FLOAT>
+      }
+    },
+```
+
+##### Pause
+
+A `Pause` is handy for after an `Image` to hold the `Image` on the AniMe for a period.
+
+```json
+    {
+      "Pause": {
+        "secs": <INT>,
+        "nanos": <INT>
+      }
+    },
+```
+
+##### Options for objects
+
+**<FILE_PATH>**
+
+Must be full path: `"/usr/share/asusd/anime/asus/gaming/Controller.gif"` or `/home/luke/Downloads/random.gif`.
+
+**<FLOAT>**
+
+A number from 0.0-1.0.
+
+- `brightness`: If it is brightness it is combined with the system daemon global brightness
+- `scale`: 1.0 is the original size with lower number shrinking, larger growing
+- `angle`: Rotation angle in radians
+- `translation`: Shift the image X -/+, and y -/+
+
+**<TIME>**
+
+Time is the length of time to run the gif for:
+
+```json
+        "time": {
+          "Time": {
+            "secs": 5,
+            "nanos": 0
+          }
+        },
+```
+
+A cycle is how many gif loops to run:
+
+```json
+        "time": {
+          "Cycles": 2
+        },
+```
+
+`Infinite` means that this gif will never end:
+
+```json
+        "time": "Infinite",
+```
+
+`Fade` allows an image or gif to fade in and out, and remain at max brightness to n time:
+
+```json
+        "time": {
+          "Fade": {
+            "fade_in": {
+              "secs": 2,
+              "nanos": 0
+            },
+            "show_for": {
+              "secs": 1,
+              "nanos": 0
+            },
+            "fade_out": {
+              "secs": 2,
+              "nanos": 0
+            }
+          }
+        },
+```
+
+`show_for` can be `null`, if it is `null` then the `show_for` becomes `gif_time_length - fade_in - fade_out`.
+This is period for which the gif or image will be max brightness (as set).
+
+**<INT>**
+
+A plain non-float integer.
+
+## asusctl
+
+`asusctl` is a commandline interface which intends to be the main method of interacting with `asusd`. It can be used in any place a terminal app can be used.
+
+This program will query `asusd` for the `Support` level of the laptop and show or hide options according to this support level.
+
+Most commands are self-explanatory.
+
+### CLI Usage and help
+
+Commands are given by:
+
+```
+asusctl <option> <command> <command-options>
+```
+
+Help is available through:
+
+```
+asusctl --help
+asusctl <command> --help
+```
+
+Some commands may have subcommands:
+
+```
+asusctl <command> <subcommand> --help
+```
+
+### Keybinds
+
+To switch to next/previous Aura modes you will need to bind both the aura keys (if available) to one of:
+**Next**
+
+```
+asusctl led-mode -n
+```
+
+**Previous**
+
+```
+asusctl led-mode -p
+```
+
+To switch Fan/Thermal profiles you need to bind the Fn+F5 key to `asusctl profile -n`.
+
+# License & Trademarks
+
+Mozilla Public License 2 (MPL-2.0)
+
+---
+
+ASUS and ROG Trademark is either a US registered trademark or trademark of ASUSTeK Computer Inc. in the United States and/or other countries.
+
+Reference to any ASUS products, services, processes, or other information and/or use of ASUS Trademarks does not constitute or imply endorsement, sponsorship, or recommendation thereof by ASUS.
+
+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.
+
+---

Makefile

@@ -1,33 +1,41 @@
-prefix ?= /usr
-sysconfdir ?= /etc
+VERSION := $(shell /usr/bin/grep -Pm1 'version = "(\d.\d.\d)"' Cargo.toml | cut -d'"' -f2)
+
+INSTALL = install
+INSTALL_PROGRAM = ${INSTALL} -D -m 0755
+INSTALL_DATA = ${INSTALL} -D -m 0644
+
+prefix = /usr
 exec_prefix = $(prefix)
 bindir = $(exec_prefix)/bin
-libdir = $(exec_prefix)/lib
-includedir = $(prefix)/include
 datarootdir = $(prefix)/share
-datadir = $(datarootdir)
+libdir = $(exec_prefix)/lib
+zshcpl = $(datarootdir)/zsh/site-functions
 
-SRC = Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
+BIN_ROG := rog-control-center
+BIN_C := asusctl
+BIN_D := asusd
+BIN_U := asusd-user
+LEDCFG := aura_support.ron
 
-.PHONY: all clean distclean install uninstall update
+SRC := Cargo.toml Cargo.lock Makefile $(shell find -type f -wholename '**/src/*.rs')
 
-BIN_C=asusctl
-BIN_D=asusd
-LEDCONFIG=asusd-ledmodes.toml
-VERSION:=$(shell grep -P 'version = "(\d.\d.\d)"' asus-nb-ctrl/Cargo.toml | cut -d'"' -f2)
+STRIP_BINARIES ?= 0
 
 DEBUG ?= 0
 ifeq ($(DEBUG),0)
-	ARGS += "--release"
+	ARGS += --release
 	TARGET = release
+else
+	ARGS += --profile dev
+	TARGET = debug
 endif
 
 VENDORED ?= 0
 ifeq ($(VENDORED),1)
-	ARGS += "--frozen"
+	ARGS += --frozen
 endif
 
-all: target/release/$(BIN_D)
+all: build
 
 clean:
 	cargo clean
@@ -35,20 +43,65 @@ clean:
 distclean:
 	rm -rf .cargo vendor vendor.tar.xz
 
-install: all
-	install -D -m 0755 "target/release/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
-	install -D -m 0755 "target/release/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
-	install -D -m 0644 "data/$(BIN_D).rules" "$(DESTDIR)/lib/udev/rules.d/99-$(BIN_D).rules"
-	install -D -m 0644 "data/$(LEDCONFIG)" "$(DESTDIR)$(sysconfdir)/asusd/$(LEDCONFIG)"
-	install -D -m 0644 "data/$(BIN_D).conf" "$(DESTDIR)$(sysconfdir)/dbus-1/system.d/$(BIN_D).conf"
-	install -D -m 0644 "data/$(BIN_D).service" "$(DESTDIR)/lib/systemd/system/$(BIN_D).service"
+install-program:
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_ROG)" "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_C)" "$(DESTDIR)$(bindir)/$(BIN_C)"
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_D)" "$(DESTDIR)$(bindir)/$(BIN_D)"
+	$(INSTALL_PROGRAM) "./target/$(TARGET)/$(BIN_U)" "$(DESTDIR)$(bindir)/$(BIN_U)"
+
+install-data:
+	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).desktop" "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	$(INSTALL_DATA) "./rog-control-center/data/$(BIN_ROG).png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+	cd rog-aura/data/layouts && find . -type f -name "*.ron" -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/rog-gui/layouts/{}" \;
+
+	$(INSTALL_DATA) "./data/$(BIN_D).rules" "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
+	$(INSTALL_DATA) "./rog-aura/data/$(LEDCFG)" "$(DESTDIR)$(datarootdir)/asusd/$(LEDCFG)"
+	$(INSTALL_DATA) "./data/$(BIN_D).conf" "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
+
+	$(INSTALL_DATA) "./data/$(BIN_D).service" "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
+	$(INSTALL_DATA) "./data/$(BIN_U).service" "$(DESTDIR)$(libdir)/systemd/user/$(BIN_U).service"
+
+	$(INSTALL_DATA) "./data/icons/asus_notif_yellow.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_green.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_blue.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_blue.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_red.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_orange.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_orange.png"
+	$(INSTALL_DATA) "./data/icons/asus_notif_white.png" "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_white.png"
+
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-compute.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-compute.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-hybrid.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-hybrid.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-integrated.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-integrated.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-nvidia.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-nvidia.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/gpu-vfio.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
+	$(INSTALL_DATA) "./data/icons/scalable/notification-reboot.svg" "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
+
+	cd rog-anime/data && find "./anime" -type f -exec $(INSTALL_DATA) "{}" "$(DESTDIR)$(datarootdir)/asusd/{}" \;
+
+install: install-program install-data
 
 uninstall:
+	rm -f "$(DESTDIR)$(bindir)/$(BIN_ROG)"
+	rm -r "$(DESTDIR)$(datarootdir)/applications/$(BIN_ROG).desktop"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/$(BIN_ROG).png"
+
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_C)"
 	rm -f "$(DESTDIR)$(bindir)/$(BIN_D)"
-	rm -f "$(DESTDIR)/lib/udev/rules.d/99-$(BIN_D).rules"
-	rm -f "$(DESTDIR)$(sysconfdir)/dbus-1/system.d/$(BIN_D).conf"
-	rm -f "$(DESTDIR)/lib/systemd/system/$(BIN_D).service"
+	rm -f "$(DESTDIR)$(libdir)/udev/rules.d/99-$(BIN_D).rules"
+	rm -f "$(DESTDIR)/etc/asusd/$(LEDCFG)"
+	rm -f "$(DESTDIR)$(datarootdir)/dbus-1/system.d/$(BIN_D).conf"
+	rm -f "$(DESTDIR)$(libdir)/systemd/system/$(BIN_D).service"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_yellow.png"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_green.png"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/512x512/apps/asus_notif_red.png"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-compute.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-hybrid.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-integrated.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-nvidia.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/gpu-vfio.svg"
+	rm -r "$(DESTDIR)$(datarootdir)/icons/hicolor/scalable/status/notification-reboot.svg"
+	rm -rf "$(DESTDIR)$(datarootdir)/asusd"
+	rm -rf "$(DESTDIR)$(datarootdir)/rog-gui"
 
 update:
 	cargo update
@@ -59,12 +112,33 @@ vendor:
 	echo 'directory = "vendor"' >> .cargo/config
 	mv .cargo/config ./cargo-config
 	rm -rf .cargo
-	tar pcfJ vendor-$(VERSION).tar.xz vendor
+	rm -rf vendor
+	cargo vendor-filterer --platform x86_64-unknown-linux-gnu vendor
+	tar pcfJ vendor_asusctl_$(VERSION).tar.xz vendor
 	rm -rf vendor
 
-target/release/$(BIN_D): $(SRC)
+bindings:
+	typeshare ./rog-anime/src/ --lang=typescript --output-file=bindings/ts/anime.ts
+	typeshare ./rog-aura/src/ --lang=typescript --output-file=bindings/ts/aura.ts
+	typeshare ./rog-profiles/src/ --lang=typescript --output-file=bindings/ts/profiles.ts
+	typeshare ./rog-platform/src/ --lang=typescript --output-file=bindings/ts/platform.ts
+
+translate:
+	find -name \*.slint | xargs slint-tr-extractor -o rog-control-center/translations/en/rog-control-center.po
+
+build:
 ifeq ($(VENDORED),1)
+	cargo vendor
 	@echo "version = $(VERSION)"
-	tar pxf vendor-$(VERSION).tar.xz
+	tar pxf vendor_asusctl_$(VERSION).tar.xz
 endif
 	cargo build $(ARGS)
+ifneq ($(STRIP_BINARIES),0)
+	strip -s ./target/$(TARGET)/$(BIN_C)
+	strip -s ./target/$(TARGET)/$(BIN_D)
+	strip -s ./target/$(TARGET)/$(BIN_U)
+	strip -s ./target/$(TARGET)/$(BIN_ROG)
+endif
+
+
+.PHONY: all clean distclean install uninstall update build bindings

README.md

@@ -1,282 +1,153 @@
-# ASUS NB Ctrl
+# `asusctl` for ASUS ROG
 
-**NOTICE:**
+[Become a Patron!](https://www.patreon.com/bePatron?u=7602281) - [Asus Linux Website](https://asus-linux.org/)
 
-This program requires the kernel patch in `./kernel-patch/` to be applied.
-As of 04/08/2020 these have been submitted to lkml. Alternatively you may
-use the dkms module for 'hid-asus-rog` from one of the repositories [here](https://download.opensuse.org/repositories/home:/luke_nukem:/asus/).
+**WARNING:** Many features are developed in tandem with kernel patches. If you see a feature is missing you either need a patched kernel or latest release.
 
-The patch enables the following in kernel:
+`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.
 
-- All hotkeys (FN+Key combos)
-- Control of keyboard brightness using FN+Key combos (not RGB)
-- FN+F5 (fan) to toggle fan modes
+Now includes a GUI, `rog-control-center`.
 
-You will not get RGB control in kernel (yet), and asusd is still required to
-change modes and RGB settings. The previous version of this program is named
-`rog-core` and takes full control of the interfaces required - if you can't
-apply the kernel patches then `rog-core` is still highly usable.
+## Kernel support
 
-Many other patches for these laptops, AMD and Intel based, are working their way
-in to the kernel.
+**The minimum supported kernel version is 6.10**, which will contain the patches from [here](https://lore.kernel.org/platform-driver-x86/20240404001652.86207-1-luke@ljones.dev/). This is especially required for 2023+ devices and possibly some lat 2022 devices.
 
----
-asusd is a utility for Linux to control many aspects of various ASUS laptops.
+Z13 devices will need [these](https://lore.kernel.org/linux-input/20240416090402.31057-1-luke@ljones.dev/T/#t)
+
+## Goals
+
+The main goal of this work is to provide a safe and easy to use abstraction over various laptop features via DBUS, and to provide some helpful defaults and other behaviour such as toggling throttle/profile on AC/battery change.
+
+1. Provide safe dbus interface
+2. Respect the users resources: be small, light, and fast
+
+Point 4? asusd currently uses a tiny fraction of cpu time, and less than 1Mb of ram, the way
+a system-level daemon should. Languages such as JS and python should never be used for system level daemons (please stop).
+
+## Keyboard LEDs
+
+The level of support for laptops is dependent on folks submitting data to include in [`./rog-aura/data/layouts/aura_support.ron`](./rog-aura/data/layouts/aura_support.ron), typically installed in `/usr/share/asusd/aura_support.ron`. This is because the controller used for keyboards and LEDs is used across many years and many laptop models, all with different firmware configurations - the only way to track this is with the file mentioned above. Why not just enable all by default? Because it confuses people.
+
+See the [rog-aura readme](./rog-aura/README.md) for more details.
 
 ## Discord
 
-[Discord server link](https://discord.gg/PVyFzWj)
+[![Discord](https://img.shields.io/badge/Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/z8y99XqPb7)
 
 ## SUPPORTED LAPTOPS
 
-If your laptop is not in the following lists, it may still work with fan-mode switching and charge limit control.
-
-**Please help test or provide info for:**
-
-- GL703(0x1869)
-- GL553/GL753 (device = 0x1854) (attempted support from researching 2nd-hand info, multizone may work)
-
-**Laptop support is modified on a per-case basis** as the EC for the keyboard varies
-a little between models, e.g, some RGB modes are missing, or it's a single colour.
-As far as I can see, the EC does not give us a way to find what modes are supported.
-
-### ANIME AND OTHER FUNCTIONS
-
-**AniMe device check is performed on start, if your device has one it will be detected.**
-
-**NOTE:** If charge limit or fan modes are not working, then you may require a kernel newer than 5.6.10.
-
-- [X] AniMe Matrix display
-- [X] Power profile switching on fan-mode (FN+F5)
-  - [X] Intel
-    - [X] Turbo enale/disable
-    - [X] Min frequency percentage
-    - [X] Max frequency percentage
-  - [X] AMD
-    - [X] Turbo enale/disable
-- [X] Battery charge limit
-
-**NOTE:** GA14/GA401 and GA15/GA502/GU502, You will need kernel [patches](https://lab.retarded.farm/zappel/asus-rog-zephyrus-g14/-/tree/master/kernel_patches).
-
-### KEYBOARD BACKLIGHT MODES
-
-Models GA401, GA502, GU502 support LED brightness change only (no RGB).
-
-| MODEL  | STATIC | BREATHING | STROBE | RAINBOW | STAR | RAIN | HIGHLIGHT | LASER | RIPPLE | PULSE | COMET | FLASH | ZONES | PER-KEY RGB |
-|:------:|:------:|:---------:|:------:|:-------:|:----:|:----:|:---------:|:-----:|:------:|:-----:|:-----:|:-----:|:-----:|:-----------:|
-| G512LI |   X    |     X     |    X   |    X    |      |      |           |       |        |       |       |       |       |             |
-| G712LI |   X    |     X     |    X   |    X    |      |      |           |       |        |       |       |       |       |             |
-| GM501  |   X    |     X     |    X   |    X    |      |      |           |       |        |       |       |       |   X   |             |
-| GX531  |   X    |     X     |    X   |    X    |      |      |           |       |        |       |       |       |   X   |             |
-| G512   |   X    |     X     |    X   |    X    |      |      |           |       |        |       |       |       |   X   |             |
-| G712   |   X    |     X     |    X   |    X    |      |      |           |       |        |       |       |       |   X   |             |
-| GX502  |   X    |     X     |    X   |    X    |  X   |  X   |     X     |   X   |    X   |   X   |   X   |   X   |       |     X       |
-| GX701  |   X    |     X     |    X   |    X    |  X   |  X   |     X     |   X   |    X   |   X   |   X   |   X   |       |     X       |
-| G531   |   X    |     X     |    X   |    X    |  X   |  X   |     X     |   X   |    X   |   X   |   X   |   X   |   X   |     X       |
-| G731   |   X    |     X     |    X   |    X    |  X   |  X   |     X     |   X   |    X   |   X   |   X   |   X   |   X   |     X       |
-| G532   |   X    |     X     |    X   |    X    |  X   |  X   |     X     |   X   |    X   |   X   |   X   |   X   |       |     X       |
-
-It is highly likely this doesn't cover all models.
-
-For editing the `/etc/asusd/asusd-ledmodes.toml`, the LED Mode numbers are as follows:
+Most ASUS gaming laptops that have a USB keyboard. If `lsusb` shows something similar
+to this:
 
 ```
-0   STATIC
-1   BREATHING
-2   STROBE
-3   RAINBOW
-4   STAR
-5   RAIN
-6   HIGHLIGHT
-7   LASER
-8   RIPPLE
-10  PULSE
-11  COMET
-12  FLASH
-13  MULTISTATIC
-255 PER_KEY
+Bus 001 Device 002: ID 0b05:1866 ASUSTek Computer, Inc. N-KEY Device
 ```
 
+or
+
+```
+Bus 003 Device 002: ID 0b05:19b6 ASUSTek Computer, Inc. [unknown]
+```
+
+then it may work without tweaks. Technically all other functions except the LED
+and AniMe parts should work regardless of your latop make.
+
 ## Implemented
 
-- [X] Daemon
-- [X] Setting/modifying built-in LED modes
-- [X] Per-key LED setting
-- [X] Fancy LED modes (See examples)
-- [X] Saving settings for reload
-- [X] Logging - required for journalctl
-- [X] AniMatrix display on G14 models that include it
-- [X] Set battery charge limit (with kernel supporting this)
+The list is a bit outdated as many features have been enabled in the Linux kernel with upstream patches and then supported in asusctl suite.
 
-## Requirements for compiling
+- [x] System daemon
+- [x] GUI app (includes tray and notifications)
+- [x] Setting/modifying built-in LED modes
+- [x] Per-key LED setting
+- [x] Fancy LED modes (See examples) (currently being reworked)
+- [x] AniMatrix display on G14 and M16 models that include it
+- [x] Set battery charge limit (with kernel supporting this)
+- [x] Fan curve control on supported laptops (G14/G15, some TUF like FA507)
+- [x] Toggle bios setting for boot/POST sound
+- [x] Toggle GPU MUX (g-sync, or called MUX on 2022+ laptops)
 
-- `rustc` + `cargo` + `make`
-- `libusb-1.0-0-dev`
-- `libdbus-1-dev`
-- `llvm`
-- `libclang-dev`
-- `libudev-dev`
+# GUI
+
+A gui is now in the repo - ROG Control Center. At this time it is still a WIP, but it has almost all features in place already.
+
+# BUILDING
+
+Rust and cargo are required, they can be installed from [rustup.rs](https://rustup.rs/) or from the distro repos if newer than 1.75.
+
+**fedora:**
+
+    dnf install cmake clang-devel libinput-devel libseat-devel libgbm-devel libxkbcommon-devel systemd-devel \
+    libdrm-devel expat-devel pcre2-devel libzstd-devel libappindicator-gtk3
+    make
+    sudo make install
+
+**openSUSE:**
+
+Works with KDE Plasma (without GTK packages)
+
+    zypper in -t pattern devel_basis
+    zypper in rustup make cmake libinput-devel libseat-devel libgbm-devel systemd-devel clang-devel llvm-devel gdk-pixbuf-devel cairo-devel pango-devel freetype-devel libexpat-devel libayatana-indicator3-7
+    make
+    sudo make install
+
+**Ubuntu, Popos (unsuported):**
+
+instructions removed as outdated
 
 ## Installing
 
-Packaging and auto-builds are available [here](https://build.opensuse.org/package/show/home:luke_nukem:asus/asus-nb-ctrl)
+- Fedora copr = https://copr.fedorainfracloud.org/coprs/lukenukem/asus-linux/
+- openSUSE = https://download.opensuse.org/repositories/home:/luke_nukem:/asus/
 
-Download repositories are available [here](https://download.opensuse.org/repositories/home:/luke_nukem:/asus/)
-
----
-
-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.
 
+You may also need to activate the service for debian install. If running Pop!\_OS, I suggest disabling `system76-power` gnome-shell extension and systemd service.
+
+## Upgrading
+
 If you are upgrading from a previous installed version, you will need to restart the service or reboot.
 
 ```
 $ systemctl daemon-reload && systemctl restart asusd
 ```
 
-You may also need to activate the service for debian install. If running Pop!_OS, I suggest disabling `system76-power`
-gnome-shell extension, or at least limiting use of the power-management parts as `asusd` lets you set the same things
-(one or the other will overwrite pstates). I will create a shell extension at some point similar to system76, but using
-the asusd parts. It is safe to leave `system76-power.service` enabled and use for switching between graphics modes.
-
 ## Uninstalling
 
-Run `sudo make uninstall` in the source repo, and remove `/etc/asusd.conf`.
+Run `sudo make uninstall` in the source repo, and remove `/etc/asusd/`.
 
-## Updating
+# Contributing
 
-Occasionally you need to remove `/etc/asusd.conf` and restart the daemon to create a new one. You *can* back up the old
-one and copy settings back over (then restart daemon again).
+See `CONTRIBUTING.md`. Additionally, also do `cargo clean` and `cargo test` on first checkout to ensure the commit hooks are used (via `cargo-husky`).
 
-# Usage
+Generation of the bindings with `make bindings` requires `typeshare` to be installed.
 
-**NOTE! Fan mode toggling requires a newer kernel**. I'm unsure when the patches required for it got merged - I've
-tested with the 5.6.6 kernel and above only. To see if the fan-mode changed cat either:
+Dbus introsepction XML requires with `make introspection` requires `anime_sim` to be running before starting `asusd`.
 
-- `cat /sys/devices/platform/asus-nb-wmi/throttle_thermal_policy` or
-- `cat /sys/devices/platform/asus-nb-wmi/fan_boost_mode`
+# OTHER
 
-The numbers are 0 = Normal/Balanced, 1 = Boost, 2 = Silent.
+## AniMe Matrix simulator
 
-Running the program as a daemon manually will require root. Standard (non-daemon) mode expects to be communicating with
-the daemon mode over dbus.
+A simulator using SDL2 can be built using `cargo build --package rog_simulators` and run with `./target/debug/anime_sim`. Once started `asusd` will need restarting to pick it up. If running this sim on a laptop _with_ the display, the simulated display will be used instead of the physical display.
 
-Commands are given by:
-
-```
-asusctl <option> <command> <command-options>
-```
-
-Help is available through:
-
-```
-asusctl --help
-asusctl <command> --help
-```
-
-Some commands may have subcommands:
-
-```
-asusctl <command> <subcommand> --help
-```
-
-### Example
-
-```
-$ asusctl --help
-Usage: asusctl [OPTIONS]
-
-Optional arguments:
-  -h, --help             print help message
-  -v, --version          show program version number
-  -k, --kbd-bright VAL   <off, low, med, high>
-  -p, --pwr-profile PWR  <silent, normal, boost>
-  -c, --chg-limit CHRG   <20-100>
-
-Available commands:
-  led-mode  Set the keyboard lighting from built-in modes
-
-$ asusctl led-mode --help
-Usage: asusctl led-mode [OPTIONS]
-
-Optional arguments:
-  -h, --help  print help message
-
-Available commands:
-  static        set a single static colour
-  breathe       pulse between one or two colours
-  strobe        strobe through all colours
-  rainbow       rainbow cycling in one of four directions
-  star          rain pattern mimicking raindrops
-  rain          rain pattern of three preset colours
-  highlight     pressed keys are highlighted to fade
-  laser         pressed keys generate horizontal laser
-  ripple        pressed keys ripple outwards like a splash
-  pulse         set a rapid pulse
-  comet         set a vertical line zooming from left
-  flash         set a wide vertical line zooming from left
-  multi-static  4-zone multi-colour
-
-$ asusctl led-mode static --help
-Usage: asusctl led-mode static [OPTIONS]
-
-Optional arguments:
-  -h, --help  print help message
-  -c HEX      set the RGB value e.g, ff00ff
-
-$ asusctl led-mode star --help
-Usage: asusctl led-mode star [OPTIONS]
-
-Optional arguments:
-  -h, --help  print help message
-  -c HEX      set the first RGB value e.g, ff00ff
-  -C HEX      set the second RGB value e.g, ff00ff
-  -s SPEED    set the speed: low, med, high
-```
-
-## Daemon mode
-
-If the daemon service is enabled then on boot the following will be reloaded from save:
-
-- LED brightness
-- Last used built-in mode
-- fan-boost/thermal mode
-- battery charging limit
-
-The daemon also saves the settings per mode as the keyboard does not do this
-itself - this means cycling through modes with the Aura keys will use the
-settings that were used via CLI.
-
-Daemon mode creates a config file at `/etc/asusd.conf` which you can edit a 
-little of. Most parts will be byte arrays, but you can adjust things like
-`mode_performance`.
-
-### DBUS Input
-
-See [README_DBUS.md](./README_DBUS.md).
-
-### AniMe input
-
-You will want to look at what MeuMeu has done with [https://github.com/Meumeu/ZephyrusBling/](https://github.com/Meumeu/ZephyrusBling/)
-
-### Wireshark captures
-
-TODO: see `./wireshark_data/` for some captures.
-
-### Supporting more laptops
+## Supporting more laptops
 
 Please file a support request.
 
-## License
+# License & Trademarks
 
 Mozilla Public License 2 (MPL-2.0)
 
-# Credits
+---
 
-- [flukejones](https://github.com/flukejones/), project maintainer.
-- [tuxuser](https://github.com/tuxuser/)
-- [aspann](https://github.com/aspann)
-- [meumeu](https://github.com/Meumeu)
-- Anyone missed? Please contact me
+ASUS and ROG Trademark is either a US registered trademark or trademark of ASUSTeK Computer Inc. in the United States and/or other countries.
+
+Reference to any ASUS products, services, processes, or other information and/or use of ASUS Trademarks does not constitute or imply endorsement, sponsorship, or recommendation thereof by ASUS.
+
+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_DBUS.md

@@ -1,158 +0,0 @@
-# DBUS Guide
-
-```rust
-pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
-pub static DBUS_PATH: &str = "/org/asuslinux/Daemon";
-pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
-```
-
-## Methods
-
-- `SetKeyBacklight`
-- `GetKeyBacklight`
-- `AnimatrixWrite`
-- `SetFanMode`
-- `GetFanMode`
-- `SetChargeLimit`
-- `GetChargeLimit`
-- `GetKeyBacklightModes`
-
-## Signals
-
-- `KeyBacklightChanged`
-- `FanModeChanged`
-- `ChargeLimitChanged`
-
-## Method Inputs
-
-### SetKeyBacklight
-
-This method expects a string of JSON as input. The JSON is of format such:
-
-```
-{
-  "Static": {
-    "colour": [ 255, 0, 0]
-  }
-}
-```
-
-The possible contents of a mode are:
-
-- `"colour": [u8, u8, u8],`
-- `"speed": <String>,` <Low, Med, High>
-- `"direction": <String>,` <Up, Down, Left, Right>
-
-Modes may or may not be available for a specific laptop (TODO: dbus getter for
-supported modes). Modes are:
-
-- `"Static": { "colour": <colour> },`
-- `"Pulse": { "colour": <colour> },`
-- `"Comet": { "colour": <colour> },`
-- `"Flash": { "colour": <colour> },`
-- `"Strobe": { "speed": <speed> },`
-- `"Rain": { "speed": <speed> },`
-- `"Laser": { "colour": <colour>, "speed": <speed> },`
-- `"Ripple": { "colour": <colour>, "speed": <speed> },`
-- `"Highlight": { "colour": <colour>, "speed": <speed> },`
-- `"Rainbow": { "direction": <direction>, "speed": <speed> },`
-- `"Breathe": { "colour": <colour>, "colour2": <colour>, "speed": <speed> },`
-- `"Star": { "colour": <colour>, "colour2": <colour>, "speed": <speed> },`
-- `"MultiStatic": { "colour1": <colour>, "colour2": <colour>, , "colour3": <colour>, "colour4": <colour> },`
-
-Additionally to the above there is `"RGB": [[u8; 64]; 11]` which is for per-key
-setting of LED's but this requires some refactoring to make it easily useable over
-dbus.
-
-Lastly, there is `"LedBrightness": <u8>` which accepts 0-3 for off, low, med, high.
-
-### GetKeyBacklight
-
-This method will return a JSON string in the same format as accepted by `SetKeyBacklight`.
-
-### GetKeyBacklightModes
-
-Will return a JSON string array of modes that this laptop accepts. The mode data
-within this will be the current settings per mode. Good for:
-
-- Getting supported modes
-- Getting all mode settings
-
-### AnimatrixWrite
-
-Used to write data to the AniMe display if available. Currently is takes `[[u8; 640]; 2]`
-which must be the byte data that will be written directly to the USB device.
-
-### SetFanMode
-
-Accepts an integer from the following:
-
-- `0`: Normal
-- `1`: Boost mode
-- `2`: Silent mode
-
-### GetFanMode
-
-Returns the integer set from above.
-
-### SetChargeLimit
-
-Accepts an integer in the range of 20-100.
-
-### GetChargeLimit
-
-Returns the integer set from above.
-
-## Signal Outs
-
-### KeyBacklightChanged
-
-When emitted, it will emit the JSON data of the mode changed to, e.g:
-
-```
-{
-  "Static": {
-    "colour": [ 255, 0, 0]
-  }
-}
-```
-
-### FanModeChanged
-
-When emitted, it will include the integer the fan mode was changed to.
-
-### ChargeLimitChanged
-
-When emitted, it will include the integer the charging limit was changed to.
-
-## dbus-send examples
-
-```
-dbus-send --system --type=method_call --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.asuslinux.Daemon.SetKeyBacklight string:'{"Static": {"colour": [ 80, 0, 40]}}'
-```
-
-```
-dbus-send --system --type=method_call --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.asuslinux.Daemon.SetKeyBacklight string:'{"Star":{"colour":[0,255,255],"colour2":[0,0,0],"speed":"Med"}}'
-```
-
-**Note:** setting colour2 to `[0,0,255]` activates random star colour. Colour2 has no effect on the
-mode otherwise.
-```
-dbus-send --system --type=method_call --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.asuslinux.Daemon.SetKeyBacklight string:'{"Star":{"colour":[0,255,255],"colour2":[0,0,255],"speed":"Med"}}'
-```
-
-```
-dbus-send --system --type=method_call --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.asuslinux.Daemon.SetKeyBacklight string:'{"LedBrightness":3}'
-```
-
-```
-dbus-send --system --type=method_call --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.asuslinux.Daemon.SetFanMode byte:'2'
-```
-
-Monitoring dbus while sending commands via `rog-core` will give you the json structure if you are otherwise unsure, e.g: `dbus-monitor --system |grep -A2 asuslinux`.
-
-## Getting an introspection .xml
-
-```
-dbus-send --system --print-reply --dest=org.asuslinux.Daemon /org/asuslinux/Daemon org.freedesktop.DBus.Introspectable.Introspect > xml/dbus-0.14.4.xml
-```

asus-nb-ctrl/Cargo.toml

@@ -1,49 +0,0 @@
-[package]
-name = "asus-nb-ctrl"
-version = "1.0.3"
-license = "MPL-2.0"
-readme = "README.md"
-authors = ["Luke <luke@ljones.dev>"]
-repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-description = "A daemon app for ASUS GX502 and similar laptops to control missing features"
-edition = "2018"
-
-[lib]
-name = "daemon"
-path = "src/lib.rs"
-
-[[bin]]
-name = "asusctl"
-path = "src/main.rs"
-
-[[bin]]
-name = "asusd"
-path = "src/daemon.rs"
-
-[dependencies]
-asus-nb = { path = "../asus-nb" }
-rusb = "^0.6.0"
-udev = "^0.4.0"
-async-trait = "0.1.36"
-
-# cli and logging
-gumdrop = "^0.8.0"
-log = "^0.4.8"
-env_logger = "^0.7.1"
-
-# async
-dbus = { version = "^0.8.2", features = ["futures"] }
-dbus-tokio = "^0.5.1"
-tokio = { version = "^0.2.4", features = ["rt-threaded", "sync"] }
-
-# serialisation
-serde = "^1.0"
-serde_derive = "^1.0"
-serde_json = "^1.0"
-toml = "0.4.6"
-
-# Device control
-sysfs-class = "^0.1.2" # used for backlight control and baord ID
-# cpu power management
-intel-pstate = "^0.2.1"

asus-nb-ctrl/src/config.rs

@@ -1,128 +0,0 @@
-use asus_nb::aura_modes::AuraModes;
-use log::{error, warn};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write};
-
-pub static CONFIG_PATH: &str = "/etc/asusd/asusd.conf";
-
-#[derive(Default, Deserialize, Serialize)]
-pub struct Config {
-    pub power_profile: u8,
-    pub bat_charge_limit: u8,
-    pub kbd_led_brightness: u8,
-    pub kbd_backlight_mode: u8,
-    pub kbd_backlight_modes: Vec<AuraModes>,
-    pub power_profiles: FanModeProfile,
-}
-
-impl Config {
-    /// `load` will attempt to read the config, but if it is not found it
-    /// will create a new default config and write that out.
-    pub fn load(mut self, supported_led_modes: &[u8]) -> Self {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(&CONFIG_PATH)
-            .unwrap(); // okay to cause panic here
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                self = Config::create_default(&mut file, &supported_led_modes);
-            } else {
-                self = serde_json::from_str(&buf).unwrap_or_else(|_| {
-                    warn!("Could not deserialise {}", CONFIG_PATH);
-                    Config::create_default(&mut file, &supported_led_modes)
-                });
-            }
-        }
-        self
-    }
-
-    fn create_default(file: &mut File, supported_led_modes: &[u8]) -> Self {
-        // create a default config here
-        let mut c = Config::default();
-        c.bat_charge_limit = 100;
-        c.kbd_backlight_mode = 0;
-        c.kbd_led_brightness = 1;
-
-        for n in supported_led_modes {
-            c.kbd_backlight_modes.push(AuraModes::from(*n))
-        }
-
-        // Should be okay to unwrap this as is since it is a Default
-        let json = serde_json::to_string_pretty(&c).unwrap();
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|_| panic!("Could not write {}", CONFIG_PATH));
-        c
-    }
-
-    pub fn read(&mut self) {
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open(&CONFIG_PATH)
-            .unwrap_or_else(|err| panic!("Error reading {}: {}", CONFIG_PATH, err));
-        let mut buf = String::new();
-        if let Ok(l) = file.read_to_string(&mut buf) {
-            if l == 0 {
-                warn!("File is empty {}", CONFIG_PATH);
-            } else {
-                let x: Config = serde_json::from_str(&buf)
-                    .unwrap_or_else(|_| panic!("Could not deserialise {}", CONFIG_PATH));
-                *self = x;
-            }
-        }
-    }
-
-    pub fn write(&self) {
-        let mut file = File::create(CONFIG_PATH).expect("Couldn't overwrite config");
-        let json = serde_json::to_string_pretty(self).expect("Parse config to JSON failed");
-        file.write_all(json.as_bytes())
-            .unwrap_or_else(|err| error!("Could not write config: {}", err));
-    }
-
-    pub fn set_mode_data(&mut self, mode: AuraModes) {
-        let byte: u8 = (&mode).into();
-        for (index, n) in self.kbd_backlight_modes.iter().enumerate() {
-            if byte == u8::from(n) {
-                // Consume it, OMNOMNOMNOM
-                self.kbd_backlight_modes[index] = mode;
-                break;
-            }
-        }
-    }
-
-    pub fn get_led_mode_data(&self, num: u8) -> Option<&AuraModes> {
-        for mode in &self.kbd_backlight_modes {
-            if u8::from(mode) == num {
-                return Some(mode);
-            }
-        }
-        None
-    }
-}
-
-#[derive(Default, Deserialize, Serialize)]
-pub struct FanModeProfile {
-    pub normal: CPUSettings,
-    pub boost: CPUSettings,
-    pub silent: CPUSettings,
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct CPUSettings {
-    pub min_percentage: u8,
-    pub max_percentage: u8,
-    pub no_turbo: bool,
-}
-
-impl Default for CPUSettings {
-    fn default() -> Self {
-        CPUSettings {
-            min_percentage: 0,
-            max_percentage: 100,
-            no_turbo: false,
-        }
-    }
-}

asus-nb-ctrl/src/ctrl_anime.rs

@@ -1,225 +0,0 @@
-const INIT_STR: &str = "ASUS Tech.Inc.";
-const PACKET_SIZE: usize = 640;
-
-// Only these two packets must be 17 bytes
-const DEV_PAGE: u8 = 0x5e;
-// These bytes are in [1] position of the array
-const WRITE: u8 = 0xc0;
-const INIT: u8 = 0xc2;
-const APPLY: u8 = 0xc3;
-const SET: u8 = 0xc4;
-
-use crate::config::Config;
-use asus_nb::error::AuraError;
-use log::{error, info, warn};
-use rusb::{Device, DeviceHandle};
-use std::error::Error;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::sync::mpsc::Receiver;
-use tokio::sync::Mutex;
-use tokio::task::JoinHandle;
-
-#[allow(dead_code)]
-#[derive(Debug)]
-pub enum AnimatrixCommand {
-    Apply,
-    Set,
-    WriteImage(Vec<Vec<u8>>),
-    //ReloadLast,
-}
-
-pub struct CtrlAnimeDisplay {
-    handle: DeviceHandle<rusb::GlobalContext>,
-    initialised: bool,
-}
-
-use ::dbus::{nonblock::SyncConnection, tree::Signal};
-use async_trait::async_trait;
-
-#[async_trait]
-impl crate::Controller for CtrlAnimeDisplay {
-    type A = Vec<Vec<u8>>;
-
-    /// Spawns two tasks which continuously check for changes
-    fn spawn_task_loop(
-        mut self,
-        _: Arc<Mutex<Config>>,
-        mut recv: Receiver<Self::A>,
-        _: Option<Arc<SyncConnection>>,
-        _: Option<Arc<Signal<()>>>,
-    ) -> Vec<JoinHandle<()>> {
-        vec![tokio::spawn(async move {
-            while let Some(image) = recv.recv().await {
-                self.do_command(AnimatrixCommand::WriteImage(image))
-                    .await
-                    .unwrap_or_else(|err| warn!("{}", err));
-            }
-        })]
-    }
-
-    async fn reload_from_config(&mut self, _: &mut Config) -> Result<(), Box<dyn Error>> {
-        Ok(())
-    }
-}
-
-impl CtrlAnimeDisplay {
-    #[inline]
-    pub fn new() -> Result<CtrlAnimeDisplay, Box<dyn Error>> {
-        // We don't expect this ID to ever change
-        let device = CtrlAnimeDisplay::get_device(0x0b05, 0x193b).map_err(|err| {
-            warn!("Could not get AniMe display handle: {:?}", err);
-            err
-        })?;
-
-        let mut device = device.open()?;
-        device.reset()?;
-
-        device.set_auto_detach_kernel_driver(true).map_err(|err| {
-            error!("Auto-detach kernel driver failed: {:?}", err);
-            err
-        })?;
-
-        device.claim_interface(0).map_err(|err| {
-            error!("Could not claim device interface: {:?}", err);
-            err
-        })?;
-
-        info!("Device has an AniMe Matrix display");
-        Ok(CtrlAnimeDisplay {
-            handle: device,
-            initialised: false,
-        })
-    }
-
-    #[inline]
-    fn get_device(vendor: u16, product: u16) -> Result<Device<rusb::GlobalContext>, rusb::Error> {
-        for device in rusb::devices()?.iter() {
-            let device_desc = device.device_descriptor()?;
-            if device_desc.vendor_id() == vendor && device_desc.product_id() == product {
-                return Ok(device);
-            }
-        }
-        Err(rusb::Error::NoDevice)
-    }
-
-    pub async fn do_command(&mut self, command: AnimatrixCommand) -> Result<(), AuraError> {
-        if !self.initialised {
-            self.do_initialization().await?
-        }
-
-        match command {
-            AnimatrixCommand::WriteImage(effect) => self.write_image(effect).await?,
-            AnimatrixCommand::Set => self.do_set().await?,
-            AnimatrixCommand::Apply => self.do_apply().await?,
-            //AnimatrixCommand::ReloadLast => self.reload_last_builtin(&config).await?,
-        }
-        Ok(())
-    }
-
-    /// Should only be used if the bytes you are writing are verified correct
-    #[inline]
-    async fn write_bytes(&self, message: &[u8]) -> Result<(), AuraError> {
-        let prev = std::time::Instant::now();
-        match self.handle.write_control(
-            0x21,  // request_type
-            0x09,  // request
-            0x35e, // value
-            0x00,  // index
-            message,
-            Duration::from_millis(200),
-        ) {
-            Ok(_) => {
-                println!(
-                    "{:?}",
-                    std::time::Instant::now().duration_since(prev).as_micros()
-                );
-            }
-            Err(err) => match err {
-                rusb::Error::Timeout => {}
-                _ => error!("Failed to write to led interrupt: {:?}", err),
-            },
-        }
-        Ok(())
-    }
-
-    /// Write an Animatrix image
-    ///
-    /// The expected input here is *two* Vectors, 640 bytes in length. The two vectors
-    /// are each one half of the full image write.
-    ///
-    /// After each write a flush is written, it is assumed that this tells the device to
-    /// go ahead and display the written bytes
-    ///
-    /// # Note:
-    /// The vectors are expected to contain the full sequence of bytes as follows
-    ///
-    /// - Write pane 1: 0x5e 0xc0 0x02 0x01 0x00 0x73 0x02 .. <led brightness>
-    /// - Write pane 2: 0x5e 0xc0 0x02 0x74 0x02 0x73 0x02 .. <led brightness>
-    ///
-    /// Where led brightness is 0..255, low to high
-    #[inline]
-    async fn write_image(&mut self, image: Vec<Vec<u8>>) -> Result<(), AuraError> {
-        for row in image.iter() {
-            self.write_bytes(row).await?;
-        }
-        self.do_flush().await?;
-        Ok(())
-    }
-
-    #[inline]
-    async fn do_initialization(&mut self) -> Result<(), AuraError> {
-        let mut init = [0; PACKET_SIZE];
-        init[0] = DEV_PAGE; // This is the USB page we're using throughout
-        for (idx, byte) in INIT_STR.as_bytes().iter().enumerate() {
-            init[idx + 1] = *byte
-        }
-        self.write_bytes(&init).await?;
-
-        // clear the init array and write other init message
-        for ch in init.iter_mut() {
-            *ch = 0;
-        }
-        init[0] = DEV_PAGE; // write it to be sure?
-        init[1] = INIT;
-
-        self.write_bytes(&init).await?;
-        self.initialised = true;
-        Ok(())
-    }
-
-    #[inline]
-    async fn do_flush(&mut self) -> Result<(), AuraError> {
-        let mut flush = [0; PACKET_SIZE];
-        flush[0] = DEV_PAGE;
-        flush[1] = WRITE;
-        flush[2] = 0x03;
-
-        self.write_bytes(&flush).await?;
-        Ok(())
-    }
-
-    #[inline]
-    async fn do_set(&mut self) -> Result<(), AuraError> {
-        let mut flush = [0; PACKET_SIZE];
-        flush[0] = DEV_PAGE;
-        flush[1] = SET;
-        flush[2] = 0x01;
-        flush[3] = 0x80;
-
-        self.write_bytes(&flush).await?;
-        Ok(())
-    }
-
-    #[inline]
-    async fn do_apply(&mut self) -> Result<(), AuraError> {
-        let mut flush = [0; PACKET_SIZE];
-        flush[0] = DEV_PAGE;
-        flush[1] = APPLY;
-        flush[2] = 0x01;
-        flush[3] = 0x80;
-
-        self.write_bytes(&flush).await?;
-        Ok(())
-    }
-}

asus-nb-ctrl/src/ctrl_charge.rs

@@ -1,96 +0,0 @@
-use crate::config::Config;
-use log::{error, info, warn};
-use std::error::Error;
-use std::fs::OpenOptions;
-use std::io::Write;
-use std::path::Path;
-use std::sync::Arc;
-use tokio::sync::mpsc::Receiver;
-use tokio::sync::Mutex;
-use tokio::task::JoinHandle;
-
-static BAT_CHARGE_PATH: &str = "/sys/class/power_supply/BAT0/charge_control_end_threshold";
-
-pub struct CtrlCharge {
-    path: &'static str,
-}
-
-use ::dbus::{nonblock::SyncConnection, tree::Signal};
-use async_trait::async_trait;
-
-#[async_trait]
-impl crate::Controller for CtrlCharge {
-    type A = u8;
-
-    /// Spawns two tasks which continuously check for changes
-    fn spawn_task_loop(
-        self,
-        config: Arc<Mutex<Config>>,
-        mut recv: Receiver<Self::A>,
-        _: Option<Arc<SyncConnection>>,
-        _: Option<Arc<Signal<()>>>,
-    ) -> Vec<JoinHandle<()>> {
-        vec![tokio::spawn(async move {
-            while let Some(n) = recv.recv().await {
-                let mut config = config.lock().await;
-                self.set_charge_limit(n, &mut config)
-                    .unwrap_or_else(|err| warn!("charge_limit: {:?}", err));
-            }
-        })]
-    }
-
-    async fn reload_from_config(&mut self, config: &mut Config) -> Result<(), Box<dyn Error>> {
-        config.read();
-        info!("Reloaded battery charge limit");
-        self.set_charge_limit(config.bat_charge_limit, config)
-    }
-}
-
-impl CtrlCharge {
-    pub fn new() -> Result<Self, Box<dyn Error>> {
-        let path = CtrlCharge::get_battery_path()?;
-        info!("Device has battery charge threshold control");
-        Ok(CtrlCharge { path })
-    }
-
-    fn get_battery_path() -> Result<&'static str, std::io::Error> {
-        if Path::new(BAT_CHARGE_PATH).exists() {
-            Ok(BAT_CHARGE_PATH)
-        } else {
-            Err(std::io::Error::new(
-                std::io::ErrorKind::NotFound,
-                "Charge control not available",
-            ))
-        }
-    }
-
-    pub(super) fn set_charge_limit(
-        &self,
-        limit: u8,
-        config: &mut Config,
-    ) -> Result<(), Box<dyn Error>> {
-        if limit < 20 || limit > 100 {
-            warn!(
-                "Unable to set battery charge limit, must be between 20-100: requested {}",
-                limit
-            );
-        }
-
-        let mut file = OpenOptions::new()
-            .write(true)
-            .open(self.path)
-            .map_err(|err| {
-                warn!("Failed to open battery charge limit path: {:?}", err);
-                err
-            })?;
-        file.write_all(limit.to_string().as_bytes())
-            .unwrap_or_else(|err| error!("Could not write to {}, {:?}", BAT_CHARGE_PATH, err));
-        info!("Battery charge limit: {}", limit);
-
-        config.read();
-        config.bat_charge_limit = limit;
-        config.write();
-
-        Ok(())
-    }
-}

asus-nb-ctrl/src/ctrl_fan_cpu.rs

@@ -1,275 +0,0 @@
-use crate::config::Config;
-use log::{error, info, warn};
-use std::error::Error;
-use std::fs::OpenOptions;
-use std::io::{Read, Write};
-use std::path::Path;
-use std::str::FromStr;
-use std::sync::Arc;
-use tokio::sync::mpsc::Receiver;
-use tokio::sync::Mutex;
-use tokio::task::JoinHandle;
-
-static FAN_TYPE_1_PATH: &str = "/sys/devices/platform/asus-nb-wmi/throttle_thermal_policy";
-static FAN_TYPE_2_PATH: &str = "/sys/devices/platform/asus-nb-wmi/fan_boost_mode";
-static AMD_BOOST_PATH: &str = "/sys/devices/system/cpu/cpufreq/boost";
-
-pub struct CtrlFanAndCPU {
-    path: &'static str,
-}
-
-use ::dbus::{nonblock::SyncConnection, tree::Signal};
-use async_trait::async_trait;
-
-#[async_trait]
-impl crate::Controller for CtrlFanAndCPU {
-    type A = u8;
-
-    /// Spawns two tasks which continuously check for changes
-    fn spawn_task_loop(
-        self,
-        config: Arc<Mutex<Config>>,
-        mut recv: Receiver<Self::A>,
-        _: Option<Arc<SyncConnection>>,
-        _: Option<Arc<Signal<()>>>,
-    ) -> Vec<JoinHandle<()>> {
-        let gate1 = Arc::new(Mutex::new(self));
-        let gate2 = gate1.clone();
-        let config1 = config.clone();
-        // spawn an endless loop
-        vec![
-            tokio::spawn(async move {
-                while let Some(mode) = recv.recv().await {
-                    let mut config = config1.lock().await;
-                    let mut lock = gate1.lock().await;
-                    lock.set_fan_mode(mode, &mut config)
-                        .unwrap_or_else(|err| warn!("{:?}", err));
-                }
-            }),
-            // need to watch file path
-            tokio::spawn(async move {
-                loop {
-                    tokio::time::delay_for(std::time::Duration::from_millis(100)).await;
-                    let mut lock = gate2.lock().await;
-                    let mut config = config.lock().await;
-                    lock.fan_mode_check_change(&mut config)
-                        .unwrap_or_else(|err| warn!("fan_ctrl: {:?}", err));
-                }
-            }),
-        ]
-    }
-
-    async fn reload_from_config(&mut self, config: &mut Config) -> Result<(), Box<dyn Error>> {
-        let mut file = OpenOptions::new().write(true).open(self.path)?;
-        file.write_all(format!("{:?}\n", config.power_profile).as_bytes())
-            .unwrap_or_else(|err| error!("Could not write to {}, {:?}", self.path, err));
-        self.set_pstate_for_fan_mode(FanLevel::from(config.power_profile), config)?;
-        info!(
-            "Reloaded fan mode: {:?}",
-            FanLevel::from(config.power_profile)
-        );
-        Ok(())
-    }
-}
-
-impl CtrlFanAndCPU {
-    pub fn new() -> Result<Self, Box<dyn Error>> {
-        let path = CtrlFanAndCPU::get_fan_path()?;
-        info!("Device has thermal throttle control");
-        Ok(CtrlFanAndCPU { path })
-    }
-
-    fn get_fan_path() -> Result<&'static str, std::io::Error> {
-        if Path::new(FAN_TYPE_1_PATH).exists() {
-            Ok(FAN_TYPE_1_PATH)
-        } else if Path::new(FAN_TYPE_2_PATH).exists() {
-            Ok(FAN_TYPE_2_PATH)
-        } else {
-            Err(std::io::Error::new(
-                std::io::ErrorKind::NotFound,
-                "Fan mode not available",
-            ))
-        }
-    }
-
-    pub(super) fn fan_mode_check_change(
-        &mut self,
-        config: &mut Config,
-    ) -> Result<(), Box<dyn Error>> {
-        let mut file = OpenOptions::new().read(true).open(self.path)?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)?;
-        if let Some(num) = char::from(buf[0]).to_digit(10) {
-            if config.power_profile != num as u8 {
-                config.read();
-                config.power_profile = num as u8;
-                config.write();
-                self.set_pstate_for_fan_mode(FanLevel::from(config.power_profile), config)?;
-                info!(
-                    "Fan mode was changed: {:?}",
-                    FanLevel::from(config.power_profile)
-                );
-            }
-            return Ok(());
-        }
-        let err = std::io::Error::new(
-            std::io::ErrorKind::InvalidData,
-            "Fan-level could not be parsed",
-        );
-        Err(Box::new(err))
-    }
-
-    pub(super) fn set_fan_mode(
-        &mut self,
-        n: u8,
-        config: &mut Config,
-    ) -> Result<(), Box<dyn Error>> {
-        let mut fan_ctrl = OpenOptions::new().write(true).open(self.path)?;
-        config.read();
-        config.power_profile = n;
-        config.write();
-        fan_ctrl
-            .write_all(format!("{:?}\n", config.power_profile).as_bytes())
-            .unwrap_or_else(|err| error!("Could not write to {}, {:?}", self.path, err));
-        info!(
-            "Fan mode set to: {:?}",
-            FanLevel::from(config.power_profile)
-        );
-        self.set_pstate_for_fan_mode(FanLevel::from(n), config)?;
-        Ok(())
-    }
-
-    fn set_pstate_for_fan_mode(
-        &self,
-        mode: FanLevel,
-        config: &mut Config,
-    ) -> Result<(), Box<dyn Error>> {
-        // Set CPU pstate
-        if let Ok(pstate) = intel_pstate::PState::new() {
-            match mode {
-                FanLevel::Normal => {
-                    pstate.set_min_perf_pct(config.power_profiles.normal.min_percentage)?;
-                    pstate.set_max_perf_pct(config.power_profiles.normal.max_percentage)?;
-                    pstate.set_no_turbo(config.power_profiles.normal.no_turbo)?;
-                    info!(
-                        "Intel CPU Power: min: {:?}%, max: {:?}%, turbo: {:?}",
-                        config.power_profiles.normal.min_percentage,
-                        config.power_profiles.normal.max_percentage,
-                        !config.power_profiles.normal.no_turbo
-                    );
-                }
-                FanLevel::Boost => {
-                    pstate.set_min_perf_pct(config.power_profiles.boost.min_percentage)?;
-                    pstate.set_max_perf_pct(config.power_profiles.boost.max_percentage)?;
-                    pstate.set_no_turbo(config.power_profiles.boost.no_turbo)?;
-                    info!(
-                        "Intel CPU Power: min: {:?}%, max: {:?}%, turbo: {:?}",
-                        config.power_profiles.boost.min_percentage,
-                        config.power_profiles.boost.max_percentage,
-                        !config.power_profiles.boost.no_turbo
-                    );
-                }
-                FanLevel::Silent => {
-                    pstate.set_min_perf_pct(config.power_profiles.silent.min_percentage)?;
-                    pstate.set_max_perf_pct(config.power_profiles.silent.max_percentage)?;
-                    pstate.set_no_turbo(config.power_profiles.silent.no_turbo)?;
-                    info!(
-                        "Intel CPU Power: min: {:?}%, max: {:?}%, turbo: {:?}",
-                        config.power_profiles.silent.min_percentage,
-                        config.power_profiles.silent.max_percentage,
-                        !config.power_profiles.silent.no_turbo
-                    );
-                }
-            }
-        } else {
-            info!("Setting pstate for AMD CPU");
-            // must be AMD CPU
-            let mut file = OpenOptions::new()
-                .write(true)
-                .open(AMD_BOOST_PATH)
-                .map_err(|err| {
-                    warn!("Failed to open AMD boost: {:?}", err);
-                    err
-                })?;
-            match mode {
-                FanLevel::Normal => {
-                    let boost = if config.power_profiles.normal.no_turbo {
-                        "0"
-                    } else {
-                        "1"
-                    }; // opposite of Intel
-                    file.write_all(boost.as_bytes()).unwrap_or_else(|err| {
-                        error!("Could not write to {}, {:?}", AMD_BOOST_PATH, err)
-                    });
-                    info!("AMD CPU Turbo: {:?}", boost);
-                }
-                FanLevel::Boost => {
-                    let boost = if config.power_profiles.boost.no_turbo {
-                        "0"
-                    } else {
-                        "1"
-                    };
-                    file.write_all(boost.as_bytes()).unwrap_or_else(|err| {
-                        error!("Could not write to {}, {:?}", AMD_BOOST_PATH, err)
-                    });
-                    info!("AMD CPU Turbo: {:?}", boost);
-                }
-                FanLevel::Silent => {
-                    let boost = if config.power_profiles.silent.no_turbo {
-                        "0"
-                    } else {
-                        "1"
-                    };
-                    file.write_all(boost.as_bytes()).unwrap_or_else(|err| {
-                        error!("Could not write to {}, {:?}", AMD_BOOST_PATH, err)
-                    });
-                    info!("AMD CPU Turbo: {:?}", boost);
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
-use crate::error::RogError;
-
-#[derive(Debug)]
-pub enum FanLevel {
-    Normal,
-    Boost,
-    Silent,
-}
-
-impl FromStr for FanLevel {
-    type Err = RogError;
-
-    fn from_str(s: &str) -> Result<Self, RogError> {
-        match s.to_lowercase().as_str() {
-            "normal" => Ok(FanLevel::Normal),
-            "boost" => Ok(FanLevel::Boost),
-            "silent" => Ok(FanLevel::Silent),
-            _ => Err(RogError::ParseFanLevel),
-        }
-    }
-}
-
-impl From<u8> for FanLevel {
-    fn from(n: u8) -> Self {
-        match n {
-            0 => FanLevel::Normal,
-            1 => FanLevel::Boost,
-            2 => FanLevel::Silent,
-            _ => FanLevel::Normal,
-        }
-    }
-}
-
-impl From<FanLevel> for u8 {
-    fn from(n: FanLevel) -> Self {
-        match n {
-            FanLevel::Normal => 0,
-            FanLevel::Boost => 1,
-            FanLevel::Silent => 2,
-        }
-    }
-}

asus-nb-ctrl/src/ctrl_leds.rs

@@ -1,337 +0,0 @@
-// Only these two packets must be 17 bytes
-static LED_APPLY: [u8; 17] = [0x5d, 0xb4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-static LED_SET: [u8; 17] = [0x5d, 0xb5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-use crate::{config::Config, error::RogError};
-use asus_nb::{
-    aura_brightness_bytes, aura_modes::AuraModes, fancy::KeyColourArray, DBUS_IFACE, DBUS_PATH,
-    LED_MSG_LEN,
-};
-use dbus::{channel::Sender, nonblock::SyncConnection, tree::Signal};
-use log::{info, warn};
-use std::error::Error;
-use std::fs::OpenOptions;
-use std::io::{Read, Write};
-use std::sync::Arc;
-use tokio::sync::mpsc::Receiver;
-use tokio::sync::Mutex;
-use tokio::task::JoinHandle;
-
-pub struct CtrlKbdBacklight {
-    led_node: String,
-    kbd_node: String,
-    bright_node: String,
-    supported_modes: Vec<u8>,
-    flip_effect_write: bool,
-}
-
-use async_trait::async_trait;
-
-#[async_trait]
-impl crate::Controller for CtrlKbdBacklight {
-    type A = AuraModes;
-
-    /// Spawns two tasks which continuously check for changes
-    fn spawn_task_loop(
-        self,
-        config: Arc<Mutex<Config>>,
-        mut recv: Receiver<Self::A>,
-        connection: Option<Arc<SyncConnection>>,
-        signal: Option<Arc<Signal<()>>>,
-    ) -> Vec<JoinHandle<()>> {
-        let gate1 = Arc::new(Mutex::new(self));
-        let gate2 = gate1.clone();
-
-        let config1 = config.clone();
-        vec![
-            tokio::spawn(async move {
-                while let Some(command) = recv.recv().await {
-                    let mut config = config1.lock().await;
-                    let mut lock = gate1.lock().await;
-                    match &command {
-                        AuraModes::PerKey(_) => {
-                            lock.do_command(command, &mut config)
-                                .await
-                                .unwrap_or_else(|err| warn!("{}", err));
-                        }
-                        _ => {
-                            let json = serde_json::to_string(&command).unwrap();
-                            lock.do_command(command, &mut config)
-                                .await
-                                .unwrap_or_else(|err| warn!("{}", err));
-                            connection
-                                .as_ref()
-                                .expect("LED Controller must have DBUS connection")
-                                .send(
-                                    signal
-                                        .as_ref()
-                                        .expect("LED Controller must have DBUS signal")
-                                        .msg(&DBUS_PATH.into(), &DBUS_IFACE.into())
-                                        .append1(json),
-                                )
-                                .unwrap_or_else(|_| 0);
-                        }
-                    }
-                }
-            }),
-            tokio::spawn(async move {
-                loop {
-                    tokio::time::delay_for(std::time::Duration::from_millis(100)).await;
-                    let mut lock = gate2.lock().await;
-                    let mut config = config.lock().await;
-                    lock.let_bright_check_change(&mut config)
-                        .unwrap_or_else(|err| warn!("led_ctrl: {:?}", err));
-                }
-            }),
-        ]
-    }
-
-    async fn reload_from_config(&mut self, config: &mut Config) -> Result<(), Box<dyn Error>> {
-        // set current mode (if any)
-        if self.supported_modes.len() > 1 {
-            if self.supported_modes.contains(&config.kbd_backlight_mode) {
-                let mode = config
-                    .get_led_mode_data(config.kbd_backlight_mode)
-                    .ok_or(RogError::NotSupported)?
-                    .to_owned();
-                self.write_mode(&mode).await?;
-                info!("Reloaded last used mode");
-            } else {
-                warn!(
-                    "An unsupported mode was set: {}, reset to first mode available",
-                    <&str>::from(&<AuraModes>::from(config.kbd_backlight_mode))
-                );
-                for (idx, mode) in config.kbd_backlight_modes.iter_mut().enumerate() {
-                    if !self.supported_modes.contains(&mode.into()) {
-                        config.kbd_backlight_modes.remove(idx);
-                        config.write();
-                        break;
-                    }
-                }
-                config.kbd_backlight_mode = self.supported_modes[0];
-                // TODO: do a recursive call with a boxed dyn future later
-                let mode = config
-                    .get_led_mode_data(config.kbd_backlight_mode)
-                    .ok_or(RogError::NotSupported)?
-                    .to_owned();
-                self.write_mode(&mode).await?;
-                info!("Reloaded last used mode");
-            }
-        }
-
-        // Reload brightness
-        let bright = config.kbd_led_brightness;
-        let bytes = aura_brightness_bytes(bright);
-        self.write_bytes(&bytes).await?;
-        info!("Reloaded last used brightness");
-        Ok(())
-    }
-}
-
-impl CtrlKbdBacklight {
-    #[inline]
-    pub fn new(id_product: &str, supported_modes: Vec<u8>) -> Result<Self, std::io::Error> {
-        Ok(CtrlKbdBacklight {
-            led_node: Self::get_node_failover(id_product, Self::scan_led_node)?,
-            kbd_node: Self::get_node_failover(id_product, Self::scan_kbd_node)?,
-            // brightness node path should always be constant but this *might* change?
-            bright_node: "/sys/class/leds/asus::kbd_backlight/brightness".to_string(),
-            supported_modes,
-            flip_effect_write: false,
-        })
-    }
-
-    fn get_node_failover(id_product: &str, fun: fn(&str) -> Result<String, std::io::Error>) -> Result<String, std::io::Error> {
-        for n in 0..2 {
-            match fun(id_product) {
-                Ok(o) => return Ok(o),
-                Err(e) => {
-                    if n > 0 {
-                        warn!("Looking for node: {}", e.to_string());
-                        std::thread::sleep(std::time::Duration::from_secs(1));
-                    } else {
-                        return Err(e);
-                    }
-                }
-            }
-        }
-        // Shouldn't be possible to reach this...
-        let err = std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            "node not found",
-        );
-        Err(err)
-    }
-
-    fn scan_led_node(id_product: &str) -> Result<String, std::io::Error> {
-        let mut enumerator = udev::Enumerator::new()?;
-        enumerator.match_subsystem("hidraw")?;
-
-        for device in enumerator.scan_devices()? {
-            if let Some(parent) = device.parent_with_subsystem_devtype("usb", "usb_device")? {
-                if parent.attribute_value("idProduct").unwrap() == id_product {
-                    // && device.parent().unwrap().sysnum().unwrap() == 3
-                    if let Some(dev_node) = device.devnode() {
-                        info!("Using device at: {:?} for LED control", dev_node);
-                        return Ok(dev_node.to_string_lossy().to_string());
-                    }
-                }
-            }
-        }
-        let err = std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            "ASUS LED device node not found",
-        );
-        Err(err)
-    }
-
-    fn scan_kbd_node(id_product: &str) -> Result<String, std::io::Error> {
-        let mut enumerator = udev::Enumerator::new()?;
-        enumerator.match_subsystem("input")?;
-        enumerator.match_property("ID_MODEL_ID", id_product)?;
-
-        for device in enumerator.scan_devices()? {
-            if let Some(dev_node) = device.devnode() {
-                if let Some(inum) = device.property_value("ID_USB_INTERFACE_NUM") {
-                    if inum == "02" {
-                        info!("Using device at: {:?} for keyboard polling", dev_node);
-                        return Ok(dev_node.to_string_lossy().to_string());
-                    }
-                }
-            }
-        }
-        let err = std::io::Error::new(
-            std::io::ErrorKind::NotFound,
-            "ASUS N-Key Consumer Device node not found",
-        );
-        Err(err)
-    }
-
-    fn let_bright_check_change(&mut self, config: &mut Config) -> Result<(), Box<dyn Error>> {
-        let mut file = OpenOptions::new().read(true).open(&self.bright_node)?;
-        let mut buf = [0u8; 1];
-        file.read_exact(&mut buf)?;
-        if let Some(num) = char::from(buf[0]).to_digit(10) {
-            if config.kbd_led_brightness != num as u8 {
-                config.read();
-                config.kbd_led_brightness = num as u8;
-                config.write();
-            }
-            return Ok(());
-        }
-        let err = std::io::Error::new(
-            std::io::ErrorKind::InvalidData,
-            "LED brightness could not be parsed",
-        );
-        Err(Box::new(err))
-    }
-
-    pub async fn do_command(
-        &mut self,
-        mode: AuraModes,
-        config: &mut Config,
-    ) -> Result<(), Box<dyn Error>> {
-        self.set_and_save(mode, config).await
-    }
-
-    /// Should only be used if the bytes you are writing are verified correct
-    #[inline]
-    async fn write_bytes(&self, message: &[u8]) -> Result<(), Box<dyn Error>> {
-        if let Ok(mut file) = OpenOptions::new().write(true).open(&self.led_node) {
-            file.write_all(message).unwrap();
-            return Ok(());
-        }
-        Err(Box::new(RogError::NotSupported))
-    }
-
-    /// Write an effect block
-    #[inline]
-    async fn write_effect(&mut self, effect: &[Vec<u8>]) -> Result<(), Box<dyn Error>> {
-        if self.flip_effect_write {
-            for row in effect.iter().rev() {
-                self.write_bytes(row).await?;
-            }
-        } else {
-            for row in effect.iter() {
-                self.write_bytes(row).await?;
-            }
-        }
-        self.flip_effect_write = !self.flip_effect_write;
-        Ok(())
-    }
-
-    /// Used to set a builtin mode and save the settings for it
-    ///
-    /// This needs to be universal so that settings applied by dbus stick
-    #[inline]
-    async fn set_and_save(
-        &mut self,
-        mode: AuraModes,
-        config: &mut Config,
-    ) -> Result<(), Box<dyn Error>> {
-        match mode {
-            AuraModes::LedBrightness(n) => {
-                let bytes: [u8; LED_MSG_LEN] = (&mode).into();
-                self.write_bytes(&bytes).await?;
-                config.read();
-                config.kbd_led_brightness = n;
-                config.write();
-                info!("LED brightness set to {:#?}", n);
-            }
-            AuraModes::PerKey(v) => {
-                if v.is_empty() || v[0].is_empty() {
-                    let bytes = KeyColourArray::get_init_msg();
-                    self.write_bytes(&bytes).await?;
-                } else {
-                    self.write_effect(&v).await?;
-                }
-            }
-            _ => {
-                config.read();
-                let mode_num: u8 = u8::from(&mode);
-                self.write_mode(&mode).await?;
-                config.kbd_backlight_mode = mode_num;
-                config.set_mode_data(mode);
-                config.write();
-            }
-        }
-        Ok(())
-    }
-
-    #[inline]
-    async fn write_mode(&mut self, mode: &AuraModes) -> Result<(), Box<dyn Error>> {
-        match mode {
-            AuraModes::PerKey(v) => {
-                if v.is_empty() || v[0].is_empty() {
-                    let bytes = KeyColourArray::get_init_msg();
-                    self.write_bytes(&bytes).await?;
-                } else {
-                    self.write_effect(v).await?;
-                }
-            }
-            _ => {
-                let mode_num: u8 = u8::from(mode);
-                match mode {
-                    AuraModes::MultiStatic(_) => {
-                        if self.supported_modes.contains(&mode_num) {
-                            let bytes: [[u8; LED_MSG_LEN]; 4] = mode.into();
-                            for array in bytes.iter() {
-                                self.write_bytes(array).await?;
-                            }
-                        }
-                    }
-                    _ => {
-                        if self.supported_modes.contains(&mode_num) {
-                            let bytes: [u8; LED_MSG_LEN] = mode.into();
-                            self.write_bytes(&bytes).await?;
-                        }
-                    }
-                }
-                self.write_bytes(&LED_SET).await?;
-                // Changes won't persist unless apply is set
-                self.write_bytes(&LED_APPLY).await?;
-            }
-        }
-        Ok(())
-    }
-}

asus-nb-ctrl/src/daemon.rs

@@ -1,253 +0,0 @@
-use daemon::{
-    config::Config, ctrl_anime::CtrlAnimeDisplay, ctrl_charge::CtrlCharge,
-    ctrl_fan_cpu::CtrlFanAndCPU, ctrl_leds::CtrlKbdBacklight, dbus::dbus_create_tree,
-    laptops::match_laptop,
-};
-
-use dbus::{
-    channel::Sender,
-    nonblock::{Process, SyncConnection},
-    tree::Signal,
-};
-use dbus_tokio::connection;
-
-use asus_nb::{DBUS_IFACE, DBUS_NAME, DBUS_PATH};
-use daemon::Controller;
-use log::LevelFilter;
-use log::{error, info, warn};
-use std::error::Error;
-use std::io::Write;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-
-#[tokio::main]
-pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut logger = env_logger::Builder::new();
-    logger
-        .target(env_logger::Target::Stdout)
-        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
-        .init();
-
-    info!("Version: {}", daemon::VERSION);
-    start_daemon().await?;
-    Ok(())
-}
-
-// Timing is such that:
-// - interrupt write is minimum 1ms (sometimes lower)
-// - read interrupt must timeout, minimum of 1ms
-// - for a single usb packet, 2ms total.
-// - to maintain constant times of 1ms, per-key colours should use
-//   the effect endpoint so that the complete colour block is written
-//   as fast as 1ms per row of the matrix inside it. (10ms total time)
-//
-// DBUS processing takes 6ms if not tokiod
-pub async fn start_daemon() -> Result<(), Box<dyn Error>> {
-    let laptop = match_laptop();
-    let mut config = if let Some(laptop) = laptop.as_ref() {
-        Config::default().load(laptop.supported_modes())
-    } else {
-        Config::default().load(&[])
-    };
-
-    let mut led_control = if let Some(laptop) = laptop {
-        CtrlKbdBacklight::new(laptop.usb_product(), laptop.supported_modes().to_owned())
-            .map_or_else(
-                |err| {
-                    error!("{}", err);
-                    None
-                },
-                Some,
-            )
-    } else {
-        None
-    };
-
-    let mut charge_control = CtrlCharge::new().map_or_else(
-        |err| {
-            error!("{}", err);
-            None
-        },
-        Some,
-    );
-
-    let mut fan_control = CtrlFanAndCPU::new().map_or_else(
-        |err| {
-            error!("{}", err);
-            None
-        },
-        Some,
-    );
-
-    // Reload settings
-    if let Some(ctrl) = fan_control.as_mut() {
-        ctrl.reload_from_config(&mut config)
-            .await
-            .unwrap_or_else(|err| warn!("Fan mode: {}", err));
-    }
-
-    if let Some(ctrl) = charge_control.as_mut() {
-        ctrl.reload_from_config(&mut config)
-            .await
-            .unwrap_or_else(|err| warn!("Battery charge limit: {}", err));
-    }
-
-    if let Some(ctrl) = led_control.as_mut() {
-        ctrl.reload_from_config(&mut config)
-            .await
-            .unwrap_or_else(|err| warn!("Reload settings: {}", err));
-    }
-
-    let (resource, connection) = connection::new_system_sync()?;
-    tokio::spawn(async {
-        let err = resource.await;
-        panic!("Lost connection to D-Bus: {}", err);
-    });
-
-    connection
-        .request_name(DBUS_NAME, false, true, true)
-        .await?;
-
-    let config = Arc::new(Mutex::new(config));
-    let (
-        tree,
-        aura_command_recv,
-        animatrix_recv,
-        fan_mode_recv,
-        charge_limit_recv,
-        led_changed_signal,
-        fanmode_signal,
-        charge_limit_signal,
-    ) = dbus_create_tree(config.clone());
-
-    // We add the tree to the connection so that incoming method calls will be handled.
-    tree.start_receive_send(&*connection);
-
-    // Send boot signals
-    send_boot_signals(
-        connection.clone(),
-        config.clone(),
-        fanmode_signal.clone(),
-        charge_limit_signal.clone(),
-        led_changed_signal.clone(),
-    )
-    .await?;
-
-    // For helping with processing signals
-    start_signal_task(
-        connection.clone(),
-        config.clone(),
-        fanmode_signal,
-        charge_limit_signal,
-    );
-
-    // Begin all tasks
-    let mut handles = Vec::new();
-    if let Ok(ctrl) = CtrlAnimeDisplay::new() {
-        handles.append(&mut ctrl.spawn_task_loop(config.clone(), animatrix_recv, None, None));
-    }
-
-    if let Some(ctrl) = fan_control.take() {
-        handles.append(&mut ctrl.spawn_task_loop(config.clone(), fan_mode_recv, None, None));
-    }
-
-    if let Some(ctrl) = charge_control.take() {
-        handles.append(&mut ctrl.spawn_task_loop(config.clone(), charge_limit_recv, None, None));
-    }
-
-    if let Some(ctrl) = led_control.take() {
-        handles.append(&mut ctrl.spawn_task_loop(
-            config.clone(),
-            aura_command_recv,
-            Some(connection.clone()),
-            Some(led_changed_signal),
-        ));
-    }
-
-    connection.process_all();
-    for handle in handles {
-        handle.await?;
-    }
-
-    Ok(())
-}
-
-// TODO: Move these in to the controllers tasks
-fn start_signal_task(
-    connection: Arc<SyncConnection>,
-    config: Arc<Mutex<Config>>,
-    fanmode_signal: Arc<Signal<()>>,
-    charge_limit_signal: Arc<Signal<()>>,
-) {
-    tokio::spawn(async move {
-        // Some small things we need to track, without passing all sorts of stuff around
-        let mut last_fan_mode = config.lock().await.power_profile;
-        let mut last_charge_limit = config.lock().await.bat_charge_limit;
-        loop {
-            // Use tokio sleep to not hold up other threads
-            tokio::time::delay_for(std::time::Duration::from_millis(500)).await;
-
-            let config = config.lock().await;
-            if config.power_profile != last_fan_mode {
-                last_fan_mode = config.power_profile;
-                connection
-                    .send(
-                        fanmode_signal
-                            .msg(&DBUS_PATH.into(), &DBUS_IFACE.into())
-                            .append1(last_fan_mode),
-                    )
-                    .unwrap_or_else(|_| 0);
-            }
-
-            if config.bat_charge_limit != last_charge_limit {
-                last_charge_limit = config.bat_charge_limit;
-                connection
-                    .send(
-                        charge_limit_signal
-                            .msg(&DBUS_PATH.into(), &DBUS_IFACE.into())
-                            .append1(last_charge_limit),
-                    )
-                    .unwrap_or_else(|_| 0);
-            }
-        }
-    });
-}
-
-async fn send_boot_signals(
-    connection: Arc<SyncConnection>,
-    config: Arc<Mutex<Config>>,
-    fanmode_signal: Arc<Signal<()>>,
-    charge_limit_signal: Arc<Signal<()>>,
-    led_changed_signal: Arc<Signal<()>>,
-) -> Result<(), Box<dyn Error>> {
-    let config = config.lock().await;
-
-    if let Some(data) = config.get_led_mode_data(config.kbd_backlight_mode) {
-        connection
-            .send(
-                led_changed_signal
-                    .msg(&DBUS_PATH.into(), &DBUS_IFACE.into())
-                    .append1(serde_json::to_string(data)?),
-            )
-            .unwrap_or_else(|_| 0);
-    }
-
-    connection
-        .send(
-            fanmode_signal
-                .msg(&DBUS_PATH.into(), &DBUS_IFACE.into())
-                .append1(config.power_profile),
-        )
-        .unwrap_or_else(|_| 0);
-
-    connection
-        .send(
-            charge_limit_signal
-                .msg(&DBUS_PATH.into(), &DBUS_IFACE.into())
-                .append1(config.bat_charge_limit),
-        )
-        .unwrap_or_else(|_| 0);
-
-    Ok(())
-}

asus-nb-ctrl/src/dbus.rs

@@ -1,235 +0,0 @@
-use crate::config::Config;
-use asus_nb::{aura_modes::AuraModes, DBUS_IFACE, DBUS_PATH};
-use dbus::tree::{Factory, MTSync, Method, MethodErr, Signal, Tree};
-use log::warn;
-use std::sync::Arc;
-use tokio::sync::{
-    mpsc::{channel, Receiver, Sender},
-    Mutex,
-};
-
-fn set_keyboard_backlight(sender: Mutex<Sender<AuraModes>>) -> Method<MTSync, ()> {
-    let factory = Factory::new_sync::<()>();
-    factory
-        // method for ledmessage
-        .method("SetKeyBacklight", (), {
-            move |m| {
-                let json: &str = m.msg.read1()?;
-                if let Ok(mut lock) = sender.try_lock() {
-                    if let Ok(data) = serde_json::from_str(json) {
-                        lock.try_send(data).unwrap_or_else(|err| {
-                            warn!("SetKeyBacklight over mpsc failed: {}", err)
-                        });
-                    } else {
-                        warn!("SetKeyBacklight could not deserialise");
-                    }
-                    Ok(vec![])
-                } else {
-                    Err(MethodErr::failed("Could not lock daemon for access"))
-                }
-            }
-        })
-        .inarg::<&str, _>("json")
-        .annotate("org.freedesktop.DBus.Method.NoReply", "true")
-}
-
-fn get_keyboard_backlight(config: Arc<Mutex<Config>>) -> Method<MTSync, ()> {
-    let factory = Factory::new_sync::<()>();
-    factory
-        .method("GetKeyBacklight", (), {
-            move |m| {
-                if let Ok(lock) = config.try_lock() {
-                    for mode in &lock.kbd_backlight_modes {
-                        if lock.kbd_backlight_mode == <u8>::from(mode) {
-                            let mode = serde_json::to_string(&mode).unwrap();
-                            let mret = m.msg.method_return().append1(mode);
-                            return Ok(vec![mret]);
-                        }
-                    }
-                    Err(MethodErr::failed(
-                        "Keyboard LED mode set to an invalid mode",
-                    ))
-                } else {
-                    Err(MethodErr::failed("Could not lock config for access"))
-                }
-            }
-        })
-        .outarg::<&str, _>("json")
-}
-
-fn get_keyboard_backlight_modes(config: Arc<Mutex<Config>>) -> Method<MTSync, ()> {
-    let factory = Factory::new_sync::<()>();
-    factory
-        .method("GetKeyBacklightModes", (), {
-            move |m| {
-                if let Ok(lock) = config.try_lock() {
-                    let mode = serde_json::to_string(&lock.kbd_backlight_modes).unwrap();
-                    let mret = m.msg.method_return().append1(mode);
-                    Ok(vec![mret])
-                } else {
-                    Err(MethodErr::failed("Could not lock config for access"))
-                }
-            }
-        })
-        .outarg::<&str, _>("json")
-}
-
-fn set_animatrix(
-    sender: Mutex<Sender<Vec<Vec<u8>>>>, // need mutex only to get interior mutability in MTSync
-) -> Method<MTSync, ()> {
-    let factory = Factory::new_sync::<()>();
-    factory
-        // method for ledmessage
-        .method("AnimatrixWrite", (), {
-            move |m| {
-                let mut iter = m.msg.iter_init();
-                let byte_array: Vec<Vec<u8>> = vec![iter.read()?, iter.read()?];
-                if let Ok(mut lock) = sender.try_lock() {
-                    // Ignore errors if the channel is already full
-                    lock.try_send(byte_array).unwrap_or_else(|_err| {});
-                    Ok(vec![])
-                } else {
-                    Err(MethodErr::failed("Could not lock daemon for access"))
-                }
-            }
-        })
-        .inarg::<Vec<u8>, _>("bytearray1")
-        .inarg::<Vec<u8>, _>("bytearray2")
-        .annotate("org.freedesktop.DBus.Method.NoReply", "true")
-}
-
-fn set_fan_mode(sender: Mutex<Sender<u8>>) -> Method<MTSync, ()> {
-    let factory = Factory::new_sync::<()>();
-    factory
-        // method for ledmessage
-        .method("SetFanMode", (), {
-            move |m| {
-                if let Ok(mut lock) = sender.try_lock() {
-                    let mut iter = m.msg.iter_init();
-                    let byte: u8 = iter.read()?;
-                    lock.try_send(byte).unwrap_or_else(|_err| {});
-                    Ok(vec![])
-                } else {
-                    Err(MethodErr::failed("Could not lock daemon for access"))
-                }
-            }
-        })
-        .inarg::<u8, _>("mode")
-        .annotate("org.freedesktop.DBus.Method.NoReply", "true")
-}
-
-fn get_fan_mode(config: Arc<Mutex<Config>>) -> Method<MTSync, ()> {
-    let factory = Factory::new_sync::<()>();
-    factory
-        .method("GetFanMode", (), {
-            move |m| {
-                if let Ok(lock) = config.try_lock() {
-                    let mret = m.msg.method_return().append1(lock.power_profile);
-                    Ok(vec![mret])
-                } else {
-                    Err(MethodErr::failed("Could not lock config for access"))
-                }
-            }
-        })
-        .outarg::<u8, _>("mode")
-}
-
-fn get_charge_limit(config: Arc<Mutex<Config>>) -> Method<MTSync, ()> {
-    let factory = Factory::new_sync::<()>();
-    factory
-        .method("GetChargeLimit", (), {
-            move |m| {
-                if let Ok(lock) = config.try_lock() {
-                    let mret = m.msg.method_return().append1(lock.bat_charge_limit);
-                    Ok(vec![mret])
-                } else {
-                    Err(MethodErr::failed("Could not lock config for access"))
-                }
-            }
-        })
-        .outarg::<u8, _>("limit")
-}
-
-fn set_charge_limit(sender: Mutex<Sender<u8>>) -> Method<MTSync, ()> {
-    let factory = Factory::new_sync::<()>();
-    factory
-        // method for ledmessage
-        .method("SetChargeLimit", (), {
-            move |m| {
-                if let Ok(mut lock) = sender.try_lock() {
-                    let mut iter = m.msg.iter_init();
-                    let byte: u8 = iter.read()?;
-                    lock.try_send(byte).unwrap_or_else(|_err| {});
-                    Ok(vec![])
-                } else {
-                    Err(MethodErr::failed("Could not lock daemon for access"))
-                }
-            }
-        })
-        .inarg::<u8, _>("limit")
-        .annotate("org.freedesktop.DBus.Method.NoReply", "true")
-}
-
-#[allow(clippy::type_complexity)]
-pub fn dbus_create_tree(
-    config: Arc<Mutex<Config>>,
-) -> (
-    Tree<MTSync, ()>,
-    Receiver<AuraModes>,
-    Receiver<Vec<Vec<u8>>>,
-    Receiver<u8>,
-    Receiver<u8>,
-    Arc<Signal<()>>,
-    Arc<Signal<()>>,
-    Arc<Signal<()>>,
-) {
-    let (aura_command_send, aura_command_recv) = channel::<AuraModes>(1);
-    let (animatrix_send, animatrix_recv) = channel::<Vec<Vec<u8>>>(1);
-    let (fan_mode_send, fan_mode_recv) = channel::<u8>(1);
-    let (charge_send, charge_recv) = channel::<u8>(1);
-
-    let factory = Factory::new_sync::<()>();
-
-    let key_backlight_changed = Arc::new(
-        factory
-            .signal("KeyBacklightChanged", ())
-            .sarg::<&str, _>("json"),
-    );
-    let chrg_limit_changed = Arc::new(
-        factory
-            .signal("ChargeLimitChanged", ())
-            .sarg::<u8, _>("limit"),
-    );
-    let fanmode_changed = Arc::new(factory.signal("FanModeChanged", ()).sarg::<u8, _>("mode"));
-
-    let tree = factory
-        .tree(())
-        .add(
-            factory.object_path(DBUS_PATH, ()).introspectable().add(
-                factory
-                    .interface(DBUS_IFACE, ())
-                    .add_m(set_keyboard_backlight(Mutex::new(aura_command_send)))
-                    .add_m(set_animatrix(Mutex::new(animatrix_send)))
-                    .add_m(set_fan_mode(Mutex::new(fan_mode_send)))
-                    .add_m(set_charge_limit(Mutex::new(charge_send)))
-                    .add_m(get_fan_mode(config.clone()))
-                    .add_m(get_charge_limit(config.clone()))
-                    .add_m(get_keyboard_backlight(config.clone()))
-                    .add_m(get_keyboard_backlight_modes(config))
-                    .add_s(key_backlight_changed.clone())
-                    .add_s(fanmode_changed.clone())
-                    .add_s(chrg_limit_changed.clone()),
-            ),
-        )
-        .add(factory.object_path("/", ()).introspectable());
-    (
-        tree,
-        aura_command_recv,
-        animatrix_recv,
-        fan_mode_recv,
-        charge_recv,
-        key_backlight_changed,
-        fanmode_changed,
-        chrg_limit_changed,
-    )
-}

asus-nb-ctrl/src/error.rs

@@ -1,19 +0,0 @@
-use std::fmt;
-
-#[derive(Debug)]
-pub enum RogError {
-    ParseFanLevel,
-    NotSupported,
-}
-
-impl std::error::Error for RogError {}
-
-impl fmt::Display for RogError {
-    // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            RogError::ParseFanLevel => write!(f, "Parse error"),
-            RogError::NotSupported => write!(f, "Not supported"),
-        }
-    }
-}

asus-nb-ctrl/src/laptops.rs

@@ -1,140 +0,0 @@
-use asus_nb::aura_modes::{AuraModes, BREATHING, STATIC, STROBE};
-use log::{info, warn};
-use serde_derive::{Deserialize, Serialize};
-use std::fs::OpenOptions;
-use std::io::Read;
-
-pub static LEDMODE_CONFIG_PATH: &str = "/etc/asusd/asusd-ledmodes.toml";
-
-static HELP_ADDRESS: &str = "https://gitlab.com/asus-linux/asus-nb-ctrl";
-
-pub struct LaptopBase {
-    usb_product: String,
-    supported_modes: Vec<u8>,
-}
-
-impl LaptopBase {
-    pub fn usb_product(&self) -> &str {
-        &self.usb_product
-    }
-    pub fn supported_modes(&self) -> &[u8] {
-        &self.supported_modes
-    }
-}
-
-pub fn match_laptop() -> Option<LaptopBase> {
-    for device in rusb::devices().unwrap().iter() {
-        let device_desc = device.device_descriptor().unwrap();
-        if device_desc.vendor_id() == 0x0b05 {
-            match device_desc.product_id() {
-                0x1866 => {
-                    let laptop = select_1866_device("1866".to_owned());
-                    print_modes(&laptop.supported_modes);
-                    return Some(laptop);
-                }
-                0x1869 => return Some(select_1866_device("1869".to_owned())),
-                0x1854 => {
-                    info!("Found GL753 or similar");
-                    return Some(LaptopBase {
-                        usb_product: "1854".to_string(),
-                        supported_modes: vec![STATIC, BREATHING, STROBE],
-                    });
-                }
-                _ => {}
-            }
-        }
-    }
-    None
-}
-
-fn select_1866_device(prod: String) -> LaptopBase {
-    let dmi = sysfs_class::DmiId::default();
-    let board_name = dmi.board_name().expect("Could not get board_name");
-    let prod_family = dmi.product_family().expect("Could not get product_family");
-    let prod_name = dmi.product_name().expect("Could not get product_name");
-
-    info!("Product name: {}", prod_name.trim());
-    info!("Board name: {}", board_name.trim());
-
-    let mut laptop = LaptopBase {
-        usb_product: prod,
-        supported_modes: vec![],
-    };
-
-    if let Some(modes) = LEDModeGroup::load_from_config() {
-        if let Some(led_modes) = modes.matcher(&prod_family, &board_name) {
-            laptop.supported_modes = led_modes;
-            return laptop;
-        }
-    }
-
-    warn!(
-        "Unsupported laptop, please request support at {}",
-        HELP_ADDRESS
-    );
-    warn!("Continuing with minimal support");
-
-    laptop
-}
-
-fn print_modes(supported_modes: &[u8]) {
-    if !supported_modes.is_empty() {
-        info!("Supported Keyboard LED modes are:");
-        for mode in supported_modes {
-            let mode = <&str>::from(&<AuraModes>::from(*mode));
-            info!("- {}", mode);
-        }
-        info!(
-            "If these modes are incorrect or missing please request support at {}",
-            HELP_ADDRESS
-        );
-    } else {
-        info!("No RGB control available");
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct LEDModeGroup {
-    led_modes: Vec<LEDModes>,
-}
-
-impl LEDModeGroup {
-    /// Consumes the LEDModes
-    fn matcher(self, prod_family: &str, board_name: &str) -> Option<Vec<u8>> {
-        for led_modes in self.led_modes {
-            if prod_family.contains(&led_modes.prod_family) {
-                for board in led_modes.board_names {
-                    if board_name.contains(&board) {
-                        info!("Matched to {} {}", led_modes.prod_family, board);
-                        return Some(led_modes.led_modes);
-                    }
-                }
-            }
-        }
-        None
-    }
-
-    fn load_from_config() -> Option<Self> {
-        if let Ok(mut file) = OpenOptions::new().read(true).open(&LEDMODE_CONFIG_PATH) {
-            let mut buf = String::new();
-            if let Ok(l) = file.read_to_string(&mut buf) {
-                if l == 0 {
-                    warn!("{} is empty", LEDMODE_CONFIG_PATH);
-                } else {
-                    return Some(toml::from_str(&buf).unwrap_or_else(|_| {
-                        panic!("Could not deserialise {}", LEDMODE_CONFIG_PATH)
-                    }));
-                }
-            }
-        }
-        warn!("Does {} exist?", LEDMODE_CONFIG_PATH);
-        None
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct LEDModes {
-    prod_family: String,
-    board_names: Vec<String>,
-    led_modes: Vec<u8>,
-}

asus-nb-ctrl/src/lib.rs

@@ -1,45 +0,0 @@
-#![deny(unused_must_use)]
-/// Configuration loading, saving
-pub mod config;
-///
-pub mod ctrl_anime;
-///
-pub mod ctrl_charge;
-///
-pub mod ctrl_fan_cpu;
-///
-pub mod ctrl_leds;
-///
-pub mod dbus;
-/// Laptop matching to determine capabilities
-pub mod laptops;
-
-mod error;
-
-use async_trait::async_trait;
-use config::Config;
-use std::error::Error;
-use std::sync::Arc;
-use tokio::sync::{mpsc::Receiver, Mutex};
-use tokio::task::JoinHandle;
-
-pub static VERSION: &str = "1.0.3";
-
-use ::dbus::{nonblock::SyncConnection, tree::Signal};
-
-#[async_trait]
-pub trait Controller {
-    type A;
-
-    async fn reload_from_config(&mut self, config: &mut Config) -> Result<(), Box<dyn Error>>;
-
-    /// Spawn an infinitely running task (usually) which checks a Receiver for input,
-    /// and may send a signal over dbus
-    fn spawn_task_loop(
-        self,
-        config: Arc<Mutex<Config>>,
-        recv: Receiver<Self::A>,
-        connection: Option<Arc<SyncConnection>>,
-        signal: Option<Arc<Signal<()>>>,
-    ) -> Vec<JoinHandle<()>>;
-}

asus-nb-ctrl/src/main.rs

@@ -1,72 +0,0 @@
-use asus_nb::{
-    cli_options::{LedBrightness, SetAuraBuiltin},
-    core_dbus::AuraDbusClient,
-};
-use daemon::ctrl_fan_cpu::FanLevel;
-use gumdrop::Options;
-use log::LevelFilter;
-use std::io::Write;
-
-#[derive(Options)]
-struct CLIStart {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(help = "show program version number")]
-    version: bool,
-    #[options(meta = "VAL", help = "<off, low, med, high>")]
-    kbd_bright: Option<LedBrightness>,
-    #[options(meta = "PWR", help = "<silent, normal, boost>")]
-    pwr_profile: Option<FanLevel>,
-    #[options(meta = "CHRG", help = "<20-100>")]
-    chg_limit: Option<u8>,
-    #[options(command)]
-    command: Option<Command>,
-}
-
-#[derive(Options)]
-enum Command {
-    #[options(help = "Set the keyboard lighting from built-in modes")]
-    LedMode(LedModeCommand),
-}
-
-#[derive(Options)]
-struct LedModeCommand {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(command, required)]
-    command: Option<SetAuraBuiltin>,
-}
-
-#[tokio::main]
-pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut logger = env_logger::Builder::new();
-    logger
-        .target(env_logger::Target::Stdout)
-        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
-        .filter(None, LevelFilter::Info)
-        .init();
-
-    let parsed = CLIStart::parse_args_default_or_exit();
-
-    if parsed.version {
-        println!("Version: {}", daemon::VERSION);
-    }
-
-    let writer = AuraDbusClient::new()?;
-
-    if let Some(Command::LedMode(mode)) = parsed.command {
-        if let Some(command) = mode.command {
-            writer.write_builtin_mode(&command.into())?
-        }
-    }
-    if let Some(brightness) = parsed.kbd_bright {
-        writer.write_brightness(brightness.level())?;
-    }
-    if let Some(fan_level) = parsed.pwr_profile {
-        writer.write_fan_mode(fan_level.into())?;
-    }
-    if let Some(chg_limit) = parsed.chg_limit {
-        writer.write_charge_limit(chg_limit)?;
-    }
-    Ok(())
-}

asus-nb/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "asus-nb"
-version = "0.15.0"
-license = "MPL-2.0"
-readme = "README.md"
-authors = ["Luke <luke@ljones.dev>"]
-repository = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-homepage = "https://gitlab.com/asus-linux/asus-nb-ctrl"
-description = "A small library of effect types and conversions for ROG Aura"
-edition = "2018"
-
-[dependencies]
-gumdrop = "^0.8"
-dbus = { version = "^0.8" }
-serde = "^1.0"
-serde_derive = "^1.0"
-serde_json = "^1.0"
-yansi-term = "^0.1"
-
-[dev-dependencies]
-tinybmp = "^0.2.3"

asus-nb/examples/animatrix.rs

@@ -1,41 +0,0 @@
-use asus_nb::anime_dbus::AniMeDbusWriter;
-use asus_nb::anime_matrix::{AniMeMatrix, AniMePacketType, HEIGHT, WIDTH};
-use tinybmp::{Bmp, Pixel};
-
-fn main() {
-    let mut writer = AniMeDbusWriter::new().unwrap();
-
-    let bmp =
-        Bmp::from_slice(include_bytes!("non-skewed_r.bmp")).expect("Failed to parse BMP image");
-    let pixels: Vec<Pixel> = bmp.into_iter().collect();
-    //assert_eq!(pixels.len(), 56 * 56);
-
-    // Try an outline, top and right
-    let mut matrix = AniMeMatrix::new();
-
-    // Aligned left
-    for px in pixels {
-        if (px.x as usize / 2) < WIDTH && (px.y as usize) < HEIGHT && px.x % 2 == 0 {
-            matrix.get_mut()[px.y as usize][px.x as usize / 2] = px.color as u8;
-        }
-    }
-
-    // Throw an alignment border up
-    // {
-    //     let tmp = matrix.get_mut();
-    //     for x in tmp[0].iter_mut() {
-    //         *x = 0xff;
-    //     }
-    //     for row in tmp.iter_mut() {
-    //         row[row.len() - 1] = 0xff;
-    //     }
-    // }
-
-    matrix.debug_print();
-
-    let mut matrix: AniMePacketType = AniMePacketType::from(matrix);
-    // println!("{:?}", matrix[0].to_vec());
-    // println!("{:?}", matrix[1].to_vec());
-
-    writer.write_image(&mut matrix).unwrap();
-}

asus-nb/examples/ball.rs

@@ -1,98 +0,0 @@
-use asus_nb::{
-    core_dbus::AuraDbusClient,
-    fancy::{GX502Layout, Key, KeyColourArray, KeyLayout},
-};
-use std::collections::LinkedList;
-
-#[derive(Debug, Clone)]
-struct Ball {
-    position: (i32, i32),
-    direction: (i32, i32),
-    trail: LinkedList<(i32, i32)>,
-}
-impl Ball {
-    fn new(x: i32, y: i32, trail_len: u32) -> Self {
-        let mut trail = LinkedList::new();
-        for _ in 1..=trail_len {
-            trail.push_back((x, y));
-        }
-
-        Ball {
-            position: (x, y),
-            direction: (1, 1),
-            trail,
-        }
-    }
-
-    #[allow(clippy::if_same_then_else)]
-    fn update(&mut self, key_map: &[[Key; 17]]) {
-        let pos = self.position;
-        let dir = self.direction;
-
-        if pos.0 + dir.0 > key_map[pos.1 as usize].len() as i32 - 1 || pos.0 + dir.0 < 0 {
-            self.direction.0 *= -1;
-        } else if key_map[(pos.1) as usize][(pos.0 + dir.0) as usize] == Key::None {
-            self.direction.0 *= -1;
-        }
-
-        if pos.1 + dir.1 > key_map.len() as i32 - 1 || pos.1 + dir.1 < 0 {
-            self.direction.1 *= -1;
-        } else if key_map[(pos.1 + dir.1) as usize][(pos.0) as usize] == Key::None {
-            self.direction.1 *= -1;
-        }
-
-        self.trail.pop_front();
-        self.trail.push_back(self.position);
-
-        self.position.0 += self.direction.0;
-        self.position.1 += self.direction.1;
-
-        if self.position.0 > key_map[self.position.1 as usize].len() as i32 {
-            self.position.0 = key_map[self.position.1 as usize].len() as i32 - 1;
-        }
-    }
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut writer = AuraDbusClient::new()?;
-
-    let mut colours = KeyColourArray::new();
-
-    let layout = GX502Layout::default();
-
-    let mut balls = [Ball::new(2, 1, 12), Ball::new(4, 6, 12)];
-
-    writer.init_effect()?;
-
-    let rows = layout.get_rows();
-    loop {
-        for (n, ball) in balls.iter_mut().enumerate() {
-            ball.update(rows);
-            for (i, pos) in ball.trail.iter().enumerate() {
-                if let Some(c) = colours.key(rows[pos.1 as usize][pos.0 as usize]) {
-                    *c.0 = 0;
-                    *c.1 = 0;
-                    *c.2 = 0;
-                    if n == 0 {
-                        *c.0 = i as u8 * (255 / ball.trail.len() as u8);
-                    } else if n == 1 {
-                        *c.1 = i as u8 * (255 / ball.trail.len() as u8);
-                    } else if n == 2 {
-                        *c.2 = i as u8 * (255 / ball.trail.len() as u8);
-                    }
-                };
-            }
-
-            if let Some(c) = colours.key(rows[ball.position.1 as usize][ball.position.0 as usize]) {
-                *c.0 = 255;
-                *c.1 = 255;
-                *c.2 = 255;
-            };
-        }
-
-        writer.write_colour_block(&colours)?;
-
-        // can change 100 times per second, so need to slow it down
-        //std::thread::sleep(std::time::Duration::from_millis(30));
-    }
-}

asus-nb/examples/comet.rs

@@ -1,31 +0,0 @@
-use asus_nb::{
-    core_dbus::AuraDbusClient,
-    fancy::{GX502Layout, KeyColourArray, KeyLayout},
-};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut writer = AuraDbusClient::new()?;
-
-    let layout = GX502Layout::default();
-
-    writer.init_effect()?;
-    let rows = layout.get_rows();
-
-    let mut column = 0;
-    loop {
-        let mut key_colours = KeyColourArray::new();
-        for row in rows {
-            if let Some(c) = key_colours.key(row[column as usize]) {
-                *c.0 = 255;
-            };
-        }
-        if column == rows[0].len() - 1 {
-            column = 0
-        } else {
-            column += 1;
-        }
-
-        writer.write_colour_block(&key_colours)?;
-        std::thread::sleep(std::time::Duration::from_millis(30));
-    }
-}

asus-nb/examples/iterate-keys.rs

@@ -1,56 +0,0 @@
-use asus_nb::{
-    core_dbus::AuraDbusClient,
-    fancy::{GX502Layout, Key, KeyColourArray, KeyLayout},
-};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut writer = AuraDbusClient::new()?;
-
-    let mut key_colours = KeyColourArray::new();
-    let layout = GX502Layout::default();
-
-    writer.init_effect()?;
-    let rows = layout.get_rows();
-    loop {
-        for (r, row) in rows.iter().enumerate() {
-            for (k, key) in row.iter().enumerate() {
-                if let Some(c) = key_colours.key(*key) {
-                    *c.0 = 255;
-                };
-                // Last key of previous row
-                if k == 0 {
-                    if r == 0 {
-                        let k = &rows[rows.len() - 1][rows[rows.len() - 1].len() - 1];
-                        if let Some(c) = key_colours.key(*k) {
-                            *c.0 = 0;
-                        };
-                    } else {
-                        let k = &rows[r - 1][rows[r - 1].len() - 1];
-                        if let Some(c) = key_colours.key(*k) {
-                            *c.0 = 0;
-                        };
-                    }
-                } else {
-                    let k = &rows[r][k - 1];
-                    if let Some(c) = key_colours.key(*k) {
-                        *c.0 = 0;
-                    };
-                }
-                if let Some(c) = key_colours.key(Key::Up) {
-                    *c.0 = 255;
-                };
-                *key_colours.key(Key::Left).unwrap().0 = 255;
-                *key_colours.key(Key::Right).unwrap().0 = 255;
-                *key_colours.key(Key::Down).unwrap().0 = 255;
-
-                *key_colours.key(Key::W).unwrap().0 = 255;
-                *key_colours.key(Key::A).unwrap().0 = 255;
-                *key_colours.key(Key::S).unwrap().0 = 255;
-                *key_colours.key(Key::D).unwrap().0 = 255;
-
-                writer.write_colour_block(&key_colours)?;
-                std::thread::sleep(std::time::Duration::from_millis(100));
-            }
-        }
-    }
-}

asus-nb/examples/per-key-effect-2.rs

@@ -1,33 +0,0 @@
-use asus_nb::{
-    core_dbus::AuraDbusClient,
-    fancy::{Key, KeyColourArray},
-};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut writer = AuraDbusClient::new()?;
-
-    let mut key_colours = KeyColourArray::new();
-
-    writer.init_effect()?;
-    loop {
-        let count = 49;
-        for _ in 0..count {
-            *key_colours.key(Key::ROG).unwrap().0 += 5;
-            *key_colours.key(Key::L).unwrap().0 += 5;
-            *key_colours.key(Key::I).unwrap().0 += 5;
-            *key_colours.key(Key::N).unwrap().0 += 5;
-            *key_colours.key(Key::U).unwrap().0 += 5;
-            *key_colours.key(Key::X).unwrap().0 += 5;
-            writer.write_colour_block(&key_colours)?;
-        }
-        for _ in 0..count {
-            *key_colours.key(Key::ROG).unwrap().0 -= 5;
-            *key_colours.key(Key::L).unwrap().0 -= 5;
-            *key_colours.key(Key::I).unwrap().0 -= 5;
-            *key_colours.key(Key::N).unwrap().0 -= 5;
-            *key_colours.key(Key::U).unwrap().0 -= 5;
-            *key_colours.key(Key::X).unwrap().0 -= 5;
-            writer.write_colour_block(&key_colours)?;
-        }
-    }
-}

asus-nb/examples/pulser.rs

@@ -1,40 +0,0 @@
-use asus_nb::{
-    core_dbus::AuraDbusClient,
-    fancy::{GX502Layout, KeyColourArray, KeyLayout},
-};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut writer = AuraDbusClient::new()?;
-
-    let mut key_colours = KeyColourArray::new();
-    let layout = GX502Layout::default();
-
-    writer.init_effect()?;
-    let rows = layout.get_rows();
-
-    let mut fade = 50;
-    let mut flip = false;
-    loop {
-        for row in rows {
-            for (k, key) in row.iter().enumerate() {
-                if let Some(c) = key_colours.key(*key) {
-                    *c.0 = 255 / fade / (k + 1) as u8;
-                };
-            }
-        }
-
-        writer.write_colour_block(&key_colours)?;
-
-        if flip {
-            if fade > 1 {
-                fade -= 1;
-            } else {
-                flip = !flip;
-            }
-        } else if fade < 17 {
-            fade += 1;
-        } else {
-            flip = !flip;
-        }
-    }
-}

asus-nb/src/anime_dbus.rs

@@ -1,78 +0,0 @@
-use crate::anime_matrix::AniMePacketType;
-use crate::{DBUS_IFACE, DBUS_NAME, DBUS_PATH};
-use dbus::channel::Sender;
-use dbus::{blocking::Connection, Message};
-use std::error::Error;
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
-};
-use std::{thread, time::Duration};
-
-pub const ANIME_PANE1_PREFIX: [u8; 7] = [0x5e, 0xc0, 0x02, 0x01, 0x00, 0x73, 0x02];
-pub const ANIME_PANE2_PREFIX: [u8; 7] = [0x5e, 0xc0, 0x02, 0x74, 0x02, 0x73, 0x02];
-
-/// Interface for the AniMe dot-matrix display
-///
-/// The resolution is 34x56 (1904) but only 1,215 LEDs in the top-left are used.
-/// The display is available only on select GA401 models.
-///
-/// Actual image ration when displayed is stretched width.
-///
-/// Data structure should be nested array of [[u8; 33]; 56]
-pub struct AniMeDbusWriter {
-    connection: Box<Connection>,
-    block_time: u64,
-    stop: Arc<AtomicBool>,
-}
-
-impl AniMeDbusWriter {
-    #[inline]
-    pub fn new() -> Result<Self, Box<dyn Error>> {
-        let connection = Connection::new_system()?;
-        Ok(AniMeDbusWriter {
-            connection: Box::new(connection),
-            block_time: 25,
-            stop: Arc::new(AtomicBool::new(false)),
-        })
-    }
-
-    pub fn write_image_to_buf(_buf: &mut AniMePacketType, _image_data: &[u8]) {
-        unimplemented!("Image format is in progress of being worked out")
-    }
-
-    /// Write an Animatrix image
-    ///
-    /// The expected input here is *two* Vectors, 640 bytes in length. The two vectors
-    /// are each one half of the full image write.
-    ///
-    /// After each write a flush is written, it is assumed that this tells the device to
-    /// go ahead and display the written bytes
-    ///
-    /// # Note:
-    /// The vectors are expected to contain the full sequence of bytes as follows
-    ///
-    /// - Write packet 1: 0x5e 0xc0 0x02 0x01 0x00 0x73 0x02 .. <led brightness>
-    /// - Write packet 2: 0x5e 0xc0 0x02 0x74 0x02 0x73 0x02 .. <led brightness>
-    ///
-    /// Where led brightness is 0..255, low to high
-    #[inline]
-    pub fn write_image(&mut self, image: &mut AniMePacketType) -> Result<(), Box<dyn Error>> {
-        if image[0][0] != ANIME_PANE1_PREFIX[0] && image[0][6] != ANIME_PANE1_PREFIX[6] {
-            image[0][..7].copy_from_slice(&ANIME_PANE1_PREFIX);
-        }
-        if image[1][0] != ANIME_PANE2_PREFIX[0] && image[1][6] != ANIME_PANE2_PREFIX[6] {
-            image[1][..7].copy_from_slice(&ANIME_PANE2_PREFIX);
-        }
-
-        let mut msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "AnimatrixWrite")?
-            .append2(image[0].to_vec(), image[1].to_vec());
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        thread::sleep(Duration::from_millis(self.block_time));
-        if self.stop.load(Ordering::Relaxed) {
-            panic!("Got signal to stop!");
-        }
-        Ok(())
-    }
-}

asus-nb/src/anime_matrix.rs

@@ -1,236 +0,0 @@
-pub const WIDTH: usize = 34; // Width is definitely 34 items
-pub const HEIGHT: usize = 56;
-pub type AniMeBufferType = [[u8; WIDTH]; HEIGHT];
-pub type AniMePacketType = [[u8; 640]; 2];
-const BLOCK_START: usize = 7;
-const BLOCK_END: usize = 634;
-use yansi_term::Colour::RGB;
-
-/// Helper structure for writing images.
-///
-///  See the examples for ways to write an image to `AniMeMatrix` format.
-pub struct AniMeMatrix(AniMeBufferType);
-
-impl Default for AniMeMatrix {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl AniMeMatrix {
-    pub fn new() -> Self {
-        AniMeMatrix([[0u8; WIDTH]; HEIGHT])
-    }
-
-    pub fn get(&self) -> &AniMeBufferType {
-        &self.0
-    }
-
-    pub fn get_mut(&mut self) -> &mut AniMeBufferType {
-        &mut self.0
-    }
-
-    pub fn fill_with(&mut self, fill: u8) {
-        for row in self.0.iter_mut() {
-            for x in row.iter_mut() {
-                *x = fill;
-            }
-        }
-    }
-
-    pub fn debug_print(&self) {
-        // this is the index from right. It is used to progressively shorten rows
-        let mut prog_row_len = WIDTH - 2;
-
-        for (count, row) in self.0.iter().enumerate() {
-            // Write the top block of LEDs (first 7 rows)
-            if count < 6 {
-                if count % 2 != 0 {
-                    print!("     ");
-                } else {
-                    print!("  ");
-                }
-                let tmp = if count == 0 || count == 1 || count == 3 || count == 5 {
-                    row[1..].iter()
-                } else {
-                    row.iter()
-                };
-                for x in tmp {
-                    print!(" {}", RGB(*x, *x, *x).paint(&format!("{:#04X}", x)));
-                }
-
-                println!();
-            } else {
-                // Switch to next block (looks like )
-                if count % 2 != 0 {
-                    // Row after 6 is only 1 less, then rows after 7 follow pattern
-                    if count == 7 {
-                        prog_row_len -= 1;
-                    } else {
-                        prog_row_len -= 2;
-                    }
-                } else {
-                    prog_row_len += 1; // if count 6, 0
-                }
-
-                let index = row.len() - prog_row_len;
-
-                if count % 2 == 0 {
-                    print!("  ");
-                }
-                for (i, x) in row.iter().enumerate() {
-                    if i >= index {
-                        print!(" {}", RGB(*x, *x, *x).paint(&format!("{:#04X}", x)));
-                    } else {
-                        print!("     ");
-                    }
-                }
-                println!();
-            }
-        }
-    }
-}
-
-impl From<AniMeMatrix> for AniMePacketType {
-    /// Do conversion from the nested Vec in AniMeMatrix to the two required
-    /// packets suitable for sending over USB
-    #[inline]
-    fn from(anime: AniMeMatrix) -> Self {
-        let mut buffers = [[0; 640]; 2];
-
-        let mut write_index = BLOCK_START;
-        let mut write_block = &mut buffers[0];
-        let mut block1_done = false;
-
-        // this is the index from right. It is used to progressively shorten rows
-        let mut prog_row_len = WIDTH - 2;
-
-        for (count, row) in anime.0.iter().enumerate() {
-            // Write the top block of LEDs (first 7 rows)
-            if count < 6 {
-                for (i, x) in row.iter().enumerate() {
-                    // Rows 0, 1, 3, 5 are short and misaligned
-                    if count == 0 || count == 1 || count == 3 || count == 5 {
-                        if i > 0 {
-                            write_block[write_index - 1] = *x;
-                        }
-                    } else {
-                        write_block[write_index] = *x;
-                    }
-                    write_index += 1;
-                }
-            } else {
-                // Switch to next block (looks like )
-                if count % 2 != 0 {
-                    // Row after 6 is only 1 less, then rows after 7 follow pattern
-                    if count == 7 {
-                        prog_row_len -= 1;
-                    } else {
-                        prog_row_len -= 2;
-                    }
-                } else {
-                    prog_row_len += 1; // if count 6, 0
-                }
-
-                let index = row.len() - prog_row_len;
-                for n in row.iter().skip(index) {
-                    // Require a special case to catch the correct end-of-packet which is
-                    // 6 bytes from the end
-                    if write_index == BLOCK_END && !block1_done {
-                        block1_done = true;
-                        write_block = &mut buffers[1];
-                        write_index = BLOCK_START;
-                    }
-
-                    write_block[write_index] = *n;
-                    write_index += 1;
-                }
-            }
-        }
-        buffers
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::anime_matrix::{AniMeMatrix, AniMePacketType};
-
-    #[test]
-    fn check_data_alignment() {
-        let mut matrix = AniMeMatrix::new();
-        {
-            let tmp = matrix.get_mut();
-            for row in tmp.iter_mut() {
-                row[row.len() - 1] = 0xff;
-            }
-        }
-
-        let matrix: AniMePacketType = AniMePacketType::from(matrix);
-
-        // The bytes at the right of the initial AniMeMatrix should always end up aligned in the
-        // same place after conversion to data packets
-
-        // Check against manually worked out right align
-        assert_eq!(
-            matrix[0].to_vec(),
-            [
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-            ]
-            .to_vec()
-        );
-        assert_eq!(
-            matrix[1].to_vec(),
-            [
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 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, 0, 0, 0,
-                255, 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, 255, 0, 0, 0,
-                0, 0, 0, 0
-            ]
-            .to_vec()
-        );
-    }
-}

asus-nb/src/aura_modes.rs

@@ -1,287 +0,0 @@
-use crate::cli_options;
-use crate::cli_options::SetAuraBuiltin;
-use serde_derive::{Deserialize, Serialize};
-
-pub const STATIC: u8 = 0x00;
-pub const BREATHING: u8 = 0x01;
-pub const STROBE: u8 = 0x02;
-pub const RAINBOW: u8 = 0x03;
-pub const STAR: u8 = 0x04;
-pub const RAIN: u8 = 0x05;
-pub const HIGHLIGHT: u8 = 0x06;
-pub const LASER: u8 = 0x07;
-pub const RIPPLE: u8 = 0x08;
-pub const PULSE: u8 = 0x0a;
-pub const COMET: u8 = 0x0b;
-pub const FLASH: u8 = 0x0c;
-pub const MULTISTATIC: u8 = 0x0d;
-pub const PER_KEY: u8 = 0xff;
-
-#[derive(Clone, Deserialize, Serialize)]
-pub struct Colour(pub u8, pub u8, pub u8);
-impl From<cli_options::Colour> for Colour {
-    fn from(c: cli_options::Colour) -> Self {
-        Colour(c.0, c.1, c.2)
-    }
-}
-impl Default for Colour {
-    fn default() -> Self {
-        Colour(128, 0, 0)
-    }
-}
-
-#[derive(Copy, Clone, Deserialize, Serialize)]
-pub enum Speed {
-    Low = 0xe1,
-    Med = 0xeb,
-    High = 0xf5,
-}
-impl From<cli_options::Speed> for Speed {
-    fn from(s: cli_options::Speed) -> Self {
-        match s {
-            cli_options::Speed::Low => Speed::Low,
-            cli_options::Speed::Med => Speed::Med,
-            cli_options::Speed::High => Speed::High,
-        }
-    }
-}
-impl Default for Speed {
-    fn default() -> Self {
-        Speed::Med
-    }
-}
-
-/// Used for Rainbow mode.
-///
-/// Enum corresponds to the required integer value
-#[derive(Copy, Clone, Deserialize, Serialize)]
-pub enum Direction {
-    Right,
-    Left,
-    Up,
-    Down,
-}
-impl From<cli_options::Direction> for Direction {
-    fn from(s: cli_options::Direction) -> Self {
-        match s {
-            cli_options::Direction::Right => Direction::Right,
-            cli_options::Direction::Left => Direction::Left,
-            cli_options::Direction::Up => Direction::Up,
-            cli_options::Direction::Down => Direction::Down,
-        }
-    }
-}
-impl Default for Direction {
-    fn default() -> Self {
-        Direction::Right
-    }
-}
-
-#[derive(Clone, Default, Deserialize, Serialize)]
-pub struct TwoColourSpeed {
-    pub colour: Colour,
-    pub colour2: Colour,
-    pub speed: Speed,
-}
-impl From<cli_options::TwoColourSpeed> for TwoColourSpeed {
-    fn from(mode: cli_options::TwoColourSpeed) -> Self {
-        TwoColourSpeed {
-            colour: mode.colour.into(),
-            colour2: mode.colour2.into(),
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Clone, Default, Deserialize, Serialize)]
-pub struct SingleSpeed {
-    pub speed: Speed,
-}
-impl From<cli_options::SingleSpeed> for SingleSpeed {
-    fn from(mode: cli_options::SingleSpeed) -> Self {
-        SingleSpeed {
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Clone, Default, Deserialize, Serialize)]
-pub struct SingleColour {
-    pub colour: Colour,
-}
-impl From<cli_options::SingleColour> for SingleColour {
-    fn from(mode: cli_options::SingleColour) -> Self {
-        SingleColour {
-            colour: mode.colour.into(),
-        }
-    }
-}
-
-#[derive(Clone, Default, Deserialize, Serialize)]
-pub struct MultiColour {
-    pub colour1: Colour,
-    pub colour2: Colour,
-    pub colour3: Colour,
-    pub colour4: Colour,
-}
-impl From<cli_options::MultiColour> for MultiColour {
-    fn from(mode: cli_options::MultiColour) -> Self {
-        MultiColour {
-            colour1: mode.colour1.into(),
-            colour2: mode.colour2.into(),
-            colour3: mode.colour3.into(),
-            colour4: mode.colour4.into(),
-        }
-    }
-}
-
-#[derive(Clone, Default, Deserialize, Serialize)]
-pub struct SingleSpeedDirection {
-    pub direction: Direction,
-    pub speed: Speed,
-}
-impl From<cli_options::SingleSpeedDirection> for SingleSpeedDirection {
-    fn from(mode: cli_options::SingleSpeedDirection) -> Self {
-        SingleSpeedDirection {
-            direction: mode.direction.into(),
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Clone, Default, Deserialize, Serialize)]
-pub struct SingleColourSpeed {
-    pub colour: Colour,
-    pub speed: Speed,
-}
-impl From<cli_options::SingleColourSpeed> for SingleColourSpeed {
-    fn from(mode: cli_options::SingleColourSpeed) -> Self {
-        SingleColourSpeed {
-            colour: mode.colour.into(),
-            speed: mode.speed.into(),
-        }
-    }
-}
-
-#[derive(Clone, Deserialize, Serialize)]
-pub enum AuraModes {
-    Static(SingleColour),
-    Breathe(TwoColourSpeed),
-    Strobe(SingleSpeed),
-    Rainbow(SingleSpeedDirection),
-    Star(TwoColourSpeed),
-    Rain(SingleSpeed),
-    Highlight(SingleColourSpeed),
-    Laser(SingleColourSpeed),
-    Ripple(SingleColourSpeed),
-    Pulse(SingleColour),
-    Comet(SingleColour),
-    Flash(SingleColour),
-    MultiStatic(MultiColour),
-    LedBrightness(u8),
-    // TODO: use a serializable structure for this (KeyColourArray)
-    PerKey(Vec<Vec<u8>>),
-}
-
-impl From<SetAuraBuiltin> for AuraModes {
-    fn from(mode: SetAuraBuiltin) -> Self {
-        match mode {
-            SetAuraBuiltin::Static(x) => AuraModes::Static(x.into()),
-            SetAuraBuiltin::Breathe(x) => AuraModes::Breathe(x.into()),
-            SetAuraBuiltin::Strobe(x) => AuraModes::Strobe(x.into()),
-            SetAuraBuiltin::Rainbow(x) => AuraModes::Rainbow(x.into()),
-            SetAuraBuiltin::Star(x) => AuraModes::Star(x.into()),
-            SetAuraBuiltin::Rain(x) => AuraModes::Rain(x.into()),
-            SetAuraBuiltin::Highlight(x) => AuraModes::Highlight(x.into()),
-            SetAuraBuiltin::Laser(x) => AuraModes::Laser(x.into()),
-            SetAuraBuiltin::Ripple(x) => AuraModes::Ripple(x.into()),
-            SetAuraBuiltin::Pulse(x) => AuraModes::Pulse(x.into()),
-            SetAuraBuiltin::Comet(x) => AuraModes::Comet(x.into()),
-            SetAuraBuiltin::Flash(x) => AuraModes::Flash(x.into()),
-            SetAuraBuiltin::MultiStatic(x) => AuraModes::MultiStatic(x.into()),
-        }
-    }
-}
-
-/// Very specific mode conversion required because numbering isn't linear
-impl From<AuraModes> for u8 {
-    fn from(mode: AuraModes) -> Self {
-        u8::from(&mode)
-    }
-}
-
-/// Very specific mode conversion required because numbering isn't linear
-impl From<&mut AuraModes> for u8 {
-    fn from(mode: &mut AuraModes) -> Self {
-        u8::from(&*mode)
-    }
-}
-
-/// Very specific mode conversion required because numbering isn't linear
-impl From<&AuraModes> for u8 {
-    fn from(mode: &AuraModes) -> Self {
-        match mode {
-            AuraModes::Static(_) => STATIC,
-            AuraModes::Breathe(_) => BREATHING,
-            AuraModes::Strobe(_) => STROBE,
-            AuraModes::Rainbow(_) => RAINBOW,
-            AuraModes::Star(_) => STAR,
-            AuraModes::Rain(_) => RAIN,
-            AuraModes::Highlight(_) => HIGHLIGHT,
-            AuraModes::Laser(_) => LASER,
-            AuraModes::Ripple(_) => RIPPLE,
-            AuraModes::Pulse(_) => PULSE,
-            AuraModes::Comet(_) => COMET,
-            AuraModes::Flash(_) => FLASH,
-            AuraModes::MultiStatic(_) => MULTISTATIC,
-            AuraModes::PerKey(_) => PER_KEY,
-            _ => panic!("Invalid mode"),
-        }
-    }
-}
-
-impl From<&AuraModes> for &str {
-    fn from(mode: &AuraModes) -> Self {
-        match mode {
-            AuraModes::Static(_) => "Static",
-            AuraModes::Breathe(_) => "Breathing",
-            AuraModes::Strobe(_) => "Strobing",
-            AuraModes::Rainbow(_) => "Rainbow",
-            AuraModes::Star(_) => "Stars",
-            AuraModes::Rain(_) => "Rain",
-            AuraModes::Highlight(_) => "Keypress Highlight",
-            AuraModes::Laser(_) => "Keypress Laser",
-            AuraModes::Ripple(_) => "Keypress Ripple",
-            AuraModes::Pulse(_) => "Pulse",
-            AuraModes::Comet(_) => "Comet",
-            AuraModes::Flash(_) => "Flash",
-            AuraModes::MultiStatic(_) => "4-Zone Static Colours",
-            AuraModes::PerKey(_) => "RGB per-key",
-            _ => panic!("Invalid mode"),
-        }
-    }
-}
-
-/// Exists to convert back from correct bytes. PER_KEY byte intentionally left off as it
-/// does not correspond to an actual pre-set mode, nor does brightness.
-impl From<u8> for AuraModes {
-    fn from(byte: u8) -> Self {
-        match byte {
-            STATIC => AuraModes::Static(SingleColour::default()),
-            BREATHING => AuraModes::Breathe(TwoColourSpeed::default()),
-            STROBE => AuraModes::Strobe(SingleSpeed::default()),
-            RAINBOW => AuraModes::Rainbow(SingleSpeedDirection::default()),
-            STAR => AuraModes::Star(TwoColourSpeed::default()),
-            RAIN => AuraModes::Rain(SingleSpeed::default()),
-            HIGHLIGHT => AuraModes::Highlight(SingleColourSpeed::default()),
-            LASER => AuraModes::Laser(SingleColourSpeed::default()),
-            RIPPLE => AuraModes::Ripple(SingleColourSpeed::default()),
-            PULSE => AuraModes::Pulse(SingleColour::default()),
-            COMET => AuraModes::Comet(SingleColour::default()),
-            FLASH => AuraModes::Flash(SingleColour::default()),
-            MULTISTATIC => AuraModes::MultiStatic(MultiColour::default()),
-            PER_KEY => AuraModes::PerKey(vec![]),
-            _ => panic!("Invalid mode byte"),
-        }
-    }
-}

asus-nb/src/cli_options.rs

@@ -1,215 +0,0 @@
-use crate::error::AuraError;
-use gumdrop::Options;
-use serde_derive::{Deserialize, Serialize};
-use std::str::FromStr;
-
-#[derive(Options)]
-pub struct LedBrightness {
-    level: u8,
-}
-impl LedBrightness {
-    pub fn level(&self) -> u8 {
-        self.level
-    }
-}
-impl FromStr for LedBrightness {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "off" => Ok(LedBrightness { level: 0x00 }),
-            "low" => Ok(LedBrightness { level: 0x01 }),
-            "med" => Ok(LedBrightness { level: 0x02 }),
-            "high" => Ok(LedBrightness { level: 0x03 }),
-            _ => {
-                println!("Missing required argument, must be one of:\noff,low,med,high\n");
-                Err(AuraError::ParseBrightness)
-            }
-        }
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct Colour(pub u8, pub u8, pub u8);
-impl Default for Colour {
-    fn default() -> Self {
-        Colour(255, 0, 0)
-    }
-}
-impl FromStr for Colour {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s.len() < 6 {
-            return Err(AuraError::ParseColour);
-        }
-        let r = u8::from_str_radix(&s[0..2], 16).or(Err(AuraError::ParseColour))?;
-        let g = u8::from_str_radix(&s[2..4], 16).or(Err(AuraError::ParseColour))?;
-        let b = u8::from_str_radix(&s[4..6], 16).or(Err(AuraError::ParseColour))?;
-        Ok(Colour(r, g, b))
-    }
-}
-
-#[derive(Deserialize, Serialize)]
-pub enum Speed {
-    Low = 0xe1,
-    Med = 0xeb,
-    High = 0xf5,
-}
-impl Default for Speed {
-    fn default() -> Self {
-        Speed::Med
-    }
-}
-impl FromStr for Speed {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "low" => Ok(Speed::Low),
-            "med" => Ok(Speed::Med),
-            "high" => Ok(Speed::High),
-            _ => Err(AuraError::ParseSpeed),
-        }
-    }
-}
-
-/// Used for Rainbow mode.
-///
-/// Enum corresponds to the required integer value
-#[derive(Deserialize, Serialize)]
-pub enum Direction {
-    Right,
-    Left,
-    Up,
-    Down,
-}
-impl Default for Direction {
-    fn default() -> Self {
-        Direction::Right
-    }
-}
-impl FromStr for Direction {
-    type Err = AuraError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "right" => Ok(Direction::Right),
-            "up" => Ok(Direction::Up),
-            "down" => Ok(Direction::Down),
-            "left" => Ok(Direction::Left),
-            _ => Err(AuraError::ParseDirection),
-        }
-    }
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct TwoColourSpeed {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "HEX", help = "set the first RGB value e.g, ff00ff")]
-    pub colour: Colour,
-    #[options(no_long, meta = "HEX", help = "set the second RGB value e.g, ff00ff")]
-    pub colour2: Colour,
-    #[options(no_long, help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleSpeed {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleColour {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour: Colour,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct MultiColour {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour1: Colour,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour2: Colour,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour3: Colour,
-    #[options(meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour4: Colour,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleSpeedDirection {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(
-        no_long,
-        meta = "DIR",
-        help = "set the direction: up, down, left, right"
-    )]
-    pub direction: Direction,
-    #[options(no_long, help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-#[derive(Default, Options, Deserialize, Serialize)]
-pub struct SingleColourSpeed {
-    #[options(help = "print help message")]
-    help: bool,
-    #[options(no_long, meta = "HEX", help = "set the RGB value e.g, ff00ff")]
-    pub colour: Colour,
-    #[options(no_long, help = "set the speed: low, med, high")]
-    pub speed: Speed,
-}
-
-/// Byte value for setting the built-in mode.
-///
-/// Enum corresponds to the required integer value
-#[derive(Options, Deserialize, Serialize)]
-pub enum SetAuraBuiltin {
-    #[options(help = "set a single static colour")]
-    Static(SingleColour),
-    #[options(help = "pulse between one or two colours")]
-    Breathe(TwoColourSpeed),
-    #[options(help = "strobe through all colours")]
-    Strobe(SingleSpeed),
-    #[options(help = "rainbow cycling in one of four directions")]
-    Rainbow(SingleSpeedDirection),
-    #[options(help = "rain pattern mimicking raindrops")]
-    Star(TwoColourSpeed),
-    #[options(help = "rain pattern of three preset colours")]
-    Rain(SingleSpeed),
-    #[options(help = "pressed keys are highlighted to fade")]
-    Highlight(SingleColourSpeed),
-    #[options(help = "pressed keys generate horizontal laser")]
-    Laser(SingleColourSpeed),
-    #[options(help = "pressed keys ripple outwards like a splash")]
-    Ripple(SingleColourSpeed),
-    #[options(help = "set a rapid pulse")]
-    Pulse(SingleColour),
-    #[options(help = "set a vertical line zooming from left")]
-    Comet(SingleColour),
-    #[options(help = "set a wide vertical line zooming from left")]
-    Flash(SingleColour),
-    #[options(help = "4-zone multi-colour")]
-    MultiStatic(MultiColour),
-}
-
-impl Default for SetAuraBuiltin {
-    fn default() -> Self {
-        SetAuraBuiltin::Static(SingleColour {
-            help: false,
-            colour: Colour(255, 0, 0),
-        })
-    }
-}

asus-nb/src/core_dbus.rs

@@ -1,124 +0,0 @@
-use super::*;
-use crate::fancy::KeyColourArray;
-use dbus::channel::Sender;
-use dbus::{blocking::Connection, channel::Token, Message};
-use std::error::Error;
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
-};
-use std::{thread, time::Duration};
-
-/// Simplified way to write a effect block
-pub struct AuraDbusClient {
-    connection: Box<Connection>,
-    block_time: u64,
-    stop: Arc<AtomicBool>,
-    stop_token: Token,
-}
-
-impl AuraDbusClient {
-    #[inline]
-    pub fn new() -> Result<Self, Box<dyn Error>> {
-        let connection = Connection::new_system()?;
-        let stop = Arc::new(AtomicBool::new(false));
-
-        let stopper2 = stop.clone();
-        let match_rule = dbus::message::MatchRule::new_signal(DBUS_IFACE, "KeyBacklightChanged");
-        let stop_token = connection.add_match(match_rule, move |_: (), _, msg| {
-            if msg.read1::<&str>().is_ok() {
-                stopper2.store(true, Ordering::Relaxed);
-            }
-            true
-        })?;
-
-        Ok(AuraDbusClient {
-            connection: Box::new(connection),
-            block_time: 33333,
-            stop,
-            stop_token,
-        })
-    }
-
-    /// This method must always be called before the very first write to initialise
-    /// the keyboard LED EC in the correct mode
-    #[inline]
-    pub fn init_effect(&self) -> Result<(), Box<dyn std::error::Error>> {
-        let mode = AuraModes::PerKey(vec![vec![]]);
-        let mut msg =
-            Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "SetKeyBacklight")?
-                .append1(serde_json::to_string(&mode)?);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        Ok(())
-    }
-
-    /// Write a single colour block.
-    ///
-    /// Intentionally blocks for 10ms after sending to allow the block to
-    /// be written to the keyboard EC. This should not be async.
-    #[inline]
-    pub fn write_colour_block(
-        &mut self,
-        key_colour_array: &KeyColourArray,
-    ) -> Result<(), Box<dyn Error>> {
-        let group = key_colour_array.get();
-        let mut vecs = Vec::with_capacity(group.len());
-        for v in group {
-            vecs.push(v.to_vec());
-        }
-        let mode = AuraModes::PerKey(vecs);
-        let mut msg =
-            Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "SetKeyBacklight")?
-                .append1(serde_json::to_string(&mode)?);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        thread::sleep(Duration::from_micros(self.block_time));
-        self.connection.process(Duration::from_micros(500))?;
-        if self.stop.load(Ordering::Relaxed) {
-            self.connection.remove_match(self.stop_token)?;
-            println!("Keyboard backlight was changed, exiting");
-            std::process::exit(1)
-        }
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_keyboard_leds(&self, mode: &AuraModes) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg =
-            Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "SetKeyBacklight")?
-                .append1(serde_json::to_string(mode)?);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_fan_mode(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "SetFanMode")?
-            .append1(level);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_charge_limit(&self, level: u8) -> Result<(), Box<dyn std::error::Error>> {
-        let mut msg = Message::new_method_call(DBUS_NAME, DBUS_PATH, DBUS_IFACE, "SetChargeLimit")?
-            .append1(level);
-        msg.set_no_reply(true);
-        self.connection.send(msg).unwrap();
-        Ok(())
-    }
-
-    #[inline]
-    pub fn write_builtin_mode(&self, mode: &AuraModes) -> Result<(), Box<dyn std::error::Error>> {
-        self.write_keyboard_leds(mode)
-    }
-
-    #[inline]
-    pub fn write_brightness(&self, level: u8) -> Result<String, Box<dyn std::error::Error>> {
-        self.write_keyboard_leds(&AuraModes::LedBrightness(level))?;
-        Ok(String::new())
-    }
-}

asus-nb/src/error.rs

@@ -1,20 +0,0 @@
-use std::fmt;
-
-pub enum AuraError {
-    ParseColour,
-    ParseSpeed,
-    ParseDirection,
-    ParseBrightness,
-}
-
-impl fmt::Display for AuraError {
-    // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            AuraError::ParseColour => write!(f, "Could not parse colour"),
-            AuraError::ParseSpeed => write!(f, "Could not parse speed"),
-            AuraError::ParseDirection => write!(f, "Could not parse direction"),
-            AuraError::ParseBrightness => write!(f, "Could not parse brightness"),
-        }
-    }
-}

asus-nb/src/fancy.rs

@@ -1,455 +0,0 @@
-/// A `KeyColourArray` contains all data to change the full set of keyboard
-/// key colours individually.
-///
-/// Each row of the internal array is a full HID packet that can be sent
-/// to the keyboard EC. One row controls one group of keys, these keys are not
-/// necessarily all on the same row of the keyboard, with some splitting between
-/// two rows.
-#[derive(Clone)]
-pub struct KeyColourArray([[u8; 64]; 11]);
-impl Default for KeyColourArray {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-impl KeyColourArray {
-    pub fn new() -> Self {
-        let mut set = [[0u8; 64]; 11];
-        for (count, row) in set.iter_mut().enumerate() {
-            row[0] = 0x5d; // Report ID
-            row[1] = 0xbc; // Mode = custom??, 0xb3 is builtin
-            row[2] = 0x00;
-            row[3] = 0x01; // ??
-            row[4] = 0x01; // ??, 4,5,6 are normally RGB for builtin mode colours
-            row[5] = 0x01; // ??
-            row[6] = (count as u8) << 4; // Key group
-            if count == 10 {
-                row[7] = 0x08; // 0b00001000
-            } else {
-                row[7] = 0x10; // 0b00010000 addressing? flips for group a0
-            }
-            row[8] = 0x00;
-        }
-        KeyColourArray(set)
-    }
-
-    /// Initialise and clear the keyboard for custom effects
-    #[inline]
-    pub fn get_init_msg() -> Vec<u8> {
-        let mut init = vec![0u8; 64];
-        init[0] = 0x5d; // Report ID
-        init[1] = 0xbc; // Mode = custom??, 0xb3 is builtin
-        init
-    }
-
-    #[inline]
-    pub fn set(&mut self, key: Key, r: u8, g: u8, b: u8) {
-        if let Some((rr, gg, bb)) = self.key(key) {
-            *rr = r;
-            *gg = g;
-            *bb = b;
-        }
-    }
-
-    /// Indexes in to `KeyColourArray` at the correct row and column
-    /// to set a series of three bytes to the chosen R,G,B values
-    pub fn key(&mut self, key: Key) -> Option<(&mut u8, &mut u8, &mut u8)> {
-        // Tuples are indexes in to array
-        let (row, col) = match key {
-            Key::VolDown => (0, 15),
-            Key::VolUp => (0, 18),
-            Key::MicMute => (0, 21),
-            Key::ROG => (0, 24),
-            //
-            Key::Esc => (1, 24),
-            Key::F1 => (1, 30),
-            Key::F2 => (1, 33),
-            Key::F3 => (1, 36),
-            Key::F4 => (1, 39),
-            Key::F5 => (1, 45),
-            Key::F6 => (1, 48),
-            Key::F7 => (1, 51),
-            Key::F8 => (1, 54),
-            //
-            Key::F9 => (2, 12),
-            Key::F10 => (2, 15),
-            Key::F11 => (2, 18),
-            Key::F12 => (2, 21),
-            Key::Del => (2, 24),
-            Key::Tilde => (2, 39),
-            Key::N1 => (2, 42),
-            Key::N2 => (2, 45),
-            Key::N3 => (2, 48),
-            Key::N4 => (2, 51),
-            Key::N5 => (2, 54),
-            //
-            Key::N6 => (3, 9),
-            Key::N7 => (3, 12),
-            Key::N8 => (3, 15),
-            Key::N9 => (3, 18),
-            Key::N0 => (3, 21),
-            Key::Hyphen => (3, 24),
-            Key::Equals => (3, 27),
-            Key::BkSpc1 => (3, 30),
-            Key::BkSpc2 => (3, 33),
-            Key::BkSpc3 => (3, 36),
-            Key::Home => (3, 39),
-            Key::Tab => (3, 54),
-            //
-            Key::Q => (4, 9),
-            Key::W => (4, 12),
-            Key::E => (4, 15),
-            Key::R => (4, 18),
-            Key::T => (4, 21),
-            Key::Y => (4, 24),
-            Key::U => (4, 27),
-            Key::I => (4, 30),
-            Key::O => (4, 33),
-            Key::P => (4, 36),
-            Key::LBracket => (4, 39),
-            Key::RBracket => (4, 42),
-            Key::BackSlash => (4, 45),
-            Key::PgUp => (4, 54),
-            //
-            Key::Caps => (5, 21),
-            Key::A => (5, 24),
-            Key::S => (5, 27),
-            Key::D => (5, 30),
-            Key::F => (5, 33),
-            Key::G => (5, 36),
-            Key::H => (5, 39),
-            Key::J => (5, 42),
-            Key::K => (5, 45),
-            Key::L => (5, 48),
-            Key::SemiColon => (5, 51),
-            Key::Quote => (5, 54),
-            //
-            Key::Ret1 => (6, 12),
-            Key::Ret2 => (6, 15),
-            Key::Ret3 => (6, 18),
-            Key::PgDn => (6, 21),
-            Key::LShift => (6, 36),
-            Key::Z => (6, 42),
-            Key::X => (6, 45),
-            Key::C => (6, 48),
-            Key::V => (6, 51),
-            Key::B => (6, 54),
-            //
-            Key::N => (7, 9),
-            Key::M => (7, 12),
-            Key::Comma => (7, 15),
-            Key::Period => (7, 18),
-            Key::FwdSlash => (7, 21),
-            Key::Rshift1 => (7, 27),
-            Key::Rshift2 => (7, 30),
-            Key::Rshift3 => (7, 33),
-            Key::End => (7, 36),
-            Key::LCtrl => (7, 51),
-            Key::LFn => (7, 54),
-            //
-            Key::Meta => (8, 9),
-            Key::LAlt => (8, 12),
-            Key::Space1 => (8, 15),
-            Key::Space2 => (8, 18),
-            Key::Space3 => (8, 21),
-            Key::Space4 => (8, 24),
-            Key::RAlt => (8, 30),
-            Key::PrtSc => (8, 33),
-            Key::RCtrl => (8, 36),
-            Key::Up => (8, 42),
-            Key::RFn => (8, 51),
-            //
-            Key::Left => (9, 54),
-            //
-            Key::Down => (10, 9),
-            Key::Right => (10, 12),
-            Key::None => return None,
-        };
-        // LOLOLOLOLOLOLOL! Look it's safe okay
-        unsafe {
-            Some((
-                &mut *(&mut self.0[row][col] as *mut u8),
-                &mut *(&mut self.0[row][col + 1] as *mut u8),
-                &mut *(&mut self.0[row][col + 2] as *mut u8),
-            ))
-        }
-    }
-
-    #[inline]
-    pub fn get(&self) -> &[[u8; 64]; 11] {
-        &self.0
-    }
-}
-
-#[derive(Debug, PartialEq, Copy, Clone)]
-pub enum Key {
-    VolUp,
-    VolDown,
-    MicMute,
-    ROG,
-    Esc,
-    F1,
-    F2,
-    F3,
-    F4,
-    F5,
-    F6,
-    F7,
-    F8,
-    F9,
-    F10,
-    F11,
-    F12,
-    Del,
-    Tilde,
-    N1,
-    N2,
-    N3,
-    N4,
-    N5,
-    N6,
-    N7,
-    N8,
-    N9,
-    N0,
-    Hyphen,
-    Equals,
-    BkSpc1,
-    BkSpc2,
-    BkSpc3,
-    Home,
-    Tab,
-    Q,
-    W,
-    E,
-    R,
-    T,
-    Y,
-    U,
-    I,
-    O,
-    P,
-    LBracket,
-    RBracket,
-    BackSlash,
-    PgUp,
-    Caps,
-    A,
-    S,
-    D,
-    F,
-    G,
-    H,
-    J,
-    K,
-    L,
-    SemiColon,
-    Quote,
-    Ret1,
-    Ret2,
-    Ret3,
-    PgDn,
-    LShift,
-    Z,
-    X,
-    C,
-    V,
-    B,
-    N,
-    M,
-    Comma,
-    Period,
-    FwdSlash,
-    Rshift1,
-    Rshift2,
-    Rshift3,
-    End,
-    LCtrl,
-    LFn,
-    Meta,
-    LAlt,
-    Space1,
-    Space2,
-    Space3,
-    Space4,
-    RAlt,
-    PrtSc,
-    RCtrl,
-    Up,
-    Down,
-    Left,
-    Right,
-    RFn,
-    None,
-}
-
-pub trait KeyLayout {
-    fn get_rows(&self) -> &Vec<[Key; 17]>;
-}
-
-pub struct GX502Layout(Vec<[Key; 17]>);
-
-impl KeyLayout for GX502Layout {
-    fn get_rows(&self) -> &Vec<[Key; 17]> {
-        &self.0
-    }
-}
-
-impl Default for GX502Layout {
-    fn default() -> Self {
-        GX502Layout(vec![
-            [
-                Key::None,
-                Key::None,
-                Key::VolDown,
-                Key::VolUp,
-                Key::MicMute,
-                Key::ROG,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-            ],
-            [
-                Key::Esc,
-                Key::None,
-                Key::F1,
-                Key::F2,
-                Key::F3,
-                Key::F4,
-                Key::None, // not sure which key to put here
-                Key::F5,
-                Key::F6,
-                Key::F7,
-                Key::F8,
-                Key::F9,
-                Key::F9,
-                Key::F10,
-                Key::F11,
-                Key::F12,
-                Key::Del,
-            ],
-            [
-                Key::Tilde,
-                Key::N1,
-                Key::N2,
-                Key::N3,
-                Key::N4,
-                Key::N5,
-                Key::N6,
-                Key::N7,
-                Key::N8,
-                Key::N9,
-                Key::N0,
-                Key::Hyphen,
-                Key::Equals,
-                Key::BkSpc1,
-                Key::BkSpc2,
-                Key::BkSpc3,
-                Key::Home,
-            ],
-            [
-                Key::Tab,
-                Key::Q,
-                Key::W,
-                Key::E,
-                Key::R,
-                Key::T,
-                Key::Y,
-                Key::U,
-                Key::I,
-                Key::O,
-                Key::P,
-                Key::LBracket,
-                Key::RBracket,
-                Key::BackSlash,
-                Key::BackSlash,
-                Key::BackSlash,
-                Key::PgUp,
-            ],
-            [
-                Key::Caps,
-                Key::A,
-                Key::S,
-                Key::D,
-                Key::F,
-                Key::G,
-                Key::H,
-                Key::J,
-                Key::K,
-                Key::L,
-                Key::SemiColon,
-                Key::Quote,
-                Key::Quote,
-                Key::Ret1,
-                Key::Ret2,
-                Key::Ret3,
-                Key::PgDn,
-            ],
-            [
-                Key::LShift,
-                Key::LShift,
-                Key::Z,
-                Key::X,
-                Key::C,
-                Key::V,
-                Key::B,
-                Key::N,
-                Key::M,
-                Key::Comma,
-                Key::Period,
-                Key::FwdSlash,
-                Key::FwdSlash,
-                Key::Rshift1,
-                Key::Rshift2,
-                Key::Rshift3,
-                Key::End,
-            ],
-            [
-                Key::LCtrl,
-                Key::LFn,
-                Key::Meta,
-                Key::LAlt,
-                Key::Space1,
-                Key::Space2,
-                Key::Space3,
-                Key::Space4,
-                Key::Space4,
-                Key::RAlt,
-                Key::PrtSc,
-                Key::RCtrl,
-                Key::RCtrl,
-                Key::Left,
-                Key::Up,
-                Key::Right,
-                Key::RFn,
-            ],
-            [
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::None,
-                Key::Left,
-                Key::Down,
-                Key::Right,
-                Key::None,
-            ],
-        ])
-    }
-}

asus-nb/src/lib.rs

@@ -1,252 +0,0 @@
-pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
-pub static DBUS_PATH: &str = "/org/asuslinux/Daemon";
-pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
-pub const LED_MSG_LEN: usize = 17;
-
-pub mod aura_modes;
-use aura_modes::AuraModes;
-
-/// Contains mostly only what is required for parsing CLI options
-pub mod cli_options;
-
-/// Enables you to create fancy RGB effects
-pub mod fancy;
-
-/// The main dbus group for system controls, e.g, fan control, keyboard LED's
-pub mod core_dbus;
-
-/// Specific dbus for writing to the AniMe Matrix display (if supported)
-pub mod anime_dbus;
-
-/// Helper functions for the AniMe display
-pub mod anime_matrix;
-
-pub mod error;
-
-// static LED_INIT1: [u8; 2] = [0x5d, 0xb9];
-// static LED_INIT2: &str = "]ASUS Tech.Inc."; // ] == 0x5d
-// static LED_INIT3: [u8; 6] = [0x5d, 0x05, 0x20, 0x31, 0, 0x08];
-// static LED_INIT4: &str = "^ASUS Tech.Inc."; // ^ == 0x5e
-// static LED_INIT5: [u8; 6] = [0x5e, 0x05, 0x20, 0x31, 0, 0x08];
-
-/// Writes aout the correct byte string for brightness
-///
-/// The HID descriptor looks like:
-///
-/// ```ignore
-/// 0x06, 0x31, 0xFF,  // Usage Page (Vendor Defined 0xFF31)
-/// 0x09, 0x76,        // Usage (0x76)
-/// 0xA1, 0x01,        // Collection (Application)
-/// 0x85, 0x5A,        //   Report ID (90)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x05,        //   Report Count (5)
-/// 0x81, 0x00,        //   Input (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x3F,        //   Report Count (63)
-/// 0xB1, 0x00,        //   Feature (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-/// 0xC0,              // End Collection
-/// ```
-pub fn aura_brightness_bytes(brightness: u8) -> [u8; 17] {
-    // TODO: check brightness range
-    [
-        0x5A, 0xBA, 0xC5, 0xC4, brightness, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ]
-}
-
-/// Parses `AuraCommands` in to packet data
-///
-/// Byte structure:
-///
-/// ```ignore
-/// | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10| 11| 12|
-/// |---|---|---|---|---|---|---|---|---|---|---|---|---|
-/// |5d |b3 |00 |03 |ff |00 |00 |00 |00 |00 |00 |ff |00 |
-/// ```
-///
-/// Bytes 0 and 1 should always be 5d, b3
-///
-/// On multizone laptops byte 2 is the zone number, RGB in usual
-/// place, byte 3 set to zero
-///
-/// Byte 3 sets the mode type:
-/// - 00 = static
-/// - 01 = breathe (can set two colours)
-/// - 02 = strobe (through all colours)
-/// - 03 = rainbow
-/// - 04 = star (byte 9 sets rain colour)
-/// - 05 = rain keys, red, white, turquoise
-/// - 06 = pressed keys light up and fade
-/// - 07 = pressed key emits laser
-/// - 08 = pressed key emits water ripple
-/// - 09 = no effect/not used
-/// - 0a fast pulse (no speed setting)
-/// - 0b vertical line racing to right (no speed setting)
-/// - 0c wider vertical line racing to right (no speed setting)
-///
-/// Bytes 4, 5, 6 are Red, Green, Blue
-///
-/// Byte 7 sets speed from
-/// - 0x00 = Off
-/// - 0xe1 = Slow
-/// - 0xeb = Medium
-/// - 0xf5 = Fast
-///
-/// Byte 8 sets rainbow direction:
-/// - 0x00 = rightwards
-/// - 0x01 = leftwards
-/// - 0x02 = upwards
-/// - 0x03 = downwards
-///
-/// Bytes 10, 11, 12 are Red, Green, Blue for second colour if mode supports it
-///
-/// The HID descriptor looks like:
-/// ```ignore
-/// 0x06, 0x31, 0xFF,  // Usage Page (Vendor Defined 0xFF31)
-/// 0x09, 0x79,        // Usage (0x79)
-/// 0xA1, 0x01,        // Collection (Application)
-/// 0x85, 0x5D,        //   Report ID (93)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x1F,        //   Report Count (31)
-/// 0x81, 0x00,        //   Input (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x3F,        //   Report Count (63)
-/// 0x91, 0x00,        //   Output (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-/// 0x19, 0x00,        //   Usage Minimum (0x00)
-/// 0x2A, 0xFF, 0x00,  //   Usage Maximum (0xFF)
-/// 0x15, 0x00,        //   Logical Minimum (0)
-/// 0x26, 0xFF, 0x00,  //   Logical Maximum (255)
-/// 0x75, 0x08,        //   Report Size (8)
-/// 0x95, 0x3F,        //   Report Count (63)
-/// 0xB1, 0x00,        //   Feature (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-/// 0xC0,              // End Collection
-/// ```
-///
-/// This descriptor is also used for the per-key LED settings
-impl From<&AuraModes> for [u8; LED_MSG_LEN] {
-    fn from(mode: &AuraModes) -> Self {
-        let mut msg = [0u8; LED_MSG_LEN];
-        msg[0] = 0x5d;
-        msg[1] = 0xb3;
-        match mode {
-            AuraModes::LedBrightness(n) => return aura_brightness_bytes(*n),
-            AuraModes::Static(_) => msg[3] = 0x00,
-            AuraModes::Breathe(_) => msg[3] = 0x01,
-            AuraModes::Strobe(_) => msg[3] = 0x02,
-            AuraModes::Rainbow(_) => msg[3] = 0x03,
-            AuraModes::Star(_) => msg[3] = 0x04,
-            AuraModes::Rain(_) => msg[3] = 0x05,
-            AuraModes::Highlight(_) => msg[3] = 0x06,
-            AuraModes::Laser(_) => msg[3] = 0x07,
-            AuraModes::Ripple(_) => msg[3] = 0x08,
-            AuraModes::Pulse(_) => msg[3] = 0x0a,
-            AuraModes::Comet(_) => msg[3] = 0x0b,
-            AuraModes::Flash(_) => msg[3] = 0x0c,
-            _ => panic!("Mode not convertable to 1D array: {}", <&str>::from(mode)),
-        }
-
-        match mode {
-            AuraModes::Rainbow(settings) => {
-                msg[7] = settings.speed as u8;
-                msg[8] = settings.direction as u8;
-            }
-            AuraModes::Star(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-                msg[7] = settings.speed as u8;
-                msg[9] = settings.colour2.2;
-            }
-            AuraModes::Breathe(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-                msg[7] = settings.speed as u8;
-                msg[10] = settings.colour2.0;
-                msg[11] = settings.colour2.1;
-                msg[12] = settings.colour2.2;
-            }
-            AuraModes::Strobe(settings) | AuraModes::Rain(settings) => {
-                msg[7] = settings.speed as u8;
-            }
-            AuraModes::Highlight(settings)
-            | AuraModes::Laser(settings)
-            | AuraModes::Ripple(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-                msg[7] = settings.speed as u8;
-            }
-            AuraModes::Static(settings)
-            | AuraModes::Pulse(settings)
-            | AuraModes::Comet(settings)
-            | AuraModes::Flash(settings) => {
-                msg[4] = settings.colour.0;
-                msg[5] = settings.colour.1;
-                msg[6] = settings.colour.2;
-            }
-            _ => panic!("Mode not convertable to 1D array: {}", <&str>::from(mode)),
-        }
-        msg
-    }
-}
-
-impl From<AuraModes> for [u8; LED_MSG_LEN] {
-    #[inline]
-    fn from(mode: AuraModes) -> Self {
-        <[u8; LED_MSG_LEN]>::from(&mode)
-    }
-}
-
-impl From<AuraModes> for [[u8; LED_MSG_LEN]; 4] {
-    #[inline]
-    fn from(mode: AuraModes) -> Self {
-        <[[u8; LED_MSG_LEN]; 4]>::from(&mode)
-    }
-}
-
-impl From<&AuraModes> for [[u8; LED_MSG_LEN]; 4] {
-    #[inline]
-    fn from(mode: &AuraModes) -> Self {
-        let mut msg = [[0u8; LED_MSG_LEN]; 4];
-        for (i, row) in msg.iter_mut().enumerate() {
-            row[0] = 0x5d;
-            row[1] = 0xb3;
-            row[2] = i as u8 + 1;
-        }
-
-        match mode {
-            AuraModes::MultiStatic(settings) => {
-                msg[0][4] = settings.colour1.0;
-                msg[0][5] = settings.colour1.1;
-                msg[0][6] = settings.colour1.2;
-                msg[1][4] = settings.colour2.0;
-                msg[1][5] = settings.colour2.1;
-                msg[1][6] = settings.colour2.2;
-                msg[2][4] = settings.colour3.0;
-                msg[2][5] = settings.colour3.1;
-                msg[2][6] = settings.colour3.2;
-                msg[3][4] = settings.colour4.0;
-                msg[3][5] = settings.colour4.1;
-                msg[3][6] = settings.colour4.2;
-            }
-            _ => panic!("Mode not convertable to 2D array: {}", <&str>::from(mode)),
-        }
-        msg
-    }
-}

asusctl/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "asusctl"
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
+
+[dependencies]
+rog_anime = { path = "../rog-anime" }
+rog_slash = { path = "../rog-slash" }
+rog_aura = { path = "../rog-aura" }
+rog_dbus = { path = "../rog-dbus" }
+rog_profiles = { path = "../rog-profiles" }
+rog_platform = { path = "../rog-platform" }
+asusd = { path = "../asusd" }
+dmi_id = { path = "../dmi-id" }
+
+ron.workspace = true
+gumdrop.workspace = true
+zbus.workspace = true
+
+[dev-dependencies]
+rog_dbus = { path = "../rog-dbus" }
+
+cargo-husky.workspace = true

asusctl/examples/anime-diag-png.rs

@@ -0,0 +1,34 @@
+use std::env;
+use std::error::Error;
+use std::path::Path;
+use std::process::exit;
+
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDiagonal, AnimeType};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
+
+    let args: Vec<String> = env::args().collect();
+    if args.len() != 3 {
+        println!("Usage: <filepath> <brightness>");
+        println!("e.g, asusctl/examples/doom_large.png 0.8");
+        exit(-1);
+    }
+
+    let matrix = AnimeDiagonal::from_png(
+        Path::new(&args[1]),
+        None,
+        args[2].parse::<f32>().unwrap(),
+        AnimeType::GA401,
+    )?;
+
+    let anime_type = get_anime_type()?;
+
+    proxy.write(matrix.into_data_buffer(anime_type)?).unwrap();
+
+    Ok(())
+}

asusctl/examples/anime-diag.rs

@@ -0,0 +1,38 @@
+use std::thread::sleep;
+use std::time::Duration;
+
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDiagonal, AnimeType};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
+
+// In usable data:
+// Top row start at 1, ends at 32
+
+// 74w x 36h diagonal used by the windows app
+
+fn main() {
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
+
+    for step in (2..50).rev() {
+        let mut matrix = AnimeDiagonal::new(AnimeType::GA401, None);
+        for c in (0..60).step_by(step) {
+            for i in matrix.get_mut().iter_mut() {
+                i[c] = 50;
+            }
+        }
+
+        for c in (0..35).step_by(step) {
+            for i in &mut matrix.get_mut()[c] {
+                *i = 50;
+            }
+        }
+
+        let anime_type = get_anime_type().unwrap();
+        proxy
+            .write(matrix.into_data_buffer(anime_type).unwrap())
+            .unwrap();
+        sleep(Duration::from_millis(300));
+    }
+}

asusctl/examples/anime-gif.rs

@@ -0,0 +1,44 @@
+use std::env;
+use std::path::Path;
+use std::thread::sleep;
+
+use rog_anime::usb::get_anime_type;
+use rog_anime::{ActionData, ActionLoader, Sequences};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
+
+fn main() {
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
+
+    let args: Vec<String> = env::args().collect();
+    if args.len() != 3 {
+        println!("Please supply filepath and brightness");
+        return;
+    }
+
+    let path = Path::new(&args[1]);
+    let brightness = args[2].parse::<f32>().unwrap();
+    let anime_type = get_anime_type().unwrap();
+    let mut seq = Sequences::new(anime_type);
+    seq.insert(
+        0,
+        &ActionLoader::AsusAnimation {
+            file: path.into(),
+            time: rog_anime::AnimTime::Infinite,
+            brightness,
+        },
+    )
+    .unwrap();
+
+    loop {
+        for action in seq.iter() {
+            if let ActionData::Animation(frames) = action {
+                for frame in frames.frames() {
+                    proxy.write(frame.frame().clone()).unwrap();
+                    sleep(frame.delay());
+                }
+            }
+        }
+    }
+}

asusctl/examples/anime-grid.rs

@@ -0,0 +1,50 @@
+use std::convert::TryFrom;
+
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeGrid};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
+
+// In usable data:
+// Top row start at 1, ends at 32
+
+// 74w x 36h diagonal used by the windows app
+
+fn main() {
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
+
+    let anime_type = get_anime_type().unwrap();
+    let mut matrix = AnimeGrid::new(anime_type);
+    let tmp = matrix.get_mut();
+
+    let mut i = 0;
+    for (y, row) in tmp.iter_mut().enumerate() {
+        if y % 2 == 0 && i + 1 != row.len() - 1 {
+            i += 1;
+        }
+        row[row.len() - i] = 0x22;
+        if i > 5 {
+            row[row.len() - i + 5] = 0x22;
+        }
+        if i > 10 {
+            row[row.len() - i + 10] = 0x22;
+        }
+
+        if i > 15 {
+            row[row.len() - i + 15] = 0x22;
+        }
+
+        if i > 20 {
+            row[row.len() - i + 20] = 0x22;
+        }
+
+        if i > 25 {
+            row[row.len() - i + 25] = 0x22;
+        }
+    }
+
+    let matrix = <AnimeDataBuffer>::try_from(matrix).unwrap();
+
+    proxy.write(matrix).unwrap();
+}

asusctl/examples/anime-outline.rs

@@ -0,0 +1,133 @@
+use rog_anime::usb::get_anime_type;
+use rog_anime::AnimeDataBuffer;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
+
+// In usable data:
+// Top row start at 1, ends at 32
+
+fn main() {
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).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.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.data_mut()[1244] = 100; // end
+    println!("{:?}", &matrix);
+
+    proxy.write(matrix).unwrap();
+}

asusctl/examples/anime-png.rs

@@ -0,0 +1,39 @@
+use std::convert::TryFrom;
+use std::env;
+use std::error::Error;
+use std::path::Path;
+use std::process::exit;
+
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
+
+    let args: Vec<String> = env::args().collect();
+    if args.len() != 7 {
+        println!("Usage: <filepath> <scale> <angle> <x pos> <y pos> <brightness>");
+        println!("e.g, asusctl/examples/doom_large.png 0.9 0.4 0.0 0.0 0.8");
+        exit(-1);
+    }
+
+    let anime_type = get_anime_type()?;
+    let matrix = AnimeImage::from_png(
+        Path::new(&args[1]),
+        args[2].parse::<f32>().unwrap(),
+        args[3].parse::<f32>().unwrap(),
+        Vec2::new(
+            args[4].parse::<f32>().unwrap(),
+            args[5].parse::<f32>().unwrap(),
+        ),
+        args[6].parse::<f32>().unwrap(),
+        anime_type,
+    )?;
+
+    proxy.write(<AnimeDataBuffer>::try_from(&matrix)?).unwrap();
+
+    Ok(())
+}

asusctl/examples/anime-spinning.rs

@@ -0,0 +1,49 @@
+use std::convert::TryFrom;
+use std::env;
+use std::error::Error;
+use std::f32::consts::PI;
+use std::path::Path;
+use std::process::exit;
+use std::thread::sleep;
+use std::time::Duration;
+
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimeDataBuffer, AnimeImage, Vec2};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use zbus::blocking::Connection;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let conn = Connection::system().unwrap();
+    let proxy = AnimeProxyBlocking::new(&conn).unwrap();
+
+    let args: Vec<String> = env::args().collect();
+    if args.len() != 7 {
+        println!("Usage: <filepath> <scale> <angle> <x pos> <y pos> <brightness>");
+        println!("e.g, asusctl/examples/doom_large.png 0.9 0.4 0.0 0.0 0.8");
+        exit(-1);
+    }
+
+    let anime_type = get_anime_type()?;
+    let mut matrix = AnimeImage::from_png(
+        Path::new(&args[1]),
+        args[2].parse::<f32>().unwrap(),
+        args[3].parse::<f32>().unwrap(),
+        Vec2::new(
+            args[4].parse::<f32>().unwrap(),
+            args[5].parse::<f32>().unwrap(),
+        ),
+        args[6].parse::<f32>().unwrap(),
+        anime_type,
+    )?;
+
+    loop {
+        matrix.angle += 0.05;
+        if matrix.angle > PI * 2.0 {
+            matrix.angle = 0.0;
+        }
+        matrix.update();
+
+        proxy.write(<AnimeDataBuffer>::try_from(&matrix)?).unwrap();
+        sleep(Duration::from_micros(500));
+    }
+}

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

@@ -0,0 +1,113 @@
+//! Very bad rushed example. The better way to do this would be to have
+//! the balles move on their own square grid, then translate that to the
+//! key layout via shape by pitch etc.
+use rog_aura::{
+    layouts::{KeyLayout, KeyRow},
+    KeyColourArray,
+};
+use rog_dbus::RogDbusClientBlocking;
+use std::collections::VecDeque;
+
+#[derive(Debug, Clone)]
+struct Ball {
+    position: (f32, f32),
+    direction: (f32, f32),
+    trail: VecDeque<(f32, f32)>,
+}
+impl Ball {
+    fn new(x: f32, y: f32, trail_len: u32) -> Self {
+        let mut trail = VecDeque::new();
+        for _ in 1..=trail_len {
+            trail.push_back((x, y));
+        }
+
+        Ball {
+            position: (x, y),
+            direction: (1.0, 1.0),
+            trail,
+        }
+    }
+
+    #[allow(clippy::if_same_then_else)]
+    fn update(&mut self, key_map: &[KeyRow]) {
+        self.position.0 += self.direction.0;
+        self.position.1 += self.direction.1;
+
+        if self.position.1.abs() as usize >= key_map.len() {
+            self.direction.1 *= -1.0;
+            self.position.1 += self.direction.1;
+            self.direction.0 *= -1.0;
+            self.position.0 += self.direction.0;
+        }
+        if self.position.0.abs() as usize >= key_map[self.position.1.abs() as usize].row_ref().len()
+        {
+            self.direction.1 *= -1.0;
+            self.position.1 += self.direction.1;
+        }
+        if self.position.0 as usize >= key_map[self.position.1.abs() as usize].row_ref().len() {
+            self.direction.0 *= -1.0;
+            self.position.0 += self.direction.0;
+        }
+
+        let pos = self.position;
+
+        if pos.1 == key_map[pos.1.abs() as usize].row_ref().len() as f32 - 1.0 || pos.1 <= 0.0 {
+            self.direction.0 *= -1.0;
+        } else if key_map[(pos.1) as usize].row_ref()[(pos.0) as usize].is_placeholder() {
+            self.direction.0 *= -1.0;
+        }
+
+        if pos.0 == key_map.len() as f32 - 1.0 || pos.0 <= 0.0 {
+            self.direction.1 *= -1.0;
+        } else if key_map[(pos.1) as usize].row_ref()[(pos.0) as usize].is_placeholder() {
+            self.direction.1 *= -1.0;
+        }
+
+        self.trail.pop_front();
+        self.trail.push_back(self.position);
+    }
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (dbus, _) = RogDbusClientBlocking::new()?;
+
+    let mut colours = KeyColourArray::new();
+    let layout = KeyLayout::gx502_layout();
+
+    let mut balls = [Ball::new(2.0, 1.0, 12), Ball::new(5.0, 2.0, 12)];
+    // let mut balls = [Ball::new(2, 1, 12)];
+
+    loop {
+        for (n, ball) in balls.iter_mut().enumerate() {
+            ball.update(layout.rows_ref());
+            for (i, pos) in ball.trail.iter().enumerate() {
+                if let Some(c) = colours
+                    .rgb_for_key(layout.rows_ref()[pos.1.abs() as usize].row_ref()[pos.0 as usize])
+                {
+                    c[0] = 0;
+                    c[1] = 0;
+                    c[2] = 0;
+                    if n == 0 {
+                        c[0] = i as u8 * (255 / ball.trail.len() as u8);
+                    } else if n == 1 {
+                        c[1] = i as u8 * (255 / ball.trail.len() as u8);
+                    } else if n == 2 {
+                        c[2] = i as u8 * (255 / ball.trail.len() as u8);
+                    }
+                };
+            }
+
+            if let Some(c) = colours.rgb_for_key(
+                layout.rows_ref()[ball.position.1.abs() as usize].row_ref()
+                    [ball.position.0 as usize],
+            ) {
+                c[0] = 255;
+                c[1] = 255;
+                c[2] = 255;
+            };
+        }
+        dbus.proxies().led().direct_addressing_raw(colours.get())?;
+
+        std::thread::sleep(std::time::Duration::from_millis(150));
+    }
+}

asusctl/examples/aura-zoned-breathe.rs

@@ -0,0 +1,69 @@
+//! Using a combination of key-colour array plus a key layout to generate
+//! outputs.
+
+use rog_aura::effects::{AdvancedEffects, Effect};
+use rog_aura::keyboard::{KeyLayout, LedCode};
+use rog_aura::Colour;
+use rog_dbus::zbus_aura::AuraProxyBlocking;
+use zbus::blocking::Connection;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let layout = KeyLayout::default_layout();
+
+    let conn = Connection::system().unwrap();
+    let proxy = AuraProxyBlocking::new(&conn).unwrap();
+
+    let mut seq = AdvancedEffects::new(true);
+
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::Single,
+    //     Colour(166, 127, 166),
+    //     Colour(127, 155, 20),
+    //     rog_aura::Speed::High,
+    // ));
+    // seq.push(zone);
+
+    // let zone = Effect::DoomLightFlash(rog_aura::effects::DoomLightFlash::new(
+    //     RgbAddress::Single,
+    //     Colour(200, 0, 0),
+    //     80,
+    //     10,
+    // ));
+    // seq.push(zone);
+
+    let zone = Effect::DoomFlicker(rog_aura::effects::DoomFlicker::new(
+        LedCode::SingleZone,
+        Colour {
+            r: 200,
+            g: 110,
+            b: 0,
+        },
+        100,
+        10,
+    ));
+    seq.push(zone);
+
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::KeyboardCenterLeft,
+    //     Colour(16, 127, 255),
+    //     Colour(127, 15, 20),
+    //     rog_aura::Speed::Low,
+    // ));
+    // seq.push(zone);
+
+    // let zone = Effect::Breathe(rog_aura::effects::Breathe::new(
+    //     RgbAddress::LightbarRightCorner,
+    //     Colour(0, 255, 255),
+    //     Colour(255, 0, 255),
+    //     rog_aura::Speed::Med,
+    // ));
+    // seq.push(zone);
+
+    loop {
+        seq.next_state(&layout);
+        let packets = seq.create_packets();
+
+        proxy.direct_addressing_raw(packets)?;
+        std::thread::sleep(std::time::Duration::from_millis(33));
+    }
+}

asusctl/src/anime_cli.rs

@@ -0,0 +1,154 @@
+use gumdrop::Options;
+use rog_anime::usb::{AnimAwake, AnimBooting, AnimShutdown, AnimSleeping, Brightness};
+use rog_anime::AnimeType;
+
+#[derive(Options)]
+pub struct AnimeCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "override the display type")]
+    pub override_type: Option<AnimeType>,
+    #[options(meta = "", help = "enable/disable the display")]
+    pub enable_display: Option<bool>,
+    #[options(meta = "", help = "enable/disable the builtin run/powersave animation")]
+    pub enable_powersave_anim: Option<bool>,
+    #[options(
+        meta = "",
+        help = "set global base brightness value <Off, Low, Med, High>"
+    )]
+    pub brightness: Option<Brightness>,
+    #[options(help = "clear the display")]
+    pub clear: bool,
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when external power is unplugged"
+    )]
+    pub off_when_unplugged: Option<bool>,
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when the laptop suspends"
+    )]
+    pub off_when_suspended: Option<bool>,
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when the lid is closed"
+    )]
+    pub off_when_lid_closed: Option<bool>,
+    #[options(no_short, meta = "", help = "Off with his head!!!")]
+    pub off_with_his_head: Option<bool>,
+    #[options(command)]
+    pub command: Option<AnimeActions>,
+}
+
+#[derive(Options)]
+pub enum AnimeActions {
+    #[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),
+    #[options(help = "change which builtin animations are shown")]
+    SetBuiltins(Builtins),
+}
+
+#[derive(Options)]
+pub struct Builtins {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:GlitchConstruction, StaticEmergence>"
+    )]
+    pub boot: AnimBooting,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:BinaryBannerScroll, RogLogoGlitch>"
+    )]
+    pub awake: AnimAwake,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:BannerSwipe, Starfield>"
+    )]
+    pub sleep: AnimSleeping,
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:GlitchOut, SeeYa>"
+    )]
+    pub shutdown: AnimShutdown,
+    #[options(meta = "", help = "set/apply the animations <true/false>")]
+    pub set: Option<bool>,
+}
+
+#[derive(Options)]
+pub struct AnimeImage {
+    #[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,
+}
+
+#[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

@@ -0,0 +1,367 @@
+use std::str::FromStr;
+
+use gumdrop::Options;
+use rog_aura::error::Error;
+use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
+
+#[derive(Options, Debug)]
+pub struct LedPowerCommand1 {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "Control if LEDs enabled while awake <true/false>")]
+    pub awake: Option<bool>,
+    #[options(help = "Use with awake option, if excluded defaults to false")]
+    pub keyboard: bool,
+    #[options(help = "Use with awake option, if excluded defaults to false")]
+    pub lightbar: bool,
+    #[options(meta = "", help = "Control boot animations <true/false>")]
+    pub boot: Option<bool>,
+    #[options(meta = "", help = "Control suspend animations <true/false>")]
+    pub sleep: Option<bool>,
+}
+
+#[derive(Options, Debug)]
+pub struct LedPowerCommand2 {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(command)]
+    pub command: Option<SetAuraZoneEnabled>,
+}
+
+#[derive(Options, Debug)]
+pub enum SetAuraZoneEnabled {
+    /// Applies to both old and new models
+    #[options(help = "")]
+    Keyboard(AuraPowerStates),
+    #[options(help = "")]
+    Logo(AuraPowerStates),
+    #[options(help = "")]
+    Lightbar(AuraPowerStates),
+    #[options(help = "")]
+    Lid(AuraPowerStates),
+    #[options(help = "")]
+    RearGlow(AuraPowerStates),
+}
+
+#[derive(Debug, Clone, Options)]
+pub struct AuraPowerStates {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub boot: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub awake: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub sleep: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub shutdown: bool,
+}
+
+#[derive(Options)]
+pub struct LedBrightness {
+    level: Option<u8>,
+}
+impl LedBrightness {
+    pub fn new(level: Option<u8>) -> Self {
+        LedBrightness { level }
+    }
+
+    pub fn level(&self) -> Option<u8> {
+        self.level
+    }
+}
+impl FromStr for LedBrightness {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_lowercase();
+        match s.as_str() {
+            "off" => Ok(LedBrightness { level: Some(0x00) }),
+            "low" => Ok(LedBrightness { level: Some(0x01) }),
+            "med" => Ok(LedBrightness { level: Some(0x02) }),
+            "high" => Ok(LedBrightness { level: Some(0x03) }),
+            _ => {
+                print!("Invalid argument, must be one of: off, low, med, high");
+                Err(Error::ParseBrightness)
+            }
+        }
+    }
+}
+#[allow(clippy::to_string_trait_impl)]
+impl ToString for LedBrightness {
+    fn to_string(&self) -> String {
+        let s = match self.level {
+            Some(0x00) => "low",
+            Some(0x01) => "med",
+            Some(0x02) => "high",
+            _ => "unknown",
+        };
+        s.to_owned()
+    }
+}
+
+#[derive(Debug, Clone, Options, Default)]
+pub struct SingleSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+    #[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")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the direction: up, down, left, right")]
+    pub direction: Direction,
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+    #[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 SingleColour {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour: Colour,
+    #[options(
+        no_long,
+        meta = "",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
+    )]
+    pub zone: AuraZone,
+}
+
+#[derive(Debug, Clone, Default, Options)]
+pub struct SingleColourSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour: Colour,
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+    #[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 TwoColourSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the first RGB value e.g, ff00ff")]
+    pub colour: Colour,
+    #[options(no_long, meta = "", help = "set the second RGB value e.g, ff00ff")]
+    pub colour2: Colour,
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+    #[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 MultiZone {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour1: Colour,
+    #[options(short = "b", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour2: Colour,
+    #[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour3: Colour,
+    #[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour4: Colour,
+}
+
+#[derive(Debug, Clone, Default, Options)]
+pub struct MultiColourSpeed {
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour1: Colour,
+    #[options(short = "b", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour2: Colour,
+    #[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour3: Colour,
+    #[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
+    pub colour4: Colour,
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
+    pub speed: Speed,
+}
+
+/// Byte value for setting the built-in mode.
+///
+/// Enum corresponds to the required integer value
+// NOTE: The option names here must match those in rog-aura crate
+#[derive(Options)]
+pub enum SetAuraBuiltin {
+    #[options(help = "set a single static colour")]
+    Static(SingleColour), // 0
+    #[options(help = "pulse between one or two colours")]
+    Breathe(TwoColourSpeed), // 1
+    #[options(help = "strobe through all colours")]
+    Strobe(SingleSpeed), // 2
+    #[options(help = "rainbow cycling in one of four directions")]
+    Rainbow(SingleSpeedDirection), // 3
+    #[options(help = "rain pattern mimicking raindrops")]
+    Stars(TwoColourSpeed), // 4
+    #[options(help = "rain pattern of three preset colours")]
+    Rain(SingleSpeed), // 5
+    #[options(help = "pressed keys are highlighted to fade")]
+    Highlight(SingleColourSpeed), // 6
+    #[options(help = "pressed keys generate horizontal laser")]
+    Laser(SingleColourSpeed), // 7
+    #[options(help = "pressed keys ripple outwards like a splash")]
+    Ripple(SingleColourSpeed), // 8
+    #[options(help = "set a rapid pulse")]
+    Pulse(SingleColour), // 10
+    #[options(help = "set a vertical line zooming from left")]
+    Comet(SingleColour), // 11
+    #[options(help = "set a wide vertical line zooming from left")]
+    Flash(SingleColour), // 12
+}
+
+impl Default for SetAuraBuiltin {
+    fn default() -> Self {
+        SetAuraBuiltin::Static(SingleColour::default())
+    }
+}
+
+impl From<&SingleColour> for AuraEffect {
+    fn from(aura: &SingleColour) -> Self {
+        Self {
+            colour1: aura.colour,
+            zone: aura.zone,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SingleSpeed> for AuraEffect {
+    fn from(aura: &SingleSpeed) -> Self {
+        Self {
+            speed: aura.speed,
+            zone: aura.zone,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SingleColourSpeed> for AuraEffect {
+    fn from(aura: &SingleColourSpeed) -> Self {
+        Self {
+            colour1: aura.colour,
+            speed: aura.speed,
+            zone: aura.zone,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&TwoColourSpeed> for AuraEffect {
+    fn from(aura: &TwoColourSpeed) -> Self {
+        Self {
+            colour1: aura.colour,
+            colour2: aura.colour2,
+            zone: aura.zone,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SingleSpeedDirection> for AuraEffect {
+    fn from(aura: &SingleSpeedDirection) -> Self {
+        Self {
+            speed: aura.speed,
+            direction: aura.direction,
+            zone: aura.zone,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<&SetAuraBuiltin> for AuraEffect {
+    fn from(aura: &SetAuraBuiltin) -> Self {
+        match aura {
+            SetAuraBuiltin::Static(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Static;
+                data
+            }
+            SetAuraBuiltin::Breathe(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Breathe;
+                data
+            }
+            SetAuraBuiltin::Strobe(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Strobe;
+                data
+            }
+            SetAuraBuiltin::Rainbow(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Rainbow;
+                data
+            }
+            SetAuraBuiltin::Stars(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Star;
+                data
+            }
+            SetAuraBuiltin::Rain(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Rain;
+                data
+            }
+            SetAuraBuiltin::Highlight(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Highlight;
+                data
+            }
+            SetAuraBuiltin::Laser(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Laser;
+                data
+            }
+            SetAuraBuiltin::Ripple(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Ripple;
+                data
+            }
+            SetAuraBuiltin::Pulse(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Pulse;
+                data
+            }
+            SetAuraBuiltin::Comet(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Comet;
+                data
+            }
+            SetAuraBuiltin::Flash(x) => {
+                let mut data: AuraEffect = x.into();
+                data.mode = AuraModeNum::Flash;
+                data
+            }
+        }
+    }
+}

asusctl/src/cli_opts.rs

@@ -0,0 +1,118 @@
+use gumdrop::Options;
+use rog_platform::platform::ThrottlePolicy;
+
+use crate::anime_cli::AnimeCommand;
+use crate::aura_cli::{LedBrightness, LedPowerCommand1, LedPowerCommand2, SetAuraBuiltin};
+use crate::fan_curve_cli::FanCurveCommand;
+use crate::slash_cli::SlashCommand;
+
+#[derive(Default, Options)]
+pub struct CliStart {
+    #[options(help_flag, help = "print help message")]
+    pub help: bool,
+    #[options(help = "show program version number")]
+    pub version: bool,
+    #[options(help = "show supported functions of this laptop")]
+    pub show_supported: bool,
+    #[options(meta = "", help = "<off, low, med, high>")]
+    pub kbd_bright: Option<LedBrightness>,
+    #[options(help = "Toggle to next keyboard brightness")]
+    pub next_kbd_bright: bool,
+    #[options(help = "Toggle to previous keyboard brightness")]
+    pub prev_kbd_bright: bool,
+    #[options(meta = "", help = "Set your battery charge limit <20-100>")]
+    pub chg_limit: Option<u8>,
+    #[options(command)]
+    pub command: Option<CliCommand>,
+}
+
+#[derive(Options)]
+pub enum CliCommand {
+    #[options(help = "Set the keyboard lighting from built-in modes")]
+    LedMode(LedModeCommand),
+    #[options(help = "Set the LED power states")]
+    LedPow1(LedPowerCommand1),
+    #[options(help = "Set the LED power states")]
+    LedPow2(LedPowerCommand2),
+    #[options(help = "Set or select platform_profile")]
+    Profile(ProfileCommand),
+    #[options(help = "Set, select, or modify fan curves if supported")]
+    FanCurve(FanCurveCommand),
+    #[options(help = "Set the graphics mode (obsoleted by supergfxctl)")]
+    Graphics(GraphicsCommand),
+    #[options(name = "anime", help = "Manage AniMe Matrix")]
+    Anime(AnimeCommand),
+    #[options(name = "slash", help = "Manage Slash Ledbar")]
+    Slash(SlashCommand),
+    #[options(help = "Change bios settings")]
+    Bios(BiosCommand),
+}
+
+#[derive(Debug, Clone, Options)]
+pub struct ProfileCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "toggle to next profile in list")]
+    pub next: bool,
+
+    #[options(help = "list available profiles")]
+    pub list: bool,
+
+    #[options(help = "get profile")]
+    pub profile_get: bool,
+
+    #[options(meta = "", help = "set the active profile")]
+    pub profile_set: Option<ThrottlePolicy>,
+}
+
+#[derive(Options)]
+pub struct LedModeCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "switch to next aura mode")]
+    pub next_mode: bool,
+    #[options(help = "switch to previous aura mode")]
+    pub prev_mode: bool,
+    #[options(command)]
+    pub command: Option<SetAuraBuiltin>,
+}
+
+#[derive(Options)]
+pub struct GraphicsCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+}
+
+#[derive(Options, Debug)]
+pub struct BiosCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(
+        meta = "",
+        short = "S",
+        no_long,
+        help = "set bios POST sound: asusctl -S <true/false>"
+    )]
+    pub post_sound_set: Option<bool>,
+    #[options(no_long, short = "s", help = "read bios POST sound")]
+    pub post_sound_get: bool,
+    #[options(
+        meta = "",
+        short = "D",
+        no_long,
+        help = "Switch GPU MUX mode: 0 = Discrete, 1 = Optimus, reboot required"
+    )]
+    pub gpu_mux_mode_set: Option<u8>,
+    #[options(no_long, short = "d", help = "get GPU mode")]
+    pub gpu_mux_mode_get: bool,
+    #[options(
+        meta = "",
+        short = "O",
+        no_long,
+        help = "Set device panel overdrive <true/false>"
+    )]
+    pub panel_overdrive_set: Option<bool>,
+    #[options(no_long, short = "o", help = "get panel overdrive")]
+    pub panel_overdrive_get: bool,
+}

asusctl/src/fan_curve_cli.rs

@@ -0,0 +1,49 @@
+use gumdrop::Options;
+use rog_platform::platform::ThrottlePolicy;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::FanCurvePU;
+
+#[derive(Debug, Clone, Options)]
+pub struct FanCurveCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "get enabled fan profiles")]
+    pub get_enabled: bool,
+
+    #[options(help = "set the active profile's fan curve to default")]
+    pub default: bool,
+
+    #[options(
+        meta = "",
+        help = "profile to modify fan-curve for. Shows data if no options provided"
+    )]
+    pub mod_profile: Option<ThrottlePolicy>,
+
+    #[options(
+        meta = "",
+        help = "enable or disable <true/false> fan all curves for a profile. `--mod_profile` \
+                required"
+    )]
+    pub enable_fan_curves: Option<bool>,
+
+    #[options(
+        meta = "",
+        help = "enable or disable <true/false> a single fan curve for a profile. `--mod_profile` \
+                and `--fan` required"
+    )]
+    pub enable_fan_curve: Option<bool>,
+
+    #[options(
+        meta = "",
+        help = "select fan <cpu/gpu/mid> to modify. `--mod_profile` required"
+    )]
+    pub fan: Option<FanCurvePU>,
+
+    #[options(
+        meta = "",
+        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>,
+}

asusctl/src/main.rs

@@ -0,0 +1,942 @@
+use std::convert::TryFrom;
+use std::env::args;
+use std::path::Path;
+use std::process::Command;
+use std::thread::sleep;
+
+use anime_cli::{AnimeActions, AnimeCommand};
+use asusd::ctrl_fancurves::FAN_CURVE_ZBUS_NAME;
+use aura_cli::{LedPowerCommand1, LedPowerCommand2};
+use dmi_id::DMIID;
+use fan_curve_cli::FanCurveCommand;
+use gumdrop::{Opt, Options};
+use rog_anime::usb::get_anime_type;
+use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType, Vec2};
+use rog_aura::keyboard::{AuraPowerState, LaptopAuraPower};
+use rog_aura::{self, AuraDeviceType, AuraEffect, PowerZones};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use rog_dbus::zbus_aura::AuraProxyBlocking;
+use rog_dbus::zbus_fan_curves::FanCurvesProxyBlocking;
+use rog_dbus::zbus_platform::PlatformProxyBlocking;
+use rog_dbus::zbus_slash::SlashProxyBlocking;
+use rog_platform::platform::{GpuMode, Properties, ThrottlePolicy};
+use rog_profiles::error::ProfileError;
+use rog_slash::SlashMode;
+use ron::ser::PrettyConfig;
+use zbus::blocking::Connection;
+
+use crate::aura_cli::{AuraPowerStates, LedBrightness};
+use crate::cli_opts::*;
+use crate::slash_cli::SlashCommand;
+
+mod anime_cli;
+mod aura_cli;
+mod cli_opts;
+mod fan_curve_cli;
+mod slash_cli;
+
+fn main() {
+    let args: Vec<String> = args().skip(1).collect();
+
+    let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
+    let parsed = match CliStart::parse_args_default(&args) {
+        Ok(p) => p,
+        Err(err) if err.to_string() == missing_argument_k.to_string() => CliStart {
+            kbd_bright: Some(LedBrightness::new(None)),
+            ..Default::default()
+        },
+        Err(err) => {
+            println!("Error: {}", err);
+            return;
+        }
+    };
+
+    let conn = Connection::system().unwrap();
+    if let Ok(platform_proxy) = PlatformProxyBlocking::new(&conn).map_err(|e| {
+        check_service("asusd");
+        println!("\nError: {e}\n");
+        print_info();
+    }) {
+        let self_version = env!("CARGO_PKG_VERSION");
+        let asusd_version = platform_proxy.version().unwrap();
+        if asusd_version != self_version {
+            println!("Version mismatch: asusctl = {self_version}, asusd = {asusd_version}");
+            return;
+        }
+
+        let supported_properties = platform_proxy.supported_properties().unwrap();
+        let supported_interfaces = platform_proxy.supported_interfaces().unwrap();
+
+        if parsed.version {
+            println!("asusctl v{}", env!("CARGO_PKG_VERSION"));
+            println!();
+            print_info();
+        }
+
+        if let Err(err) = do_parsed(&parsed, &supported_interfaces, &supported_properties, conn) {
+            print_error_help(&*err, &supported_interfaces, &supported_properties);
+        }
+    }
+}
+
+fn print_error_help(
+    err: &dyn std::error::Error,
+    supported_interfaces: &[String],
+    supported_properties: &[Properties],
+) {
+    check_service("asusd");
+    println!("\nError: {}\n", err);
+    print_info();
+    println!();
+    println!("Supported interfaces:\n\n{:#?}\n", supported_interfaces);
+    println!("Supported properties:\n\n{:#?}\n", supported_properties);
+}
+
+fn print_info() {
+    let dmi = DMIID::new().unwrap_or_default();
+    let board_name = dmi.board_name;
+    let prod_family = dmi.product_family;
+    println!("asusctl version: {}", env!("CARGO_PKG_VERSION"));
+    println!(" Product family: {}", prod_family.trim());
+    println!("     Board name: {}", board_name.trim());
+}
+
+fn check_service(name: &str) -> bool {
+    if name != "asusd" && !check_systemd_unit_enabled(name) {
+        println!(
+            "\n\x1b[0;31m{} is not enabled, enable it with `systemctl enable {}\x1b[0m",
+            name, name
+        );
+        return true;
+    } else if !check_systemd_unit_active(name) {
+        println!(
+            "\n\x1b[0;31m{} is not running, start it with `systemctl start {}\x1b[0m",
+            name, name
+        );
+        return true;
+    }
+    false
+}
+
+fn find_aura_iface() -> Result<Vec<AuraProxyBlocking<'static>>, Box<dyn std::error::Error>> {
+    let conn = zbus::blocking::Connection::system().unwrap();
+    let f = zbus::blocking::fdo::ObjectManagerProxy::new(
+        &conn,
+        "org.asuslinux.Daemon",
+        "/org/asuslinux",
+    )
+    .unwrap();
+    let interfaces = f.get_managed_objects().unwrap();
+    let mut aura_paths = Vec::new();
+    for v in interfaces.iter() {
+        // let o: Vec<zbus::names::OwnedInterfaceName> = v.1.keys().map(|e|
+        // e.to_owned()).collect(); println!("{}, {:?}", v.0, o);
+        for k in v.1.keys() {
+            if k.as_str() == "org.asuslinux.Aura" {
+                println!("Found aura device at {}, {}", v.0, k);
+                aura_paths.push(v.0.clone());
+            }
+        }
+    }
+    if aura_paths.len() > 1 {
+        println!("Multiple aura devices found: {aura_paths:?}");
+        println!("TODO: enable selection");
+    }
+    if !aura_paths.is_empty() {
+        let mut ctrl = Vec::new();
+        for path in aura_paths {
+            ctrl.push(
+                AuraProxyBlocking::builder(&conn)
+                    .path(path.clone())?
+                    .destination("org.asuslinux.Daemon")?
+                    .build()?,
+            );
+        }
+        return Ok(ctrl);
+    }
+
+    Err("No Aura interface".into())
+}
+
+fn do_parsed(
+    parsed: &CliStart,
+    supported_interfaces: &[String],
+    supported_properties: &[Properties],
+    conn: Connection,
+) -> Result<(), Box<dyn std::error::Error>> {
+    match &parsed.command {
+        Some(CliCommand::LedMode(mode)) => handle_led_mode(&find_aura_iface()?, mode)?,
+        Some(CliCommand::LedPow1(pow)) => handle_led_power1(&find_aura_iface()?, pow)?,
+        Some(CliCommand::LedPow2(pow)) => handle_led_power2(&find_aura_iface()?, pow)?,
+        Some(CliCommand::Profile(cmd)) => {
+            handle_throttle_profile(&conn, supported_properties, cmd)?
+        }
+        Some(CliCommand::FanCurve(cmd)) => {
+            handle_fan_curve(&conn, supported_interfaces, cmd)?;
+        }
+        Some(CliCommand::Graphics(_)) => do_gfx(),
+        Some(CliCommand::Anime(cmd)) => handle_anime(&conn, cmd)?,
+        Some(CliCommand::Slash(cmd)) => handle_slash(&conn, cmd)?,
+        Some(CliCommand::Bios(cmd)) => {
+            handle_platform_properties(&conn, supported_properties, cmd)?
+        }
+        None => {
+            if (!parsed.show_supported
+                && parsed.kbd_bright.is_none()
+                && parsed.chg_limit.is_none()
+                && !parsed.next_kbd_bright
+                && !parsed.prev_kbd_bright)
+                || parsed.help
+            {
+                println!("{}", CliStart::usage());
+                println!();
+                if let Some(cmdlist) = CliStart::command_list() {
+                    let dev_type = if let Ok(proxy) = find_aura_iface() {
+                        // TODO: commands on all?
+                        proxy
+                            .first()
+                            .unwrap()
+                            .device_type()
+                            .unwrap_or(AuraDeviceType::Unknown)
+                    } else {
+                        AuraDeviceType::Unknown
+                    };
+                    let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
+                    for command in commands.iter().filter(|command| {
+                        if !dev_type.is_old_laptop()
+                            && !dev_type.is_tuf_laptop()
+                            && command.trim().starts_with("led-pow-1")
+                        {
+                            return false;
+                        }
+                        if !dev_type.is_new_laptop() && command.trim().starts_with("led-pow-2") {
+                            return false;
+                        }
+                        true
+                    }) {
+                        println!("{}", command);
+                    }
+                }
+
+                println!("\nExtra help can be requested on any command or subcommand:");
+                println!(" asusctl led-mode --help");
+                println!(" asusctl led-mode static --help");
+            }
+        }
+    }
+
+    if let Some(brightness) = &parsed.kbd_bright {
+        if let Ok(aura) = find_aura_iface() {
+            for aura in aura.iter() {
+                match brightness.level() {
+                    None => {
+                        let level = aura.brightness()?;
+                        println!("Current keyboard led brightness: {level:?}");
+                    }
+                    Some(level) => aura.set_brightness(rog_aura::LedBrightness::from(level))?,
+                }
+            }
+        } else {
+            println!("No aura interface found");
+        }
+    }
+
+    if parsed.next_kbd_bright {
+        if let Ok(aura) = find_aura_iface() {
+            for aura in aura.iter() {
+                let brightness = aura.brightness()?;
+                aura.set_brightness(brightness.next())?;
+            }
+        } else {
+            println!("No aura interface found");
+        }
+    }
+
+    if parsed.prev_kbd_bright {
+        if let Ok(aura) = find_aura_iface() {
+            for aura in aura.iter() {
+                let brightness = aura.brightness()?;
+                aura.set_brightness(brightness.prev())?;
+            }
+        } else {
+            println!("No aura interface found");
+        }
+    }
+
+    if parsed.show_supported {
+        println!("Supported Core Functions:\n{:#?}", supported_interfaces);
+        println!(
+            "Supported Platform Properties:\n{:#?}",
+            supported_properties
+        );
+        if let Ok(aura) = find_aura_iface() {
+            // TODO: multiple RGB check
+            let bright = aura.first().unwrap().supported_brightness()?;
+            let modes = aura.first().unwrap().supported_basic_modes()?;
+            let zones = aura.first().unwrap().supported_basic_zones()?;
+            let power = aura.first().unwrap().supported_power_zones()?;
+            println!("Supported Keyboard Brightness:\n{:#?}", bright);
+            println!("Supported Aura Modes:\n{:#?}", modes);
+            println!("Supported Aura Zones:\n{:#?}", zones);
+            println!("Supported Aura Power Zones:\n{:#?}", power);
+        } else {
+            println!("No aura interface found");
+        }
+    }
+
+    if let Some(chg_limit) = parsed.chg_limit {
+        let proxy = PlatformProxyBlocking::new(&conn)?;
+        proxy.set_charge_control_end_threshold(chg_limit)?;
+    }
+
+    Ok(())
+}
+
+fn do_gfx() {
+    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");
+}
+
+fn handle_anime(conn: &Connection, cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
+    if (cmd.command.is_none()
+        && cmd.enable_display.is_none()
+        && cmd.enable_powersave_anim.is_none()
+        && cmd.brightness.is_none()
+        && cmd.off_when_lid_closed.is_none()
+        && cmd.off_when_suspended.is_none()
+        && cmd.off_when_unplugged.is_none()
+        && cmd.off_with_his_head.is_none()
+        && !cmd.clear)
+        || cmd.help
+    {
+        println!("Missing arg or command\n\n{}", cmd.self_usage());
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+    }
+    let proxy = AnimeProxyBlocking::new(conn)?;
+    if let Some(enable) = cmd.enable_display {
+        proxy.set_enable_display(enable)?;
+    }
+    if let Some(enable) = cmd.enable_powersave_anim {
+        proxy.set_builtins_enabled(enable)?;
+    }
+    if let Some(bright) = cmd.brightness {
+        proxy.set_brightness(bright)?;
+    }
+    if let Some(enable) = cmd.off_when_lid_closed {
+        proxy.set_off_when_lid_closed(enable)?;
+    }
+    if let Some(enable) = cmd.off_when_suspended {
+        proxy.set_off_when_suspended(enable)?;
+    }
+    if let Some(enable) = cmd.off_when_unplugged {
+        proxy.set_off_when_unplugged(enable)?;
+    }
+    if cmd.off_with_his_head.is_some() {
+        println!("Did Alice _really_ make it back from Wonderland?");
+    }
+
+    let mut anime_type = get_anime_type()?;
+    if let AnimeType::Unknown = anime_type {
+        if let Some(model) = cmd.override_type {
+            anime_type = model;
+        }
+    }
+
+    if cmd.clear {
+        let data = vec![255u8; anime_type.data_length()];
+        let tmp = AnimeDataBuffer::from_vec(anime_type, data)?;
+        proxy.write(tmp)?;
+    }
+
+    if let Some(action) = cmd.command.as_ref() {
+        match action {
+            AnimeActions::Image(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);
+                    }
+                    return Ok(());
+                }
+                verify_brightness(image.bright);
+
+                let matrix = AnimeImage::from_png(
+                    Path::new(&image.path),
+                    image.scale,
+                    image.angle,
+                    Vec2::new(image.x_pos, image.y_pos),
+                    image.bright,
+                    anime_type,
+                )?;
+
+                proxy.write(<AnimeDataBuffer>::try_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);
+                    }
+                    return Ok(());
+                }
+                verify_brightness(image.bright);
+
+                let matrix = AnimeDiagonal::from_png(
+                    Path::new(&image.path),
+                    None,
+                    image.bright,
+                    anime_type,
+                )?;
+
+                proxy.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);
+                    }
+                    return Ok(());
+                }
+                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() {
+                        proxy.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);
+                    }
+                    return Ok(());
+                }
+                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() {
+                        proxy.write(frame.frame().clone())?;
+                        sleep(frame.delay());
+                    }
+                    if loops >= 0 {
+                        loops -= 1;
+                    }
+                    if loops == 0 {
+                        break;
+                    }
+                }
+            }
+            AnimeActions::SetBuiltins(builtins) => {
+                if builtins.help_requested() || builtins.set.is_none() {
+                    println!("\nAny unspecified args will be set to default (first shown var)\n");
+                    println!("\n{}", builtins.self_usage());
+                    if let Some(lst) = builtins.self_command_list() {
+                        println!("\n{}", lst);
+                    }
+                    return Ok(());
+                }
+
+                proxy.set_builtin_animations(rog_anime::Animations {
+                    boot: builtins.boot,
+                    awake: builtins.awake,
+                    sleep: builtins.sleep,
+                    shutdown: builtins.shutdown,
+                })?;
+            }
+        }
+    }
+    Ok(())
+}
+
+fn verify_brightness(brightness: f32) {
+    if !(0.0..=1.0).contains(&brightness) {
+        println!(
+            "Image and global brightness must be between 0.0 and 1.0 (inclusive), was {}",
+            brightness
+        );
+    }
+}
+
+fn handle_slash(conn: &Connection, cmd: &SlashCommand) -> Result<(), Box<dyn std::error::Error>> {
+    if (cmd.brightness.is_none()
+        && cmd.interval.is_none()
+        && cmd.slash_mode.is_none()
+        && !cmd.list
+        && !cmd.enable
+        && !cmd.disable)
+        || cmd.help
+    {
+        println!("Missing arg or command\n\n{}", cmd.self_usage());
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+    }
+    let proxy = SlashProxyBlocking::new(conn)?;
+    if cmd.enable {
+        proxy.set_enabled(true)?;
+    }
+    if cmd.disable {
+        proxy.set_enabled(false)?;
+    }
+    if let Some(brightness) = cmd.brightness {
+        proxy.set_brightness(brightness)?;
+    }
+    if let Some(interval) = cmd.interval {
+        proxy.set_interval(interval)?;
+    }
+    if let Some(slash_mode) = cmd.slash_mode {
+        proxy.set_slash_mode(slash_mode)?;
+    }
+    if cmd.list {
+        let res = SlashMode::list();
+        for p in &res {
+            println!("{:?}", p);
+        }
+    }
+
+    Ok(())
+}
+
+fn handle_led_mode(
+    aura: &[AuraProxyBlocking],
+    mode: &LedModeCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if mode.command.is_none() && !mode.prev_mode && !mode.next_mode {
+        if !mode.help {
+            println!("Missing arg or command\n");
+        }
+        println!("{}\n", mode.self_usage());
+        println!("Commands available");
+
+        if let Some(cmdlist) = LedModeCommand::command_list() {
+            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
+            // TODO: multiple rgb check
+            let modes = aura.first().unwrap().supported_basic_modes()?;
+            for command in commands.iter().filter(|command| {
+                for mode in &modes {
+                    if command
+                        .trim()
+                        .starts_with(&<&str>::from(mode).to_lowercase())
+                    {
+                        return true;
+                    }
+                }
+                // TODO
+                // if !supported.basic_zones.is_empty() && command.trim().starts_with("multi") {
+                //     return true;
+                // }
+                false
+            }) {
+                println!("{}", command);
+            }
+        }
+
+        println!("\nHelp can also be requested on modes, e.g: static --help");
+        return Ok(());
+    }
+
+    if mode.next_mode && mode.prev_mode {
+        println!("Please specify either next or previous");
+        return Ok(());
+    }
+    if mode.next_mode {
+        for aura in aura {
+            let mode = aura.led_mode()?;
+            let modes = aura.supported_basic_modes()?;
+            let mut pos = modes.iter().position(|m| *m == mode).unwrap() + 1;
+            if pos >= modes.len() {
+                pos = 0;
+            }
+            aura.set_led_mode(modes[pos])?;
+        }
+    } else if mode.prev_mode {
+        for aura in aura {
+            let mode = aura.led_mode()?;
+            let modes = aura.supported_basic_modes()?;
+            let mut pos = modes.iter().position(|m| *m == mode).unwrap();
+            if pos == 0 {
+                pos = modes.len() - 1;
+            } else {
+                pos -= 1;
+            }
+            aura.set_led_mode(modes[pos])?;
+        }
+    } else if let Some(mode) = mode.command.as_ref() {
+        if mode.help_requested() {
+            println!("{}", mode.self_usage());
+            return Ok(());
+        }
+        for aura in aura {
+            aura.set_led_mode_data(<AuraEffect>::from(mode))?;
+        }
+    }
+
+    Ok(())
+}
+
+fn handle_led_power1(
+    aura: &[AuraProxyBlocking],
+    power: &LedPowerCommand1,
+) -> Result<(), Box<dyn std::error::Error>> {
+    for aura in aura {
+        let dev_type = aura.device_type()?;
+        if !dev_type.is_old_laptop() && !dev_type.is_tuf_laptop() {
+            println!("This option applies only to keyboards 2021+");
+        }
+
+        if power.awake.is_none()
+            && power.sleep.is_none()
+            && power.boot.is_none()
+            && !power.keyboard
+            && !power.lightbar
+        {
+            if !power.help {
+                println!("Missing arg or command\n");
+            }
+            println!("{}\n", power.self_usage());
+            return Ok(());
+        }
+
+        if dev_type.is_old_laptop() || dev_type.is_tuf_laptop() {
+            handle_led_power_1_do_1866(aura, power)?;
+            return Ok(());
+        }
+    }
+
+    println!("These options are for keyboards of product ID 0x1866 or TUF only");
+    Ok(())
+}
+
+fn handle_led_power_1_do_1866(
+    aura: &AuraProxyBlocking,
+    power: &LedPowerCommand1,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let zone = if power.keyboard && power.lightbar {
+        PowerZones::KeyboardAndLightbar
+    } else if power.lightbar {
+        PowerZones::Lightbar
+    } else {
+        PowerZones::Keyboard
+    };
+    let states = LaptopAuraPower {
+        states: vec![AuraPowerState {
+            zone,
+            boot: power.boot.unwrap_or_default(),
+            awake: power.awake.unwrap_or_default(),
+            sleep: power.sleep.unwrap_or_default(),
+            shutdown: false,
+        }],
+    };
+
+    aura.set_led_power(states)?;
+
+    Ok(())
+}
+
+fn handle_led_power2(
+    aura: &[AuraProxyBlocking],
+    power: &LedPowerCommand2,
+) -> Result<(), Box<dyn std::error::Error>> {
+    for aura in aura {
+        let dev_type = aura.device_type()?;
+        if !dev_type.is_new_laptop() {
+            println!("This option applies only to keyboards 2021+");
+            continue;
+        }
+
+        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) = LedPowerCommand2::command_list() {
+                let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
+                for command in &commands {
+                    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(());
+            }
+
+            let mut states = aura.led_power()?;
+            let mut set = |zone: PowerZones, set_to: &AuraPowerStates| {
+                for state in states.states.iter_mut() {
+                    if state.zone == zone {
+                        state.boot = set_to.boot;
+                        state.awake = set_to.awake;
+                        state.sleep = set_to.sleep;
+                        state.shutdown = set_to.shutdown;
+                        break;
+                    }
+                }
+            };
+
+            if let Some(cmd) = &power.command {
+                match cmd {
+                    aura_cli::SetAuraZoneEnabled::Keyboard(k) => set(PowerZones::Keyboard, k),
+                    aura_cli::SetAuraZoneEnabled::Logo(l) => set(PowerZones::Logo, l),
+                    aura_cli::SetAuraZoneEnabled::Lightbar(l) => set(PowerZones::Lightbar, l),
+                    aura_cli::SetAuraZoneEnabled::Lid(l) => set(PowerZones::Lid, l),
+                    aura_cli::SetAuraZoneEnabled::RearGlow(r) => set(PowerZones::RearGlow, r),
+                }
+            }
+
+            aura.set_led_power(states)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn handle_throttle_profile(
+    conn: &Connection,
+    supported: &[Properties],
+    cmd: &ProfileCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if !supported.contains(&Properties::ThrottlePolicy) {
+        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");
+        }
+        println!("{}", ProfileCommand::usage());
+
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+        return Ok(());
+    }
+
+    let proxy = PlatformProxyBlocking::new(conn)?;
+    let current = proxy.throttle_thermal_policy()?;
+
+    if cmd.next {
+        proxy.set_throttle_thermal_policy(current.next())?;
+    } else if let Some(profile) = cmd.profile_set {
+        proxy.set_throttle_thermal_policy(profile)?;
+    }
+
+    if cmd.list {
+        let res = ThrottlePolicy::list();
+        for p in &res {
+            println!("{:?}", p);
+        }
+    }
+
+    if cmd.profile_get {
+        println!("Active profile is {current:?}");
+    }
+
+    Ok(())
+}
+
+fn handle_fan_curve(
+    conn: &Connection,
+    supported: &[String],
+    cmd: &FanCurveCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if !supported.contains(&FAN_CURVE_ZBUS_NAME.to_string()) {
+        println!("Fan-curves not supported by either this kernel or by the laptop.");
+        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");
+        }
+        println!("{}", FanCurveCommand::usage());
+
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+        return Ok(());
+    }
+
+    if (cmd.enable_fan_curves.is_some() || cmd.fan.is_some() || cmd.data.is_some())
+        && cmd.mod_profile.is_none()
+    {
+        println!(
+            "--enable-fan-curves, --enable-fan-curve, --fan, and --data options require \
+             --mod-profile"
+        );
+        return Ok(());
+    }
+
+    let plat_proxy = PlatformProxyBlocking::new(conn)?;
+    let fan_proxy = FanCurvesProxyBlocking::new(conn)?;
+    if cmd.get_enabled {
+        let profile = plat_proxy.throttle_thermal_policy()?;
+        let curves = fan_proxy.fan_curve_data(profile)?;
+        for curve in curves.iter() {
+            println!("{}", String::from(curve));
+        }
+    }
+
+    if cmd.default {
+        let active = plat_proxy.throttle_thermal_policy()?;
+        fan_proxy.set_curves_to_defaults(active)?;
+    }
+
+    if let Some(profile) = cmd.mod_profile {
+        if cmd.enable_fan_curves.is_none() && cmd.data.is_none() {
+            let data = fan_proxy.fan_curve_data(profile)?;
+            let ron = ron::ser::to_string_pretty(&data, PrettyConfig::new().depth_limit(4))?;
+            println!("\nFan curves for {:?}\n\n{}", profile, ron);
+        }
+
+        if let Some(enabled) = cmd.enable_fan_curves {
+            fan_proxy.set_fan_curves_enabled(profile, enabled)?;
+        }
+
+        if let Some(enabled) = cmd.enable_fan_curve {
+            if let Some(fan) = cmd.fan {
+                fan_proxy.set_profile_fan_curve_enabled(profile, fan, enabled)?;
+            } else {
+                println!(
+                    "--enable-fan-curves, --enable-fan-curve, --fan, and --data options require \
+                     --mod-profile"
+                );
+            }
+        }
+
+        if let Some(mut curve) = cmd.data.clone() {
+            let fan = cmd.fan.unwrap_or_default();
+            curve.set_fan(fan);
+            fan_proxy.set_fan_curve(profile, curve)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn handle_platform_properties(
+    conn: &Connection,
+    supported: &[Properties],
+    cmd: &BiosCommand,
+) -> Result<(), Box<dyn std::error::Error>> {
+    {
+        if (cmd.gpu_mux_mode_set.is_none()
+            && !cmd.gpu_mux_mode_get
+            && cmd.post_sound_set.is_none()
+            && !cmd.post_sound_get
+            && cmd.panel_overdrive_set.is_none()
+            && !cmd.panel_overdrive_get)
+            || cmd.help
+        {
+            println!("Missing arg or command\n");
+
+            let usage: Vec<String> = BiosCommand::usage().lines().map(|s| s.to_owned()).collect();
+
+            for line in usage.iter().filter(|line| {
+                line.contains("sound") && supported.contains(&Properties::PostAnimationSound)
+                    || line.contains("GPU") && supported.contains(&Properties::GpuMuxMode)
+                    || line.contains("panel") && supported.contains(&Properties::PanelOd)
+            }) {
+                println!("{}", line);
+            }
+        }
+
+        let proxy = PlatformProxyBlocking::new(conn)?;
+
+        if let Some(opt) = cmd.post_sound_set {
+            proxy.set_boot_sound(opt)?;
+        }
+        if cmd.post_sound_get {
+            let res = proxy.boot_sound()?;
+            println!("Bios POST sound on: {}", res);
+        }
+
+        if let Some(opt) = cmd.gpu_mux_mode_set {
+            println!("Rebuilding initrd to include drivers");
+            proxy.set_gpu_mux_mode(GpuMode::from_mux(opt))?;
+            println!(
+                "The mode change is not active until you reboot, on boot the bios will make the \
+                 required change"
+            );
+        }
+        if cmd.gpu_mux_mode_get {
+            let res = proxy.gpu_mux_mode()?;
+            println!("Bios GPU MUX: {:?}", res);
+        }
+
+        if let Some(opt) = cmd.panel_overdrive_set {
+            proxy.set_panel_od(opt)?;
+        }
+        if cmd.panel_overdrive_get {
+            let res = proxy.panel_od()?;
+            println!("Panel overdrive on: {}", res);
+        }
+    }
+    Ok(())
+}
+
+fn check_systemd_unit_active(name: &str) -> bool {
+    if let Ok(out) = Command::new("systemctl")
+        .arg("is-active")
+        .arg(name)
+        .output()
+    {
+        let buf = String::from_utf8_lossy(&out.stdout);
+        return !buf.contains("inactive") && !buf.contains("failed");
+    }
+    false
+}
+
+fn check_systemd_unit_enabled(name: &str) -> bool {
+    if let Ok(out) = Command::new("systemctl")
+        .arg("is-enabled")
+        .arg(name)
+        .output()
+    {
+        let buf = String::from_utf8_lossy(&out.stdout);
+        return buf.contains("enabled");
+    }
+    false
+}

asusctl/src/slash_cli.rs

@@ -0,0 +1,20 @@
+use gumdrop::Options;
+use rog_slash::SlashMode;
+
+#[derive(Options)]
+pub struct SlashCommand {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "Enable the Slash Ledbar")]
+    pub enable: bool,
+    #[options(help = "Ddisable the Slash Ledbar")]
+    pub disable: bool,
+    #[options(meta = "", help = "Set brightness value <0-255>")]
+    pub brightness: Option<u8>,
+    #[options(meta = "", help = "Set interval value <0-255>")]
+    pub interval: Option<u8>,
+    #[options(help = "Set SlashMode (so 'list' for all options)")]
+    pub slash_mode: Option<SlashMode>,
+    #[options(help = "list available animations")]
+    pub list: bool,
+}

asusd-user/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "asusd-user"
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
+
+[[bin]]
+name = "asusd-user"
+path = "src/daemon.rs"
+
+[dependencies]
+dirs.workspace = true
+smol.workspace = true
+
+# serialisation
+serde.workspace = true
+serde_derive.workspace = true
+ron.workspace = true
+
+rog_anime = { path = "../rog-anime" }
+rog_aura = { path = "../rog-aura" }
+rog_dbus = { path = "../rog-dbus" }
+rog_platform = { path = "../rog-platform" }
+config-traits = { path = "../config-traits" }
+
+zbus.workspace = true
+env_logger.workspace = true
+
+[dev-dependencies]
+cargo-husky.workspace = true
+
+[package.metadata.cargo-machete]
+ignored = ["serde"]

asusd-user/README.md

@@ -0,0 +1,14 @@
+# daemon-user
+
+This crate is for the binary of `asusd-user` and its helper lib.
+
+The purpose of `asusd-user` is to run in userland and provide the user + third-party apps an interface for such things as creating AniMe sequences (and more in future, see todo list).
+
+`asusd-user` should try to be as simple as possible while allowing a decent degree of control.
+
+## TODO
+
+- [ ] CLI for basic settings/interaction
+- [ ] RGB keyboard per-key programs
+- [ ] User profiles (fan, cpu etc). These would be replacing the system-daemon profiles only when the user is active, otherwise system-daemon defaults to system settings.
+- [ ] Audio EQ visualiser - for use with anime + keyboard lighting

asusd-user/src/config.rs

@@ -0,0 +1,232 @@
+use std::path::PathBuf;
+use std::time::Duration;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_anime::{ActionLoader, AnimTime, AnimeType, Fade, Sequences as AnimeSequences, Vec2};
+use rog_aura::effects::{AdvancedEffects as AuraSequences, Breathe, DoomFlicker, Effect, Static};
+use rog_aura::keyboard::LedCode;
+use rog_aura::{Colour, Speed};
+use serde_derive::{Deserialize, Serialize};
+
+use crate::error::Error;
+
+const ROOT_CONF_DIR: &str = "rog";
+
+fn root_conf_dir() -> PathBuf {
+    let mut dir = dirs::config_dir().unwrap_or_else(|| PathBuf::from("/tmp"));
+    dir.push(ROOT_CONF_DIR);
+    dir
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ConfigAnime {
+    pub name: String,
+    pub anime: Vec<ActionLoader>,
+}
+
+impl ConfigAnime {
+    pub fn create(&self, anime_type: AnimeType) -> Result<AnimeSequences, Error> {
+        let mut seq = AnimeSequences::new(anime_type);
+
+        for (idx, action) in self.anime.iter().enumerate() {
+            seq.insert(idx, action)?;
+        }
+
+        Ok(seq)
+    }
+
+    pub fn set_name(mut self, name: String) -> Self {
+        self.name = name;
+        self
+    }
+}
+
+impl Default for ConfigAnime {
+    fn default() -> Self {
+        Self {
+            name: "anime-default".to_owned(),
+            anime: vec![
+                ActionLoader::AsusImage {
+                    file: "/usr/share/asusd/anime/custom/diagonal-template.png".into(),
+                    brightness: 1.0,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        None,
+                        Duration::from_secs(2),
+                    )),
+                },
+                ActionLoader::AsusAnimation {
+                    file: "/usr/share/asusd/anime/asus/rog/Sunset.gif".into(),
+                    brightness: 0.5,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(6),
+                        None,
+                        Duration::from_secs(3),
+                    )),
+                },
+                ActionLoader::ImageAnimation {
+                    file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                    scale: 0.9,
+                    angle: 0.65,
+                    translation: Vec2::default(),
+                    brightness: 0.5,
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        Some(Duration::from_secs(2)),
+                        Duration::from_secs(2),
+                    )),
+                },
+                ActionLoader::Image {
+                    file: "/usr/share/asusd/anime/custom/rust.png".into(),
+                    scale: 1.0,
+                    angle: 0.0,
+                    translation: Vec2::default(),
+                    time: AnimTime::Fade(Fade::new(
+                        Duration::from_secs(2),
+                        Some(Duration::from_secs(1)),
+                        Duration::from_secs(2),
+                    )),
+                    brightness: 0.6,
+                },
+                ActionLoader::Pause(Duration::from_secs(1)),
+                ActionLoader::ImageAnimation {
+                    file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
+                    scale: 0.9,
+                    angle: 0.0,
+                    translation: Vec2::new(3.0, 2.0),
+                    brightness: 0.5,
+                    time: AnimTime::Count(2),
+                },
+            ],
+        }
+    }
+}
+
+impl StdConfig for ConfigAnime {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        format!("{}.ron", self.name)
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigAnime {}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ConfigAura {
+    pub name: String,
+    pub aura: AuraSequences,
+}
+
+impl ConfigAura {
+    pub fn set_name(mut self, name: String) -> Self {
+        self.name = name;
+        self
+    }
+}
+
+impl Default for ConfigAura {
+    fn default() -> Self {
+        let mut seq = AuraSequences::new(false);
+        let mut key = Effect::Breathe(Breathe::new(
+            LedCode::W,
+            Colour {
+                r: 255,
+                g: 0,
+                b: 20,
+            },
+            Colour {
+                r: 20,
+                g: 255,
+                b: 0,
+            },
+            Speed::Low,
+        ));
+
+        seq.push(key.clone());
+        key.set_led(LedCode::A);
+        seq.push(key.clone());
+        key.set_led(LedCode::S);
+        seq.push(key.clone());
+        key.set_led(LedCode::D);
+        seq.push(key);
+
+        let key = Effect::Breathe(Breathe::new(
+            LedCode::F,
+            Colour { r: 255, g: 0, b: 0 },
+            Colour { r: 255, g: 0, b: 0 },
+            Speed::High,
+        ));
+        seq.push(key);
+
+        let mut key = Effect::Static(Static::new(LedCode::RCtrl, Colour { r: 0, g: 0, b: 255 }));
+        seq.push(key.clone());
+        key.set_led(LedCode::LCtrl);
+        seq.push(key.clone());
+        key.set_led(LedCode::Esc);
+        seq.push(key);
+
+        let key = Effect::DoomFlicker(DoomFlicker::new(
+            LedCode::N9,
+            Colour { r: 0, g: 0, b: 255 },
+            80,
+            40,
+        ));
+        seq.push(key);
+
+        Self {
+            name: "aura-default".to_owned(),
+            aura: seq,
+        }
+    }
+}
+
+impl StdConfig for ConfigAura {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        format!("{}.ron", self.name)
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigAura {}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(default)]
+pub struct ConfigBase {
+    /// Name of active anime config file in the user config directory
+    pub active_anime: Option<String>,
+    /// Name of active aura config file in the user config directory
+    pub active_aura: Option<String>,
+}
+
+impl StdConfig for ConfigBase {
+    fn new() -> Self {
+        Self {
+            active_anime: Some("anime-default".to_owned()),
+            active_aura: Some("aura-default".to_owned()),
+        }
+    }
+
+    fn file_name(&self) -> String {
+        "rog-user.ron".to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        root_conf_dir()
+    }
+}
+
+impl StdConfigLoad for ConfigBase {}

asusd-user/src/ctrl_anime.rs

@@ -0,0 +1,361 @@
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::thread::sleep;
+use std::time::{Duration, Instant};
+
+use config_traits::StdConfig;
+use rog_anime::error::AnimeError;
+use rog_anime::{ActionData, ActionLoader, AnimTime, Fade, Sequences, Vec2};
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use ron::ser::PrettyConfig;
+use serde_derive::{Deserialize, Serialize};
+use zbus::interface;
+use zbus::zvariant::{ObjectPath, Type};
+
+use crate::config::ConfigAnime;
+use crate::error::Error;
+
+#[derive(Debug, Clone, Deserialize, Serialize, Type)]
+pub struct Timer {
+    type_of: TimeType,
+    /// If time type is Timer then this is milliseonds, otherwise it is
+    /// animation loop count
+    count: u64,
+    /// Used only for `TimeType::Timer`, milliseonds to fade the image in for
+    fade_in: u64,
+    /// Used only for `TimeType::Timer`, milliseonds to fade the image out for
+    fade_out: u64,
+}
+
+impl From<Timer> for AnimTime {
+    fn from(time: Timer) -> Self {
+        match time.type_of {
+            TimeType::Timer => {
+                if time.fade_in != 0 && time.fade_out != 0 {
+                    let fade_in = Duration::from_millis(time.fade_in);
+                    let fade_out = Duration::from_millis(time.fade_out);
+                    let show_for = if time.count != 0 {
+                        Some(Duration::from_millis(time.count))
+                    } else {
+                        None
+                    };
+                    AnimTime::Fade(Fade::new(fade_in, show_for, fade_out))
+                } else {
+                    AnimTime::Time(Duration::from_millis(time.count))
+                }
+            }
+            TimeType::Count => AnimTime::Count(time.count as u32),
+            TimeType::Infinite => AnimTime::Infinite,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, Type)]
+pub enum TimeType {
+    Timer,
+    Count,
+    Infinite,
+}
+
+/// The inner object exists to allow the zbus proxy to share it with a runner
+/// thread and a zbus server behind `Arc<Mutex<T>>`
+pub struct CtrlAnimeInner<'a> {
+    sequences: Sequences,
+    client: AnimeProxyBlocking<'a>,
+    do_early_return: Arc<AtomicBool>,
+}
+
+impl<'a> CtrlAnimeInner<'static> {
+    pub fn new(
+        sequences: Sequences,
+        client: AnimeProxyBlocking<'static>,
+        do_early_return: Arc<AtomicBool>,
+    ) -> Result<Self, Error> {
+        Ok(Self {
+            sequences,
+            client,
+            do_early_return,
+        })
+    }
+
+    /// To be called on each main loop iteration to pump out commands to the
+    /// anime
+    pub fn run(&'a self) -> Result<(), Error> {
+        if self.do_early_return.load(Ordering::SeqCst) {
+            return Ok(());
+        }
+
+        for action in self.sequences.iter() {
+            match action {
+                ActionData::Animation(frames) => {
+                    rog_anime::run_animation(frames, &|output| {
+                        if self.do_early_return.load(Ordering::Acquire) {
+                            return Ok(true); // Do safe exit
+                        }
+                        self.client
+                            .write(output)
+                            .map_err(|e| AnimeError::Dbus(format!("{}", e)))
+                            .map(|_| false)
+                    });
+                }
+                ActionData::Image(image) => {
+                    self.client.write(image.as_ref().clone()).ok();
+                }
+                ActionData::Pause(duration) => {
+                    let start = Instant::now();
+                    'pause: loop {
+                        if self.do_early_return.load(Ordering::SeqCst) {
+                            return Ok(());
+                        }
+                        if Instant::now().duration_since(start) > *duration {
+                            break 'pause;
+                        }
+                        sleep(Duration::from_millis(1));
+                    }
+                }
+                ActionData::AudioEq
+                | ActionData::SystemInfo
+                | ActionData::TimeDate
+                | ActionData::Matrix => {}
+            }
+        }
+
+        Ok(())
+    }
+}
+
+pub struct CtrlAnime<'a> {
+    config: Arc<Mutex<ConfigAnime>>,
+    client: AnimeProxyBlocking<'a>,
+    inner: Arc<Mutex<CtrlAnimeInner<'a>>>,
+    /// Must be the same Atomic as in CtrlAnimeInner
+    inner_early_return: Arc<AtomicBool>,
+}
+
+impl CtrlAnime<'static> {
+    pub fn new(
+        config: Arc<Mutex<ConfigAnime>>,
+        inner: Arc<Mutex<CtrlAnimeInner<'static>>>,
+        client: AnimeProxyBlocking<'static>,
+        inner_early_return: Arc<AtomicBool>,
+    ) -> Result<Self, Error> {
+        Ok(CtrlAnime {
+            config,
+            client,
+            inner,
+            inner_early_return,
+        })
+    }
+
+    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
+            })
+            .ok();
+    }
+}
+
+// The pattern for a zbus method is:
+// - Get config lock if required
+// - Set inner_early_return to stop the inner run loop temporarily
+// - Do actions
+// - Write config if required
+// - Unset inner_early_return
+#[interface(name = "org.asuslinux.Daemon")]
+impl CtrlAnime<'static> {
+    pub fn insert_asus_gif(
+        &mut self,
+        index: u32,
+        file: &str,
+        time: Timer,
+        brightness: f32,
+    ) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let time: AnimTime = time.into();
+            let file = Path::new(&file);
+            let action = ActionLoader::AsusAnimation {
+                file: file.into(),
+                brightness,
+                time,
+            };
+
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+            }
+            config.anime.push(action);
+            config.write();
+
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
+
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(ron);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn insert_image_gif(
+        &mut self,
+        index: u32,
+        file: &str,
+        scale: f32,
+        angle: f32,
+        xy: (f32, f32),
+        time: Timer,
+        brightness: f32,
+    ) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let time: AnimTime = time.into();
+            let file = Path::new(&file);
+            let translation = Vec2::new(xy.0, xy.1);
+            let action = ActionLoader::ImageAnimation {
+                file: file.into(),
+                scale,
+                angle,
+                translation,
+                brightness,
+                time,
+            };
+
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+            }
+            config.anime.push(action);
+            config.write();
+
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(ron);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn insert_image(
+        &mut self,
+        index: u32,
+        file: &str,
+        scale: f32,
+        angle: f32,
+        xy: (f32, f32),
+        time: Timer,
+        brightness: f32,
+    ) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let file = Path::new(&file);
+            let time = time.into();
+            let action = ActionLoader::Image {
+                file: file.into(),
+                scale,
+                angle,
+                translation: Vec2::new(xy.0, xy.1),
+                brightness,
+                time,
+            };
+
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+            }
+            config.anime.push(action);
+            config.write();
+
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(ron);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    pub fn insert_pause(&mut self, index: u32, millis: u64) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            let action = ActionLoader::Pause(Duration::from_millis(millis));
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller
+                    .sequences
+                    .insert(index as usize, &action)
+                    .map_err(|err| zbus::fdo::Error::Failed(err.to_string()))?;
+            }
+            config.anime.push(action);
+            config.write();
+
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(ron);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    pub fn remove_item(&mut self, index: u32) -> zbus::fdo::Result<String> {
+        if let Ok(mut config) = self.config.try_lock() {
+            // Must make the inner run loop return early
+            self.inner_early_return.store(true, Ordering::SeqCst);
+
+            if let Ok(mut controller) = self.inner.lock() {
+                controller.sequences.remove_item(index as usize);
+            }
+            if (index as usize) < config.anime.len() {
+                config.anime.remove(index as usize);
+            }
+            config.write();
+
+            let ron = ron::ser::to_string_pretty(&*config, PrettyConfig::new().depth_limit(4))
+                .expect("Parse config to RON failed");
+            // Release the inner run loop again
+            self.inner_early_return.store(false, Ordering::SeqCst);
+            return Ok(ron);
+        }
+        Err(zbus::fdo::Error::Failed("UserConfig lock fail".into()))
+    }
+
+    pub fn set_state(&mut self, on: bool) -> zbus::fdo::Result<()> {
+        // Operations here need to be in specific order
+        if on {
+            self.client.set_enable_display(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.set_enable_display(on).ok();
+        }
+        Ok(())
+    }
+}

asusd-user/src/daemon.rs

@@ -0,0 +1,123 @@
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::atomic::AtomicBool;
+use std::sync::{Arc, Mutex};
+
+use asusd_user::config::*;
+use asusd_user::ctrl_anime::{CtrlAnime, CtrlAnimeInner};
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_anime::usb::get_anime_type;
+use rog_aura::aura_detection::LedSupportData;
+use rog_aura::keyboard::KeyLayout;
+use rog_dbus::zbus_anime::AnimeProxyBlocking;
+use rog_dbus::zbus_aura::AuraProxyBlocking;
+use rog_dbus::zbus_platform::PlatformProxyBlocking;
+use rog_dbus::DBUS_NAME;
+use smol::Executor;
+use zbus::Connection;
+
+#[cfg(not(feature = "local_data"))]
+const DATA_DIR: &str = "/usr/share/rog-gui/";
+#[cfg(feature = "local_data")]
+const DATA_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const BOARD_NAME: &str = "/sys/class/dmi/id/board_name";
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut logger = env_logger::Builder::new();
+    logger
+        .parse_default_env()
+        .target(env_logger::Target::Stdout)
+        .format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()))
+        .init();
+
+    println!("  user daemon v{}", asusd_user::VERSION);
+    println!("    rog-anime v{}", rog_anime::VERSION);
+    println!("     rog-dbus v{}", rog_dbus::VERSION);
+    println!("rog-platform v{}", rog_platform::VERSION);
+
+    let conn = zbus::blocking::Connection::system().unwrap();
+    let platform_proxy = PlatformProxyBlocking::new(&conn).unwrap();
+
+    let supported = platform_proxy
+        .supported_interfaces()
+        .unwrap_or_default()
+        .contains(&"Anime".to_string());
+    let config = ConfigBase::new().load();
+    let executor = Executor::new();
+
+    let early_return = Arc::new(AtomicBool::new(false));
+    // Set up the anime data and run loop/thread
+    if supported {
+        if let Some(cfg) = config.active_anime {
+            let anime_type = get_anime_type()?;
+            let anime_config = ConfigAnime::new().set_name(cfg).load();
+            let anime = anime_config.create(anime_type)?;
+            let anime_config = Arc::new(Mutex::new(anime_config));
+
+            let anime_proxy_blocking = AnimeProxyBlocking::new(&conn).unwrap();
+            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,
+                            anime_proxy_blocking.clone(),
+                            early_return.clone(),
+                        )
+                        .unwrap(),
+                    ));
+                    // Need new client object for dbus control part
+                    let anime_control = CtrlAnime::new(
+                        anime_config,
+                        inner.clone(),
+                        anime_proxy_blocking,
+                        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 let Some(cfg) = config.active_aura {
+        let mut aura_config = ConfigAura::new().set_name(cfg).load();
+        // let baord_name = std::fs::read_to_string(BOARD_NAME)?;
+
+        let led_support = LedSupportData::get_data("");
+
+        let layout = KeyLayout::find_layout(led_support, PathBuf::from(DATA_DIR))
+            .map_err(|e| {
+                println!("{BOARD_NAME}, {e}");
+            })
+            .unwrap_or_else(|_| KeyLayout::default_layout());
+
+        let aura_proxy_blocking = AuraProxyBlocking::new(&conn).unwrap();
+        executor
+            .spawn(async move {
+                loop {
+                    aura_config.aura.next_state(&layout);
+                    let packets = aura_config.aura.create_packets();
+
+                    aura_proxy_blocking.direct_addressing_raw(packets).unwrap();
+                    std::thread::sleep(std::time::Duration::from_millis(33));
+                }
+            })
+            .detach();
+    }
+    // }
+
+    loop {
+        smol::block_on(executor.tick());
+    }
+}

asusd-user/src/error.rs

@@ -0,0 +1,45 @@
+use std::fmt;
+
+use rog_anime::error::AnimeError;
+
+#[derive(Debug)]
+pub enum Error {
+    Io(std::io::Error),
+    ConfigLoadFail,
+    ConfigLockFail,
+    XdgVars,
+    Anime(AnimeError),
+}
+
+impl fmt::Display for Error {
+    // This trait requires `fmt` with this exact signature.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::Io(err) => write!(f, "Failed to open: {}", err),
+            Error::ConfigLoadFail => write!(f, "Failed to load user config"),
+            Error::ConfigLockFail => write!(f, "Failed to lock user config"),
+            Error::XdgVars => write!(f, "XDG environment vars appear unset"),
+            Error::Anime(err) => write!(f, "Anime error: {}", err),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Error::Io(err)
+    }
+}
+
+impl From<AnimeError> for Error {
+    fn from(err: AnimeError) -> Self {
+        Error::Anime(err)
+    }
+}
+
+impl From<Error> for zbus::fdo::Error {
+    fn from(err: Error) -> Self {
+        zbus::fdo::Error::Failed(format!("Anime zbus error: {}", err))
+    }
+}

asusd-user/src/lib.rs

@@ -0,0 +1,9 @@
+pub mod config;
+
+pub mod error;
+
+pub mod ctrl_anime;
+
+pub mod zbus_anime;
+
+pub static VERSION: &str = env!("CARGO_PKG_VERSION");

asusd-user/src/zbus_anime.rs

@@ -0,0 +1,73 @@
+//! # `DBus` interface proxy for: `org.asuslinux.Daemon`
+//!
+//! This code was generated by `zbus-xmlgen` `1.0.0` from `DBus` introspection
+//! data. Source: `Interface '/org/asuslinux/Anime' from service
+//! 'org.asuslinux.Daemon' on session bus`.
+//!
+//! You may prefer to adapt it, instead of using it verbatim.
+//!
+//! More information can be found in the
+//! [Writing a client proxy](https://dbus.pages.freedesktop.org/zbus/client.html)
+//! section of the zbus documentation.
+//!
+//! This `DBus` object implements
+//! [standard `DBus` interfaces](https://dbus.freedesktop.org/doc/dbus-specification.html),
+//! (`org.freedesktop.DBus.*`) for which the following zbus proxies can be used:
+//!
+//! * [`zbus::fdo::PeerProxy`]
+//! * [`zbus::fdo::IntrospectableProxy`]
+//! * [`zbus::fdo::PropertiesProxy`]
+//!
+//! …consequently `zbus-xmlgen` did not generate code for the above interfaces.
+#![allow(clippy::too_many_arguments)]
+
+use zbus::proxy;
+
+#[proxy(
+    interface = "org.asuslinux.Daemon",
+    default_path = "/org/asuslinux/Anime"
+)]
+trait Daemon {
+    /// InsertAsusGif method
+    fn insert_asus_gif(
+        &self,
+        index: u32,
+        file: &str,
+        time: u32,
+        count: u32,
+        brightness: f64,
+    ) -> zbus::Result<String>;
+
+    /// InsertImage method
+    fn insert_image(
+        &self,
+        index: u32,
+        file: &str,
+        scale: f64,
+        angle: f64,
+        xy: &(f64, f64),
+        brightness: f64,
+    ) -> zbus::Result<String>;
+
+    /// InsertImageGif method
+    fn insert_image_gif(
+        &self,
+        index: u32,
+        file: &str,
+        scale: f64,
+        angle: f64,
+        xy: &(f64, f64),
+        time: u32,
+        count: u32,
+        brightness: f64,
+    ) -> zbus::Result<String>;
+
+    /// InsertPause method
+    fn insert_pause(&self, index: u32, millis: u64) -> zbus::Result<String>;
+
+    /// RemoveItem method
+    fn remove_item(&self, index: u32) -> zbus::Result<String>;
+
+    /// SetState method
+    fn set_state(&self, on: bool) -> zbus::Result<()>;
+}

asusd/Cargo.toml

@@ -0,0 +1,49 @@
+[package]
+name = "asusd"
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+description.workspace = true
+edition.workspace = true
+
+[[bin]]
+name = "asusd"
+path = "src/daemon.rs"
+
+[dependencies]
+config-traits = { path = "../config-traits" }
+rog_anime = { path = "../rog-anime", features = ["dbus"] }
+rog_slash = { path = "../rog-slash", features = ["dbus"] }
+rog_aura = { path = "../rog-aura", features = ["dbus"] }
+rog_platform = { path = "../rog-platform" }
+rog_profiles = { path = "../rog-profiles" }
+dmi_id = { path = "../dmi-id" }
+futures-lite = "*"
+udev.workspace = true
+inotify.workspace = true
+
+mio.workspace = true
+tokio.workspace = true
+# console-subscriber = "0.2.0"
+
+# cli and logging
+log.workspace = true
+env_logger.workspace = true
+
+zbus.workspace = true
+logind-zbus.workspace = true
+
+# serialisation
+serde.workspace = true
+serde_derive.workspace = true
+
+concat-idents.workspace = true
+
+[dev-dependencies]
+cargo-husky.workspace = true
+
+[package.metadata.cargo-machete]
+ignored = ["serde"]

asusd/src/config.rs

@@ -0,0 +1,235 @@
+use config_traits::{StdConfig, StdConfigLoad3};
+use rog_platform::cpu::CPUEPP;
+use rog_platform::platform::ThrottlePolicy;
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "asusd.ron";
+
+#[derive(Deserialize, Serialize, Debug, PartialEq, PartialOrd)]
+pub struct Config {
+    /// Save charge limit for restoring on boot/resume
+    pub charge_control_end_threshold: u8,
+    pub panel_od: bool,
+    pub boot_sound: bool,
+    pub mini_led_mode: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    /// An optional command/script to run when power is changed to AC
+    pub ac_command: String,
+    /// An optional command/script to run when power is changed to battery
+    pub bat_command: String,
+    /// Set true if energy_performance_preference should be set if the
+    /// throttle/platform profile is changed
+    pub throttle_policy_linked_epp: bool,
+    /// Which throttle/profile to use on battery power
+    pub throttle_policy_on_battery: ThrottlePolicy,
+    /// Which throttle/profile to use on AC power
+    pub throttle_policy_on_ac: ThrottlePolicy,
+    /// The energy_performance_preference for this throttle/platform profile
+    pub throttle_quiet_epp: CPUEPP,
+    /// The energy_performance_preference for this throttle/platform profile
+    pub throttle_balanced_epp: CPUEPP,
+    /// The energy_performance_preference for this throttle/platform profile
+    pub throttle_performance_epp: CPUEPP,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_pl1_spl: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_pl2_sppt: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_fppt: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_apu_sppt: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub ppt_platform_sppt: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub nv_dynamic_boost: Option<u8>,
+    /// Defaults to `None` if not supported
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub nv_temp_target: Option<u8>,
+    /// Temporary state for AC/Batt
+    #[serde(skip)]
+    pub last_power_plugged: u8,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            charge_control_end_threshold: 100,
+            panel_od: false,
+            boot_sound: false,
+            mini_led_mode: false,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: Default::default(),
+            bat_command: Default::default(),
+            throttle_policy_linked_epp: true,
+            throttle_policy_on_battery: ThrottlePolicy::Quiet,
+            throttle_policy_on_ac: ThrottlePolicy::Performance,
+            throttle_quiet_epp: CPUEPP::Power,
+            throttle_balanced_epp: CPUEPP::BalancePower,
+            throttle_performance_epp: CPUEPP::Performance,
+            ppt_pl1_spl: Default::default(),
+            ppt_pl2_sppt: Default::default(),
+            ppt_fppt: Default::default(),
+            ppt_apu_sppt: Default::default(),
+            ppt_platform_sppt: Default::default(),
+            nv_dynamic_boost: Default::default(),
+            nv_temp_target: Default::default(),
+            last_power_plugged: Default::default(),
+        }
+    }
+}
+
+impl StdConfig for Config {
+    fn new() -> Self {
+        Config {
+            charge_control_end_threshold: 100,
+            disable_nvidia_powerd_on_battery: true,
+            throttle_policy_on_battery: ThrottlePolicy::Quiet,
+            throttle_policy_on_ac: ThrottlePolicy::Performance,
+            ac_command: String::new(),
+            bat_command: String::new(),
+            ..Default::default()
+        }
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad3<Config472, Config506, Config507> for Config {}
+
+#[derive(Deserialize, Serialize)]
+pub struct Config507 {
+    /// Save charge limit for restoring on boot
+    pub charge_control_end_threshold: u8,
+    pub panel_od: bool,
+    pub mini_led_mode: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+    pub platform_policy_linked_epp: bool,
+    pub platform_policy_on_battery: ThrottlePolicy,
+    pub platform_policy_on_ac: ThrottlePolicy,
+    //
+    pub ppt_pl1_spl: Option<u8>,
+    pub ppt_pl2_sppt: Option<u8>,
+    pub ppt_fppt: Option<u8>,
+    pub ppt_apu_sppt: Option<u8>,
+    pub ppt_platform_sppt: Option<u8>,
+    pub nv_dynamic_boost: Option<u8>,
+    pub nv_temp_target: Option<u8>,
+}
+
+impl From<Config507> for Config {
+    fn from(c: Config507) -> Self {
+        Self {
+            charge_control_end_threshold: c.charge_control_end_threshold,
+            panel_od: c.panel_od,
+            boot_sound: false,
+            disable_nvidia_powerd_on_battery: c.disable_nvidia_powerd_on_battery,
+            ac_command: c.ac_command,
+            bat_command: c.bat_command,
+            mini_led_mode: c.mini_led_mode,
+            throttle_policy_linked_epp: true,
+            throttle_policy_on_battery: c.platform_policy_on_battery,
+            throttle_policy_on_ac: c.platform_policy_on_ac,
+            throttle_quiet_epp: CPUEPP::Power,
+            throttle_balanced_epp: CPUEPP::BalancePower,
+            throttle_performance_epp: CPUEPP::Performance,
+            ppt_pl1_spl: c.ppt_pl1_spl,
+            ppt_pl2_sppt: c.ppt_pl2_sppt,
+            ppt_fppt: c.ppt_fppt,
+            ppt_apu_sppt: c.ppt_apu_sppt,
+            ppt_platform_sppt: c.ppt_platform_sppt,
+            nv_dynamic_boost: c.nv_dynamic_boost,
+            nv_temp_target: c.nv_temp_target,
+            last_power_plugged: 0,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct Config506 {
+    /// Save charge limit for restoring on boot
+    pub charge_control_end_threshold: u8,
+    pub panel_od: bool,
+    pub mini_led_mode: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+    /// Restored on boot as well as when power is plugged
+    #[serde(skip)]
+    pub platform_policy_to_restore: ThrottlePolicy,
+    pub platform_policy_on_battery: ThrottlePolicy,
+    pub platform_policy_on_ac: ThrottlePolicy,
+    //
+    pub ppt_pl1_spl: Option<u8>,
+    pub ppt_pl2_sppt: Option<u8>,
+    pub ppt_fppt: Option<u8>,
+    pub ppt_apu_sppt: Option<u8>,
+    pub ppt_platform_sppt: Option<u8>,
+    pub nv_dynamic_boost: Option<u8>,
+    pub nv_temp_target: Option<u8>,
+}
+
+impl From<Config506> for Config {
+    fn from(c: Config506) -> Self {
+        Self {
+            charge_control_end_threshold: c.charge_control_end_threshold,
+            panel_od: c.panel_od,
+            boot_sound: false,
+            disable_nvidia_powerd_on_battery: c.disable_nvidia_powerd_on_battery,
+            ac_command: c.ac_command,
+            bat_command: c.bat_command,
+            mini_led_mode: c.mini_led_mode,
+            throttle_policy_linked_epp: true,
+            throttle_policy_on_battery: c.platform_policy_on_battery,
+            throttle_policy_on_ac: c.platform_policy_on_ac,
+            throttle_quiet_epp: CPUEPP::Power,
+            throttle_balanced_epp: CPUEPP::BalancePower,
+            throttle_performance_epp: CPUEPP::Performance,
+            ppt_pl1_spl: c.ppt_pl1_spl,
+            ppt_pl2_sppt: c.ppt_pl2_sppt,
+            ppt_fppt: c.ppt_fppt,
+            ppt_apu_sppt: c.ppt_apu_sppt,
+            ppt_platform_sppt: c.ppt_platform_sppt,
+            nv_dynamic_boost: c.nv_dynamic_boost,
+            nv_temp_target: c.nv_temp_target,
+            last_power_plugged: 0,
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct Config472 {
+    /// Save charge limit for restoring on boot
+    pub bat_charge_limit: u8,
+    pub panel_od: bool,
+    pub mini_led_mode: bool,
+    pub disable_nvidia_powerd_on_battery: bool,
+    pub ac_command: String,
+    pub bat_command: String,
+}
+
+impl From<Config472> for Config {
+    fn from(c: Config472) -> Self {
+        Self {
+            charge_control_end_threshold: c.bat_charge_limit,
+            panel_od: c.panel_od,
+            disable_nvidia_powerd_on_battery: true,
+            ac_command: c.ac_command,
+            bat_command: c.bat_command,
+            ..Default::default()
+        }
+    }
+}

asusd/src/ctrl_anime/config.rs

@@ -0,0 +1,229 @@
+use std::time::Duration;
+
+use config_traits::{StdConfig, StdConfigLoad2};
+use rog_anime::error::AnimeError;
+use rog_anime::usb::Brightness;
+use rog_anime::{
+    ActionData, ActionLoader, AnimTime, Animations, AnimeType, DeviceState, Fade, Vec2,
+};
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "anime.ron";
+
+#[derive(Deserialize, Serialize)]
+pub struct AnimeConfigV460 {
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub sleep: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    pub brightness: f32,
+}
+
+impl From<AnimeConfigV460> for AnimeConfig {
+    fn from(c: AnimeConfigV460) -> AnimeConfig {
+        AnimeConfig {
+            system: c.system,
+            boot: c.boot,
+            wake: c.wake,
+            shutdown: c.shutdown,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct AnimeConfigV472 {
+    pub model_override: Option<AnimeType>,
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub sleep: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    pub brightness: f32,
+    pub display_enabled: bool,
+    pub display_brightness: Brightness,
+    pub builtin_anims_enabled: bool,
+    pub builtin_anims: Animations,
+}
+
+impl From<AnimeConfigV472> for AnimeConfig {
+    fn from(c: AnimeConfigV472) -> AnimeConfig {
+        AnimeConfig {
+            system: c.system,
+            boot: c.boot,
+            wake: c.wake,
+            shutdown: c.shutdown,
+            model_override: c.model_override,
+            display_enabled: c.display_enabled,
+            display_brightness: c.display_brightness,
+            builtin_anims_enabled: c.builtin_anims_enabled,
+            builtin_anims: c.builtin_anims,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Default)]
+pub struct AnimeConfigCached {
+    pub system: Vec<ActionData>,
+    pub boot: Vec<ActionData>,
+    pub wake: Vec<ActionData>,
+    pub shutdown: Vec<ActionData>,
+}
+
+impl AnimeConfigCached {
+    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 {
+            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 {
+            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 {
+            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 {
+            shutdown.push(ActionData::from_anime_action(anime_type, ani)?);
+        }
+        self.shutdown = shutdown;
+        Ok(())
+    }
+}
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug, Clone)]
+pub struct AnimeConfig {
+    pub model_override: Option<AnimeType>,
+    pub system: Vec<ActionLoader>,
+    pub boot: Vec<ActionLoader>,
+    pub wake: Vec<ActionLoader>,
+    pub shutdown: Vec<ActionLoader>,
+    // pub brightness: f32,
+    pub display_enabled: bool,
+    pub display_brightness: Brightness,
+    pub builtin_anims_enabled: bool,
+    pub off_when_unplugged: bool,
+    pub off_when_suspended: bool,
+    pub off_when_lid_closed: bool,
+    pub brightness_on_battery: Brightness,
+    pub builtin_anims: Animations,
+}
+
+impl Default for AnimeConfig {
+    fn default() -> Self {
+        AnimeConfig {
+            model_override: None,
+            system: Vec::new(),
+            boot: Vec::new(),
+            wake: Vec::new(),
+            shutdown: Vec::new(),
+            // brightness: 1.0,
+            display_enabled: true,
+            display_brightness: Brightness::Med,
+            builtin_anims_enabled: true,
+            off_when_unplugged: true,
+            off_when_suspended: true,
+            off_when_lid_closed: true,
+            brightness_on_battery: Brightness::Low,
+            builtin_anims: Animations::default(),
+        }
+    }
+}
+
+impl StdConfig for AnimeConfig {
+    fn new() -> Self {
+        Self::create_default()
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad2<AnimeConfigV460, AnimeConfigV472> for AnimeConfig {}
+
+impl From<&AnimeConfig> for DeviceState {
+    fn from(config: &AnimeConfig) -> Self {
+        DeviceState {
+            display_enabled: config.display_enabled,
+            display_brightness: config.display_brightness,
+            builtin_anims_enabled: config.builtin_anims_enabled,
+            builtin_anims: config.builtin_anims,
+            off_when_unplugged: config.off_when_unplugged,
+            off_when_suspended: config.off_when_suspended,
+            off_when_lid_closed: config.off_when_lid_closed,
+            brightness_on_battery: config.brightness_on_battery,
+        }
+    }
+}
+
+impl AnimeConfig {
+    // 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() -> Self {
+        // create a default config here
+        AnimeConfig {
+            system: vec![],
+            boot: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                scale: 0.9,
+                angle: 0.65,
+                translation: Vec2::default(),
+                brightness: 1.0,
+                time: AnimTime::Fade(Fade::new(
+                    Duration::from_secs(2),
+                    Some(Duration::from_secs(2)),
+                    Duration::from_secs(2),
+                )),
+            }],
+            wake: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-run.gif".into(),
+                scale: 0.9,
+                angle: 0.65,
+                translation: Vec2::default(),
+                brightness: 1.0,
+                time: AnimTime::Fade(Fade::new(
+                    Duration::from_secs(2),
+                    Some(Duration::from_secs(2)),
+                    Duration::from_secs(2),
+                )),
+            }],
+            shutdown: vec![ActionLoader::ImageAnimation {
+                file: "/usr/share/asusd/anime/custom/sonic-wait.gif".into(),
+                scale: 0.9,
+                angle: 0.0,
+                translation: Vec2::new(3.0, 2.0),
+                brightness: 1.0,
+                time: AnimTime::Infinite,
+            }],
+            ..Default::default()
+        }
+    }
+}

asusd/src/ctrl_anime/mod.rs

@@ -0,0 +1,292 @@
+pub mod config;
+/// Implements `CtrlTask`, Reloadable, `ZbusRun`
+pub mod trait_impls;
+
+use std::convert::TryFrom;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::thread::sleep;
+
+use ::zbus::export::futures_util::lock::Mutex;
+use config_traits::{StdConfig, StdConfigLoad2};
+use log::{error, info, warn};
+use rog_anime::error::AnimeError;
+use rog_anime::usb::{
+    get_anime_type, pkt_flush, pkt_set_brightness, pkt_set_enable_display,
+    pkt_set_enable_powersave_anim, pkts_for_init, Brightness,
+};
+use rog_anime::{ActionData, AnimeDataBuffer, AnimePacketType, AnimeType};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::usb_raw::USBRaw;
+
+use self::config::{AnimeConfig, AnimeConfigCached};
+use crate::error::RogError;
+
+enum Node {
+    Usb(USBRaw),
+    Hid(HidRaw),
+}
+
+impl Node {
+    pub fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
+        // TODO: map and pass on errors
+        match self {
+            Node::Usb(u) => {
+                u.write_bytes(message).ok();
+            }
+            Node::Hid(h) => {
+                h.write_bytes(message).ok();
+            }
+        }
+        Ok(())
+    }
+
+    pub fn set_builtins_enabled(&self, enabled: bool, bright: Brightness) -> Result<(), RogError> {
+        self.write_bytes(&pkt_set_enable_powersave_anim(enabled))?;
+        self.write_bytes(&pkt_set_enable_display(enabled))?;
+        self.write_bytes(&pkt_set_brightness(bright))?;
+        self.write_bytes(&pkt_set_enable_powersave_anim(enabled))
+    }
+}
+
+pub struct CtrlAnime {
+    // node: HidRaw,
+    node: Node,
+    anime_type: AnimeType,
+    cache: AnimeConfigCached,
+    config: AnimeConfig,
+    // set to force thread to exit
+    thread_exit: Arc<AtomicBool>,
+    // Set to false when the thread exits
+    thread_running: Arc<AtomicBool>,
+}
+
+impl CtrlAnime {
+    #[inline]
+    pub fn new() -> Result<CtrlAnime, RogError> {
+        let usb = USBRaw::new(0x193b).ok();
+        let hid = HidRaw::new("193b").ok();
+        let node = if usb.is_some() {
+            info!("Anime using the USB interface");
+            unsafe { Node::Usb(usb.unwrap_unchecked()) }
+        } else if hid.is_some() {
+            info!("Anime using the HID interface");
+            unsafe { Node::Hid(hid.unwrap_unchecked()) }
+        } else {
+            return Err(RogError::Anime(AnimeError::NoDevice));
+        };
+
+        // TODO: something better to set wakeups disabled
+        // if matches!(node, Node::Usb(_)) {
+        //     if let Ok(mut enumerator) = udev::Enumerator::new() {
+        //         enumerator.match_subsystem("usb").ok();
+        //         enumerator.match_attribute("idProduct", "193b").ok();
+
+        //         if let Ok(mut enumer) = enumerator.scan_devices() {
+        //             if let Some(mut dev) = enumer.next() {
+        //                 dev.set_attribute_value("power/wakeup", "disabled").ok();
+        //             }
+        //         }
+        //     }
+        // }
+
+        let config = AnimeConfig::new().load();
+        let mut anime_type = get_anime_type()?;
+        if let AnimeType::Unknown = anime_type {
+            if let Some(model) = config.model_override {
+                warn!("Overriding the Animatrix type as {model:?}");
+                anime_type = model;
+            }
+        }
+
+        info!("Device has an AniMe Matrix display: {anime_type:?}");
+        let mut cache = AnimeConfigCached::default();
+        cache.init_from_config(&config, anime_type)?;
+
+        let ctrl = CtrlAnime {
+            node,
+            anime_type,
+            cache,
+            config,
+            thread_exit: Arc::new(AtomicBool::new(false)),
+            thread_running: Arc::new(AtomicBool::new(false)),
+        };
+        ctrl.do_initialization()?;
+
+        Ok(ctrl)
+    }
+
+    // let device = CtrlAnime::get_device(0x0b05, 0x193b)?;
+
+    /// Start an action thread. This is classed as a singleton and there should
+    /// be only one running - so the thread uses atomics to signal run/exit.
+    ///
+    /// Because this also writes to the usb device, other write tries (display
+    /// only) *must* get the mutex lock and set the `thread_exit` atomic.
+    async fn run_thread(inner: Arc<Mutex<CtrlAnime>>, actions: Vec<ActionData>, mut once: bool) {
+        if actions.is_empty() {
+            warn!("AniMe system actions was empty");
+            return;
+        }
+
+        if let Some(lock) = inner.try_lock() {
+            lock.node
+                .write_bytes(&pkt_set_enable_powersave_anim(false))
+                .map_err(|err| {
+                    warn!("rog_anime::run_animation:callback {}", err);
+                })
+                .ok();
+        }
+
+        // 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
+
+        // The only reason for this outer thread is to prevent blocking while waiting
+        // for the next spawned thread to exit
+        // TODO: turn this in to async task (maybe? COuld still risk blocking main
+        // thread)
+        std::thread::Builder::new()
+            .name("AniMe system thread start".into())
+            .spawn(move || {
+                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;
+                let anime_type;
+                loop {
+                    if let Some(lock) = inner.try_lock() {
+                        thread_exit = lock.thread_exit.clone();
+                        thread_running = lock.thread_running.clone();
+                        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);
+                }
+
+                info!("AniMe no previous system thread running (now)");
+                thread_exit.store(false, Ordering::SeqCst);
+                thread_running.store(true, Ordering::SeqCst);
+                'main: loop {
+                    for action in &actions {
+                        if thread_exit.load(Ordering::SeqCst) {
+                            break 'main;
+                        }
+                        match action {
+                            ActionData::Animation(frames) => {
+                                rog_anime::run_animation(frames, &|frame| {
+                                    if thread_exit.load(Ordering::Acquire) {
+                                        info!("rog-anime: animation sub-loop was asked to exit");
+                                        return Ok(true); // Do safe exit
+                                    }
+                                    inner
+                                        .try_lock()
+                                        .map(|lock| {
+                                            lock.write_data_buffer(frame)
+                                                .map_err(|err| {
+                                                    warn!(
+                                                        "rog_anime::run_animation:callback {}",
+                                                        err
+                                                    );
+                                                })
+                                                .ok();
+                                            false // Don't exit yet
+                                        })
+                                        .map_or_else(
+                                            || {
+                                                warn!("rog_anime::run_animation:callback failed");
+                                                Err(AnimeError::NoFrames)
+                                            },
+                                            Ok,
+                                        )
+                                });
+                                if thread_exit.load(Ordering::Acquire) {
+                                    info!("rog-anime: sub-loop exited and main loop exiting now");
+                                    break 'main;
+                                }
+                            }
+                            ActionData::Image(image) => {
+                                once = false;
+                                if let Some(lock) = inner.try_lock() {
+                                    lock.write_data_buffer(image.as_ref().clone())
+                                        .map_err(|e| error!("{}", e))
+                                        .ok();
+                                }
+                            }
+                            ActionData::Pause(duration) => sleep(*duration),
+                            ActionData::AudioEq
+                            | ActionData::SystemInfo
+                            | ActionData::TimeDate
+                            | ActionData::Matrix => {}
+                        }
+                    }
+                    if thread_exit.load(Ordering::SeqCst) {
+                        break 'main;
+                    }
+                    if once || actions.is_empty() {
+                        break 'main;
+                    }
+                }
+                // Clear the display on exit
+                if let Some(lock) = inner.try_lock() {
+                    if let Ok(data) =
+                        AnimeDataBuffer::from_vec(anime_type, vec![0u8; anime_type.data_length()])
+                            .map_err(|e| error!("{}", e))
+                    {
+                        lock.write_data_buffer(data)
+                            .map_err(|err| {
+                                warn!("rog_anime::run_animation:callback {}", err);
+                            })
+                            .ok();
+                    }
+                    lock.node
+                        .write_bytes(&pkt_set_enable_powersave_anim(
+                            lock.config.builtin_anims_enabled,
+                        ))
+                        .map_err(|err| {
+                            warn!("rog_anime::run_animation:callback {}", err);
+                        })
+                        .ok();
+                }
+                // Loop ended, set the atmonics
+                thread_running.store(false, Ordering::SeqCst);
+                info!("AniMe system thread exited");
+            })
+            .map(|err| info!("AniMe system thread: {:?}", err))
+            .ok();
+    }
+
+    /// 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) -> Result<(), RogError> {
+        for led in buffer.data_mut().iter_mut() {
+            let mut bright = *led as f32;
+            if bright > 254.0 {
+                bright = 254.0;
+            }
+            *led = bright as u8;
+        }
+        let data = AnimePacketType::try_from(buffer)?;
+        for row in &data {
+            self.node.write_bytes(row)?;
+        }
+        self.node.write_bytes(&pkt_flush())?;
+        Ok(())
+    }
+
+    fn do_initialization(&self) -> Result<(), RogError> {
+        let pkts = pkts_for_init();
+        self.node.write_bytes(&pkts[0])?;
+        self.node.write_bytes(&pkts[1])?;
+        Ok(())
+    }
+}

asusd/src/ctrl_anime/trait_impls.rs

@@ -0,0 +1,522 @@
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+
+use config_traits::StdConfig;
+use log::warn;
+use logind_zbus::manager::ManagerProxy;
+use rog_anime::usb::{
+    pkt_set_brightness, pkt_set_builtin_animations, pkt_set_enable_display,
+    pkt_set_enable_powersave_anim, Brightness,
+};
+use rog_anime::{Animations, AnimeDataBuffer, DeviceState};
+use zbus::export::futures_util::lock::Mutex;
+use zbus::{interface, CacheProperties, Connection, SignalContext};
+
+use super::config::AnimeConfig;
+use super::CtrlAnime;
+use crate::error::RogError;
+
+pub const ANIME_ZBUS_NAME: &str = "Anime";
+pub const ANIME_ZBUS_PATH: &str = "/org/asuslinux";
+
+async fn get_logind_manager<'a>() -> ManagerProxy<'a> {
+    let connection = Connection::system()
+        .await
+        .expect("Controller could not create dbus connection");
+
+    ManagerProxy::builder(&connection)
+        .cache_properties(CacheProperties::No)
+        .build()
+        .await
+        .expect("Controller could not create ManagerProxy")
+}
+
+#[derive(Clone)]
+pub struct CtrlAnimeZbus(pub Arc<Mutex<CtrlAnime>>);
+
+/// The struct with the main dbus methods requires this trait
+impl crate::ZbusRun for CtrlAnimeZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, ANIME_ZBUS_PATH, server).await;
+    }
+}
+
+// None of these calls can be guarnateed to succeed unless we loop until okay
+// If the try_lock *does* succeed then any other thread trying to lock will not
+// grab it until we finish.
+#[interface(name = "org.asuslinux.Anime")]
+impl CtrlAnimeZbus {
+    /// Writes a data stream of length. Will force system thread to exit until
+    /// it is restarted
+    async fn write(&self, input: AnimeDataBuffer) -> zbus::fdo::Result<()> {
+        self.0
+            .lock()
+            .await
+            .thread_exit
+            .store(true, Ordering::SeqCst);
+        self.0
+            .lock()
+            .await
+            .write_data_buffer(input)
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+                err
+            })?;
+        Ok(())
+    }
+
+    /// Set base brightness level
+    #[zbus(property)]
+    async fn brightness(&self) -> Brightness {
+        self.0.lock().await.config.display_brightness
+    }
+
+    /// Set base brightness level
+    #[zbus(property)]
+    async fn set_brightness(&self, brightness: Brightness) {
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_brightness(brightness))
+            .map_err(|err| {
+                warn!("ctrl_anime::set_brightness {}", err);
+            })
+            .ok();
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_enable_display(brightness != Brightness::Off))
+            .map_err(|err| {
+                warn!("ctrl_anime::set_brightness {}", err);
+            })
+            .ok();
+
+        self.0.lock().await.config.display_enabled = brightness != Brightness::Off;
+        self.0.lock().await.config.display_brightness = brightness;
+        self.0.lock().await.config.write();
+    }
+
+    #[zbus(property)]
+    async fn builtins_enabled(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.builtin_anims_enabled
+    }
+
+    /// Enable the builtin animations or not. This is quivalent to "Powersave
+    /// animations" in Armory crate
+    #[zbus(property)]
+    async fn set_builtins_enabled(&self, enabled: bool) {
+        let brightness = self.0.lock().await.config.display_brightness;
+        self.0
+            .lock()
+            .await
+            .node
+            .set_builtins_enabled(enabled, brightness)
+            .map_err(|err| {
+                warn!("ctrl_anime::set_builtins_enabled {}", err);
+            })
+            .ok();
+
+        if !enabled {
+            let anime_type = self.0.lock().await.anime_type;
+            let data = vec![255u8; anime_type.data_length()];
+            if let Ok(tmp) = AnimeDataBuffer::from_vec(anime_type, data).map_err(|err| {
+                warn!("ctrl_anime::set_builtins_enabled {}", err);
+            }) {
+                self.0
+                    .lock()
+                    .await
+                    .node
+                    .write_bytes(tmp.data())
+                    .map_err(|err| {
+                        warn!("ctrl_anime::set_builtins_enabled {}", err);
+                    })
+                    .ok();
+            }
+        }
+
+        self.0.lock().await.config.builtin_anims_enabled = enabled;
+        self.0.lock().await.config.write();
+        if enabled {
+            self.0
+                .lock()
+                .await
+                .thread_exit
+                .store(true, Ordering::Release);
+        }
+    }
+
+    #[zbus(property)]
+    async fn builtin_animations(&self) -> Animations {
+        self.0.lock().await.config.builtin_anims
+    }
+
+    /// Set which builtin animation is used for each stage
+    #[zbus(property)]
+    async fn set_builtin_animations(&self, settings: Animations) {
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_builtin_animations(
+                settings.boot,
+                settings.awake,
+                settings.sleep,
+                settings.shutdown,
+            ))
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_enable_powersave_anim(true))
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        self.0.lock().await.config.display_enabled = true;
+        self.0.lock().await.config.builtin_anims = settings;
+        self.0.lock().await.config.write();
+    }
+
+    #[zbus(property)]
+    async fn enable_display(&self) -> bool {
+        self.0.lock().await.config.display_enabled
+    }
+
+    /// Set whether the AniMe is enabled at all
+    #[zbus(property)]
+    async fn set_enable_display(&self, enabled: bool) {
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_enable_display(enabled))
+            .map_err(|err| {
+                warn!("ctrl_anime::run_animation:callback {}", err);
+            })
+            .ok();
+        self.0.lock().await.config.display_enabled = enabled;
+        self.0.lock().await.config.write();
+    }
+
+    #[zbus(property)]
+    async fn off_when_unplugged(&self) -> bool {
+        self.0.lock().await.config.off_when_unplugged
+    }
+
+    /// Set if to turn the AniMe Matrix off when external power is unplugged
+    #[zbus(property)]
+    async fn set_off_when_unplugged(&self, enabled: bool) {
+        let manager = get_logind_manager().await;
+        let pow = manager.on_external_power().await.unwrap_or_default();
+
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_enable_display(!pow && !enabled))
+            .map_err(|err| {
+                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+            })
+            .ok();
+
+        self.0.lock().await.config.off_when_unplugged = enabled;
+        self.0.lock().await.config.write();
+    }
+
+    #[zbus(property)]
+    async fn off_when_suspended(&self) -> bool {
+        self.0.lock().await.config.off_when_suspended
+    }
+
+    /// Set if to turn the AniMe Matrix off when the laptop is suspended
+    #[zbus(property)]
+    async fn set_off_when_suspended(&self, enabled: bool) {
+        self.0.lock().await.config.off_when_suspended = enabled;
+        self.0.lock().await.config.write();
+    }
+
+    #[zbus(property)]
+    async fn off_when_lid_closed(&self) -> bool {
+        self.0.lock().await.config.off_when_lid_closed
+    }
+
+    /// Set if to turn the AniMe Matrix off when the lid is closed
+    #[zbus(property)]
+    async fn set_off_when_lid_closed(&self, enabled: bool) {
+        let manager = get_logind_manager().await;
+        let lid = manager.lid_closed().await.unwrap_or_default();
+
+        self.0
+            .lock()
+            .await
+            .node
+            .write_bytes(&pkt_set_enable_display(lid && !enabled))
+            .map_err(|err| {
+                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+            })
+            .ok();
+
+        self.0.lock().await.config.off_when_lid_closed = enabled;
+        self.0.lock().await.config.write();
+    }
+
+    /// The main loop is the base system set action if the user isn't running
+    /// the user daemon
+    async fn run_main_loop(&self, start: bool) {
+        if start {
+            self.0
+                .lock()
+                .await
+                .thread_exit
+                .store(true, Ordering::SeqCst);
+            CtrlAnime::run_thread(
+                self.0.clone(),
+                self.0.lock().await.cache.system.clone(),
+                false,
+            )
+            .await;
+        }
+    }
+
+    /// Get the device state as stored by asusd
+    // #[zbus(property)]
+    async fn device_state(&self) -> DeviceState {
+        DeviceState::from(&self.0.lock().await.config)
+    }
+}
+
+impl crate::CtrlTask for CtrlAnimeZbus {
+    fn zbus_path() -> &'static str {
+        ANIME_ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        let inner1 = self.0.clone();
+        let inner2 = self.0.clone();
+        let inner3 = self.0.clone();
+        let inner4 = self.0.clone();
+        self.create_sys_event_tasks(
+            move |sleeping| {
+                // on_sleep
+                let inner = inner1.clone();
+                async move {
+                    let config = inner.lock().await.config.clone();
+                    if config.display_enabled {
+                        inner
+                            .lock()
+                            .await
+                            .thread_exit
+                            .store(true, Ordering::Release); // ensure clean slate
+
+                        inner
+                            .lock()
+                            .await
+                            .node
+                            .write_bytes(&pkt_set_enable_display(
+                                !(sleeping && config.off_when_suspended),
+                            ))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                            })
+                            .ok();
+
+                        if config.builtin_anims_enabled {
+                            inner
+                                .lock()
+                                .await
+                                .node
+                                .write_bytes(&pkt_set_enable_powersave_anim(
+                                    !(sleeping && config.off_when_suspended),
+                                ))
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        } else if !sleeping && !config.builtin_anims_enabled {
+                            // Run custom wake animation
+                            inner
+                                .lock()
+                                .await
+                                .node
+                                .write_bytes(&pkt_set_enable_powersave_anim(false))
+                                .ok(); // ensure builtins are disabled
+
+                            CtrlAnime::run_thread(
+                                inner.clone(),
+                                inner.lock().await.cache.wake.clone(),
+                                true,
+                            )
+                            .await;
+                        }
+                    }
+                }
+            },
+            move |shutting_down| {
+                // on_shutdown
+                let inner = inner2.clone();
+                async move {
+                    let AnimeConfig {
+                        display_enabled,
+                        builtin_anims_enabled,
+                        ..
+                    } = inner.lock().await.config;
+                    if display_enabled && !builtin_anims_enabled {
+                        if shutting_down {
+                            CtrlAnime::run_thread(
+                                inner.clone(),
+                                inner.lock().await.cache.shutdown.clone(),
+                                true,
+                            )
+                            .await;
+                        } else {
+                            CtrlAnime::run_thread(
+                                inner.clone(),
+                                inner.lock().await.cache.boot.clone(),
+                                true,
+                            )
+                            .await;
+                        }
+                    }
+                }
+            },
+            move |lid_closed| {
+                let inner = inner3.clone();
+                // on lid change
+                async move {
+                    let AnimeConfig {
+                        off_when_lid_closed,
+                        builtin_anims_enabled,
+                        ..
+                    } = inner.lock().await.config;
+                    if off_when_lid_closed {
+                        if builtin_anims_enabled {
+                            inner
+                                .lock()
+                                .await
+                                .node
+                                .write_bytes(&pkt_set_enable_powersave_anim(!lid_closed))
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        }
+                        inner
+                            .lock()
+                            .await
+                            .node
+                            .write_bytes(&pkt_set_enable_display(!lid_closed))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_lid_closed {}", err);
+                            })
+                            .ok();
+                    }
+                }
+            },
+            move |power_plugged| {
+                let inner = inner4.clone();
+                // on power change
+                async move {
+                    let AnimeConfig {
+                        off_when_unplugged,
+                        builtin_anims_enabled,
+                        brightness_on_battery,
+                        ..
+                    } = inner.lock().await.config;
+                    if off_when_unplugged {
+                        if builtin_anims_enabled {
+                            inner
+                                .lock()
+                                .await
+                                .node
+                                .write_bytes(&pkt_set_enable_powersave_anim(power_plugged))
+                                .map_err(|err| {
+                                    warn!("create_sys_event_tasks::off_when_suspended {}", err);
+                                })
+                                .ok();
+                        }
+                        inner
+                            .lock()
+                            .await
+                            .node
+                            .write_bytes(&pkt_set_enable_display(power_plugged))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_unplugged {}", err);
+                            })
+                            .ok();
+                    } else {
+                        inner
+                            .lock()
+                            .await
+                            .node
+                            .write_bytes(&pkt_set_brightness(brightness_on_battery))
+                            .map_err(|err| {
+                                warn!("create_sys_event_tasks::off_when_unplugged {}", err);
+                            })
+                            .ok();
+                    }
+                }
+            },
+        )
+        .await;
+
+        Ok(())
+    }
+}
+
+impl crate::Reloadable for CtrlAnimeZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        if let Some(lock) = self.0.try_lock() {
+            let anim = &lock.config.builtin_anims;
+            // Set builtins
+            if lock.config.builtin_anims_enabled {
+                lock.node.write_bytes(&pkt_set_builtin_animations(
+                    anim.boot,
+                    anim.awake,
+                    anim.sleep,
+                    anim.shutdown,
+                ))?;
+            }
+            // Builtins enabled or na?
+            lock.node.set_builtins_enabled(
+                lock.config.builtin_anims_enabled,
+                lock.config.display_brightness,
+            )?;
+
+            let manager = get_logind_manager().await;
+            let lid_closed = manager.lid_closed().await.unwrap_or_default();
+            let power_plugged = manager.on_external_power().await.unwrap_or_default();
+
+            let turn_off = (lid_closed && lock.config.off_when_lid_closed)
+                || (!power_plugged && lock.config.off_when_unplugged);
+            lock.node
+                .write_bytes(&pkt_set_enable_display(!turn_off))
+                .map_err(|err| {
+                    warn!("create_sys_event_tasks::reload {}", err);
+                })
+                .ok();
+
+            if turn_off || !lock.config.display_enabled {
+                lock.node.write_bytes(&pkt_set_enable_display(false))?;
+                // early return so we don't run animation thread
+                return Ok(());
+            }
+
+            if !lock.config.builtin_anims_enabled && !lock.cache.boot.is_empty() {
+                lock.node
+                    .write_bytes(&pkt_set_enable_powersave_anim(false))
+                    .ok();
+
+                let action = lock.cache.boot.clone();
+                CtrlAnime::run_thread(self.0.clone(), action, true).await;
+            }
+        }
+        Ok(())
+    }
+}

asusd/src/ctrl_aura/config.rs

@@ -0,0 +1,277 @@
+use std::collections::BTreeMap;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use log::{debug, info, warn};
+use rog_aura::aura_detection::LedSupportData;
+use rog_aura::keyboard::LaptopAuraPower;
+use rog_aura::{
+    AuraDeviceType, AuraEffect, AuraModeNum, AuraZone, Direction, LedBrightness, Speed, GRADIENT,
+};
+use serde_derive::{Deserialize, Serialize};
+
+#[derive(Deserialize, Serialize, Default, Debug, Clone)]
+// #[serde(default)]
+pub struct AuraConfig {
+    pub config_name: String,
+    pub brightness: LedBrightness,
+    pub current_mode: AuraModeNum,
+    pub builtins: BTreeMap<AuraModeNum, AuraEffect>,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    pub multizone: Option<BTreeMap<AuraModeNum, Vec<AuraEffect>>>,
+    pub multizone_on: bool,
+    pub enabled: LaptopAuraPower,
+}
+
+impl StdConfig for AuraConfig {
+    /// Detect the keyboard type and load from default DB if data available
+    fn new() -> Self {
+        panic!("This should not be used");
+    }
+
+    fn file_name(&self) -> String {
+        if self.config_name.is_empty() {
+            panic!("Config file name should not be empty");
+        }
+        self.config_name.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for AuraConfig {}
+
+impl AuraConfig {
+    /// Detect the keyboard type and load from default DB if data available
+    pub fn new(prod_id: &str) -> Self {
+        info!("Setting up AuraConfig for {prod_id:?}");
+        // create a default config here
+        let device_type = AuraDeviceType::from(prod_id);
+        if device_type == AuraDeviceType::Unknown {
+            warn!("idProduct:{prod_id:?} is unknown");
+        }
+        let support_data = LedSupportData::get_data(prod_id);
+        let enabled = LaptopAuraPower::new(device_type, &support_data);
+        let mut config = AuraConfig {
+            config_name: format!("aura_{prod_id}.ron"),
+            brightness: LedBrightness::Med,
+            current_mode: AuraModeNum::Static,
+            builtins: BTreeMap::new(),
+            multizone: None,
+            multizone_on: false,
+            enabled,
+        };
+
+        for n in &support_data.basic_modes {
+            debug!("creating default for {n}");
+            config
+                .builtins
+                .insert(*n, AuraEffect::default_with_mode(*n));
+
+            if !support_data.basic_zones.is_empty() {
+                let mut default = vec![];
+                for (i, tmp) in support_data.basic_zones.iter().enumerate() {
+                    default.push(AuraEffect {
+                        mode: *n,
+                        zone: *tmp,
+                        colour1: *GRADIENT.get(i).unwrap_or(&GRADIENT[0]),
+                        colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
+                        speed: Speed::Med,
+                        direction: Direction::Left,
+                    });
+                }
+                if let Some(m) = config.multizone.as_mut() {
+                    m.insert(*n, default);
+                } else {
+                    let mut tmp = BTreeMap::new();
+                    tmp.insert(*n, default);
+                    config.multizone = Some(tmp);
+                }
+            }
+        }
+        config
+    }
+
+    /// Set the mode data, current mode, and if multizone enabled.
+    ///
+    /// Multipurpose, will accept `AuraEffect` with zones and put in the correct
+    /// store.
+    pub fn set_builtin(&mut self, effect: AuraEffect) {
+        self.current_mode = effect.mode;
+        if effect.zone() == AuraZone::None {
+            self.builtins.insert(*effect.mode(), effect);
+            self.multizone_on = false;
+        } else {
+            if let Some(multi) = self.multizone.as_mut() {
+                if let Some(fx) = multi.get_mut(effect.mode()) {
+                    for fx in fx.iter_mut() {
+                        if fx.zone == effect.zone {
+                            *fx = effect;
+                            return;
+                        }
+                    }
+                    fx.push(effect);
+                } else {
+                    multi.insert(*effect.mode(), vec![effect]);
+                }
+            } else {
+                let mut tmp = BTreeMap::new();
+                tmp.insert(*effect.mode(), vec![effect]);
+                self.multizone = Some(tmp);
+            }
+            self.multizone_on = true;
+        }
+    }
+
+    pub fn get_multizone(&self, aura_type: AuraModeNum) -> Option<&[AuraEffect]> {
+        if let Some(multi) = &self.multizone {
+            return multi.get(&aura_type).map(|v| v.as_slice());
+        }
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour};
+
+    use super::AuraConfig;
+
+    #[test]
+    fn set_multizone_4key_config() {
+        let mut config = AuraConfig::new("19b6");
+
+        let effect = AuraEffect {
+            colour1: Colour {
+                r: 0xff,
+                g: 0x00,
+                b: 0xff,
+            },
+            zone: AuraZone::Key1,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        assert!(config.multizone.is_some());
+
+        let effect = AuraEffect {
+            colour1: Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0xff,
+            },
+            zone: AuraZone::Key2,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            colour1: Colour {
+                r: 0xff,
+                g: 0xff,
+                b: 0x00,
+            },
+            zone: AuraZone::Key3,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            colour1: Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0x00,
+            },
+            zone: AuraZone::Key4,
+            ..Default::default()
+        };
+        let effect_clone = effect.clone();
+        config.set_builtin(effect);
+        // This should replace existing
+        config.set_builtin(effect_clone);
+
+        let res = config.multizone.unwrap();
+        let sta = res.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(sta.len(), 4);
+        assert_eq!(
+            sta[0].colour1,
+            Colour {
+                r: 0xff,
+                g: 0x00,
+                b: 0xff
+            }
+        );
+        assert_eq!(
+            sta[1].colour1,
+            Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0xff
+            }
+        );
+        assert_eq!(
+            sta[2].colour1,
+            Colour {
+                r: 0xff,
+                g: 0xff,
+                b: 0x00
+            }
+        );
+        assert_eq!(
+            sta[3].colour1,
+            Colour {
+                r: 0x00,
+                g: 0xff,
+                b: 0x00
+            }
+        );
+    }
+
+    #[test]
+    fn set_multizone_multimode_config() {
+        let mut config = AuraConfig::new("19b6");
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key1,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        assert!(config.multizone.is_some());
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key2,
+            mode: AuraModeNum::Breathe,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key3,
+            mode: AuraModeNum::Comet,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let effect = AuraEffect {
+            zone: AuraZone::Key4,
+            mode: AuraModeNum::Pulse,
+            ..Default::default()
+        };
+        config.set_builtin(effect);
+
+        let res = config.multizone.unwrap();
+        let sta = res.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(sta.len(), 1);
+
+        let sta = res.get(&AuraModeNum::Breathe).unwrap();
+        assert_eq!(sta.len(), 1);
+
+        let sta = res.get(&AuraModeNum::Comet).unwrap();
+        assert_eq!(sta.len(), 1);
+
+        let sta = res.get(&AuraModeNum::Pulse).unwrap();
+        assert_eq!(sta.len(), 1);
+    }
+}

asusd/src/ctrl_aura/controller.rs

@@ -0,0 +1,467 @@
+use std::collections::{BTreeMap, HashSet};
+
+use config_traits::{StdConfig, StdConfigLoad};
+use dmi_id::DMIID;
+use inotify::Inotify;
+use log::{debug, info, warn};
+use rog_aura::aura_detection::LedSupportData;
+use rog_aura::keyboard::{LedUsbPackets, UsbPackets};
+use rog_aura::usb::{LED_APPLY, LED_SET};
+use rog_aura::{
+    AuraDeviceType, AuraEffect, Direction, LedBrightness, Speed, GRADIENT, LED_MSG_LEN,
+};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::keyboard_led::KeyboardLed;
+use zbus::zvariant::OwnedObjectPath;
+
+use super::config::AuraConfig;
+use crate::ctrl_aura::manager::{dbus_path_for_dev, dbus_path_for_tuf};
+use crate::error::RogError;
+
+#[derive(Debug)]
+pub enum LEDNode {
+    /// Brightness and/or TUF RGB controls
+    KbdLed(KeyboardLed),
+    /// Raw HID handle
+    Rog(KeyboardLed, HidRaw),
+}
+
+impl LEDNode {
+    // TODO: move various methods upwards to this
+    pub fn set_brightness(&self, value: u8) -> Result<(), RogError> {
+        match self {
+            LEDNode::KbdLed(k) => k.set_brightness(value)?,
+            LEDNode::Rog(k, _) => k.set_brightness(value)?,
+        }
+        Ok(())
+    }
+
+    pub fn get_brightness(&self) -> Result<u8, RogError> {
+        Ok(match self {
+            LEDNode::KbdLed(k) => k.get_brightness()?,
+            LEDNode::Rog(k, _) => k.get_brightness()?,
+        })
+    }
+
+    pub fn monitor_brightness(&self) -> Result<Inotify, RogError> {
+        Ok(match self {
+            LEDNode::KbdLed(k) => k.monitor_brightness()?,
+            LEDNode::Rog(k, _) => k.monitor_brightness()?,
+        })
+    }
+}
+
+/// Individual controller for one Aura device
+pub struct CtrlKbdLed {
+    pub led_type: AuraDeviceType,
+    pub led_node: LEDNode,
+    pub supported_data: LedSupportData, // TODO: is storing this really required?
+    pub per_key_mode_active: bool,
+    pub config: AuraConfig,
+    pub dbus_path: OwnedObjectPath,
+}
+
+impl CtrlKbdLed {
+    pub fn find_all() -> Result<Vec<Self>, RogError> {
+        info!("Searching for all Aura devices");
+        let mut devices = Vec::new();
+        let mut found = HashSet::new(); // track and ensure we use only one hidraw per prod_id
+
+        let mut enumerator = udev::Enumerator::new().map_err(|err| {
+            warn!("{}", err);
+            err
+        })?;
+
+        enumerator.match_subsystem("hidraw").map_err(|err| {
+            warn!("{}", err);
+            err
+        })?;
+
+        for end_point in enumerator.scan_devices()? {
+            // usb_device gives us a product and vendor ID
+            if let Some(usb_device) =
+                end_point.parent_with_subsystem_devtype("usb", "usb_device")?
+            {
+                // The asus_wmi driver latches MCU that controls the USB endpoints
+                if let Some(parent) = end_point.parent() {
+                    if let Some(driver) = parent.driver() {
+                        // There is a tree of devices added so filter by driver
+                        if driver != "asus" {
+                            continue;
+                        }
+                    } else {
+                        continue;
+                    }
+                }
+                // Device is something like 002, while its parent is the MCU
+                // Think of it like the device is an endpoint of the USB device attached
+                let mut prod_id = String::new();
+                if let Some(usb_id) = usb_device.attribute_value("idProduct") {
+                    prod_id = usb_id.to_string_lossy().to_string();
+                    let aura_dev = AuraDeviceType::from(prod_id.as_str());
+                    if aura_dev == AuraDeviceType::Unknown || found.contains(&aura_dev) {
+                        log::debug!("Unknown or invalid device: {usb_id:?}, skipping");
+                        continue;
+                    }
+                    found.insert(aura_dev);
+                }
+
+                let dev_node = if let Some(dev_node) = usb_device.devnode() {
+                    dev_node
+                } else {
+                    debug!("Device has no devnode, skipping");
+                    continue;
+                };
+                info!("AuraControl found device at: {:?}", dev_node);
+                let dbus_path = dbus_path_for_dev(&usb_device).unwrap_or_default();
+                let dev = HidRaw::from_device(end_point)?;
+                let mut dev = Self::from_hidraw(dev, dbus_path)?;
+                dev.config = Self::init_config(&prod_id);
+                devices.push(dev);
+            }
+        }
+
+        // Check for a TUF laptop LED. Assume there is only ever one.
+        if let Ok(kbd_backlight) = KeyboardLed::new() {
+            if kbd_backlight.has_kbd_rgb_mode() {
+                // Extra sure double-check that this isn't a laptop with crap
+                // ACPI with borked return on the TUF rgb methods
+                let dmi = DMIID::new().unwrap_or_default();
+                info!("Found a TUF with product family: {}", dmi.product_family);
+                info!("and board name: {}", dmi.board_name);
+
+                if dmi.product_family.contains("TUF") {
+                    info!("AuraControl found a TUF laptop keyboard");
+                    let ctrl = CtrlKbdLed {
+                        led_type: AuraDeviceType::LaptopTuf,
+                        led_node: LEDNode::KbdLed(kbd_backlight),
+                        supported_data: LedSupportData::get_data("tuf"),
+                        per_key_mode_active: false,
+                        config: Self::init_config("tuf"),
+                        dbus_path: dbus_path_for_tuf(),
+                    };
+                    devices.push(ctrl);
+                }
+            }
+        }
+
+        info!("Found {} Aura devices", devices.len());
+
+        Ok(devices)
+    }
+
+    /// The generated data from this function has a default config. This config
+    /// should be overwritten. The reason for the default config is because
+    /// of async issues between this and udev/hidraw
+    pub fn from_hidraw(device: HidRaw, dbus_path: OwnedObjectPath) -> Result<Self, RogError> {
+        let rgb_led = KeyboardLed::new()?;
+        let prod_id = AuraDeviceType::from(device.prod_id());
+        if prod_id == AuraDeviceType::Unknown {
+            log::error!("{} is AuraDevice::Unknown", device.prod_id());
+            return Err(RogError::NoAuraNode);
+        }
+
+        // New loads data from the DB also
+        // let config = Self::init_config(prod_id, data);
+
+        let data = LedSupportData::get_data(device.prod_id());
+        let ctrl = CtrlKbdLed {
+            led_type: prod_id,
+            led_node: LEDNode::Rog(rgb_led, device),
+            supported_data: data.clone(),
+            per_key_mode_active: false,
+            config: AuraConfig::default(),
+            dbus_path,
+        };
+        Ok(ctrl)
+    }
+
+    pub fn init_config(prod_id: &str) -> AuraConfig {
+        // New loads data from the DB also
+        let mut config_init = AuraConfig::new(prod_id);
+        // config_init.set_filename(prod_id);
+        let mut config_loaded = config_init.clone().load();
+        // update the initialised data with what we loaded from disk
+        for mode in &mut config_init.builtins {
+            // update init values from loaded values if they exist
+            if let Some(loaded) = config_loaded.builtins.get(mode.0) {
+                *mode.1 = loaded.clone();
+            }
+        }
+        // Then replace just incase the initialised data contains new modes added
+        config_loaded.builtins = config_init.builtins;
+
+        if let (Some(mut multizone_init), Some(multizone_loaded)) =
+            (config_init.multizone, config_loaded.multizone.as_mut())
+        {
+            for mode in multizone_init.iter_mut() {
+                // update init values from loaded values if they exist
+                if let Some(loaded) = multizone_loaded.get(mode.0) {
+                    let mut new_set = Vec::new();
+                    let data = LedSupportData::get_data(prod_id);
+                    // only reuse a zone mode if the mode is supported
+                    for mode in loaded {
+                        if data.basic_modes.contains(&mode.mode) {
+                            new_set.push(mode.clone());
+                        }
+                    }
+                    *mode.1 = new_set;
+                }
+            }
+            *multizone_loaded = multizone_init;
+        }
+
+        config_loaded
+    }
+
+    /// Set combination state for boot animation/sleep animation/all leds/keys
+    /// leds/side leds LED active
+    pub(super) fn set_power_states(&mut self) -> Result<(), RogError> {
+        if let LEDNode::KbdLed(_platform) = &mut self.led_node {
+            // TODO: tuf bool array
+            // if let Some(pwr) =
+            // AuraPowerConfig::to_tuf_bool_array(&self.config.enabled) {
+            //     let buf = [1, pwr[1] as u8, pwr[2] as u8, pwr[3] as u8,
+            // pwr[4] as u8];     platform.set_kbd_rgb_state(&buf)?;
+            // }
+        } else if let LEDNode::Rog(_, hid_raw) = &self.led_node {
+            let bytes = self.config.enabled.to_bytes(self.led_type);
+            let message = [0x5d, 0xbd, 0x01, bytes[0], bytes[1], bytes[2], bytes[3]];
+
+            hid_raw.write_bytes(&message)?;
+            hid_raw.write_bytes(&LED_SET)?;
+            // Changes won't persist unless apply is set
+            hid_raw.write_bytes(&LED_APPLY)?;
+        }
+        Ok(())
+    }
+
+    /// Write an effect block. This is for per-key, but can be repurposed to
+    /// write the raw factory mode packets - when doing this it is expected that
+    /// only the first `Vec` (`effect[0]`) is valid.
+    pub fn write_effect_block(&mut self, effect: &UsbPackets) -> Result<(), RogError> {
+        if self.config.brightness == LedBrightness::Off {
+            self.config.brightness = LedBrightness::Med;
+            self.config.write();
+        }
+
+        let pkt_type = effect[0][1];
+        const PER_KEY_TYPE: u8 = 0xbc;
+
+        if pkt_type != PER_KEY_TYPE {
+            self.per_key_mode_active = false;
+            if let LEDNode::Rog(_, hid_raw) = &self.led_node {
+                hid_raw.write_bytes(&effect[0])?;
+                hid_raw.write_bytes(&LED_SET)?;
+                // hid_raw.write_bytes(&LED_APPLY)?;
+            }
+        } else {
+            if !self.per_key_mode_active {
+                if let LEDNode::Rog(_, hid_raw) = &self.led_node {
+                    let init = LedUsbPackets::get_init_msg();
+                    hid_raw.write_bytes(&init)?;
+                }
+                self.per_key_mode_active = true;
+            }
+            if let LEDNode::Rog(_, hid_raw) = &self.led_node {
+                for row in effect.iter() {
+                    hid_raw.write_bytes(row)?;
+                }
+            } else if let LEDNode::KbdLed(tuf) = &self.led_node {
+                for row in effect.iter() {
+                    let r = row[9];
+                    let g = row[10];
+                    let b = row[11];
+                    tuf.set_kbd_rgb_mode(&[0, 0, r, g, b, 0])?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub fn write_mode(&mut self, mode: &AuraEffect) -> Result<(), RogError> {
+        if let LEDNode::KbdLed(platform) = &self.led_node {
+            let buf = [
+                1,
+                mode.mode as u8,
+                mode.colour1.r,
+                mode.colour1.g,
+                mode.colour1.b,
+                mode.speed as u8,
+            ];
+            platform.set_kbd_rgb_mode(&buf)?;
+        } else if let LEDNode::Rog(_, hid_raw) = &self.led_node {
+            let bytes: [u8; LED_MSG_LEN] = mode.into();
+            hid_raw.write_bytes(&bytes)?;
+            hid_raw.write_bytes(&LED_SET)?;
+            // Changes won't persist unless apply is set
+            hid_raw.write_bytes(&LED_APPLY)?;
+        } else {
+            return Err(RogError::NoAuraKeyboard);
+        }
+        self.per_key_mode_active = false;
+        Ok(())
+    }
+
+    pub(super) fn write_current_config_mode(&mut self) -> Result<(), RogError> {
+        if self.config.multizone_on {
+            let mode = self.config.current_mode;
+            let mut create = false;
+            // There is no multizone config for this mode so create one here
+            // using the colours of rainbow if it exists, or first available
+            // mode, or random
+            if self.config.multizone.is_none() {
+                create = true;
+            } else if let Some(multizones) = self.config.multizone.as_ref() {
+                if !multizones.contains_key(&mode) {
+                    create = true;
+                }
+            }
+            if create {
+                info!("No user-set config for zone founding, attempting a default");
+                self.create_multizone_default()?;
+            }
+
+            if let Some(multizones) = self.config.multizone.as_mut() {
+                if let Some(set) = multizones.get(&mode) {
+                    for mode in set.clone() {
+                        self.write_mode(&mode)?;
+                    }
+                }
+            }
+        } else {
+            let mode = self.config.current_mode;
+            if let Some(effect) = self.config.builtins.get(&mode).cloned() {
+                self.write_mode(&effect)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Create a default for the `current_mode` if multizone and no config
+    /// exists.
+    fn create_multizone_default(&mut self) -> Result<(), RogError> {
+        let mut default = vec![];
+        for (i, tmp) in self.supported_data.basic_zones.iter().enumerate() {
+            default.push(AuraEffect {
+                mode: self.config.current_mode,
+                zone: *tmp,
+                colour1: *GRADIENT.get(i).unwrap_or(&GRADIENT[0]),
+                colour2: *GRADIENT.get(GRADIENT.len() - i).unwrap_or(&GRADIENT[6]),
+                speed: Speed::Med,
+                direction: Direction::Left,
+            });
+        }
+        if default.is_empty() {
+            return Err(RogError::AuraEffectNotSupported);
+        }
+
+        if let Some(multizones) = self.config.multizone.as_mut() {
+            multizones.insert(self.config.current_mode, default);
+        } else {
+            let mut tmp = BTreeMap::new();
+            tmp.insert(self.config.current_mode, default);
+            self.config.multizone = Some(tmp);
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rog_aura::aura_detection::LedSupportData;
+    use rog_aura::{AuraDeviceType, AuraModeNum, AuraZone, PowerZones};
+    use rog_platform::hid_raw::HidRaw;
+    use rog_platform::keyboard_led::KeyboardLed;
+    use zbus::zvariant::OwnedObjectPath;
+
+    use super::CtrlKbdLed;
+    use crate::ctrl_aura::config::AuraConfig;
+    use crate::ctrl_aura::controller::LEDNode;
+
+    #[test]
+    #[ignore = "Unable to run in CI as the HIDRAW device is required"]
+    fn create_multizone_if_no_config() {
+        // Checking to ensure set_mode errors when unsupported modes are tried
+        let config = AuraConfig::new("19b6");
+        let supported_basic_modes = LedSupportData {
+            device_name: String::new(),
+            product_id: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![],
+            advanced_type: rog_aura::keyboard::AdvancedAuraType::None,
+            power_zones: vec![PowerZones::Keyboard, PowerZones::RearGlow],
+        };
+        let mut controller = CtrlKbdLed {
+            led_type: AuraDeviceType::LaptopPost2021,
+            led_node: LEDNode::Rog(KeyboardLed::default(), HidRaw::new("19b6").unwrap()),
+            supported_data: supported_basic_modes,
+            per_key_mode_active: false,
+            config,
+            dbus_path: OwnedObjectPath::default(),
+        };
+
+        assert!(controller.config.multizone.is_none());
+        assert!(controller.create_multizone_default().is_err());
+        assert!(controller.config.multizone.is_none());
+
+        controller.supported_data.basic_zones.push(AuraZone::Key1);
+        controller.supported_data.basic_zones.push(AuraZone::Key2);
+        assert!(controller.create_multizone_default().is_ok());
+        assert!(controller.config.multizone.is_some());
+
+        let m = controller.config.multizone.unwrap();
+        assert!(m.contains_key(&AuraModeNum::Static));
+        let e = m.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(e.len(), 2);
+        assert_eq!(e[0].zone, AuraZone::Key1);
+        assert_eq!(e[1].zone, AuraZone::Key2);
+    }
+
+    #[test]
+    #[ignore = "Unable to run in CI as the HIDRAW device is required"]
+    // TODO: use sim device
+    fn next_mode_create_multizone_if_no_config() {
+        // Checking to ensure set_mode errors when unsupported modes are tried
+        let config = AuraConfig::new("19b6");
+        let supported_basic_modes = LedSupportData {
+            device_name: String::new(),
+            product_id: String::new(),
+            layout_name: "ga401".to_owned(),
+            basic_modes: vec![AuraModeNum::Static],
+            basic_zones: vec![AuraZone::Key1, AuraZone::Key2],
+            advanced_type: rog_aura::keyboard::AdvancedAuraType::None,
+            power_zones: vec![PowerZones::Keyboard, PowerZones::RearGlow],
+        };
+        let mut controller = CtrlKbdLed {
+            led_type: AuraDeviceType::LaptopPost2021,
+            led_node: LEDNode::Rog(KeyboardLed::default(), HidRaw::new("19b6").unwrap()),
+            supported_data: supported_basic_modes,
+            per_key_mode_active: false,
+            config,
+            dbus_path: OwnedObjectPath::default(),
+        };
+
+        assert!(controller.config.multizone.is_none());
+        controller.config.multizone_on = true;
+        // This is called in toggle_mode. It will error here because we have no
+        // keyboard node in tests.
+        assert_eq!(
+            controller
+                .write_current_config_mode()
+                .unwrap_err()
+                .to_string(),
+            "No supported Aura keyboard"
+        );
+        assert!(controller.config.multizone.is_some());
+
+        let m = controller.config.multizone.unwrap();
+        assert!(m.contains_key(&AuraModeNum::Static));
+        let e = m.get(&AuraModeNum::Static).unwrap();
+        assert_eq!(e.len(), 2);
+        assert_eq!(e[0].zone, AuraZone::Key1);
+        assert_eq!(e[1].zone, AuraZone::Key2);
+    }
+}

asusd/src/ctrl_aura/manager.rs

@@ -0,0 +1,187 @@
+// Plan:
+// - Manager has udev monitor on USB looking for ROG devices
+// - If a device is found, add it to watch
+// - Add it to Zbus server
+// - If udev sees device removed then remove the zbus path
+
+use std::collections::HashSet;
+
+use log::{debug, error, info, warn};
+use mio::{Events, Interest, Poll, Token};
+use rog_aura::AuraDeviceType;
+use rog_platform::hid_raw::HidRaw;
+use tokio::task::spawn_blocking;
+use udev::{Device, MonitorBuilder};
+use zbus::object_server::SignalContext;
+use zbus::zvariant::{ObjectPath, OwnedObjectPath};
+use zbus::Connection;
+
+use crate::ctrl_aura::controller::CtrlKbdLed;
+use crate::ctrl_aura::trait_impls::{CtrlAuraZbus, AURA_ZBUS_PATH};
+use crate::error::RogError;
+use crate::{CtrlTask, Reloadable};
+
+pub struct AuraManager {
+    _connection: Connection,
+}
+
+impl AuraManager {
+    pub async fn new(connection: Connection) -> Result<Self, RogError> {
+        let conn_copy = connection.clone();
+        let mut interfaces = HashSet::new();
+
+        // Do the initial keyboard detection:
+        let all = CtrlKbdLed::find_all()?;
+        for ctrl in all {
+            let path = ctrl.dbus_path.clone();
+            interfaces.insert(path.clone()); // ensure we record the initial stuff
+            let sig_ctx = CtrlAuraZbus::signal_context(&connection)?;
+            let sig_ctx2 = sig_ctx.clone();
+            let zbus = CtrlAuraZbus::new(ctrl, sig_ctx);
+            start_tasks(zbus, connection.clone(), sig_ctx2, path).await?;
+        }
+
+        let manager = Self {
+            _connection: connection,
+        };
+
+        // detect all plugged in aura devices (eventually)
+        // only USB devices are detected for here
+        spawn_blocking(move || {
+            let mut monitor = MonitorBuilder::new()?.match_subsystem("hidraw")?.listen()?;
+            let mut poll = Poll::new()?;
+            let mut events = Events::with_capacity(1024);
+            poll.registry()
+                .register(&mut monitor, Token(0), Interest::READABLE)?;
+
+            loop {
+                if poll.poll(&mut events, None).is_err() {
+                    continue;
+                }
+                for event in monitor.iter() {
+                    let parent = if let Some(parent) =
+                        event.parent_with_subsystem_devtype("usb", "usb_device")?
+                    {
+                        parent
+                    } else {
+                        continue;
+                    };
+
+                    let action = if let Some(action) = event.action() {
+                        action
+                    } else {
+                        continue;
+                    };
+
+                    let id_product = if let Some(id_product) = parent.attribute_value("idProduct") {
+                        id_product.to_string_lossy()
+                    } else {
+                        continue;
+                    };
+
+                    let path = if let Some(path) = dbus_path_for_dev(&parent) {
+                        path
+                    } else {
+                        continue;
+                    };
+
+                    let aura_device = AuraDeviceType::from(&*id_product);
+                    if aura_device == AuraDeviceType::Unknown {
+                        warn!("idProduct:{id_product:?} is unknown, not using");
+                        continue;
+                    }
+
+                    if action == "remove" {
+                        if interfaces.remove(&path) {
+                            info!("AuraManager removing: {path:?}");
+                            let conn_copy = conn_copy.clone();
+                            tokio::spawn(async move {
+                                let res = conn_copy
+                                    .object_server()
+                                    .remove::<CtrlAuraZbus, _>(&path)
+                                    .await
+                                    .map_err(|e| {
+                                        error!("Failed to remove {path:?}, {e:?}");
+                                        e
+                                    })?;
+                                info!("AuraManager removed: {path:?}, {res}");
+                                Ok::<(), RogError>(())
+                            });
+                        }
+                    } else if action == "add" {
+                        if interfaces.contains(&path) {
+                            debug!("Already a ctrl at {path:?}");
+                            continue;
+                        }
+
+                        // Need to check the driver is asus to prevent using hid_generic
+                        if let Some(p2) = event.parent() {
+                            if let Some(driver) = p2.driver() {
+                                // There is a tree of devices added so filter by driver
+                                if driver != "asus" {
+                                    debug!("{id_product:?} driver was not asus, skipping");
+                                    continue;
+                                }
+                            } else {
+                                continue;
+                            }
+                        }
+
+                        if let Some(dev_node) = event.devnode() {
+                            if let Ok(raw) = HidRaw::from_device(event.device())
+                                .map_err(|e| error!("device path error: {e:?}"))
+                            {
+                                if let Ok(mut ctrl) = CtrlKbdLed::from_hidraw(raw, path.clone()) {
+                                    ctrl.config = CtrlKbdLed::init_config(&id_product);
+                                    interfaces.insert(path.clone());
+                                    info!("AuraManager starting device at: {dev_node:?}, {path:?}");
+                                    let sig_ctx = CtrlAuraZbus::signal_context(&conn_copy)?;
+                                    let zbus = CtrlAuraZbus::new(ctrl, sig_ctx);
+                                    let sig_ctx = CtrlAuraZbus::signal_context(&conn_copy)?;
+                                    let conn_copy = conn_copy.clone();
+                                    tokio::spawn(async move {
+                                        start_tasks(zbus, conn_copy.clone(), sig_ctx, path).await
+                                    });
+                                }
+                            }
+                        }
+                    };
+                }
+            }
+            // Required for return type on spawn
+            #[allow(unreachable_code)]
+            Ok::<(), RogError>(())
+        });
+        Ok(manager)
+    }
+}
+
+pub(crate) fn dbus_path_for_dev(parent: &Device) -> Option<OwnedObjectPath> {
+    if let Some(filename) = super::filename_partial(parent) {
+        return Some(
+            ObjectPath::from_str_unchecked(&format!("{AURA_ZBUS_PATH}/{filename}")).into(),
+        );
+    }
+    None
+}
+
+pub(crate) fn dbus_path_for_tuf() -> OwnedObjectPath {
+    ObjectPath::from_str_unchecked(&format!("{AURA_ZBUS_PATH}/tuf")).into()
+}
+
+async fn start_tasks(
+    mut zbus: CtrlAuraZbus,
+    connection: Connection,
+    _signal_ctx: SignalContext<'static>,
+    path: OwnedObjectPath,
+) -> Result<(), RogError> {
+    // let task = zbus.clone();
+    // let signal_ctx = signal_ctx.clone();
+    zbus.reload()
+        .await
+        .unwrap_or_else(|err| warn!("Controller error: {}", err));
+    connection.object_server().at(path, zbus).await.unwrap();
+    // TODO: skip this until we keep handles to tasks so they can be killed
+    // task.create_tasks(signal_ctx).await
+    Ok(())
+}

asusd/src/ctrl_aura/mod.rs

@@ -0,0 +1,29 @@
+use udev::Device;
+use zbus::zvariant::{ObjectPath, OwnedObjectPath};
+
+pub mod config;
+pub mod controller;
+pub mod manager;
+/// Implements `CtrlTask`, `Reloadable`, `ZbusRun`
+pub mod trait_impls;
+
+/// Returns only the Device details concatenated in a form usable for
+/// adding/appending to a filename
+pub(super) fn filename_partial(parent: &Device) -> Option<OwnedObjectPath> {
+    if let Some(id_product) = parent.attribute_value("idProduct") {
+        let id_product = id_product.to_string_lossy();
+        let path = if let Some(devnum) = parent.attribute_value("devnum") {
+            let devnum = devnum.to_string_lossy();
+            if let Some(devpath) = parent.attribute_value("devpath") {
+                let devpath = devpath.to_string_lossy();
+                format!("{id_product}_{devnum}_{devpath}")
+            } else {
+                format!("{id_product}_{devnum}")
+            }
+        } else {
+            format!("{id_product}")
+        };
+        return Some(ObjectPath::from_str_unchecked(&path).into());
+    }
+    None
+}

asusd/src/ctrl_aura/trait_impls.rs

@@ -0,0 +1,295 @@
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use config_traits::StdConfig;
+use log::{debug, error, info, warn};
+use rog_aura::keyboard::{LaptopAuraPower, UsbPackets};
+use rog_aura::{AuraDeviceType, AuraEffect, AuraModeNum, AuraZone, LedBrightness, PowerZones};
+use zbus::export::futures_util::lock::{Mutex, MutexGuard};
+use zbus::export::futures_util::StreamExt;
+use zbus::fdo::Error as ZbErr;
+use zbus::{interface, SignalContext};
+
+use super::controller::CtrlKbdLed;
+use crate::error::RogError;
+use crate::CtrlTask;
+
+pub const AURA_ZBUS_NAME: &str = "Aura";
+pub const AURA_ZBUS_PATH: &str = "/org/asuslinux";
+
+#[derive(Clone)]
+pub struct CtrlAuraZbus(Arc<Mutex<CtrlKbdLed>>, SignalContext<'static>);
+
+impl CtrlAuraZbus {
+    pub fn new(controller: CtrlKbdLed, signal: SignalContext<'static>) -> Self {
+        Self(Arc::new(Mutex::new(controller)), signal)
+    }
+
+    fn update_config(lock: &mut CtrlKbdLed) -> Result<(), RogError> {
+        let bright = lock.led_node.get_brightness()?;
+        lock.config.read();
+        lock.config.brightness = bright.into();
+        lock.config.write();
+        Ok(())
+    }
+}
+
+/// The main interface for changing, reading, or notfying
+///
+/// LED commands are split between Brightness, Modes, Per-Key
+#[interface(name = "org.asuslinux.Aura")]
+impl CtrlAuraZbus {
+    /// Return the device type for this Aura keyboard
+    #[zbus(property)]
+    async fn device_type(&self) -> AuraDeviceType {
+        let ctrl = self.0.lock().await;
+        ctrl.led_type
+    }
+
+    /// Return the current LED brightness
+    #[zbus(property)]
+    async fn brightness(&self) -> Result<LedBrightness, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.led_node.get_brightness().map(|n| n.into())?)
+    }
+
+    /// Set the keyboard brightness level (0-3)
+    #[zbus(property)]
+    async fn set_brightness(&mut self, brightness: LedBrightness) -> Result<(), ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.led_node.set_brightness(brightness.into())?)
+    }
+
+    /// Total levels of brightness available
+    #[zbus(property)]
+    async fn supported_brightness(&self) -> Vec<LedBrightness> {
+        vec![
+            LedBrightness::Off,
+            LedBrightness::Low,
+            LedBrightness::Med,
+            LedBrightness::High,
+        ]
+    }
+
+    /// The total available modes
+    #[zbus(property)]
+    async fn supported_basic_modes(&self) -> Result<Vec<AuraModeNum>, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.config.builtins.keys().cloned().collect())
+    }
+
+    #[zbus(property)]
+    async fn supported_basic_zones(&self) -> Result<Vec<AuraZone>, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.supported_data.basic_zones.clone())
+    }
+
+    #[zbus(property)]
+    async fn supported_power_zones(&self) -> Result<Vec<PowerZones>, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.supported_data.power_zones.clone())
+    }
+
+    /// The current mode data
+    #[zbus(property)]
+    async fn led_mode(&self) -> Result<AuraModeNum, ZbErr> {
+        let ctrl = self.0.lock().await;
+        Ok(ctrl.config.current_mode)
+    }
+
+    /// Set an Aura effect if the effect mode or zone is supported.
+    ///
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
+    #[zbus(property)]
+    async fn set_led_mode(&mut self, num: AuraModeNum) -> Result<(), ZbErr> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.config.current_mode = num;
+        ctrl.write_current_config_mode()?;
+        if ctrl.config.brightness == LedBrightness::Off {
+            ctrl.config.brightness = LedBrightness::Med;
+        }
+        ctrl.led_node
+            .set_brightness(ctrl.config.brightness.into())?;
+        ctrl.config.write();
+
+        self.led_mode_data_invalidate(&self.1).await.ok();
+        Ok(())
+    }
+
+    /// The current mode data
+    #[zbus(property)]
+    async fn led_mode_data(&self) -> Result<AuraEffect, ZbErr> {
+        let ctrl = self.0.lock().await;
+        let mode = ctrl.config.current_mode;
+        match ctrl.config.builtins.get(&mode) {
+            Some(effect) => Ok(effect.clone()),
+            None => Err(ZbErr::Failed("Could not get the current effect".into())),
+        }
+    }
+
+    /// Set an Aura effect if the effect mode or zone is supported.
+    ///
+    /// On success the aura config file is read to refresh cached values, then
+    /// the effect is stored and config written to disk.
+    #[zbus(property)]
+    async fn set_led_mode_data(&mut self, effect: AuraEffect) -> Result<(), ZbErr> {
+        let mut ctrl = self.0.lock().await;
+        if !ctrl.supported_data.basic_modes.contains(&effect.mode)
+            || effect.zone != AuraZone::None
+                && !ctrl.supported_data.basic_zones.contains(&effect.zone)
+        {
+            return Err(ZbErr::NotSupported(format!(
+                "The Aura effect is not supported: {effect:?}"
+            )));
+        }
+
+        ctrl.write_mode(&effect)?;
+        if ctrl.config.brightness == LedBrightness::Off {
+            ctrl.config.brightness = LedBrightness::Med;
+        }
+        ctrl.led_node
+            .set_brightness(ctrl.config.brightness.into())?;
+        ctrl.config.set_builtin(effect);
+        ctrl.config.write();
+
+        self.led_mode_invalidate(&self.1).await.ok();
+        Ok(())
+    }
+
+    /// Get the data set for every mode available
+    async fn all_mode_data(&self) -> BTreeMap<AuraModeNum, AuraEffect> {
+        let ctrl = self.0.lock().await;
+        ctrl.config.builtins.clone()
+    }
+
+    // As property doesn't work for AuraPowerDev (complexity of serialization?)
+    #[zbus(property)]
+    async fn led_power(&self) -> LaptopAuraPower {
+        let ctrl = self.0.lock().await;
+        ctrl.config.enabled.clone()
+    }
+
+    /// Set a variety of states, input is array of enum.
+    /// `enabled` sets if the sent array should be disabled or enabled
+    ///
+    /// For Modern ROG devices the "enabled" flag is ignored.
+    #[zbus(property)]
+    async fn set_led_power(&mut self, options: LaptopAuraPower) -> Result<(), ZbErr> {
+        let mut ctrl = self.0.lock().await;
+        for opt in options.states {
+            let zone = opt.zone;
+            for config in ctrl.config.enabled.states.iter_mut() {
+                if config.zone == zone {
+                    *config = opt;
+                }
+            }
+        }
+        ctrl.config.write();
+        Ok(ctrl.set_power_states().map_err(|e| {
+            warn!("{}", e);
+            e
+        })?)
+    }
+
+    /// On machine that have some form of either per-key keyboard or per-zone
+    /// this can be used to write custom effects over dbus. The input is a
+    /// nested `Vec<Vec<8>>` where `Vec<u8>` is a raw USB packet
+    async fn direct_addressing_raw(&self, data: UsbPackets) -> Result<(), ZbErr> {
+        let mut ctrl = self.0.lock().await;
+        ctrl.write_effect_block(&data)?;
+        Ok(())
+    }
+}
+
+impl CtrlTask for CtrlAuraZbus {
+    fn zbus_path() -> &'static str {
+        "/org/asuslinux"
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        let load_save =
+            |start: bool, mut lock: MutexGuard<'_, CtrlKbdLed>| -> Result<(), RogError> {
+                // If waking up
+                if !start {
+                    info!("CtrlKbdLedTask reloading brightness and modes");
+                    lock.led_node
+                        .set_brightness(lock.config.brightness.into())
+                        .map_err(|e| {
+                            error!("CtrlKbdLedTask: {e}");
+                            e
+                        })?;
+                    lock.write_current_config_mode().map_err(|e| {
+                        error!("CtrlKbdLedTask: {e}");
+                        e
+                    })?;
+                } else if start {
+                    Self::update_config(&mut lock).map_err(|e| {
+                        error!("CtrlKbdLedTask: {e}");
+                        e
+                    })?;
+                }
+                Ok(())
+            };
+
+        let inner1 = self.0.clone();
+        let inner3 = self.0.clone();
+        self.create_sys_event_tasks(
+            move |sleeping| {
+                let inner1 = inner1.clone();
+                async move {
+                    let lock = inner1.lock().await;
+                    load_save(sleeping, lock).unwrap(); // unwrap as we want to
+                                                        // bomb out of the task
+                }
+            },
+            move |_shutting_down| {
+                let inner3 = inner3.clone();
+                async move {
+                    let lock = inner3.lock().await;
+                    load_save(false, lock).unwrap(); // unwrap as we want to
+                                                     // bomb out of the task
+                }
+            },
+            move |_lid_closed| {
+                // on lid change
+                async move {}
+            },
+            move |_power_plugged| {
+                // power change
+                async move {}
+            },
+        )
+        .await;
+
+        let ctrl2 = self.0.clone();
+        let ctrl = self.0.lock().await;
+        let watch = ctrl.led_node.monitor_brightness()?;
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            watch
+                .into_event_stream(&mut buffer)
+                .unwrap()
+                .for_each(|_| async {
+                    if let Some(lock) = ctrl2.try_lock() {
+                        load_save(true, lock).unwrap(); // unwrap as we want to
+                                                        // bomb out of the task
+                    }
+                })
+                .await;
+        });
+
+        Ok(())
+    }
+}
+
+impl crate::Reloadable for CtrlAuraZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let mut ctrl = self.0.lock().await;
+        debug!("reloading keyboard mode");
+        ctrl.write_current_config_mode()?;
+        debug!("reloading power states");
+        ctrl.set_power_states().map_err(|err| warn!("{err}")).ok();
+        Ok(())
+    }
+}

asusd/src/ctrl_fancurves.rs

@@ -0,0 +1,286 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use futures_lite::StreamExt;
+use log::{debug, error, info, warn};
+use rog_platform::platform::{RogPlatform, ThrottlePolicy};
+use rog_profiles::error::ProfileError;
+use rog_profiles::fan_curve_set::CurveData;
+use rog_profiles::{find_fan_curve_node, FanCurvePU, FanCurveProfiles};
+use serde_derive::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+use zbus::{interface, Connection, SignalContext};
+
+use crate::error::RogError;
+use crate::{CtrlTask, CONFIG_PATH_BASE};
+
+pub const FAN_CURVE_ZBUS_NAME: &str = "FanCurves";
+pub const FAN_CURVE_ZBUS_PATH: &str = "/org/asuslinux";
+
+#[derive(Deserialize, Serialize, Debug, Default)]
+pub struct FanCurveConfig {
+    pub profiles: FanCurveProfiles,
+    #[serde(skip)]
+    pub current: u8,
+}
+
+impl StdConfig for FanCurveConfig {
+    /// Create a new config. The defaults are zeroed so the device must be read
+    /// to get the actual device defaults.
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        "fan_curves.ron".to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        PathBuf::from(CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for FanCurveConfig {}
+
+#[derive(Debug, Clone)]
+pub struct CtrlFanCurveZbus {
+    config: Arc<Mutex<FanCurveConfig>>,
+    platform: RogPlatform,
+}
+
+// Non-zbus-derive impl
+impl CtrlFanCurveZbus {
+    pub fn new() -> Result<Self, RogError> {
+        let platform = RogPlatform::new()?;
+        if platform.has_throttle_thermal_policy() {
+            info!("Device has profile control available");
+            find_fan_curve_node()?;
+            info!("Device has fan curves available");
+            let mut config = FanCurveConfig::new().load();
+            let mut fan_curves = FanCurveProfiles::default();
+
+            // Only do defaults if the config doesn't already exist\
+            if config.profiles.balanced.is_empty() || !config.file_path().exists() {
+                info!("Fetching default fan curves");
+
+                let current = platform.get_throttle_thermal_policy()?;
+                for this in [
+                    ThrottlePolicy::Balanced,
+                    ThrottlePolicy::Performance,
+                    ThrottlePolicy::Quiet,
+                ] {
+                    // For each profile we need to switch to it before we
+                    // can read the existing values from hardware. The ACPI method used
+                    // for this is what limits us.
+                    platform.set_throttle_thermal_policy(this.into())?;
+                    let mut dev = find_fan_curve_node()?;
+                    fan_curves.set_active_curve_to_defaults(this, &mut dev)?;
+
+                    info!("{this:?}:");
+                    for curve in fan_curves.get_fan_curves_for(this) {
+                        info!("{}", String::from(curve));
+                    }
+                }
+                platform.set_throttle_thermal_policy(current)?;
+                config.profiles = fan_curves;
+                config.write();
+            } else {
+                info!("Fan curves previously stored, loading...");
+                config = config.load();
+            }
+
+            return Ok(Self {
+                config: Arc::new(Mutex::new(config)),
+                platform,
+            });
+        }
+
+        Err(ProfileError::NotSupported.into())
+    }
+}
+
+#[interface(name = "org.asuslinux.FanCurves")]
+impl CtrlFanCurveZbus {
+    /// Set all fan curves for a profile to enabled status. Will also activate a
+    /// fan curve if in the same profile mode
+    async fn set_fan_curves_enabled(
+        &mut self,
+        profile: ThrottlePolicy,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_profile_curves_enabled(profile, enabled);
+        self.config
+            .lock()
+            .await
+            .profiles
+            .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Set a single fan curve for a profile to enabled status. Will also
+    /// activate a fan curve if in the same profile mode
+    async fn set_profile_fan_curve_enabled(
+        &mut self,
+        profile: ThrottlePolicy,
+        fan: FanCurvePU,
+        enabled: bool,
+    ) -> zbus::fdo::Result<()> {
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_profile_fan_curve_enabled(profile, fan, enabled);
+        self.config
+            .lock()
+            .await
+            .profiles
+            .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Get the fan-curve data for the currently active ThrottlePolicy
+    async fn fan_curve_data(
+        &mut self,
+        profile: ThrottlePolicy,
+    ) -> zbus::fdo::Result<Vec<CurveData>> {
+        let curve = self
+            .config
+            .lock()
+            .await
+            .profiles
+            .get_fan_curves_for(profile)
+            .to_vec();
+        Ok(curve)
+    }
+
+    /// Set the fan curve for the specified profile.
+    /// Will also activate the fan curve if the user is in the same mode.
+    async fn set_fan_curve(
+        &mut self,
+        profile: ThrottlePolicy,
+        curve: CurveData,
+    ) -> zbus::fdo::Result<()> {
+        self.config
+            .lock()
+            .await
+            .profiles
+            .save_fan_curve(curve, profile)?;
+        let active: ThrottlePolicy = self.platform.get_throttle_thermal_policy()?.into();
+        if active == profile {
+            self.config
+                .lock()
+                .await
+                .profiles
+                .write_profile_curve_to_platform(profile, &mut find_fan_curve_node()?)?;
+        }
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Reset the stored (self) and device curves to the defaults of the
+    /// platform.
+    ///
+    /// Each platform_profile has a different default and the default can be
+    /// read only for the currently active profile.
+    async fn set_curves_to_defaults(&mut self, profile: ThrottlePolicy) -> zbus::fdo::Result<()> {
+        let active = self.platform.get_throttle_thermal_policy()?;
+        self.platform.set_throttle_thermal_policy(profile.into())?;
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_active_curve_to_defaults(profile, &mut find_fan_curve_node()?)?;
+        self.platform.set_throttle_thermal_policy(active)?;
+        self.config.lock().await.write();
+        Ok(())
+    }
+
+    /// Reset the stored (self) and device curve to the defaults of the
+    /// platform.
+    ///
+    /// Each platform_profile has a different default and the defualt can be
+    /// read only for the currently active profile.
+    async fn reset_profile_curves(&self, profile: ThrottlePolicy) -> zbus::fdo::Result<()> {
+        let active = self.platform.get_throttle_thermal_policy()?;
+
+        self.platform.set_throttle_thermal_policy(profile.into())?;
+        self.config
+            .lock()
+            .await
+            .profiles
+            .set_active_curve_to_defaults(active.into(), &mut find_fan_curve_node()?)?;
+        self.platform.set_throttle_thermal_policy(active)?;
+
+        self.config.lock().await.write();
+        Ok(())
+    }
+}
+
+impl crate::ZbusRun for CtrlFanCurveZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, FAN_CURVE_ZBUS_PATH, server).await;
+    }
+}
+
+impl CtrlTask for CtrlFanCurveZbus {
+    fn zbus_path() -> &'static str {
+        FAN_CURVE_ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _signal_ctxt: SignalContext<'static>) -> Result<(), RogError> {
+        let watch_throttle_thermal_policy = self.platform.monitor_throttle_thermal_policy()?;
+        let platform = self.platform.clone();
+        let config = self.config.clone();
+        let fan_curves = self.config.clone();
+
+        tokio::spawn(async move {
+            let mut buffer = [0; 32];
+            if let Ok(mut stream) = watch_throttle_thermal_policy.into_event_stream(&mut buffer) {
+                while (stream.next().await).is_some() {
+                    debug!("watch_throttle_thermal_policy changed");
+                    if let Ok(profile) = platform.get_throttle_thermal_policy().map_err(|e| {
+                        error!("get_throttle_thermal_policy error: {e}");
+                    }) {
+                        if profile != config.lock().await.current {
+                            fan_curves
+                                .lock()
+                                .await
+                                .profiles
+                                .write_profile_curve_to_platform(
+                                    profile.into(),
+                                    &mut find_fan_curve_node().unwrap(),
+                                )
+                                .map_err(|e| warn!("write_profile_curve_to_platform, {}", e))
+                                .ok();
+                            config.lock().await.current = profile;
+                        }
+                    }
+                }
+            }
+        });
+
+        Ok(())
+    }
+}
+
+impl crate::Reloadable for CtrlFanCurveZbus {
+    /// Fetch the active profile and use that to set all related components up
+    async fn reload(&mut self) -> Result<(), RogError> {
+        let active = self.platform.get_throttle_thermal_policy()?.into();
+        let mut config = self.config.lock().await;
+        if let Ok(mut device) = find_fan_curve_node() {
+            config
+                .profiles
+                .write_profile_curve_to_platform(active, &mut device)?;
+        }
+
+        Ok(())
+    }
+}

asusd/src/ctrl_slash/config.rs

@@ -0,0 +1,51 @@
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_slash::{DeviceState, SlashMode};
+use serde_derive::{Deserialize, Serialize};
+
+const CONFIG_FILE: &str = "slash.ron";
+
+/// Config for base system actions for the anime display
+#[derive(Deserialize, Serialize, Debug)]
+pub struct SlashConfig {
+    pub slash_enabled: bool,
+    pub slash_brightness: u8,
+    pub slash_interval: u8,
+    pub slash_mode: SlashMode,
+}
+
+impl Default for SlashConfig {
+    fn default() -> Self {
+        SlashConfig {
+            slash_enabled: true,
+            slash_brightness: 255,
+            slash_interval: 0,
+            slash_mode: SlashMode::Bounce,
+        }
+    }
+}
+impl StdConfig for SlashConfig {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn file_name(&self) -> String {
+        CONFIG_FILE.to_owned()
+    }
+
+    fn config_dir() -> std::path::PathBuf {
+        std::path::PathBuf::from(crate::CONFIG_PATH_BASE)
+    }
+}
+
+impl StdConfigLoad for SlashConfig {}
+
+impl From<&SlashConfig> for DeviceState {
+    fn from(config: &SlashConfig) -> Self {
+        DeviceState {
+            slash_enabled: config.slash_enabled,
+            slash_brightness: config.slash_brightness,
+            slash_interval: config.slash_interval,
+            slash_mode: config.slash_mode,
+        }
+    }
+}

asusd/src/ctrl_slash/mod.rs

@@ -0,0 +1,98 @@
+pub mod config;
+pub mod trait_impls;
+
+use config_traits::{StdConfig, StdConfigLoad};
+use rog_platform::hid_raw::HidRaw;
+use rog_platform::usb_raw::USBRaw;
+use rog_slash::error::SlashError;
+use rog_slash::usb::{get_slash_type, pkt_set_mode, pkt_set_options, pkts_for_init};
+use rog_slash::{SlashMode, SlashType};
+
+use crate::ctrl_slash::config::SlashConfig;
+use crate::error::RogError;
+
+enum Node {
+    Usb(USBRaw),
+    Hid(HidRaw),
+}
+
+impl Node {
+    pub fn write_bytes(&self, message: &[u8]) -> Result<(), RogError> {
+        // TODO: map and pass on errors
+        match self {
+            Node::Usb(u) => {
+                u.write_bytes(message).ok();
+            }
+            Node::Hid(h) => {
+                h.write_bytes(message).ok();
+            }
+        }
+        Ok(())
+    }
+}
+
+pub struct CtrlSlash {
+    node: Node,
+    config: SlashConfig,
+}
+
+impl CtrlSlash {
+    #[inline]
+    pub fn new() -> Result<CtrlSlash, RogError> {
+        let slash_type = get_slash_type()?;
+        if matches!(slash_type, SlashType::Unknown | SlashType::Unsupported) {
+            return Err(RogError::Slash(SlashError::NoDevice));
+        }
+
+        let usb = USBRaw::new(rog_slash::usb::PROD_ID).ok();
+        let hid = HidRaw::new(rog_slash::usb::PROD_ID_STR).ok();
+        let node = if usb.is_some() {
+            unsafe { Node::Usb(usb.unwrap_unchecked()) }
+        } else if hid.is_some() {
+            unsafe { Node::Hid(hid.unwrap_unchecked()) }
+        } else {
+            return Err(RogError::NotSupported);
+        };
+
+        let ctrl = CtrlSlash {
+            node,
+            config: SlashConfig::new().load(),
+        };
+        ctrl.do_initialization()?;
+
+        Ok(ctrl)
+    }
+
+    fn do_initialization(&self) -> Result<(), RogError> {
+        let init_packets = pkts_for_init();
+        self.node.write_bytes(&init_packets[0])?;
+        self.node.write_bytes(&init_packets[1])?;
+
+        // Apply config upon initialization
+        let option_packets = pkt_set_options(
+            self.config.slash_enabled,
+            self.config.slash_brightness,
+            self.config.slash_interval,
+        );
+        self.node.write_bytes(&option_packets)?;
+
+        let mode_packets = pkt_set_mode(self.config.slash_mode);
+        self.node.write_bytes(&mode_packets[0])?;
+        self.node.write_bytes(&mode_packets[1])?;
+
+        Ok(())
+    }
+
+    pub fn set_options(&self, enabled: bool, brightness: u8, interval: u8) -> Result<(), RogError> {
+        let command_packets = pkt_set_options(enabled, brightness, interval);
+        self.node.write_bytes(&command_packets)?;
+        Ok(())
+    }
+
+    pub fn set_slash_mode(&self, slash_mode: SlashMode) -> Result<(), RogError> {
+        let command_packets = pkt_set_mode(slash_mode);
+        self.node.write_bytes(&command_packets[0])?;
+        self.node.write_bytes(&command_packets[1])?;
+        Ok(())
+    }
+}

asusd/src/ctrl_slash/trait_impls.rs

@@ -0,0 +1,161 @@
+use std::sync::Arc;
+
+use config_traits::StdConfig;
+use log::warn;
+use rog_slash::usb::{pkt_set_mode, pkt_set_options};
+use rog_slash::{DeviceState, SlashMode};
+use zbus::export::futures_util::lock::Mutex;
+use zbus::{interface, Connection, SignalContext};
+
+use crate::ctrl_slash::CtrlSlash;
+use crate::error::RogError;
+
+pub const SLASH_ZBUS_NAME: &str = "Slash";
+pub const SLASH_ZBUS_PATH: &str = "/org/asuslinux";
+
+#[derive(Clone)]
+pub struct CtrlSlashZbus(pub Arc<Mutex<CtrlSlash>>);
+
+/// The struct with the main dbus methods requires this trait
+impl crate::ZbusRun for CtrlSlashZbus {
+    async fn add_to_server(self, server: &mut Connection) {
+        Self::add_to_server_helper(self, SLASH_ZBUS_PATH, server).await;
+    }
+}
+
+#[interface(name = "org.asuslinux.Slash")]
+impl CtrlSlashZbus {
+    /// Get enabled or not
+    #[zbus(property)]
+    async fn enabled(&self) -> bool {
+        let lock = self.0.lock().await;
+        lock.config.slash_enabled
+    }
+
+    /// Set enabled true or false
+    async fn set_enabled(&self, enabled: bool) {
+        let mut lock = self.0.lock().await;
+        let brightness = if enabled && lock.config.slash_brightness == 0 {
+            0x88
+        } else {
+            lock.config.slash_brightness
+        };
+        lock.node
+            .write_bytes(&pkt_set_options(
+                enabled,
+                brightness,
+                lock.config.slash_interval,
+            ))
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        lock.config.slash_enabled = enabled;
+        lock.config.slash_brightness = brightness;
+        lock.config.write();
+    }
+
+    /// Get brightness level
+    #[zbus(property)]
+    async fn brightness(&self) -> u8 {
+        let lock = self.0.lock().await;
+        lock.config.slash_brightness
+    }
+
+    /// Set brightness level
+    async fn set_brightness(&self, brightness: u8) {
+        let mut lock = self.0.lock().await;
+        let enabled = brightness > 0;
+        lock.node
+            .write_bytes(&pkt_set_options(
+                enabled,
+                brightness,
+                lock.config.slash_interval,
+            ))
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        lock.config.slash_enabled = enabled;
+        lock.config.slash_brightness = brightness;
+        lock.config.write();
+    }
+
+    #[zbus(property)]
+    async fn interval(&self) -> u8 {
+        let lock = self.0.lock().await;
+        lock.config.slash_interval
+    }
+
+    /// Set interval between slash animations (0-255)
+    async fn set_interval(&self, interval: u8) {
+        let mut lock = self.0.lock().await;
+        lock.node
+            .write_bytes(&pkt_set_options(
+                lock.config.slash_enabled,
+                lock.config.slash_brightness,
+                interval,
+            ))
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        lock.config.slash_interval = interval;
+        lock.config.write();
+    }
+
+    #[zbus(property)]
+    async fn slash_mode(&self) -> u8 {
+        let lock = self.0.lock().await;
+        lock.config.slash_interval
+    }
+
+    /// Set interval between slash animations (0-255)
+    async fn set_slash_mode(&self, slash_mode: SlashMode) {
+        let mut lock = self.0.lock().await;
+
+        let command_packets = pkt_set_mode(slash_mode);
+
+        lock.node
+            .write_bytes(&command_packets[0])
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+        lock.node
+            .write_bytes(&command_packets[1])
+            .map_err(|err| {
+                warn!("ctrl_slash::set_options {}", err);
+            })
+            .ok();
+
+        lock.config.slash_mode = slash_mode;
+        lock.config.write();
+    }
+
+    /// Get the device state as stored by asusd
+    // #[zbus(property)]
+    async fn device_state(&self) -> DeviceState {
+        let lock = self.0.lock().await;
+        DeviceState::from(&lock.config)
+    }
+}
+
+impl crate::CtrlTask for CtrlSlashZbus {
+    fn zbus_path() -> &'static str {
+        SLASH_ZBUS_PATH
+    }
+
+    async fn create_tasks(&self, _: SignalContext<'static>) -> Result<(), RogError> {
+        Ok(())
+    }
+}
+
+impl crate::Reloadable for CtrlSlashZbus {
+    async fn reload(&mut self) -> Result<(), RogError> {
+        Ok(())
+    }
+}

asusd/src/daemon.rs

@@ -0,0 +1,134 @@
+use std::env;
+use std::error::Error;
+use std::sync::Arc;
+
+use ::zbus::export::futures_util::lock::Mutex;
+use ::zbus::Connection;
+use asusd::config::Config;
+use asusd::ctrl_anime::trait_impls::CtrlAnimeZbus;
+use asusd::ctrl_anime::CtrlAnime;
+use asusd::ctrl_aura::manager::AuraManager;
+use asusd::ctrl_fancurves::CtrlFanCurveZbus;
+use asusd::ctrl_platform::CtrlPlatform;
+use asusd::ctrl_slash::trait_impls::CtrlSlashZbus;
+use asusd::ctrl_slash::CtrlSlash;
+use asusd::{print_board_info, start_tasks, CtrlTask, DBUS_NAME};
+use config_traits::{StdConfig, StdConfigLoad3};
+use log::{error, info};
+use zbus::fdo::ObjectManager;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // console_subscriber::init();
+    let mut logger = env_logger::Builder::new();
+    logger
+        .parse_default_env()
+        .target(env_logger::Target::Stdout)
+        .format_timestamp(None)
+        .init();
+
+    let is_service = match env::var_os("IS_SERVICE") {
+        Some(val) => val == "1",
+        None => false,
+    };
+
+    if !is_service {
+        println!("asusd schould be only run from the right systemd service");
+        println!(
+            "do not run in your terminal, if you need an logs please use journalctl -b -u asusd"
+        );
+        println!("asusd will now exit");
+        return Ok(());
+    }
+
+    info!("       daemon v{}", asusd::VERSION);
+    info!("    rog-anime v{}", rog_anime::VERSION);
+    info!("    rog-slash v{}", rog_slash::VERSION);
+    info!("     rog-aura v{}", rog_aura::VERSION);
+    info!(" rog-profiles v{}", rog_profiles::VERSION);
+    info!("rog-platform v{}", rog_platform::VERSION);
+
+    start_daemon().await?;
+    Ok(())
+}
+
+/// The actual main loop for the daemon
+async fn start_daemon() -> Result<(), Box<dyn Error>> {
+    // let supported = SupportedFunctions::get_supported();
+    print_board_info();
+    // println!("{:?}", supported.supported_functions());
+
+    // Start zbus server
+    let mut connection = Connection::system().await?;
+    connection
+        .object_server()
+        .at("/org/asuslinux", ObjectManager)
+        .await
+        .unwrap();
+
+    let config = Config::new().load();
+    let cfg_path = config.file_path();
+    let config = Arc::new(Mutex::new(config));
+
+    // supported.add_to_server(&mut connection).await;
+
+    match CtrlFanCurveZbus::new() {
+        Ok(ctrl) => {
+            let sig_ctx = CtrlFanCurveZbus::signal_context(&connection)?;
+            start_tasks(ctrl, &mut connection, sig_ctx).await?;
+        }
+        Err(err) => {
+            error!("FanCurves: {}", err);
+        }
+    }
+
+    match CtrlPlatform::new(
+        config.clone(),
+        &cfg_path,
+        CtrlPlatform::signal_context(&connection)?,
+    ) {
+        Ok(ctrl) => {
+            let sig_ctx = CtrlPlatform::signal_context(&connection)?;
+            start_tasks(ctrl, &mut connection, sig_ctx).await?;
+        }
+        Err(err) => {
+            error!("CtrlPlatform: {}", err);
+        }
+    }
+
+    match CtrlAnime::new() {
+        Ok(ctrl) => {
+            let zbus = CtrlAnimeZbus(Arc::new(Mutex::new(ctrl)));
+            let sig_ctx = CtrlAnimeZbus::signal_context(&connection)?;
+            start_tasks(zbus, &mut connection, sig_ctx).await?;
+        }
+        Err(err) => {
+            info!("AniMe control: {}", err);
+        }
+    }
+
+    match CtrlSlash::new() {
+        Ok(ctrl) => {
+            let zbus = CtrlSlashZbus(Arc::new(Mutex::new(ctrl)));
+            // Currently, the Slash has no need for a loop watching power events, however,
+            // it could be cool to have the slash do some power-on/off animation
+            // (It has a built-in power on animation which plays when u plug in the power
+            // supply)
+            let sig_ctx = CtrlSlashZbus::signal_context(&connection)?;
+            start_tasks(zbus, &mut connection, sig_ctx).await?;
+        }
+        Err(err) => {
+            info!("AniMe control: {}", err);
+        }
+    }
+
+    let _ = AuraManager::new(connection.clone()).await?;
+
+    // Request dbus name after finishing initalizing all functions
+    connection.request_name(DBUS_NAME).await?;
+
+    loop {
+        // This is just a blocker to idle and ensure the reator reacts
+        connection.executor().tick().await;
+    }
+}

asusd/src/error.rs

@@ -0,0 +1,144 @@
+use std::convert::From;
+use std::fmt;
+
+use config_traits::ron;
+use rog_anime::error::AnimeError;
+use rog_platform::error::PlatformError;
+use rog_profiles::error::ProfileError;
+use rog_slash::error::SlashError;
+
+#[derive(Debug)]
+pub enum RogError {
+    ParseVendor,
+    ParseLed,
+    MissingProfile(String),
+    Udev(String, std::io::Error),
+    Path(String, std::io::Error),
+    Read(String, std::io::Error),
+    Write(String, std::io::Error),
+    NotSupported,
+    NotFound(String),
+    DoTask(String),
+    MissingFunction(String),
+    MissingLedBrightNode(String, std::io::Error),
+    ReloadFail(String),
+    Profiles(ProfileError),
+    Initramfs(String),
+    Modprobe(String),
+    Io(std::io::Error),
+    Zbus(zbus::Error),
+    ChargeLimit(u8),
+    AuraEffectNotSupported,
+    NoAuraKeyboard,
+    NoAuraNode,
+    Anime(AnimeError),
+    Slash(SlashError),
+    Platform(PlatformError),
+    SystemdUnitAction(String),
+    SystemdUnitWaitTimeout(String),
+    Command(String, std::io::Error),
+    ParseRon(ron::Error),
+}
+
+impl fmt::Display for RogError {
+    // This trait requires `fmt` with this exact signature.
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RogError::ParseVendor => write!(f, "Parse gfx vendor error"),
+            RogError::ParseLed => write!(f, "Parse LED error"),
+            RogError::MissingProfile(profile) => write!(f, "Profile does not exist {}", profile),
+            RogError::Udev(deets, error) => write!(f, "udev {}: {}", deets, error),
+            RogError::Path(path, error) => write!(f, "Path {}: {}", path, error),
+            RogError::Read(path, error) => write!(f, "Read {}: {}", path, error),
+            RogError::Write(path, error) => write!(f, "Write {}: {}", path, error),
+            RogError::NotSupported => write!(f, "Not supported"),
+            RogError::NotFound(deets) => write!(f, "Not found: {}", deets),
+            RogError::DoTask(deets) => write!(f, "Task error: {}", deets),
+            RogError::MissingFunction(deets) => write!(f, "Missing functionality: {}", deets),
+            RogError::MissingLedBrightNode(path, error) => write!(
+                f,
+                "Led node at {} is missing, please check you have the required patch or dkms \
+                 module installed: {}",
+                path, error
+            ),
+            RogError::ReloadFail(deets) => write!(f, "Reload error: {}", deets),
+            RogError::Profiles(deets) => write!(f, "Profile error: {}", deets),
+            RogError::Initramfs(detail) => write!(f, "Initiramfs error: {}", detail),
+            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)
+            }
+            RogError::AuraEffectNotSupported => write!(f, "Aura effect not supported"),
+            RogError::NoAuraKeyboard => write!(f, "No supported Aura keyboard"),
+            RogError::NoAuraNode => write!(f, "No Aura keyboard node found"),
+            RogError::Anime(deets) => write!(f, "AniMe Matrix error: {}", deets),
+            RogError::Slash(deets) => write!(f, "Slash error: {}", deets),
+            RogError::Platform(deets) => write!(f, "Asus Platform error: {}", deets),
+            RogError::SystemdUnitAction(action) => {
+                write!(f, "systemd unit action {} failed", action)
+            }
+            RogError::SystemdUnitWaitTimeout(state) => {
+                write!(
+                    f,
+                    "Timed out waiting for systemd unit change {} state",
+                    state
+                )
+            }
+            RogError::Command(func, error) => write!(f, "Command exec error: {}: {}", func, error),
+            RogError::ParseRon(error) => write!(f, "Parse config error: {}", error),
+        }
+    }
+}
+
+impl std::error::Error for RogError {}
+
+impl From<ProfileError> for RogError {
+    fn from(err: ProfileError) -> Self {
+        RogError::Profiles(err)
+    }
+}
+
+impl From<AnimeError> for RogError {
+    fn from(err: AnimeError) -> Self {
+        RogError::Anime(err)
+    }
+}
+
+impl From<SlashError> for RogError {
+    fn from(err: SlashError) -> Self {
+        RogError::Slash(err)
+    }
+}
+
+impl From<PlatformError> for RogError {
+    fn from(err: PlatformError) -> Self {
+        RogError::Platform(err)
+    }
+}
+
+impl From<zbus::Error> for RogError {
+    fn from(err: zbus::Error) -> Self {
+        RogError::Zbus(err)
+    }
+}
+
+impl From<std::io::Error> for RogError {
+    fn from(err: std::io::Error) -> Self {
+        RogError::Io(err)
+    }
+}
+
+impl From<ron::Error> for RogError {
+    fn from(err: ron::Error) -> Self {
+        RogError::ParseRon(err)
+    }
+}
+
+impl From<RogError> for zbus::fdo::Error {
+    #[inline]
+    fn from(err: RogError) -> Self {
+        zbus::fdo::Error::Failed(format!("{}", err))
+    }
+}

asusd/src/lib.rs

@@ -0,0 +1,311 @@
+#![deny(unused_must_use)]
+/// Configuration loading, saving
+pub mod config;
+/// Control of anime matrix display
+pub mod ctrl_anime;
+/// Keyboard LED brightness control, RGB, and LED display modes
+pub mod ctrl_aura;
+/// Control platform profiles + fan-curves if available
+pub mod ctrl_fancurves;
+/// Control ASUS bios function such as boot sound, Optimus/Dedicated gfx mode
+pub mod ctrl_platform;
+/// Control of Slash led bar
+pub mod ctrl_slash;
+
+pub mod error;
+
+use std::future::Future;
+use std::time::Duration;
+
+use dmi_id::DMIID;
+use futures_lite::stream::StreamExt;
+use log::{debug, info, warn};
+use logind_zbus::manager::ManagerProxy;
+use tokio::time::sleep;
+use zbus::zvariant::ObjectPath;
+use zbus::{CacheProperties, Connection, SignalContext};
+
+use crate::error::RogError;
+
+const CONFIG_PATH_BASE: &str = "/etc/asusd/";
+pub static DBUS_NAME: &str = "org.asuslinux.Daemon";
+pub static DBUS_PATH: &str = "/org/asuslinux/Daemon";
+pub static DBUS_IFACE: &str = "org.asuslinux.Daemon";
+
+/// This macro adds a function which spawns an `inotify` task on the passed in
+/// `Executor`.
+///
+/// The generated function is `watch_<name>()`. Self requires the following
+/// methods to be available:
+/// - `<name>() -> SomeValue`, functionally is a getter, but is allowed to have
+///   side effects.
+/// - `notify_<name>(SignalContext, SomeValue)`
+///
+/// In most cases if `SomeValue` is stored in a config then `<name>()` getter is
+/// expected to update it. The getter should *never* write back to the path or
+/// attribute that is being watched or an infinite loop will occur.
+///
+/// # Example
+///
+/// ```ignore
+/// impl RogPlatform {
+///     task_watch_item!(panel_od platform);
+///     task_watch_item!(gpu_mux_mode platform);
+/// }
+/// ```\
+/// // TODO: this is kind of useless if it can't trigger some action
+#[macro_export]
+macro_rules! task_watch_item {
+    ($name:ident $self_inner:ident) => {
+        concat_idents::concat_idents!(fn_name = watch_, $name {
+        async fn fn_name(
+            &self,
+            signal_ctxt: SignalContext<'static>,
+        ) -> Result<(), RogError> {
+            use zbus::export::futures_util::StreamExt;
+
+            let ctrl = self.clone();
+            concat_idents::concat_idents!(watch_fn = monitor_, $name {
+                match self.$self_inner.watch_fn() {
+                    Ok(watch) => {
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            watch.into_event_stream(&mut buffer).unwrap().for_each(|_| async {
+                                if let Ok(value) = ctrl.$name() { // get new value from zbus method
+                                    concat_idents::concat_idents!(notif_fn = $name, _changed {
+                                        ctrl.notif_fn(&signal_ctxt).await.ok();
+                                    });
+                                    let mut lock = ctrl.config.lock().await;
+                                    lock.$name = value;
+                                    lock.write();
+                                }
+                            }).await;
+                        });
+                    }
+                    Err(e) => info!("inotify watch failed: {}. You can ignore this if your device does not support the feature", e),
+                }
+            });
+            Ok(())
+        }
+        });
+    };
+}
+
+#[macro_export]
+macro_rules! task_watch_item_notify {
+    ($name:ident $self_inner:ident) => {
+        concat_idents::concat_idents!(fn_name = watch_, $name {
+        async fn fn_name(
+            &self,
+            signal_ctxt: SignalContext<'static>,
+        ) -> Result<(), RogError> {
+            use zbus::export::futures_util::StreamExt;
+
+            let ctrl = self.clone();
+            concat_idents::concat_idents!(watch_fn = monitor_, $name {
+                match self.$self_inner.watch_fn() {
+                    Ok(watch) => {
+                        tokio::spawn(async move {
+                            let mut buffer = [0; 32];
+                            watch.into_event_stream(&mut buffer).unwrap().for_each(|_| async {
+                                concat_idents::concat_idents!(notif_fn = $name, _changed {
+                                    ctrl.notif_fn(&signal_ctxt).await.ok();
+                                });
+                            }).await;
+                        });
+                    }
+                    Err(e) => info!("inotify watch failed: {}. You can ignore this if your device does not support the feature", e),
+                }
+            });
+            Ok(())
+        }
+        });
+    };
+}
+
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+pub fn print_board_info() {
+    let dmi = DMIID::new().unwrap_or_default();
+    info!("Product family: {}", dmi.product_family);
+    info!("Board name: {}", dmi.board_name);
+}
+
+pub trait Reloadable {
+    fn reload(&mut self) -> impl Future<Output = Result<(), RogError>> + Send;
+}
+
+pub trait ReloadAndNotify {
+    type Data: Send;
+
+    fn reload_and_notify(
+        &mut self,
+        signal_context: &SignalContext<'static>,
+        data: Self::Data,
+    ) -> impl Future<Output = Result<(), RogError>> + Send;
+}
+
+pub trait ZbusRun {
+    fn add_to_server(self, server: &mut Connection) -> impl Future<Output = ()> + Send;
+
+    fn add_to_server_helper(
+        iface: impl zbus::Interface,
+        path: &str,
+        server: &mut Connection,
+    ) -> impl Future<Output = ()> + Send {
+        async move {
+            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
+pub trait CtrlTask {
+    fn zbus_path() -> &'static str;
+
+    fn signal_context(connection: &Connection) -> Result<SignalContext<'static>, zbus::Error> {
+        SignalContext::new(connection, Self::zbus_path())
+    }
+
+    /// 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.
+    fn create_tasks(
+        &self,
+        signal: SignalContext<'static>,
+    ) -> impl Future<Output = Result<(), RogError>> + Send;
+
+    // /// Create a timed repeating task
+    // async fn repeating_task(&self, millis: u64, mut task: impl FnMut() + Send +
+    // 'static) {     use std::time::Duration;
+    //     use tokio::time;
+    //     let mut timer = time::interval(Duration::from_millis(millis));
+    //     tokio::spawn(async move {
+    //         timer.tick().await;
+    //         task();
+    //     });
+    // }
+
+    /// Free helper method to create tasks to run on: sleep, wake, shutdown,
+    /// boot
+    ///
+    /// The closures can potentially block, so execution time should be the
+    /// minimal possible such as save a variable.
+    fn create_sys_event_tasks<Fut1, Fut2, Fut3, Fut4, F1, F2, F3, F4>(
+        &self,
+        mut on_prepare_for_sleep: F1,
+        mut on_prepare_for_shutdown: F2,
+        mut on_lid_change: F3,
+        mut on_external_power_change: F4,
+    ) -> impl Future<Output = ()> + Send
+    where
+        F1: FnMut(bool) -> Fut1 + Send + 'static,
+        F2: FnMut(bool) -> Fut2 + Send + 'static,
+        F3: FnMut(bool) -> Fut3 + Send + 'static,
+        F4: FnMut(bool) -> Fut4 + Send + 'static,
+        Fut1: Future<Output = ()> + Send,
+        Fut2: Future<Output = ()> + Send,
+        Fut3: Future<Output = ()> + Send,
+        Fut4: Future<Output = ()> + Send,
+    {
+        async {
+            let connection = Connection::system()
+                .await
+                .expect("Controller could not create dbus connection");
+
+            let manager = ManagerProxy::builder(&connection)
+                .cache_properties(CacheProperties::No)
+                .build()
+                .await
+                .expect("Controller could not create ManagerProxy");
+
+            let manager1 = manager.clone();
+            tokio::spawn(async move {
+                if let Ok(mut notif) = manager1.receive_prepare_for_shutdown().await {
+                    while let Some(event) = notif.next().await {
+                        // blocks thread :|
+                        if let Ok(args) = event.args() {
+                            debug!("Doing on_prepare_for_shutdown({})", args.start);
+                            on_prepare_for_shutdown(args.start).await;
+                        }
+                    }
+                }
+            });
+
+            let manager2 = manager.clone();
+            tokio::spawn(async move {
+                if let Ok(mut notif) = manager2.receive_prepare_for_sleep().await {
+                    while let Some(event) = notif.next().await {
+                        // blocks thread :|
+                        if let Ok(args) = event.args() {
+                            debug!("Doing on_prepare_for_sleep({})", args.start);
+                            on_prepare_for_sleep(args.start).await;
+                        }
+                    }
+                }
+            });
+
+            let manager3 = manager.clone();
+            tokio::spawn(async move {
+                let mut last_power = manager3.on_external_power().await.unwrap_or_default();
+
+                loop {
+                    if let Ok(next) = manager3.on_external_power().await {
+                        if next != last_power {
+                            last_power = next;
+                            on_external_power_change(next).await;
+                        }
+                    }
+                    sleep(Duration::from_secs(2)).await;
+                }
+            });
+
+            tokio::spawn(async move {
+                let mut last_lid = manager.lid_closed().await.unwrap_or_default();
+                // need to loop on these as they don't emit signals
+                loop {
+                    if let Ok(next) = manager.lid_closed().await {
+                        if next != last_lid {
+                            last_lid = next;
+                            on_lid_change(next).await;
+                        }
+                    }
+                    sleep(Duration::from_secs(2)).await;
+                }
+            });
+        }
+    }
+}
+
+pub trait GetSupported {
+    type A;
+
+    fn get_supported() -> Self::A;
+}
+
+pub async fn start_tasks<T>(
+    mut zbus: T,
+    connection: &mut Connection,
+    signal_ctx: SignalContext<'static>,
+) -> Result<(), RogError>
+where
+    T: ZbusRun + Reloadable + CtrlTask + Clone,
+{
+    let zbus_clone = zbus.clone();
+
+    zbus.reload()
+        .await
+        .unwrap_or_else(|err| warn!("Controller error: {}", err));
+    zbus.add_to_server(connection).await;
+
+    zbus_clone.create_tasks(signal_ctx).await.ok();
+    Ok(())
+}

config-traits/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "config-traits"
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
+
+[dependencies]
+serde.workspace = true
+ron.workspace = true
+
+log.workspace = true
+
+[dev-dependencies]
+cargo-husky.workspace = true

config-traits/README.md

@@ -0,0 +1,10 @@
+# config-traits
+
+`config_traits` is a crate that broke out from the requirement to manage various
+different config files, including parsing from different formats and updating
+them from previous versions where fields or names are changed in some way.
+
+The end canonical file format is `.ron` as this supports rust types well, and includes
+the ability to add commenting, and is less verbose than `json`. Currently the crate will
+also try to parse from `json` and `toml` if the `ron` parsing fails, then update to `ron`
+format.

config-traits/src/lib.rs

@@ -0,0 +1,328 @@
+//! `config_traits` is a crate that broke out from the requirement to manage
+//! various different config files, including parsing from different formats and
+//! updating them from previous versions where fields or names are changed in
+//! some way.
+//!
+//! The end canonical file format is `.ron` as this supports rust types well
+
+use std::fs::{self, create_dir, File, OpenOptions};
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+use log::{error, warn};
+pub use ron;
+use ron::ser::PrettyConfig;
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+
+/// Config file helper traits. Only `new()` and `file_name()` are required to be
+/// implemented, the rest are intended to be free methods.
+pub trait StdConfig
+where
+    Self: Serialize + DeserializeOwned,
+{
+    /// Taking over the standard `new()` to ensure things can be generic
+    fn new() -> Self;
+
+    /// Return the config files names, such as `wibble.cfg`
+    fn file_name(&self) -> String;
+
+    /// Return the full path to the directory the config file resides in
+    fn config_dir() -> PathBuf;
+
+    /// Return the full path to the config file
+    fn file_path(&self) -> PathBuf {
+        let mut config = Self::config_dir();
+        if !config.exists() {
+            create_dir(config.as_path())
+                .unwrap_or_else(|e| panic!("Could not create {:?} {e}", Self::config_dir()));
+        }
+        config.push(self.file_name());
+        let mut do_rename = !config.exists();
+        let mut cfg_old = config.clone();
+        // Migrating all configs to .ron format, so we do need to check for older ones
+        if do_rename {
+            warn!("Config {cfg_old:?} does not exist, looking for .cfg next");
+            cfg_old.pop();
+            let tmp = self.file_name();
+            let parts: Vec<_> = tmp.split('.').collect();
+            cfg_old.push(format!("{}.cfg", parts[0]));
+        }
+        if do_rename && cfg_old.exists() {
+            // Now we gotta rename it
+            warn!("Renaming {cfg_old:?} to {config:?}");
+            std::fs::rename(&cfg_old, &config).unwrap_or_else(|err| {
+                error!(
+                    "Could not rename. Please remove {} then restart service: Error {}",
+                    self.file_name(),
+                    err
+                );
+            });
+            do_rename = false;
+        }
+        if do_rename && !cfg_old.exists() {
+            warn!("Config {cfg_old:?} does not exist, looking for .conf next");
+            cfg_old.pop();
+            let tmp = self.file_name();
+            let parts: Vec<_> = tmp.split('.').collect();
+            cfg_old.push(format!("{}.conf", parts[0]));
+        }
+        if do_rename && cfg_old.exists() {
+            // Now we gotta rename it
+            warn!("Renaming {cfg_old:?} to {config:?}");
+            std::fs::rename(&cfg_old, &config).unwrap_or_else(|err| {
+                error!(
+                    "Could not rename. Please remove {} then restart service: Error {}",
+                    self.file_name(),
+                    err
+                );
+            });
+        }
+        config
+    }
+
+    /// Directly open the config file for read and write. If the config file
+    /// does not exist it is created, including the directories the file
+    /// resides in.
+    fn file_open(&self) -> File {
+        OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .truncate(false)
+            .open(self.file_path())
+            .unwrap_or_else(|e| panic!("Could not open {:?} {e}", self.file_path()))
+    }
+
+    /// Open and parse the config file to self from ron format
+    fn read(&mut self) {
+        if let Ok(data) = fs::read_to_string(self.file_path()) {
+            if data.is_empty() {
+                warn!("File is empty {:?}", self.file_path());
+            } else if let Ok(data) = ron::from_str(&data) {
+                *self = data;
+            } else {
+                warn!("Could not deserialise {:?}", self.file_path());
+            }
+        }
+    }
+
+    /// Open and parse the config file to self from ron format
+    fn read_new(&self) -> Option<Self> {
+        if let Ok(data) = fs::read_to_string(self.file_path()) {
+            if data.is_empty() {
+                warn!("File is empty {:?}", self.file_path());
+            } else if let Ok(data) = ron::from_str(&data) {
+                return Some(data);
+            } else {
+                warn!("Could not deserialise {:?}", self.file_path());
+            }
+        }
+        None
+    }
+
+    /// Write the config file data to pretty ron format
+    fn write(&self) {
+        let mut file = match File::create(self.file_path()) {
+            Ok(data) => data,
+            Err(e) => {
+                error!(
+                    "Couldn't overwrite config {:?}, error: {e}",
+                    self.file_path()
+                );
+                return;
+            }
+        };
+        let ron = match ron::ser::to_string_pretty(&self, PrettyConfig::new().depth_limit(4)) {
+            Ok(data) => data,
+            Err(e) => {
+                error!("Parse {:?} to RON failed, error: {e}", self.file_path());
+                return;
+            }
+        };
+        file.write_all(ron.as_bytes())
+            .unwrap_or_else(|err| error!("Could not write config: {}", err));
+    }
+
+    /// Renames the existing file to `<file>-old`
+    fn rename_file_old(&self) {
+        warn!(
+            "Renaming {} to {}-old and recreating config",
+            self.file_name(),
+            self.file_name()
+        );
+        let mut cfg_old = self.file_path().to_string_lossy().to_string();
+        cfg_old.push_str("-old");
+        std::fs::rename(self.file_path(), cfg_old).unwrap_or_else(|err| {
+            error!(
+                "Could not rename. Please remove {} then restart service: Error {}",
+                self.file_name(),
+                err
+            );
+        });
+    }
+}
+
+#[macro_export]
+macro_rules! std_config_load {
+    ($trait_name:ident: $($generic:ident),*) => {
+        /// Base trait for loading/parsing. This is intended to be used to help update
+        /// configs to new versions
+        ///
+        /// # Example
+        /// ```rust
+        /// use std::path::PathBuf;
+        /// use serde::{Deserialize, Serialize};
+        /// use config_traits::{StdConfig, StdConfigLoad2};
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfigOld {}
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfigOlder {}
+        ///
+        /// #[derive(Deserialize, Serialize, Debug)]
+        /// struct FanCurveConfig {}
+        ///
+        /// impl From<FanCurveConfigOld> for FanCurveConfig {
+        ///     fn from(_: FanCurveConfigOld) -> Self { Self {} }
+        /// }
+        ///
+        /// impl From<FanCurveConfigOlder> for FanCurveConfig {
+        ///     fn from(_: FanCurveConfigOlder) -> Self { Self {} }
+        /// }
+        ///
+        /// impl StdConfig for FanCurveConfig {
+        ///     fn new() -> Self { Self {} }
+        ///
+        ///     fn file_name(&self) -> std::string::String { "test_name.conf".to_owned() }
+        ///
+        ///     fn config_dir() -> PathBuf { PathBuf::from("/tmp") }
+        /// }
+        ///
+        /// impl StdConfigLoad2<FanCurveConfigOld, FanCurveConfigOlder> for FanCurveConfig {}
+        /// ```
+        ///
+        /// If all of the generics fails to parse, then the old config is renamed and a
+        /// new one created
+        pub trait $trait_name<$($generic),*>
+        where
+            Self: $crate::StdConfig +std::fmt::Debug + DeserializeOwned + Serialize,
+            $($generic: DeserializeOwned + Into<Self>),*
+        {
+            fn load(mut self) -> Self {
+                let mut file = self.file_open();
+                let mut buf = String::new();
+                if let Ok(read_len) = file.read_to_string(&mut buf) {
+                    if read_len != 0 {
+                        if let Ok(data) = ron::from_str(&buf) {
+                            self = data;
+                            log::info!("Parsed RON for {:?}", std::any::type_name::<Self>());
+                        }  $(else if let Ok(data) = ron::from_str::<$generic>(&buf) {
+                            self = data.into();
+                            log::info!("New version failed, trying previous: Parsed RON for {:?}", std::any::type_name::<$generic>());
+                        })* else {
+                            self.rename_file_old();
+                            self = Self::new();
+                        }
+                    } else {
+                        error!("Config file {} zero read length", self.file_name());
+                    }
+                }
+                self.write();
+                self
+            }
+        }
+    };
+}
+
+std_config_load!(StdConfigLoad:);
+std_config_load!(StdConfigLoad1: T1);
+std_config_load!(StdConfigLoad2: T1, T2);
+std_config_load!(StdConfigLoad3: T1, T2, T3);
+std_config_load!(StdConfigLoad4: T1, T2, T3, T4);
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    #[test]
+    fn check_macro_from_1() {
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Test {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old1 {}
+
+        impl crate::StdConfig for Test {
+            fn new() -> Self {
+                Self {}
+            }
+
+            fn file_name(&self) -> String {
+                String::new()
+            }
+
+            fn config_dir() -> PathBuf {
+                PathBuf::new()
+            }
+        }
+
+        impl From<Old1> for Test {
+            fn from(_: Old1) -> Self {
+                Self {}
+            }
+        }
+
+        impl crate::StdConfigLoad1<Old1> for Test {}
+    }
+
+    #[test]
+    fn check_macro_from_3() {
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Test {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old1 {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old2 {}
+
+        #[derive(serde::Deserialize, serde::Serialize, Debug)]
+        struct Old3 {}
+
+        impl crate::StdConfig for Test {
+            fn new() -> Self {
+                Self {}
+            }
+
+            fn file_name(&self) -> String {
+                String::new()
+            }
+
+            fn config_dir() -> PathBuf {
+                PathBuf::new()
+            }
+        }
+
+        impl From<Old1> for Test {
+            fn from(_: Old1) -> Self {
+                Self {}
+            }
+        }
+
+        impl From<Old2> for Test {
+            fn from(_: Old2) -> Self {
+                Self {}
+            }
+        }
+
+        impl From<Old3> for Test {
+            fn from(_: Old3) -> Self {
+                Self {}
+            }
+        }
+
+        impl crate::StdConfigLoad3<Old1, Old2, Old3> for Test {}
+    }
+}

cpuctl/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "cpuctl"
+license.workspace = true
+version.workspace = true
+readme.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+edition.workspace = true
+
+[dependencies]

cpuctl/src/lib.rs

@@ -0,0 +1,14 @@
+pub fn add(left: usize, right: usize) -> usize {
+    left + right
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        let result = add(2, 2);
+        assert_eq!(result, 4);
+    }
+}