Salastil/OpenRGB
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Salastil/OpenRGB:release_0.5
Branches Tags
Salastil/OpenRGB:master Salastil/OpenRGB:settings_schema_ignore Salastil/OpenRGB:msi_185_firmware_check Salastil/OpenRGB:msi_185_debug Salastil/OpenRGB:windows_steam_machine Salastil/OpenRGB:rc3_hotfix Salastil/OpenRGB:plugin_save_profile Salastil/OpenRGB:release_0.9_patch Salastil/OpenRGB:show_hide_rework Salastil/OpenRGB:valve_leds_linux Salastil/OpenRGB:next Salastil/OpenRGB:keychron_k10_v2 Salastil/OpenRGB:redragon_m921 Salastil/OpenRGB:next_remove_led_value Salastil/OpenRGB:build_msi_on_windows Salastil/OpenRGB:next_configuredevice Salastil/OpenRGB:next_plugin_interface Salastil/OpenRGB:next_description_size_verification Salastil/OpenRGB:gigabyte_rx9070xt_ice Salastil/OpenRGB:next_zone_segment_updates Salastil/OpenRGB:cm_argb_rework Salastil/OpenRGB:next_sdk_flags Salastil/OpenRGB:cmake Salastil/OpenRGB:aoc_gh300 Salastil/OpenRGB:fan_controller Salastil/OpenRGB:airgoo_commander_controller Salastil/OpenRGB:raspberry_pi_gpio Salastil/OpenRGB:xpg_s20g Salastil/OpenRGB:translations_rgbcontroller_api Salastil/OpenRGB:settings_manager_ui Salastil/OpenRGB:acermonitor Salastil/OpenRGB:ene_mode_14 Salastil/OpenRGB:razercontroller_save Salastil/OpenRGB:steamdeck_test Salastil/OpenRGB:ene_zero_test Salastil/OpenRGB:ene_read_byte_data Salastil/OpenRGB:razer_single_zone_test Salastil/OpenRGB:mr_1041 Salastil/OpenRGB:mr_1179 Salastil/OpenRGB:mr_1008 Salastil/OpenRGB:alpine_ci_test Salastil/OpenRGB:i2c_reg_devel Salastil/OpenRGB:xpg_ssd_devel Salastil/OpenRGB:crucial_openaurasdk_dump Salastil/OpenRGB:qmk_delay_test Salastil/OpenRGB:mr_555_merge Salastil/OpenRGB:logitech_g915_merge Salastil/OpenRGB:sinowealth_0016_merge Salastil/OpenRGB:auma0_e8k4_0101_register_v1 Salastil/OpenRGB:steelseries_rival_600_merge Salastil/OpenRGB:corsair_k100_merge Salastil/OpenRGB:alienware_aw510k_merge Salastil/OpenRGB:hyperx_pulsefire_haste_devel Salastil/OpenRGB:alloy_origins_modes_merge Salastil/OpenRGB:qmk_improvements_merge Salastil/OpenRGB:viper-block-read-fix Salastil/OpenRGB:asus_strix_scope_test Salastil/OpenRGB:qmk_sonix Salastil/OpenRGB:extra_buttons_test Salastil/OpenRGB:lian_li_rebase Salastil/OpenRGB:gigabyte_fusion_0x48_test Salastil/OpenRGB:device_list_management_merge Salastil/OpenRGB:qmk_testing Salastil/OpenRGB:settings_manager_devel Salastil/OpenRGB:polychrome_b450_steel_legend Salastil/OpenRGB:graphical_led_map Salastil/OpenRGB:alloy_fps_devel Salastil/OpenRGB:gui_client_devel Salastil/OpenRGB:i2c_sniffer_i801 Salastil/OpenRGB:network_devel Salastil/OpenRGB:libusb_hidapi_windows Salastil/OpenRGB:profile_devel Salastil/OpenRGB:nvapi_rgbfusion_gpu Salastil/OpenRGB:msirgb_devel Salastil/OpenRGB:aura_addressable Salastil/OpenRGB:mode_colors_devel Salastil/OpenRGB:openrazer_windows Salastil/OpenRGB:poseidon_2 Salastil/OpenRGB:mode_api_improvements Salastil/OpenRGB:rgb_fusion_2 Salastil/OpenRGB:crucial_ballistix_rgb Salastil/OpenRGB:corsair_kbd Salastil/OpenRGB:msi_3_zone_devel Salastil/OpenRGB:i2c_threadsafe Salastil/OpenRGB:hue_plus_autodetect_devel_2 Salastil/OpenRGB:hue_plus_autodetect_devel Salastil/OpenRGB:wraith_prism_devel Salastil/OpenRGB:qt_ui_rework Salastil/OpenRGB:openrgb Salastil/OpenRGB:qt_windows Salastil/OpenRGB:i2c_sniffer_piix4 Salastil/OpenRGB:generic_rgb_interface_test Salastil/OpenRGB:openaurasdk Salastil/OpenRGB:e131_devel Salastil/OpenRGB:visual-studio-gui-devel Salastil/OpenRGB:linux-test
Salastil/OpenRGB:release_1.0 Salastil/OpenRGB:release_candidate_1.0rc3.1 Salastil/OpenRGB:release_candidate_1.0rc3 Salastil/OpenRGB:release_candidate_1.0rc2 Salastil/OpenRGB:release_candidate_1.0rc2wr0 Salastil/OpenRGB:release_candidate_1.0rc1 Salastil/OpenRGB:release_0.9 Salastil/OpenRGB:release_0.8 Salastil/OpenRGB:release_0.7 Salastil/OpenRGB:release_0.6 Salastil/OpenRGB:release_0.5 Salastil/OpenRGB:release_0.4 Salastil/OpenRGB:release_0.3 Salastil/OpenRGB:release_0.2 Salastil/OpenRGB:release_0.1
..
compare: Salastil/OpenRGB:release_0.6
Branches Tags
Salastil/OpenRGB:master Salastil/OpenRGB:settings_schema_ignore Salastil/OpenRGB:msi_185_firmware_check Salastil/OpenRGB:msi_185_debug Salastil/OpenRGB:windows_steam_machine Salastil/OpenRGB:rc3_hotfix Salastil/OpenRGB:plugin_save_profile Salastil/OpenRGB:release_0.9_patch Salastil/OpenRGB:show_hide_rework Salastil/OpenRGB:valve_leds_linux Salastil/OpenRGB:next Salastil/OpenRGB:keychron_k10_v2 Salastil/OpenRGB:redragon_m921 Salastil/OpenRGB:next_remove_led_value Salastil/OpenRGB:build_msi_on_windows Salastil/OpenRGB:next_configuredevice Salastil/OpenRGB:next_plugin_interface Salastil/OpenRGB:next_description_size_verification Salastil/OpenRGB:gigabyte_rx9070xt_ice Salastil/OpenRGB:next_zone_segment_updates Salastil/OpenRGB:cm_argb_rework Salastil/OpenRGB:next_sdk_flags Salastil/OpenRGB:cmake Salastil/OpenRGB:aoc_gh300 Salastil/OpenRGB:fan_controller Salastil/OpenRGB:airgoo_commander_controller Salastil/OpenRGB:raspberry_pi_gpio Salastil/OpenRGB:xpg_s20g Salastil/OpenRGB:translations_rgbcontroller_api Salastil/OpenRGB:settings_manager_ui Salastil/OpenRGB:acermonitor Salastil/OpenRGB:ene_mode_14 Salastil/OpenRGB:razercontroller_save Salastil/OpenRGB:steamdeck_test Salastil/OpenRGB:ene_zero_test Salastil/OpenRGB:ene_read_byte_data Salastil/OpenRGB:razer_single_zone_test Salastil/OpenRGB:mr_1041 Salastil/OpenRGB:mr_1179 Salastil/OpenRGB:mr_1008 Salastil/OpenRGB:alpine_ci_test Salastil/OpenRGB:i2c_reg_devel Salastil/OpenRGB:xpg_ssd_devel Salastil/OpenRGB:crucial_openaurasdk_dump Salastil/OpenRGB:qmk_delay_test Salastil/OpenRGB:mr_555_merge Salastil/OpenRGB:logitech_g915_merge Salastil/OpenRGB:sinowealth_0016_merge Salastil/OpenRGB:auma0_e8k4_0101_register_v1 Salastil/OpenRGB:steelseries_rival_600_merge Salastil/OpenRGB:corsair_k100_merge Salastil/OpenRGB:alienware_aw510k_merge Salastil/OpenRGB:hyperx_pulsefire_haste_devel Salastil/OpenRGB:alloy_origins_modes_merge Salastil/OpenRGB:qmk_improvements_merge Salastil/OpenRGB:viper-block-read-fix Salastil/OpenRGB:asus_strix_scope_test Salastil/OpenRGB:qmk_sonix Salastil/OpenRGB:extra_buttons_test Salastil/OpenRGB:lian_li_rebase Salastil/OpenRGB:gigabyte_fusion_0x48_test Salastil/OpenRGB:device_list_management_merge Salastil/OpenRGB:qmk_testing Salastil/OpenRGB:settings_manager_devel Salastil/OpenRGB:polychrome_b450_steel_legend Salastil/OpenRGB:graphical_led_map Salastil/OpenRGB:alloy_fps_devel Salastil/OpenRGB:gui_client_devel Salastil/OpenRGB:i2c_sniffer_i801 Salastil/OpenRGB:network_devel Salastil/OpenRGB:libusb_hidapi_windows Salastil/OpenRGB:profile_devel Salastil/OpenRGB:nvapi_rgbfusion_gpu Salastil/OpenRGB:msirgb_devel Salastil/OpenRGB:aura_addressable Salastil/OpenRGB:mode_colors_devel Salastil/OpenRGB:openrazer_windows Salastil/OpenRGB:poseidon_2 Salastil/OpenRGB:mode_api_improvements Salastil/OpenRGB:rgb_fusion_2 Salastil/OpenRGB:crucial_ballistix_rgb Salastil/OpenRGB:corsair_kbd Salastil/OpenRGB:msi_3_zone_devel Salastil/OpenRGB:i2c_threadsafe Salastil/OpenRGB:hue_plus_autodetect_devel_2 Salastil/OpenRGB:hue_plus_autodetect_devel Salastil/OpenRGB:wraith_prism_devel Salastil/OpenRGB:qt_ui_rework Salastil/OpenRGB:openrgb Salastil/OpenRGB:qt_windows Salastil/OpenRGB:i2c_sniffer_piix4 Salastil/OpenRGB:generic_rgb_interface_test Salastil/OpenRGB:openaurasdk Salastil/OpenRGB:e131_devel Salastil/OpenRGB:visual-studio-gui-devel Salastil/OpenRGB:linux-test
Salastil/OpenRGB:release_1.0 Salastil/OpenRGB:release_candidate_1.0rc3.1 Salastil/OpenRGB:release_candidate_1.0rc3 Salastil/OpenRGB:release_candidate_1.0rc2 Salastil/OpenRGB:release_candidate_1.0rc2wr0 Salastil/OpenRGB:release_candidate_1.0rc1 Salastil/OpenRGB:release_0.9 Salastil/OpenRGB:release_0.8 Salastil/OpenRGB:release_0.7 Salastil/OpenRGB:release_0.6 Salastil/OpenRGB:release_0.5 Salastil/OpenRGB:release_0.4 Salastil/OpenRGB:release_0.3 Salastil/OpenRGB:release_0.2 Salastil/OpenRGB:release_0.1
414 Commits
release_0.5 .. release_0.6
Author SHA1 Message Date
Adam Honse 405ff7f6a5 OpenRGB version 0.6 2021-06-01 00:05:08 -05:00
Adam Honse 563ff31fe3 Wait up to 5 seconds for the local server connection to retrieve all controllers before continuing, so that CLI mode has all controllers available for applying changes 2021-05-31 23:44:33 -05:00
Chris 4a6c4f0e52 Adding test stages to Linux builds 
* Build based on new OpenRGB docker image (Debian Stretch)
* Adapting AppImage build scripts to new docker image
* Changing postinstall script to avoid error

+ Adding test stage keyword
+ Adding needs keyword
+ Debian 10       Buster 32bit & 64bit
+ Debian 11       Bullseye 32bit & 64bit
+ Fedora 34       v34 64bit only
+ Ubuntu 18.04LTS Bionic 32bit & 64bit
+ Ubuntu 20.04LTS Focal 64bit only
+ Ubuntu 20.10    Groovy 64bit only
+ Mint   20.1     Ulyssa 32bit & 64bit

Amended to leave Bullseye builds in place by Adam Honse <[email protected]>
 2021-05-31 23:32:09 -05:00
TheRogueZeta be838aa1d6 Update Logitech Lightspeed detector names 2021-06-01 04:13:46 +00:00
Adam Honse 68b0287cdd Make detectors for QMK OpenRGB controller configurable 2021-05-31 18:35:07 -05:00
Adam Honse d18f66f995 Implement dynamic detectors - run-once functions that can register detectors dynamically 2021-05-31 13:55:22 -05:00
Chris 259ba898b0 Enumerate Wireless connected Logitech Lightspeed (Unifying) devices 
+ Added common library for Logitech Protocol
    + Moved wireless detection to the LogitechProtocolCommon.cpp
    + Adding Direct Mode to the wireless control
    + Copying the mutex from Lightsync controller to avoid interference
    + Adding LED count info to controller constructor

+ Created a new Logitech class
    + Added Feature list enumeration
    + Added DeviceName detection from device

* Changed LogitechGProWirelessController to accomodate generic devices
    * LED count from device is now used in RGBController setup

+ Adding Windows specific detection as Linux Kernel handles this already.
+ Adding virtual PIDS for wireless detection
    * LOGITECH G403
    * LOGITECH G502
    * LOGITECH G703
    * LOGITECH G900
    * LOGITECH G903
    * LOGITECH GPRO
+ Adding Logitech G900 Wired Gaming Mouse PID
+ Adding other all lightspeed mice to wired detector for testing
    * Genericised and optimised code paths
    * Speed up wireless detection

Commit amended for code style by Adam Honse <[email protected]>
 2021-05-31 10:59:04 -07:00
Adam Honse d8252281ce Prevent theme box from saving theme setting until initialized 2021-05-30 21:08:23 -07:00
Kasper a5928518c1 Implement QMK OpenRGB Procotol 
This commit squashes commits by:

    Kasper <[email protected]>
    jath03 <[email protected]>
    Adam Honse <[email protected]>

Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-05-30 18:41:55 -05:00
Felipe Guaycuru b3b392b3e2 Make Corsair K55 behavior be closer to iCue's 2021-05-30 22:33:31 +00:00
Adam Honse 1df6e8f559 Add geometry settings to settings page 2021-05-28 12:07:38 -05:00
morg c1b9f79052 Add settings page under settings tab 2021-05-28 16:37:41 +00:00
Adam Honse 4764198df7 Add Logitech G910 Orion Spark 2021-05-27 10:25:20 -05:00
Kasper f04da17e4e Corsair hydro platinum fix soft brick once again by increasing delay to 5ms 2021-05-27 14:31:43 +00:00
Adam Honse 6dda941d97 Add debug logging for Aura SMBus DRAM detection 2021-05-26 00:41:57 -05:00
harre b2be4a9411 Added include needed by arch #1427 2021-05-26 02:09:50 +00:00
Adam Honse 9b974d7108 Update Logitech G910 LED list to add G keys and second Logo, update matrix 2021-05-25 19:15:45 -05:00
Adam Honse 4509b9d2e9 Initial support for Logitech G910 Orion Spectrum - G Keys and G910 bottom logo not working yet 2021-05-25 15:38:53 -05:00
Adam Honse 4287128fb4 Attempt to implement !513 using shared mutex pointer for each detected mouse/mousemat combo 2021-05-25 11:48:16 -05:00
Adam Honse a2a93daaab Add numerical_labels setting to UserInterface settings 2021-05-24 23:08:39 -05:00
Kasper f9c7df21f1 Add a number as a label for LEDs that otherwise would be nameless in DeviceView 2021-05-24 22:51:37 -05:00
k1-801 65623d3978 Autoclose updated 
Commit amended for code style by Adam Honse <[email protected]>
 2021-05-24 22:45:24 -05:00
k1-801 abfb6ea22d Tiny fixups (server conn info leak closed, log va leak closed, config dir optimized) 
Commit amended for code style by Adam Honse <[email protected]>
 2021-05-24 22:41:12 -05:00
Adam Honse 33b840b2b9 Revert change disabling redetection of i2c interfaces and fix disconnected WMI failure by always reconnecting before query 2021-05-24 18:38:26 -05:00
Adam Honse 2a3a736f09 Don't delete i2c bus list on redetect, as WMI query issues prevent them from being redetected 2021-05-24 17:00:18 -05:00
Adam Honse 8ada7cd6da Add MSI Mystic Light 185 7D13 (MSI MEG B550 Unify), tested on Discord by Markellus 2021-05-23 23:25:47 -05:00
Adam Honse cb656ebdf7 Don't print Running standalone message when local server connection succeeds 2021-05-23 23:22:46 -05:00
TheRogueZeta 707df85d1f DMI Info for MSI-RGB boards 2021-05-23 00:08:43 -07:00
TheRogueZeta 78955de65f Get DMI info for MSI USB boards 2021-05-23 00:08:43 -07:00
edbgon a8e2feddbe New controller for SteelSeries QCK Mousemat 2021-05-22 23:49:20 -05:00
TheRogueZeta fd31b4db7d Fixed Dev and Feature index for PowerPlay 2021-05-22 15:48:06 -07:00
TheRogueZeta a87d2aead7 PowerPlay mat should only be 1 zone. 2021-05-22 15:45:34 -07:00
Adam Honse 2afddf9bbf Only join/delete E1.31 keepalive thread if it has actually been created 2021-05-21 20:43:14 -05:00
TheRogueZeta 1f2d298e14 Add ASUS ROG-STRIX-RTX2080-O8G-GAMING 2021-05-22 00:42:52 +00:00
Adam Honse cdae9b1e78 Fix client registration for auto-detected local server 2021-05-21 19:25:12 -05:00
Diogo Trindade 4c6653bdb4 Asus ROG Strix Flare - Added ISO LEDs 2021-05-22 00:01:32 +00:00
Adam Honse e5d16dedcc Add option in settings file to pass client controllers through to server 2021-05-21 16:58:42 -05:00
Adam Honse d103906c75 Override UpdateLEDs() for RGBController_Network to always process synchronously 2021-05-21 16:39:03 -05:00
Adam Honse 5e959f6bc3 Add Pipeline Status badge to README 2021-05-20 20:56:40 +00:00
Adam Honse 618faf42ec Use block writes for updating all LEDs at once on ASUS Aura SMBus 2021-05-19 21:49:22 -05:00
edbgon 961fbc2585 Update rules file in accordance to detectors 2021-05-19 09:44:15 +02:00
Adam Honse eb9710ee26 Fix name change 2021-05-18 23:21:56 -05:00
Adam Honse 39de6fc175 Code style cleanup for Logitech G Lightsync RGBController 2021-05-18 22:57:45 -05:00
Adam Honse 39d989891e Code style cleanup for Logitech detector 2021-05-18 22:53:38 -05:00
TheRogueZeta 734912732c Rework individual Logitech mouse controllers into a single shared controller and add Direct mode. 
Squashes all commits from Merge Request !495
 2021-05-19 03:25:55 +00:00
Adam Honse 47160ac7cd Add visitors badge to README 2021-05-18 18:26:14 +00:00
Daniel Augustin 9f0fa7eb67 Add Asus Aura on Asus H570-PRO Motherboards 2021-05-17 18:42:22 -05:00
TheRogueZeta a6cfcdeb1d Retrieve motherboard name for ASUS boards via DMI 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-05-17 18:34:21 -05:00
Cheerpipe cf922db7d5 G815 performance tweaks 
* Remove some unnecessary operations on the G815 controller
* Use reserved memory for key color array to avoid excessive memory copy on vector pushback

Commits squashed and commit message amended by Adam Honse <[email protected]>
 2021-05-17 18:29:17 -05:00
Cheerpipe 8a56a5103c Packet read size fix. Should be 20, not 200 
This bug causes rare unwanted volume changes.
 2021-05-17 17:41:59 +00:00
TheRogueZeta 3026a10ff8 Add ASUS ROG STRIX RTX 2080 Ti O11G Gaming 2021-05-17 13:17:44 +00:00
morg f54ecd8b1b Add detection start and end callbacks 2021-05-17 08:14:00 -05:00
Adam Honse d88f9979a9 Rework network client callback pipeline - route callbacks from clients through ResourceManager so that device list callbacks get called. Fixes remote devices not showing up in plugins. 2021-05-14 23:29:34 -05:00
Martin Hartl 94370c24a8 cli: Fix mode specific colors for range 2021-05-14 15:14:11 +02:00
nightsky30 c29a38a8c9 Fix the number of LEDs for Lancehead devices; 16 LEDs, not 18 #6 2021-05-13 23:03:06 -05:00
Artur Pieniążek 651a8d2f2a Handle K95 Platinum ANSI and ISO layouts 
Commits merged by Adam Honse <[email protected]>
 2021-05-13 22:51:03 -05:00
silas a51e2f8ac8 Make device list change warning callback 
This will be helpful for keeping plugins from crashing

Commit amended to change callback function name for consistency by Adam Honse <[email protected]>
 2021-05-13 22:30:38 -05:00
k1-801 02ba8a799e Server freed from ResourceManager 
Commit amended to revert OpenRGBInterfaces.h header (may reconsider in the future) by Adam Honse
<[email protected]>
 2021-05-13 22:10:41 -05:00
alpemwarrior a6bc30a31c Add 64-bit .rpm package build to CI for Fedora. 2021-05-14 02:02:28 +00:00
Chris 81bf61867f Amending QTwindow geometry config to resovle #1245 
+ Code to initialise config values.
    + Added "load_geometry" variable so that you can load set values but not have to "save_on_exit"

Commit amended for code style by Adam Honse <[email protected]>
 2021-05-13 20:59:32 -05:00
Martin Hartl 1f21d9ad62 Asus mainboard: Rename RGB headers 
There is currently no difference in naming for the integrated
motherboard LEDs and the motherboard non-addressable RGB headers. This
commit renames the RGB headers in the RGB controller. The number of RGB
headers is read from the configuration table.

Commit amended for code style by Adam Honse <[email protected]>
 2021-05-12 22:35:21 -05:00
Pol Rius 658eb3a1f7 Initialize profile_loaded properly 2021-05-12 18:27:22 +02:00
edbgon a567aa1e62 Update Ducky to support ISO layouts 2021-05-12 07:44:41 +02:00
Adam Honse d3ee9911b5 Change UI_Settings key to UserInterface 2021-05-10 22:17:11 -05:00
Chris 166bc13dec Adding ability to save QTwindow geometry to config solving #1245 
+ Load window geometry from config added to constructor
+ Save window geometry to config added to destructor
+ Added an opt out boolean to allow for saving / not saving geometry
+ Consolidated the Minimize settings into the "UI_Settings" in config
+ Code to initialise config values.

Amended for code style by Adam Honse <[email protected]>
 2021-05-10 22:15:20 -05:00
Adam Honse 47e4dc7431 Add MSI Mystic Light 7D09 PID to 185 byte controllers list 2021-05-10 08:47:10 -05:00
Adam Honse 20b149aeef Implement direct mode for Corsair K57, only in wired mode. 2021-05-09 15:09:29 -05:00
Adam Honse 91dd39f3f3 Start implementing Corsair Wireless (K57) controller. Detects both keyboard and dongle, no other functionality implemented yet 2021-05-08 13:40:19 -05:00
Dmitry K 647670a04a Skip Inpout-dependent detection when inpout is not available 2021-05-06 23:11:30 +00:00
morg 23db961be3 Refactor OpenRGBDialog2 + add SettingsTab as plugin location 2021-05-06 17:57:28 +02:00
morg 59a0bec399 Toggle plugins visibility for all locations 2021-05-06 01:16:06 +00:00
morg 3543218722 Automatically create the plugins folder 2021-05-06 01:02:08 +00:00
morg 0fbe96f8ec Add button to open settings folder 2021-05-06 01:00:34 +00:00
Gabriel Marcano 30f88d5fcf Fix mismatched new[] / delete 
- The device description buffer was allocated using new[] in
   RGBController. Make sure to free it using delete[].
 2021-05-05 02:07:19 -07:00
Adam Honse 198a246af1 Add timeouts to prevent lockup of Razer Naga Epic Chroma 2021-05-02 12:02:46 -05:00
silas 827c78da13 Fix window getting larger when spamming toggle LED view 
Commit amended to only implement size hint change by Adam Honse <[email protected]>
 2021-05-02 11:33:20 -05:00
Adam Honse 08d495941e Add effect handling for per-LED Razer devices 2021-05-02 01:50:19 -05:00
morg 8ee0b12ef8 Auto hide/show plugin containers 
Commit amended for code style and to add comments by Adam Honse <[email protected]>
 2021-05-02 00:01:52 -05:00
TheRogueZeta 84371c3cd8 Add Asus Strix 2070S A8G Gaming PCIe ID 2021-05-02 02:16:24 +00:00
morg 0b4a8ffce2 Software info: add website link, make links clickable 2021-04-30 21:02:35 +02:00
Bernhard Held 2df555d864 Add support for Gainward RTX 2070 Super Phantom 2021-04-30 16:06:34 +00:00
Adam Honse 429068760d Fix more warnings 2021-04-30 10:56:40 -05:00
Tam Do 47877193a7 rename mode to reactive, behavior is that key changes from color1 to color2 when pressed, and fades back to color1 after some time configured by the speed parameter 2021-04-30 01:42:49 +00:00
Tam Do 7952a035b5 Continued the work started by !62 with respect to adding support for Cooler Master keyboards using the libcmmk library. 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-04-30 01:42:49 +00:00
Lukas Niederbremer 7e4b9c0cb0 Add experimental Cooler Master MasterKeys support 2021-04-30 01:42:49 +00:00
shawnc722 b3e1cc6552 Fix invalid serial numbers crashing the python interface. 
(cherry picked from commit a5ff98940cbe2e91ecaf2445febd87e373f35723)
 2021-04-29 19:17:09 +00:00
shawnc722 13b1da9d64 Removed various brightness modes and made highest brightness into Direct mode. Can use relative intensity to set brightness, ie RGB(255,0,255) (magenta) at ~60% brightness is RGB(150,0,150) 
(cherry picked from commit b43cfd3b04e9faf980e319c596be5de49140f9b0)
 2021-04-29 19:14:54 +00:00
Adam Honse 5616f547e4 Fix a bunch of warnings 2021-04-29 13:42:49 -05:00
shawnc722 37d58ee1a6 Add support for ASUS GTX 1080 2021-04-29 00:17:10 +00:00
TheRogueZeta 74b05f17fd Add ASUS ROG STRIX RTX 2060 EVO Gaming 6G 2021-04-26 12:31:44 -07:00
Chris 6a8524f371 Adding ASUS GTX 1070 Strix OC 
* As per yozukiRR adding 0x8599 for the ASUS GTX 1070 Strix OC
 2021-04-26 09:42:38 -05:00
k1-801 ad2cd89128 Add filesystem header to select between std::filesystem and std::experimental::filesystem depending on system availability. 
Commit amended by Adam Honse <[email protected]>
 2021-04-25 22:55:49 -05:00
shawnc722 05d72ba96f Fixed detection of Apex 350 and tweaked display names of OG Apex 2021-04-25 17:06:57 -05:00
k1-801 402423e338 Fix a memory leak in NetworkClient 2021-04-25 16:55:15 -05:00
Adam Honse dd4865c3e0 Add initial version of the Plugin Container, which prevents plugins from resizing the window unless shown 2021-04-23 22:45:30 -05:00
Adam Honse 30623b36fd Use Debian Bullseye for CI builds 2021-04-23 22:37:39 -05:00
Chris 9b8d2c38d3 Changed "Set All Devices" 
* Changed `Set All Devices` to `Apply To All Devices`
* Added a tooltip to `Apply to All`
* Added Black and White quick colour swatches and left them "not flat" to
ensure visibility in Light and Dark mode.

Commit amended to fix display issues on Windows and to group buttons in layout by Adam Honse <[email protected]>
 2021-04-23 11:44:59 -05:00
Adam Honse be1fbc27ca Add device type string for virtual device 2021-04-22 16:24:48 -05:00
TheRogueZeta 95f40039eb Correct errant hyphen with underscore and update CI names 2021-04-22 19:44:17 +00:00
TheRogueZeta cd8e455b79 Update CI config to rename artifacts.zip with build info 2021-04-22 00:08:17 -05:00
morg 57db50f642 Fix VisualMap plugin URL in README 2021-04-22 00:11:22 +00:00
TheRogueZeta 9789ac0fde Remove 7z compression on Windows builds 2021-04-21 16:05:48 -07:00
morg c45f864977 Add virtual device type 2021-04-21 21:37:50 +02:00
Gareth Hancock 28af2da1c2 Added support for EVGA 2080Ti FTW3 Ultra 2021-04-21 15:44:44 +00:00
Cheerpipe b32ef76121 Creative Sound BlasterX G6 support 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-04-21 00:03:46 -05:00
edbgon a300e80f47 AMD Reference 6800 cards custom mode set to static 2021-04-21 04:15:32 +00:00
Boothin e098bb5c41 Added Rival 310 and compatible special editions to detector 2021-04-20 22:25:17 -04:00
Adam Honse f06b0ee952 Use NULL (shared) libusb context 2021-04-20 20:30:58 -05:00
Luca Lovisa 0da484bffc Add support for the Lian Li Uni Hub 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-04-20 20:30:57 -05:00
Adam Honse bea2ae2fdc Add OpenRGB Visual Map plugin link to README 2021-04-20 12:07:19 -05:00
morg 2a6b457324 Add UnregisterRGBController method to ResourceManager 
Commit amended by Adam Honse <[email protected]>
 2021-04-20 09:21:24 -05:00
TheRogueZeta 50adf9ab51 Correct SetCustomMode() to use virtual mode. 2021-04-18 21:42:54 +00:00
Diogo Trindade 5e2b04618d Initial Wooting One controller 
Commits squashed and amended for code style by Adam Honse <[email protected]
 2021-04-18 16:26:18 -05:00
Artur Pieniazek 65c626b8c1 Fix Corsair K95 Platinum software mode initialization 2021-04-18 20:49:28 +00:00
git 4110335e30 AsusAuraCore: Support Asus ROG Strix GA15DH. 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-04-18 15:38:53 -05:00
Cheerpipe 5ce9ddc40a Logitech G815 controller 
* All keys works, including media, G and light indicator.
 * mode 2 and 6 functions working to achieve "best" framerate.
 * Add a wakeup function to ensure that all keys works with the first command (just copy/paste bits from what GHub do)

Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-04-18 14:52:19 -05:00
Adam Honse 4dd061e880 Add direction control to RazerController Wave mode 2021-04-18 00:52:42 -05:00
TheRogueZeta cec9675e9a Add EVGA RTX 2080 SC Ultra Gaming PCI ID 2021-04-17 22:38:47 -07:00
TheRogueZeta 0d058ef576 Update EVGA Turing controller to expose HW modes 2021-04-17 22:38:02 -07:00
Chris 55c8ac8e3e Normalising the inverted value to fix #1326 
* Inverted value speeds need to be normalised when applying the value to
the slider as well as when reading from the slider
+ added code to UpdateModeUi() to address this
 2021-04-18 14:59:00 +10:00
jeffp1 bd3529b1d3 Added Sensei 310 PID, renamed files/classes to be generic to Sensei 
products.
 2021-04-16 15:59:50 -05:00
jeffp1 6c2013a6bf Added SteelSeries Sensei TEN 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-04-16 15:15:14 -05:00
TheRogueZeta b342e9a993 Add ASUS GTX 1080 ROG Strix A8G Gaming PCI ID. 2021-04-16 10:10:57 -07:00
Adam Honse 046abeb1ec Get wave mode working 2021-04-16 00:42:05 -05:00
Adam Honse c83ab4bbf6 Add wave mode function parameter for direction 2021-04-16 00:08:27 -05:00
Adam Honse b8f044b296 Enable wave mode for compatible Razer devices in RazerController 2021-04-15 23:31:42 -05:00
Adam Honse fea40cae6d Lower max brightness of EVision back to 4 2021-04-15 00:16:14 -05:00
Adam Honse 5c76284d54 Remove T-Dagger Bora as it is not an EVision/Sonix keyboard 2021-04-15 00:13:07 -05:00
Chris 727fd9efb9 Moved GB_Fusion2USB calibration & custom layout loading to config file 
+ Adding layout for Z390 AORUS MASTER-CF
+ Adding destructor to RGBController_GigabyteRGBFusion2USB.cpp to
'delete controller'

+ Allows custom layout saving to config
+ Custom config will save out to config if not present
+ Layout is enablable and disabled by default
+ Added a lookup map from mapping in config
+ Added a template for the reverse_map for saving to the config
+ Removed the header integers from the config to avoid invalid values
+ Changed internal mapping closer to JSON for ease of lookup
+ Added protection to the led count

+ Added calibration to config
* Disabled execution of calibration until explicitely enabled in config

Commit amended for code style of changes as well as general cleanup of RGB Fusion 2 USB controller by Adam Honse <[email protected]>
 2021-04-14 23:30:34 -05:00
Kasper 9b2296b0bc Fix sequence number having the wrong value 
* I'm really not sure what it is, but for some reason with the ternary operator the sequence number was ending up wrong - it would end up being 1 twice in a row, at startup it would be 0 when it should have been 1 and other issues. This fixes that
* Also made it atomic

Commit amended for code style by Adam Honse <[email protected]>
 2021-04-14 15:27:19 -05:00
Adam Honse b2736d6575 Add functions to RazerController for enabling Wave and Reactive modes 2021-04-13 22:30:24 -05:00
Adam Honse 2d9e7f85af Add usage page filtering for MSI Mystic Light 162-byte controllers 2021-04-13 19:33:30 -05:00
Adam Honse cc9e9ad6e3 Add ASUS ROG Strix GTX1080Ti Gaming 2021-04-13 19:15:30 -05:00
Simbaclaws 1ba0104ddd Added ASUS RX 5700XT Strix Gaming OC and RX 580 Strix Gamnig OC 
Commits squashed by Adam Honse <[email protected]>
 2021-04-13 18:34:06 -05:00
Adam Honse f1dc813782 Update RazerController detection for Kraken Kitty Edition 2021-04-13 15:04:48 -05:00
Adam Honse 4a7d74923f Update MSI usage and usage page to work on both Windows and Linux 2021-04-13 13:01:00 -05:00
Adam Honse f08a2edf01 Add usage and usage page to MSI Mystic Light 185-byte detector to prevent double-detection in Linux 2021-04-13 00:44:11 -05:00
Adam Honse d1f6bc1c27 Rename Mystic Light's Static mode to Direct. Allows effect engines to control MSI Mystic Light, but does not enable per-LED ARGB control 2021-04-13 00:18:44 -05:00
Adam Honse 987cfbbcfc Disable Crucial DRAM addresses that overlap Aura DRAM addresses until a proper detection fix can be implemented 2021-04-12 22:02:25 -05:00
Adam Honse c7e8eec328 Enable Razer Tiamat 7.1 V2 in RazerController 2021-04-12 13:28:26 -05:00
Chris 684594c801 Splitting the set mode code from the set colour code 
* Set mode is now only applied in
RGBController_MSIGPU::DeviceUpdateMode()
* Set color is now only applied in
RGBController_MSIGPU::DeviceUpdateLEDs()

- Removes extra (modes[active_mode].color_mode == MODE_COLORS_PER_LED)
check as it's already checked in calling function

+ Profile loading from CLI and GUI now works flawlessly as per #1252
 2021-04-12 23:30:53 +10:00
Adam Honse 503cb7c7fe Send resize command to Razer ARGB controller when resizing zones 2021-04-12 00:17:33 -05:00
Adam Honse 516aefeaa6 Make Razer Chroma ARGB controller outputs resizable 2021-04-11 21:24:46 -05:00
Adam Honse 78b4b8fa7c Add Razer Blade 15 (2021 Base model) 2021-04-11 12:08:27 -05:00
Chris 4ae8ea94ea Logging info and adding zeroed speed initialisation to fix #1241 
* Adding zeroed speed initialisation to modes that do not support speed to avoid bad save values in profile
* Bad values in saved profile will corrupt brightness calculation on load.
* Aligning profile version and header string
* Adding profile validation logging
* Adding success / failure logging for each controller when attempting to load profile

Commit amended by Adam Honse <[email protected]>
 2021-04-11 11:59:25 -05:00
Chris "koying" Browet e08c63a3c0 FIX: crash with older radeon drivers 
Commit amended for code style, including surrounding code, by Adam Honse <[email protected]>
 2021-04-11 11:52:18 -05:00
silas a3f2cd96c5 Fix OpenRGB not closing 2021-04-11 11:46:32 -05:00
TheRogueZeta 9dccdeff0e Add MSI RTX 2070 Armor OC ID. 2021-04-10 10:23:55 -07:00
TheRogueZeta 4661a56e35 Add Asus ROG GTX1660 Ti device ID. 2021-04-09 23:48:21 -07:00
Adam Honse a897d2c797 Fix newline on OpenRazer version and serial strings on Windows 2021-04-09 22:57:06 -05:00
Adam Honse b148bbe740 Initialize OpenRazer/OpenRazer-Win32 controller to disabled if not present in settings 2021-04-09 22:20:07 -05:00
Adam Honse bfdf620650 Enable Mystic Light 7C92 2021-04-09 22:09:14 -05:00
Adam Honse 4e179b06b6 Add breathing mode to Razer Kraken headsets using RazerKrakenController 2021-04-09 22:07:34 -05:00
Adam Honse 276c7e66e9 Update the detector settings list before running the detectors, so that the list is populated even if a detector crashes 2021-04-09 18:28:37 -05:00
morg b24f989dbc Ignore pre-detection argument (fixes #1300) 2021-04-09 16:48:56 +02:00
Chris 9f58584c05 Removing duplicate GetDeviceMode() entries from 
RGBController_CMMP750Controller.cpp
 2021-04-09 08:36:03 -05:00
Chris 1cc2c3c252 Resolving the Windows HIDAPI interface problem by changing the IPU macro to PU 
* Moved "Off" mode to last
* Created GetDeviceMode() to accomodate change
* Code formatting cleanup
 2021-04-09 08:35:46 -05:00
Adam Honse 49d2550815 Add device description for Base Station V2 Chroma 2021-04-09 00:46:51 -05:00
Adam Honse e506c34191 Create FUDING.yml for GitHub 2021-04-09 00:39:35 -05:00
Adam Honse 2af26eb9e9 Clean up Razer Blade laptop naming and add missing device descriptions 2021-04-09 00:36:42 -05:00
Adam Honse 9df6fed170 Clean up Razer Lancehead naming and add RazerDevices definitions for 2017 version 2021-04-08 23:04:53 -05:00
Adam Honse 2aaf23ef1e Add detectors for all remaining devices in RazerDevices.h and rename a few things 2021-04-08 22:47:08 -05:00
Martin Hartl 87150072c8 Asus Mainboard: Fix send color 
Byte 3 of the send color message is currently sending the channel id.
Byte 4 is set to a hard coded 0xff and 0x00 for mainboard LEDs and
addressable LEDs respectively. Apparently this is a 16 bit mask to
select the colors to be updated instead.

Commit amended for code style by Adam Honse <[email protected]>
 2021-04-07 23:02:21 -05:00
Niels Westphal fc463db074 Update Asus GPU controller to use PCI ID based detection. 2021-04-07 13:45:25 +00:00
KundaPanda 61d70f064d Add ISO/ANSI HyperX Alloy Elite 2 support 2021-04-07 13:44:01 +00:00
Kasper 6aa62c5002 Fix spacing 2021-04-07 00:42:30 +03:00
Kasper 3297742203 Fixed the matrix again 
Last time
 2021-04-06 08:36:35 +03:00
Kasper bcbd4f88be Implement a controller for Corsair Hydro Platinum AIO coolers 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-04-04 23:18:20 -05:00
Kasper d8bc1c9042 Fixes an issue where the LED colors show incorrect colors 2021-04-04 19:10:15 -05:00
KundaPanda b572c15cce Add HyperX Alloy Elite 2 support 
Squash commits and code style changes, minor reworks to match Alloy Elite 1 code by Adam Honse <[email protected]>
 2021-04-04 19:05:32 -05:00
sakloui 2ae12c52ec Updated DuckyKeyboardController with 2ms delays between each packet sent 
This should fix the issue where Ducky keyboards would softlock

Commit amended to move delays to packet send functions by Adam Honse <[email protected]>
 2021-04-04 15:53:57 -05:00
Adam Honse 0fd106cb92 Enable MSI Mystic Light 7C90 2021-04-03 15:02:07 -05:00
KundaPanda 26e4c76f03 Add V2 Gainward Controller for new NVidia GPUs 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-04-03 14:43:26 -05:00
KundaPanda 2b6a3e19ea Enable LED select box for mode-specific color mode 2021-04-03 19:23:02 +00:00
KundaPanda c8e3554442 Initialize led_count in MysticLight controllers to prevent occasional crashes 2021-04-03 21:03:30 +02:00
Pol Rius 37e021fb1c Add dualshock 4 wireless adapter 2021-04-03 18:41:41 +00:00
Pol Rius bd12100a07 Add second PID for ROG Chakram mouse 2021-04-03 18:29:13 +00:00
Adam Honse e0c5909757 Fix some issues with Yeelight that prevented a different model bulb from working 2021-04-03 13:15:12 -05:00
Adam Honse 81590d8321 Enable MSI Mystic Light 7C86 as it has been tested 2021-04-01 11:00:37 -05:00
TheRogueZeta 1c5a11f426 Add Deskmini Addressable LED Strip PID + Detector 2021-04-01 15:15:58 +00:00
Adam Honse c9e8602f85 Add T-Dagger BORA VID/PID to EVision Keyboard Controller 2021-03-31 22:48:15 -05:00
Adam Honse 27784db5e1 Implement matrix type field for Razer controllers to reduce redundant code 2021-03-31 22:27:30 -05:00
denk_mal db9146147b activate controller for Metadot Das Keyboard 5Q 2021-03-31 12:05:31 +02:00
denk_mal 84f7f32ec2 reformat code 2021-03-31 11:13:44 +02:00
denk_mal 3a270cbea7 handle hid get error and avoid buffer overflow error 2021-03-31 11:13:17 +02:00
denk_mal e69b59d339 resend data on hid send errors 2021-03-31 11:13:13 +02:00
denk_mal 59752dce98 move call of SetupZone from class constuctor to load function 2021-03-31 11:13:06 +02:00
denk_mal 813069a359 remove unused class variables 2021-03-31 11:13:00 +02:00
Adam Honse d5e344f9d9 Add missing keepalive_time parameter back to E1.31 json config 2021-03-30 13:55:10 -05:00
Adam Honse a77792a996 Disable Zalman Z Sync Controller due to bricking, cause unknown, but seems to also happen with official software 2021-03-30 12:23:16 -05:00
Adam Honse 0280ac3b29 Mask off speed bits in MSI Mystic Light controller 2021-03-30 08:53:58 -05:00
Adam Honse d4ae75c512 Add one and two color breathing modes to RazerController 2021-03-29 23:28:23 -05:00
Adam Honse 9cab2437d2 Add random breathing mode to RazerController 2021-03-29 22:38:36 -05:00
Adam Honse a94b43ee3d Scan for an open port, so that multiple Yeelight controllers can be in music mode at the same time 2021-03-29 19:36:23 -05:00
Adam Honse 3e9993a6a4 Add Yeelight music mode, enabled with "music_mode" option in Yeelight configuration. Probably only works for one light right now. 2021-03-29 18:52:38 -05:00
Adam Honse a5a9482206 Fix log folder creation on MacOS 2021-03-29 15:49:12 -05:00
Adam Honse 212c3e6297 Add universe_size field to E1.31 configuration to set number of channels per universe 2021-03-28 23:57:33 -05:00
Chris 501a1ff489 Updated parsers to allow GUI to run implicitly for -v, -vv and --print- 
source options

* Added cfg_args counter for each in cli_pre_detection()
* Added each to the ignore options in ProcessOptions()
* Includes slight update to OptionHelp()
 2021-03-28 22:27:27 +11:00
Adam Honse 827b75320c Fix profile versioning. Profile version 1 used protocol version 0. Move profile version up to 2 using protocol version 2 and keep them synchronized if a new protocol version is added 2021-03-28 01:40:48 -05:00
Jan Henrik Müller 8e1cb178ca Add real Gigabyte RTC2070 Super Gaming OC 2021-03-28 01:07:13 -05:00
Chris 067aa4d88a Adding logging notices to ResourceManager to track explicit hid_init() and hid_exit() 2021-03-28 01:03:42 -05:00
Chris d926754745 Adding "--loglevel" to ignore list in cli::ProcessOptions 2021-03-28 00:55:40 -05:00
Chris ae8b502ad2 Gathering logging info to fix #1241 
* Aligning profile version and header string
* Adding profile validation loggging
* Adding success / failure logging for each controller when attempting
to load profile
 2021-03-28 00:53:10 -05:00
kevin wulff e3f7394498 Added z390 Pro Carbon and Gaming Edge MB 2021-03-28 00:43:51 -05:00
morg 8ef9f622f1 Fix memory leak (RGBController::GetDeviceDescription) 2021-03-27 22:15:24 +01:00
Adam Honse e848be5159 Add ASUS ROG Strix Flare PNK LTD 2021-03-27 11:44:48 -05:00
Adam Honse 2103982d7d Add Asus Aura Keyboard controller for ROG Strix Flare (Direct mode only for now) 2021-03-27 00:26:50 -05:00
k1-801 1fdd4379a7 Small adjustments in LogManager 2021-03-24 11:39:26 -05:00
silas 460e53368d Fix bad matrix for custom debug devices 2021-03-24 08:56:14 -05:00
silas 905d52ca57 Make spin box values be correct on startup 2021-03-24 13:40:29 +00:00
Chris d65def0179 Fixing --help string for -p option 
* Tweaked the profile mananger to allow to load profiles either with or
without the file extension
* Changed the --help string to reflect the change
 2021-03-24 08:18:07 -05:00
Adam Honse 69cb7a0d9e Use resource manager to register I2C interfaces and log them 2021-03-24 01:22:48 -05:00
Adam Honse ec90f4678b Change all I2C/SMBus detectors to use RegisterRGBController 2021-03-23 20:41:50 -05:00
k1-801 f1d6c2953d Logger tweaks 
Commit amended for code style and minor cleanup by Adam Honse <[email protected]>
 2021-03-23 20:20:52 -05:00
Adam Honse 0089852395 Rename RedragonK556Controller to EVisionKeyboardController 2021-03-23 14:40:08 -05:00
Chris 8492a8c76e Prevent profiles loaded on startup from being overwritten 2021-03-23 12:47:27 -05:00
Adam Honse 16cc5ce6d4 Enable Mystic Light 7C80 2021-03-20 09:52:19 -05:00
Adam Honse 3230a18f98 Rename G502 static mode to direct after verification that it qualifies as a direct mode 2021-03-16 20:58:09 -05:00
Adam Honse 0bf9156374 Add MSI-RGB board 7A34 (MSI B350 PC Mate) 2021-03-16 20:04:43 -05:00
Adam Honse f5d9a4e79f Add 7B12 to 162-byte Mystic Light list 2021-03-13 15:23:49 -06:00
Adam Honse 0022371d64 Clean up MacOS section of OpenRGB.pro 2021-03-13 15:03:18 -06:00
Adam Honse 33957755c3 Use arch x86_64 2021-03-13 14:56:50 -06:00
Adam Honse bac68ee861 Check MacOS architecture and add Intel MacOS build target 2021-03-13 14:50:59 -06:00
Adam Honse 288a1deb91 Enable Mystic Light 7C76 2021-03-13 13:59:25 -06:00
Adam Honse 62b99bb83d Add 7C84 to supported MSI Mystic Light PIDs 2021-03-12 00:00:10 -06:00
Adam Honse 19f0dde82c Add more tested Mystic Light boards 2021-03-11 16:11:19 -06:00
Adam Honse d3da09f47e Add Razer Firefly V2 to OpenRazer device list 2021-03-09 10:05:13 -06:00
Mervin de Ruiter 526a4daae2 Added support for HUE 2 Cable comb 2021-03-09 00:29:16 -06:00
Adam Honse 7531ea3b2f Update OpenRazer-win32 to OpenRazer commit 1316cb9 2021-03-08 23:51:42 -06:00
Biswapriyo Nath 9e9a91a048 SettingsManager: Catch exception with constant reference parameter. 
This fixes warning: catching polymorphic type 'class std::exception' by value.
 2021-03-09 04:31:21 +00:00
morg e1faa783b6 Add new CLI option, separate auto-detect and auto-connect 2021-03-08 22:25:37 -06:00
silas 30c595c6d6 Fix building on Qt6 2021-03-08 22:06:11 -06:00
Chris e46325cbea Updated CM ARGB Controller to v0023 protocol 
* All RGB Modes are working
* All ARGB Modes are working sans Direct
* Direct Mode left available so zones are resizable

Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-03-08 21:57:40 -06:00
Adam Honse 1cd0269f60 Move MSI Mystic Light 7C56 to enabled PIDs as it has been tested 2021-03-08 11:49:46 -06:00
Diogo Trindade a8408d0956 Added razer blackwidow v2 keymap 2021-03-08 13:50:11 +00:00
Chris 9767f97719 Initial commit for the Riing Quad Fan Controller Hub 
* Only looks like a direct mode controller
* Implemented just that mode
* Likely needs an Effect Engine (EE) to drive it

Commits squashed and amended to more closely match existing Thermaltake Riing controller by Adam Honse <[email protected]>
 2021-03-07 21:40:39 -06:00
Adam Honse c401413cb1 Move MSI Mystic Light 7C91 to enabled PIDs as it has been tested 2021-03-07 21:17:41 -06:00
Adam Honse 130e14a26a Move MSI Mystic Light 7C75 to enabled PIDs as it has been tested 2021-03-07 21:01:57 -06:00
Adam Honse 5729e7436c Move MSI Mystic Light 7C35 to enabled PIDs as it has been tested 2021-03-07 14:18:59 -06:00
Adam Honse 090c6421a4 Enable two tested MSI Mystic Light PIDs. Leaving untested ones disabled for now 2021-03-06 23:58:40 -06:00
Adam Honse 7e06b7f3a5 Group pipe and onboard LEDs into zones 2021-03-06 23:46:18 -06:00
Adam Honse 5695a55411 Add MSI Mystic Light 162-byte controller 2021-03-06 23:34:45 -06:00
Adam Honse 40bf2b75b8 Clean up MSI Mystic Light code for 185-byte devices 2021-03-06 22:54:05 -06:00
jath03 ec245617f6 Adding a new SDK version for profile controls 2021-03-06 08:36:31 +00:00
k1-801 e050ca8350 Glory! 2021-03-06 00:21:06 -06:00
Adam Honse 5a5cc52a80 Fix segfault for Sinowealth (Glorious) 2021-03-05 22:51:33 -06:00
Adam Honse a08fb8b532 Move plugin initialization into PluginManager and log plugin loading 2021-03-05 16:58:06 -06:00
Luca Lovisa 00a47f600c Restrict MacOS build to original project 2021-03-05 21:03:40 +00:00
k1-801 ca11939277 Add LogManager and add log messages for the detection process 
Commit amended for code style and to remove unrelated changes by Adam Honse <[email protected]>
 2021-03-05 14:57:53 -06:00
silas 78ea2ee8f0 Ready To Merge™ 2021-03-05 17:12:36 +00:00
Aleksey Krichevskiy 75a14f2250 ProfileManager: trunc flag to file overwrite 2021-03-05 11:09:16 -06:00
Aleksey Krichevskiy bca9407f70 OpenRGBDialog2: Save Profile button with Save Profile As menu 2021-03-05 11:01:18 -06:00
silas 874a63bab7 Add large comment block 2021-03-05 16:45:54 +00:00
silas 7f90efa75b Move topTabLoaded bool as morg suggested 2021-03-05 16:45:54 +00:00
Adam Honse df92064e20 Add ASUS ROG Gladius II PNK LTD 2021-03-04 15:47:00 -06:00
Adam Honse 126b1b4841 Clean up serial_port class and add MacOS support (only standard baud rates for now) 2021-03-04 12:22:17 -06:00
Adam Honse f1107fc2a5 Add Gigabyte GTX1080Ti Gaming OC BLACK 11G 2021-03-04 08:13:16 -06:00
Adam Honse a0078b6a5e Add MacOS build instructions to README 2021-03-04 00:20:18 -06:00
Adam Honse 22d73da536 Add MacOS target to CI 2021-03-03 23:44:14 -06:00
silas 52a9120257 Fix Hue box not updating when set all is used 2021-03-04 04:44:05 +00:00
Adam Honse 313bc8b616 Fix Razer Charging Pad Chroma detector so it doesn't detect twice 2021-03-03 18:49:39 -06:00
Adam Honse 2915133d96 Update paths for homebrew on Apple Silicon Macs and use Qt Fusion theme on MacOS 2021-03-03 17:14:45 -06:00
Cheerpipe 7c272a909d Small performance and stability tweaks 
Performance: Don't set mode on each zone change.
Stability: Fix read buffer size to avoid command corruption - Increase command delay if there is any volume change command conflict.

Commits merged and amended for code style by Adam Honse <[email protected]>
 2021-03-02 21:10:04 -06:00
Josh e58fb8935c Support for EVGA GeForce RTX 2070 SUPER XC ULTRA+ 2021-03-03 02:37:07 +00:00
Adam Honse 8437be2304 Define USE_HID_USAGE on MacOS 2021-03-02 18:26:32 -08:00
Adam Honse fdab8a2066 Ignore interface check for non-safe-mode as well 2021-03-02 20:23:49 -06:00
Adam Honse c3c4b3a8eb Ignore interface check if usage page or usage is checked 2021-03-02 19:22:47 -06:00
CoffeeIsLife 3b9f07d52e Switch RazerController to IPU detector macro to prevent multiple instances of devices in Linux with older hidapi versions 
Commit amended for code style by Adam Honse <[email protected]>
 2021-03-02 19:21:20 -06:00
Luca Lovisa ed48c9634c Fix cli profile mode loading 2021-03-01 23:14:36 +01:00
Martin Hartl ea31b37f91 Asus USB: Remove commit write 2021-03-01 21:24:49 +01:00
Adam Honse 03bf5eb50d Add message queue to speed up FanBus updates 2021-03-01 13:42:45 -06:00
Adam Honse 15829e4dfe Add the rest of the Kraken USB PIDs 2021-03-01 11:05:37 -06:00
Adam Honse 25484a6152 Add Razer Kraken controller based on OpenRazer 2021-02-28 17:42:08 -06:00
silas 11b3f55b94 Fix Color Wheel background 2021-02-27 10:26:45 -06:00
silas 27fb7984f8 Accidentally didn't test enough 
loading something like the updates plugin (Which appears in the info tab) would make it load multiple times
This commit fixes that
 2021-02-26 17:16:39 -06:00
silas aea6f82026 Fix OpenRGB not closing when min to tray was on 2021-02-26 16:27:34 -06:00
silas f4ab8bd14a Fixed :) 2021-02-26 18:57:01 +00:00
edbgon 5afca1758d Fix for RX 6000 segfault when in "off" mode (!374) 2021-02-26 12:55:29 -06:00
Adam Honse 398c347b20 Add Gigabyte GTX1080Ti Xtreme and rename existing Xtreme to Xtreme Waterforce, as they apparently have different IDs 2021-02-26 09:45:36 -06:00
jath03 84861ef989 Fixing profile loading #1135 2021-02-26 08:17:44 -06:00
silas ea6e961a13 Added some sleeps as well as other changes to the Corsair Vengeance Pro controller 
Changed the way direct is handled for corsair devices

Commit amended for code style by Adam Honse <[email protected]>
 2021-02-25 09:22:34 -06:00
morg 50fc6308d7 Update EE plugin link in README 2021-02-22 19:45:32 +01:00
TheRogueZeta e4e2f8d73e Add Logitch G303 based on G403 2021-02-20 21:52:53 +00:00
Martin Hartl e0e46f2ceb Logitech: Fix HID usage on Linux 2021-02-20 22:26:55 +01:00
Chris 80f4e5137e Quick formatting change to correct upstream issue and refresh issue 
templates
 2021-02-20 22:13:29 +11:00
Jack f844108022 Removing .orp extension from profile names 2021-02-19 03:29:39 +00:00
TheRogueZeta f0fbe17456 Add Gainward GTX 1080 Phoenix 2021-02-19 03:12:57 +00:00
Adam Honse 4b1c68abd2 Add Gigabyte 3060Ti EAGLE OC 8G 2021-02-17 12:05:11 -06:00
TheRogueZeta dc9d977efe Add KFA2 RTX 2080 EX OC sub device ID 2021-02-16 23:42:31 -08:00
William Wilson 65e5674b4f Add support for the Gigabyte RTX 3070 Vision 2021-02-16 15:47:31 -06:00
Chris 2b2478fea5 Initial Commit for new device Coolermaster Small ARGB Controller 
* Added a new controller class
* Compiles cleanly

Commits squashed by Adam Honse <[email protected]>
 2021-02-15 09:33:58 -06:00
Adam Honse 88eb979544 Change device type for Razer Nommos to Speaker 2021-02-15 08:47:43 -06:00
Cheerpipe e9f3a1b3b9 Logitech G560 initial support 
Logitech G560 Speaker working with Direct Mode using same bits as the Logitech Ambilight and Audioviz. Other modes are not working (get) as expected.

Note: G560 Direct mode is slow because Logitech hardware implementation but it is working.

Changing volume at the same time colors are changing can reduce FPS because G560 uses the same channel for led and audio modes commands.

Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-02-15 08:45:57 -06:00
TheRogueZeta 00b8e74239 Add Deathadder Essential and Deathadder Essential White Eddition 2021-02-15 14:35:56 +00:00
Mike Achtelik e9107276cf Add support for latest Crucial Ballistix RGB RAM 
The latest RAM modules all show up at address 0x27 instead of 0x20-0x23.
So lets remap them so they can be detected and controlled individually.
Since other RGB software can already handle them add and assign the
addresses used there as well.
 2021-02-15 14:30:00 +00:00
Chris d5336c9f36 Adding "X570 AORUS ELITE WIFI" to GBFusion2USB layouts as per faux1234 2021-02-15 14:28:15 +00:00
denk_mal 029a04cee8 Das Keyboard version check and udev rules 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-02-15 08:26:06 -06:00
Adam Honse ae4857e24e Add Razer Chroma PC Case Lighting Kit detector 2021-02-12 11:03:30 -06:00
Adam Honse 99f9b6daa9 Add Razer PC Case Lighting Kit 2021-02-12 10:44:14 -06:00
Adam Honse ce22bcfb86 Razer Mug Holder requires device mode change 2021-02-11 16:57:16 -06:00
Diogo Trindade f63aec118c Fixed profile string sdk response not being null terminated 2021-02-10 23:10:57 +00:00
Adam Honse faf7f65372 Add tooltips to the device tabs so that you can see names that are too long to fit on the tab 2021-02-10 16:39:19 -06:00
Alexey Sokolov 367d01ceff Add description tooltips for common modes 
Partially addresses #232

Commits squashed and amended for code style and to remove QItemDelegate by Adam Honse <[email protected]>
 2021-02-10 13:11:21 -06:00
Adam Honse e20f7f3a44 Remove WIN32 check around Razer ARGB detector, it is needed in Linux too 2021-02-10 01:02:45 +00:00
Adam Honse 1817d3ac4a Only register detector for interface 0 of Razer ARGB controller as detector code looks for interface 1 on its own 2021-02-09 17:53:10 -06:00
Adam Honse 2fd21992b0 Add Razer Chroma Addressable RGB Controller to RazerController 2021-02-09 16:51:25 -06:00
morg 79dacbaeb0 Fix crash on server stop 
Commit amended to initialize listening variable by Adam Honse <[email protected]>
 2021-02-09 16:34:25 -06:00
alpemwarrior 300e2b526b rename static to direct, as we don't save to flash memory 2021-02-09 16:02:44 +01:00
Adam Honse cdbf9736ae Modify RazerController to work on Linux 2021-02-08 20:58:02 -06:00
TheRogueZeta aed1409eed Add whitespace in Polychrome controller lists. 2021-02-08 14:34:54 +00:00
alpemwarrior 18fd5c75ee add superio udev rule 2021-02-08 14:31:18 +00:00
edbgon 67031bc004 Mode specific fixes 2021-02-08 08:30:19 -06:00
edbgon 5a7e6ae8d4 Fixes for mode specific color 
Code style changes by Adam Honse <[email protected]>
 2021-02-08 08:29:13 -06:00
santeri3700 f7a68e6fe2 Add support for HyperX Pulsefire Dart 
Commit amended to address review comments by Adam Honse <[email protected]>
 2021-02-06 14:05:40 -06:00
morg 5b35e64fbe Add a toggle all checkbox on supported devices page 2021-02-06 19:56:01 +00:00
Dredvard 065bbd249c Initial support for ASRock Polychrome USB Controller 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-02-06 13:53:54 -06:00
edbgon f7bcadd9ed Add initial support for AMD Radeon 6000 series reference cards 
Commits from edbgon, bobris, and Dr_No squashed and code style changes by Adam Honse <[email protected]>
 2021-02-06 13:36:06 -06:00
JesusSanches 16c34572ed Added Naga Trinity to Razer Detect cpp 
Commits squashed and code cleanup by Adam Honse <[email protected]>
 2021-02-06 11:55:29 -06:00
K900 267dfff247 SapphireGPUController: reimplement configuration readback 
Commit amended for code style by Adam Honse <[email protected]>
 2021-02-06 11:45:24 -06:00
Ildar Gainanov bae1e08732 Add MSI GTX 1660 Super Gaming 2021-02-06 18:58:40 +03:00
morg e2bc1003e6 Add profile management to SDK 
Commit amended for code style by Adam Honse <[email protected]>
 2021-02-05 19:13:50 -06:00
Martin Hartl 3026feeebe DS4: Check return value of get serial call 2021-02-06 01:07:28 +00:00
morg 96bbb5a69f Prevent out of bounds access 2021-02-05 21:41:53 +00:00
morg dba814215d Fixing memory leaks in controllers 2021-02-05 16:25:46 +01:00
Chris aa59c6132e Adding X470 AORUS Gaming 7 Wifi 50 to the Gigabyte Fusion2 SMBus Detector 
* As confirmed by LimitingFactor on Discord
* https://www.gigabyte.com/Motherboard/X470-AORUS-GAMING-7-WIFI-50-
rev-11#kf
 2021-02-04 21:02:13 +11:00
Th3d0nGsT3R 35c76887db Add Firefly V2 and Basilisk Essential to RazerController 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-02-03 23:33:42 -06:00
Chris 4df33a2ad2 Adding the GeForce GTX 1080 Ti Gaming OC 11G 
* As per Sharky_PI on Discord
 2021-02-03 14:18:39 +00:00
K900 f7756c003f SapphireGPUController: Implement Nitro Glow V3 
Commit amended for code style and to squash commits by Adam Honse <[email protected]>
 2021-02-03 00:56:20 -06:00
Adam Honse 50219f231a Fix missing default case in Razer custom frame 2021-02-01 16:54:49 -06:00
Morg 77d5e6c550 Add link to OpenRGBRemote repo 2021-02-01 14:14:18 +01:00
Adam Honse 7c7fe16ab9 Disable modes for Zalman Z Sync 2021-01-31 20:19:04 -06:00
Adam Honse 51142d6ab6 Copy Corsair Lighting Node code to Zalman Z Sync code as the two use the same protocol 2021-01-31 17:06:03 -06:00
Adam Honse 578157f44d Initial implementation of Zalman Z Sync controller 2021-01-31 00:33:51 -06:00
Adam Honse a00c259b96 Add function for setting device mode 2021-01-29 23:00:41 -06:00
Adam Honse fdf8d0a093 Add Razer Charging Pad Chroma support, direct mode only for now 2021-01-29 22:14:08 -06:00
Fabricio Zimmerer Murta 271e98c733 Un-swapped zones in Razer Deathadder V2 mice. 
The logo and wheel zones were swapped in the zones definitions header
file.
 2021-01-29 00:24:50 -06:00
Fabrício Zimmerer Murta 776f512d11 Skips Razer device loading if invalid data is received. 
This probably happens due to a general issue with OpenRazer windows
driver.

The "fix" here, simply skips loading the driver if it identifies the
device information fetched doesn't make sense -- instead of employing
NULL references at run time.

The proper fix for this issue seems to be completely remove this razer
support and move to the new RazerController approach being developed in
razer_controller branch.

Related issue: #1047.
 2021-01-29 06:23:04 +00:00
Adam Honse 6969542e2d Initial commit of standalone Razer controller 2021-01-29 00:10:42 -06:00
Adam Honse 4fa5b413ee Check the validity of the PCI device string in AMD ADL I2C driver to prevent crash if the string is malformed 2021-01-28 18:03:52 -06:00
Trevor Rowbotham f977598392 Add EVGA RTX 2080 XC BLACK 2021-01-27 20:16:56 +00:00
Kasper 80decf1482 Update SetCustomMode to change to static mode instead of off 2021-01-27 12:42:25 +02:00
denk_mal 582afad557 Das Keyboard 4Q Fix-up 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-01-26 12:17:43 -06:00
Morg 6ca1c1af35 add sdk projects 2021-01-25 23:53:17 +01:00
Adam Honse 92999a06f1 Add Gigabyte RTX2080 (non-A) GAMING OC 8G 2021-01-25 14:04:59 -06:00
Adam Honse c682767d81 Add Hue 2 Underglow (200mm) to Hue 2 accessory list 2021-01-25 13:18:41 -06:00
denk_mal bab18473aa Add support for Das Keyboard 4Q 
Commit amended for code style by Adam Honse <[email protected]>
 2021-01-25 10:15:44 -06:00
silas ae23037cce Add underglow matrix zone to debug keyboard 
Amended by Adam Honse <[email protected]>
 2021-01-25 09:27:37 -06:00
silas ca9ab8989b Add proper Direct control of Corsair Vengeance Pro 
Amended for code style and to remove unrelated functionality by Adam Honse <[email protected]>
 2021-01-25 09:08:18 -06:00
Adam Honse 64e948073d Add Corsair Glaive RGB 2021-01-22 09:33:03 -06:00
Icenowy Zheng 1df7a45691 Add support for Gigabyte GTX1050 Ti G1 Gaming 
This card seems to be controllable in the same way as GTX1080 G1 Gaming.

Signed-off-by: Icenowy Zheng <[email protected]>
 2021-01-22 06:15:10 +08:00
Morg f955303e0a Make sure to delete QTabWidget after removal 
Commit amended for code style by Adam Honse <[email protected]>
 2021-01-21 15:00:18 -06:00
XeR addd173944 Add support for Gigabyte GTX 1650 Gaming OC 2021-01-21 11:53:33 +01:00
Adam Honse 99dfeef77c Use a mirror for Qt download because download.qt.io is down 2021-01-19 17:12:50 -06:00
Adam Honse 49bc09d9c2 Initial Yeelight support 2021-01-18 17:52:25 -06:00
mrblade 25a1ad9de7 Add support for Corsair K55 
Commits squashed and amended for code style by Adam Honse <[email protected]>
 2021-01-17 17:51:34 -06:00
Adam Honse aec70382f5 Add plugins section to README 2021-01-17 17:42:55 -06:00
alpemwarrior 4bbb824ce1 check for msi dmi without trailing dot 2021-01-17 15:35:32 +01:00
Adam Honse 82eade005e README cleanup 2021-01-15 00:17:19 -06:00
Adam Honse 48125a38a2 Add Adalight protocol support to LED Strip controller 2021-01-15 00:08:33 -06:00
Adam Honse 524fefc7d5 Clean up Keyboard Visualizer protocol code 2021-01-14 17:28:42 -06:00
Adam Honse ae5143a520 Update description of LEDStrip since it now supports multiple protocols 2021-01-14 17:04:22 -06:00
Adam Honse 5503560775 Add TPM2 protocol support for LED Strip controller 2021-01-14 17:00:07 -06:00
TheRogueZeta 4a1a6cde5d Correct command to run and add git to debian cmd. 2021-01-13 23:52:05 -08:00
Aurum 639894718d Added G610's second PID 
Commit amended for code style by Adam Honse <[email protected]>
 2021-01-13 17:02:23 -06:00
Adam Honse 36a9fb85fe Fix Windows build 2021-01-12 17:59:25 -06:00
Adam Honse 117500ad04 Add FanBus support 2021-01-12 17:42:18 -06:00
staticdev 2a2c0f010c Fix readme instructions 2021-01-10 20:01:15 +01:00
silas 667a24a63a Add waitfordevicedetection to resourcemanager interface 2021-01-09 18:00:06 +00:00
Chris M 98244a2b6f Changing SetCustomMode to resolve #955 
* Setting Active mode to MSI_GPU_MODE_STATIC at index 2
 2021-01-09 17:59:28 +00:00
jath03 e4ec0fa46b Fixed GUI not starting when configuration flags are used 2021-01-07 22:39:29 -08:00
silas b1b260d7cf A bit of cleanup (Remove depreciated entry from PluginInfo Struct) 2021-01-07 12:10:27 -06:00
TheRogueZeta e956ab419b Add EVGA 1070 Ti FTW2 2021-01-06 16:29:23 +00:00
Adam Honse 3ad57aba9a Interfaceify RGBController so it can be used in plugins, add GetDetectionPercent to Resource Manager interface so it can be used in plugins 2021-01-06 00:34:26 -06:00
silas 75df81f972 Allow closing to tray by setting "minimize_on_close" to true in settings key "Minimize" 
Code changes and setting key name change by Adam Honse <[email protected]>
 2021-01-05 20:28:32 -06:00
Chris be7ca2a16c Update udev rules to allow for normal user control on Asus TUF Laptops 
* Resolves #938
 2021-01-06 13:12:22 +11:00
silas 93231c3225 Initial commit for Plugins 
Commits squashed, code style and naming changes by Adam Honse <[email protected]>
 2021-01-05 20:07:13 -06:00
Alex Avance 5f5d50ffd8 Enable profile loading for gui and server 2021-01-04 02:15:57 +00:00
TheRogueZeta c83433ac06 Add Razer Viper to OpenRazerDevices.h 2021-01-02 21:17:01 -08:00
Martin Hartl 7a8c4dd2a6 Support hidraw USAGE/USAGE_PAGE 
* Support hidapi 0.10.1 and newer
 2021-01-02 14:03:54 -06:00
edo-2313 6454f6c5f2 Added support for Holtek based mousemats 
Commits amended and squashed by Adam Honse <[email protected]>
 2021-01-01 19:03:10 -06:00
Adam Honse c20ecbffe5 Revert changes to ResourceManager.cpp 2021-01-01 18:28:33 -06:00
Chris b0d12c5850 Corrected mode assignment read from device in constructor 2021-01-01 16:52:33 -06:00
Chris 215baa487a Corrected Logical errors in ResourceManager.cpp 
* Removed comparison of -1 to unsigned int
* Corrected comparison of current_device to HID_INTERFACE_ANY
* Exposed downstream errors in Windows implementation of CM_MP750
controller corrected
* Added "Off" mode
 2021-01-01 16:52:27 -06:00
TheRogueZeta 14834e1e28 Add EVGA RTX 2070 XC Gaming 2020-12-30 17:09:23 -08:00
TheRogueZeta 7628fe5491 Add EVGA RTX 2080Ti XC Ultra 2020-12-30 17:00:14 -08:00
TheRogueZeta d91d53ceae Update pci_ids.h and add MSI RTX 2080 GAMING TRIO 2020-12-29 16:09:36 -08:00
TheRogueZeta b920aed734 Add Gigabyte RTX2070 Gaming OC 8G 2020-12-28 13:36:22 -08:00
Marcel B fc133dc5d1 Add MSI RTX 3090 Suprim X 2020-12-27 15:58:54 +00:00
jath03 e673b9d331 fixing gui not starting 2020-12-26 01:58:25 -08:00
jath03 5c50cc2ca9 Stopped GUI from starting when only --server flag is set 2020-12-26 03:20:10 -06:00
thombo 36380457d6 Gigabyte RTX2070S Gaming OC graphics card added 2020-12-26 03:17:41 -06:00
Adam Honse 6c3baf477c Add controller for HyperX Pulsefire FPS Pro mouse (new NGenuity firmware) 2020-12-26 03:05:46 -06:00
Adam Honse 5c30255a06 Add bounds check on matrix map index to prevent crashing when matrix map has an out-of-range entry 2020-12-23 18:00:34 -06:00
Thomas Karl Pietrowski 3579a2b529 Fixing upgrade-ability of latest Debian packaging 
Seems to be unwanted in the current deployment pipeline of the project.

Signed-off-by: Thomas Karl Pietrowski <[email protected]>
 2020-12-23 18:53:10 +00:00
Chris M c7323e8eb5 Update New Device.md to address #883 2020-12-22 06:16:43 +00:00
alpemwarrior d386b4cf4f add layout 2020-12-21 20:27:08 -06:00
alpemwarrior 5464fc0c19 try to add two last columns 2020-12-21 20:27:03 -06:00
TheRogueZeta 58a7201aa4 Add Gigabyte GTX 1060 Xtreme Gaming 2020-12-22 02:25:27 +00:00
TheRogueZeta 1d317ebbb5 Add MSI RTX 3060 Ti Gaming X Trio 2020-12-21 14:54:01 -08:00
TheRogueZeta de01f8beb9 Add Gigabyte RTX 2080 Gaming OC 2020-12-18 20:31:09 -08:00
TheRogueZeta 64bb8fac2c Alpha sort list 2020-12-18 20:30:05 -08:00
TheRogueZeta ef0a4c31ad Add MSI GeForce RTX 3080 Suprim X 10G 2020-12-12 11:48:29 -08:00
Adam Honse 0fd302b7d1 Reload sizes when changing configuration directory 2020-12-09 12:24:05 -06:00
Chris Jones abf8072710 Add Asus ROG Chakram mouse (wired and 2.4GHz wireless) 
Commit amended by Adam Honse <[email protected]>
 2020-12-09 10:34:24 -06:00
alpemwarrior 03bf187c7b Filter msi-rgb by dmi 
Commits squashed by Adam Honse <[email protected]>
 2020-12-08 23:22:15 -06:00
Niels Westphal 70028e6d23 Corsair K95 / Platinum Fixes 2020-12-09 04:39:45 +00:00
TheRogueZeta b733600f4f Add additonal cards 2020-12-07 21:33:31 -08:00
Jan Wendland 9d5b2a705b Add AllMyLights to apps supporting OpenRGB SDK 2020-12-08 05:08:48 +00:00
Chris 42a6bfc2ec Small change to OpenRGB.pro to address #824 
* explicitly declaring c++14 for unix:!macx
 2020-12-07 23:06:50 -06:00
Chris 836dc03adf Amended the New Device template with the new label types and included a 
checklist for admin purposes
 2020-12-08 15:10:33 +11:00
TheRogueZeta 8dc4f1f660 Add AORUS GTX 1080 Ti 11G 2020-12-07 20:00:33 +00:00
k1-801 8d3de51a71 One more inter-faceless HID 2020-12-07 23:29:37 +04:00
Jack b2ccea552e Added Gigabyte GTX 1660S Gaming OC PCI id 2020-12-07 14:33:53 +00:00
Adam Honse e43d7f8ba5 Increment version number post-release 2020-12-06 21:22:37 -06:00
485 changed files with 42374 additions and 5011 deletions
Expand all files Collapse all files
.github/FUNDING.yml
+12
View File
@@ -0,0 +1,12 @@
# These are supported funding model platforms
github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
patreon: CalcProgrammer1
open_collective: # Replace with a single Open Collective username
ko_fi: # Replace with a single Ko-fi username
tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
liberapay: # Replace with a single Liberapay username
issuehunt: # Replace with a single IssueHunt username
otechie: # Replace with a single Otechie username
custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
.gitlab-ci.yml
+339 -36
View File
@@ -16,6 +16,7 @@
stages:
- build
- test
before_script:
- echo "started by ${GITLAB_USER_NAME}"
@@ -23,21 +24,22 @@ before_script:
#reusable templates
.ccache_init: &ccache_init
before_script:
- apt update
- apt install -y build-essential qtcreator qt5-default libusb-1.0-0-dev libhidapi-dev pkgconf wget git
- export QT_SELECT=qt5
- export APPIMAGE_EXTRACT_AND_RUN=1
#-----------------------------------------------------------------------#
# Linux (AppImage) 32-bit Build Target #
#-----------------------------------------------------------------------#
build_linux_32:
"Linux 32 AppImage":
<<: *ccache_init
image: i386/ubuntu:bionic
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:stretch-32
stage: build
script:
- export $(dpkg-architecture)
- ./scripts/build-appimage.sh
artifacts:
name: "${CI_PROJECT_NAME}_Linux_32_${CI_COMMIT_SHORT_SHA}"
paths:
- OpenRGB-i386.AppImage
- 60-openrgb.rules
@@ -47,15 +49,16 @@ build_linux_32:
#-----------------------------------------------------------------------#
# Linux (AppImage) 64-bit Build Target #
#-----------------------------------------------------------------------#
build_linux_64:
"Linux 64 AppImage":
<<: *ccache_init
image: ubuntu:bionic
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:stretch-64
stage: build
script:
- export $(dpkg-architecture)
- ./scripts/build-appimage.sh
artifacts:
name: "${CI_PROJECT_NAME}_Linux_64_${CI_COMMIT_SHORT_SHA}"
paths:
- OpenRGB-x86_64.AppImage
- 60-openrgb.rules
@@ -65,18 +68,18 @@ build_linux_64:
#-----------------------------------------------------------------------#
# Linux (.deb) 32-bit Build Target #
#-----------------------------------------------------------------------#
build_linux_deb32:
"Linux 32 deb":
<<: *ccache_init
image: i386/ubuntu:bionic
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:stretch-32
stage: build
script:
- apt install -y debhelper
- dpkg-architecture -l
- dpkg-buildpackage --target-arch i386 -us -B
- rm -v ../openrgb-dbgsym*.ddeb
- rm -v ../openrgb-dbgsym*.deb
- mv -v ../openrgb*.deb ./
artifacts:
name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
paths:
- openrgb*.deb
exclude:
@@ -86,28 +89,287 @@ build_linux_deb32:
#-----------------------------------------------------------------------#
# Linux (.deb) 64-bit Build Target #
#-----------------------------------------------------------------------#
build_linux_deb64:
"Linux 64 deb":
<<: *ccache_init
image: ubuntu:bionic
image: registry.gitlab.com/openrgbdevelopers/openrgb-linux-ci-deb-builder:stretch-64
stage: build
script:
- apt install -y debhelper
- dpkg-architecture -l
- dpkg-buildpackage -us -B
- rm -v ../openrgb-dbgsym*.ddeb
- rm -v ../openrgb-dbgsym*.deb
- mv -v ../openrgb*.deb ./
artifacts:
name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
paths:
- openrgb*.deb
exclude:
- openrgb-dbgsym*.deb
expire_in: 30 days
#-----------------------------------------------------------------------#
# Linux (.rpm) 64-bit Build Target #
#-----------------------------------------------------------------------#
"Linux 64 rpm":
image: fedora:34
stage: build
script:
- dnf install rpmdevtools dnf-plugins-core -y
- rpmdev-setuptree
- ls /root/
- cp fedora/OpenRGB.spec /root/rpmbuild/SPECS
- cp ../OpenRGB /root/rpmbuild/SOURCES/ -r
- cd /root/rpmbuild/SOURCES
- tar -cf OpenRGB.tar.gz OpenRGB/
- cd ..
- dnf builddep SPECS/OpenRGB.spec -y
- rpmbuild -ba SPECS/OpenRGB.spec
- cd RPMS/x86_64/
- mv openrgb*.rpm ${CI_PROJECT_DIR}/
- cd ${CI_PROJECT_DIR}
artifacts:
name: "${CI_PROJECT_NAME}_Linux_64_rpm_${CI_COMMIT_SHORT_SHA}"
paths:
- openrgb*.rpm
expire_in: 30 days
#-----------------------------------------------------------------------#
# Linux (.deb) Debian Bullseye 32-bit Build Target #
#-----------------------------------------------------------------------#
"Linux 32 deb Bullseye":
<<: *ccache_init
image: i386/debian:bullseye
stage: build
script:
- apt update
- apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev pkgconf wget git file debhelper
- dpkg-architecture -l
- dpkg-buildpackage --target-arch i386 -us -B
- rm -v ../openrgb-dbgsym*.deb
- mv -v ../openrgb*.deb ./
artifacts:
name: "${CI_PROJECT_NAME}_Linux_32_deb_${CI_COMMIT_SHORT_SHA}"
paths:
- openrgb*.deb
exclude:
- openrgb-dbgsym*.deb
expire_in: 30 days
#-----------------------------------------------------------------------#
# Linux (.deb) Debian Bullseye 64-bit Build Target #
#-----------------------------------------------------------------------#
"Linux 64 deb Bullseye":
<<: *ccache_init
image: debian:bullseye
stage: build
script:
- apt update
- apt install -y build-essential qtcreator qtbase5-dev libusb-1.0-0-dev libhidapi-dev pkgconf wget git file debhelper
- dpkg-architecture -l
- dpkg-buildpackage -us -B
- rm -v ../openrgb-dbgsym*.deb
- mv -v ../openrgb*.deb ./
artifacts:
name: "${CI_PROJECT_NAME}_Linux_64_deb_${CI_COMMIT_SHORT_SHA}"
paths:
- openrgb*.deb
exclude:
- openrgb-dbgsym*.deb
expire_in: 30 days
#-----------------------------------------------------------------------#
# Debian 32 Buster test #
#-----------------------------------------------------------------------#
"Debian 32 Buster":
image: i386/debian:buster
stage: test
script:
- apt update
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
- openrgb --version
- openrgb -l
- apt remove -y openrgb
dependencies:
- "Linux 32 deb"
needs:
- "Linux 32 deb"
#-----------------------------------------------------------------------#
# Debian 32 Bullseye test #
#-----------------------------------------------------------------------#
"Debian 32 Bullseye":
image: i386/debian:bullseye
stage: test
script:
- apt update
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
- openrgb --version
- openrgb -l
- apt remove -y openrgb
dependencies:
- "Linux 32 deb"
needs:
- "Linux 32 deb"
#-----------------------------------------------------------------------#
# Ubuntu 32 18.04LTS test #
#-----------------------------------------------------------------------#
"Ubuntu 32 18.04LTS":
image: i386/ubuntu:bionic
stage: test
script:
- apt update
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
- openrgb --version
- openrgb -l
- apt remove -y openrgb
dependencies:
- "Linux 32 deb"
needs:
- "Linux 32 deb"
#-----------------------------------------------------------------------#
# Mint 32 19.3 test #
#-----------------------------------------------------------------------#
"Mint 32 20.1":
image: linuxmintd/mint19.3-i386
stage: test
script:
- apt update
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*i386.deb
- openrgb --version
- openrgb -l
- apt remove -y openrgb
dependencies:
- "Linux 32 deb"
needs:
- "Linux 32 deb"
#-----------------------------------------------------------------------#
# Debian 64 Buster test #
#-----------------------------------------------------------------------#
"Debian 64 Buster":
image: debian:buster
stage: test
script:
- apt update
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
- openrgb --version
- openrgb -l
- apt remove -y openrgb
dependencies:
- "Linux 64 deb"
needs:
- "Linux 64 deb"
#-----------------------------------------------------------------------#
# Debian 64 Bullseye test #
#-----------------------------------------------------------------------#
"Debian 64 Bullseye":
image: debian:bullseye
stage: test
script:
- apt update
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
- openrgb --version
- openrgb -l
- apt remove -y openrgb
dependencies:
- "Linux 64 deb"
needs:
- "Linux 64 deb"
#-----------------------------------------------------------------------#
# Fedora 64 v34 test #
#-----------------------------------------------------------------------#
"Fedora 64 v34":
image: fedora:34
stage: test
script:
- yum -y localinstall ./openrgb*64.rpm
- openrgb --version
- openrgb -l
- yum -y remove openrgb
dependencies:
- "Linux 64 rpm"
needs:
- "Linux 64 rpm"
#-----------------------------------------------------------------------#
# Ubuntu 64 18.04LTS test #
#-----------------------------------------------------------------------#
"Ubuntu 64 18.04LTS":
image: ubuntu:bionic
stage: test
script:
- apt update
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
- openrgb --version
- openrgb -l
- apt remove -y openrgb
dependencies:
- "Linux 64 deb"
needs:
- "Linux 64 deb"
#-----------------------------------------------------------------------#
# Ubuntu 64 20.04LTS test #
#-----------------------------------------------------------------------#
"Ubuntu 64 20.04LTS":
image: ubuntu:focal
stage: test
script:
- apt update
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
- openrgb --version
- openrgb -l
- apt remove -y openrgb
dependencies:
- "Linux 64 deb"
needs:
- "Linux 64 deb"
#-----------------------------------------------------------------------#
# Ubuntu 64 20.10 test #
#-----------------------------------------------------------------------#
"Ubuntu 64 20.10":
image: ubuntu:groovy
stage: test
script:
- apt update
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
- openrgb --version
- openrgb -l
- apt remove -y openrgb
dependencies:
- "Linux 64 deb"
needs:
- "Linux 64 deb"
#-----------------------------------------------------------------------#
# Mint 64 20.1 test #
#-----------------------------------------------------------------------#
"Mint 64 20.1":
image: linuxmintd/mint20.1-amd64
stage: test
script:
- apt update
- DEBIAN_FRONTEND=noninteractive apt install -yq --no-install-recommends ./openrgb*amd64.deb
- openrgb --version
- openrgb -l
- apt remove -y openrgb
dependencies:
- "Linux 64 deb"
needs:
- "Linux 64 deb"
#-----------------------------------------------------------------------#
# Windows (32-bit) Build Target #
#-----------------------------------------------------------------------#
build_windows_32:
"Windows 32":
extends:
- .shared_windows_runners
stage: build
@@ -129,9 +391,9 @@ build_windows_32:
- mkdir _qt
- mkdir _qt_download
- Push-Location _qt_download
- curl.exe -LJ -o qt-base.7z 'https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
- curl.exe -LJ -o qt-tools.7z 'https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
- curl.exe -LJ -o qt-jom.zip 'https://download.qt.io/official_releases/jom/jom.zip'
- curl.exe -LJ -o qt-base.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
- curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win32_msvc2019/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86.7z'
- curl.exe -LJ -o qt-jom.zip 'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
- _fold_final_
- _fold_start_ 'extracting the downloaded qt binaries'
@@ -160,26 +422,23 @@ build_windows_32:
- ..\_qt\5.15.0\msvc2019\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
- _fold_final_
- _fold_start_ 'compressing the release folder so that we can upload it as artifact'
- mv release 'OpenRGB Windows 32-bit'
- ${datetime} = Get-Date ([datetime]::UtcNow) -Format "yyyy-MM-ddTHH-mm-ss"
- ${revision} = ((git rev-parse --short HEAD) | Out-String).Trim()
- ${rversion} = (((Get-Content '..\OpenRGB.pro' | Select-String -Pattern "VERSION =") | Out-String).Trim().Split("="))[1].Trim()
- 7z a -mx9 -r -y "OpenRGB_${rversion}_32_${revision}_nightly_${datetime}.7z" 'OpenRGB Windows 32-bit'
- _fold_start_ 'Moving results for upload'
- mv release ../'OpenRGB Windows 32-bit'
- _fold_final_
# cache:
# key: same-key
# paths:
# - C:\vcpkg\installed\
artifacts:
name: "${CI_PROJECT_NAME}_Windows_32_${CI_COMMIT_SHORT_SHA}"
paths:
- _build/*.7z
- 'OpenRGB Windows 32-bit'
expire_in: 30 days
#-----------------------------------------------------------------------#
# Windows (64-bit) Build Target #
#-----------------------------------------------------------------------#
build_windows_64:
"Windows 64":
extends:
- .shared_windows_runners
stage: build
@@ -201,9 +460,9 @@ build_windows_64:
- mkdir _qt
- mkdir _qt_download
- Push-Location _qt_download
- curl.exe -LJ -o qt-base.7z 'https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
- curl.exe -LJ -o qt-tools.7z 'https://download.qt.io/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
- curl.exe -LJ -o qt-jom.zip 'https://download.qt.io/official_releases/jom/jom.zip'
- curl.exe -LJ -o qt-base.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qtbase-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
- curl.exe -LJ -o qt-tools.7z 'https://qt-mirror.dannhauer.de/online/qtsdkrepository/windows_x86/desktop/qt5_5150/qt.qt5.5150.win64_msvc2019_64/5.15.0-0-202005150700qttools-Windows-Windows_10-MSVC2019-Windows-Windows_10-X86_64.7z'
- curl.exe -LJ -o qt-jom.zip 'https://qt-mirror.dannhauer.de/official_releases/jom/jom.zip'
- _fold_final_
- _fold_start_ 'extracting the downloaded qt binaries'
@@ -232,18 +491,62 @@ build_windows_64:
- ..\_qt\5.15.0\msvc2019_64\bin\windeployqt --no-angle --no-translations --no-opengl-sw --no-system-d3d-compiler --no-compiler-runtime --no-webkit2 .\release\
- _fold_final_
- _fold_start_ 'compressing the release folder so that we can upload it as artifact'
- mv release 'OpenRGB Windows 64-bit'
- ${datetime} = Get-Date ([datetime]::UtcNow) -Format "yyyy-MM-ddTHH-mm-ss"
- ${revision} = ((git rev-parse --short HEAD) | Out-String).Trim()
- ${rversion} = (((Get-Content '..\OpenRGB.pro' | Select-String -Pattern "VERSION =") | Out-String).Trim().Split("="))[1].Trim()
- 7z a -mx9 -r -y "OpenRGB_${rversion}_64_${revision}_nightly_${datetime}.7z" 'OpenRGB Windows 64-bit'
- _fold_start_ 'Moving results for upload'
- mv release ../'OpenRGB Windows 64-bit'
- _fold_final_
# cache:
# key: same-key
# paths:
# - C:\vcpkg\installed\
artifacts:
name: "${CI_PROJECT_NAME}_Windows_64_${CI_COMMIT_SHORT_SHA}"
paths:
- _build/*.7z
- 'OpenRGB Windows 64-bit'
expire_in: 30 days
#-----------------------------------------------------------------------#
# MacOS Build Target #
#-----------------------------------------------------------------------#
"MacOS ARM64":
tags:
- macos
stage: build
script:
- eval $(/opt/homebrew/bin/brew shellenv)
- qmake OpenRGB.pro
- make -j16
- macdeployqt OpenRGB.app -codesign=OpenRGB
artifacts:
name: "${CI_PROJECT_NAME}_MacOS_ARM64_${CI_COMMIT_SHORT_SHA}"
paths:
- OpenRGB.app
expire_in: 30 days
rules:
- if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
when: on_success
- if: '$BUILD_MACOS =~ /.+/'
when: on_success
"MacOS Intel":
tags:
- macos
stage: build
script:
- eval $(/usr/local/bin/brew shellenv)
- arch -x86_64 /usr/local/bin/qmake OpenRGB.pro
- arch -x86_64 make -j16
- arch -x86_64 macdeployqt OpenRGB.app -codesign=OpenRGB
artifacts:
name: "${CI_PROJECT_NAME}_MacOS_Intel_${CI_COMMIT_SHORT_SHA}"
paths:
- OpenRGB.app
expire_in: 30 days
rules:
- if: '$CI_PROJECT_PATH == "CalcProgrammer1/OpenRGB"'
when: on_success
- if: '$BUILD_MACOS =~ /.+/'
when: on_success
.gitlab/issue_templates/Bug Report.md
+9 -4
View File
@@ -1,14 +1,19 @@
<!--
Found a bug? Something isn't working as expected? To help us keep track of the requests please start the title with [Bug Report]
Found a bug? Something isn't working as expected?
To help us keep track of the requests please start the title with [Bug Report]
-->
### Description of Bug
<!--
Please describe the bug. Explain steps taken to reproduce the bug and what you expect the correct behavior to be.
Please describe the bug.
Explain any steps taken to reproduce the bug
and what you expect the correct behavior to be.
-->
### Hardware Configuration
<!--
Please list the RGB hardware that you are using with OpenRGB. If your bug does not relate to any one particular device or device type, or if the bug is in a part of the code not directly interacting with hardware, this is optional.
-->
Please list the RGB hardware that you are using with OpenRGB.
If your bug does not relate to any one particular device or device type,
or if the bug is in a part of the code not directly interacting with hardware, this is optional.
-->
.gitlab/issue_templates/Feature Request.md
+3 -1
View File
@@ -5,5 +5,7 @@ To help us keep track of the requests please start the title with [Feature Reque
### Feature Request
<!--
Please explain the new feature you would like to see added in detail. Explain how you think it should work and provide any mock-ups, code snippets, etc. that you think will help explain the feature.
Please explain the new feature you would like to see added in detail.
Explain how you think it should work and provide any mock-ups,
code snippets, etc. that you think will help explain the feature.
-->
.gitlab/issue_templates/New Device.md
+53 -15
View File
@@ -1,7 +1,7 @@
<!--
When naming the support request please title the request as
`[New Device] <Name of new device>`
Please open one issue per device you would lke to add
Please open one issue per device you would like to add
-->
### Name of device:
@@ -12,27 +12,43 @@ Please put the name of the product, including manufacturer, beneath this line
### Link to manufacturer's product page:
<!--
Please link us to the manufacturer's product page beneath this line
Please add a link to the manufacturer's product page beneath this line
-->
### Please select what type of device/interface the device uses:
<!--
Place an x between the brackets to check the box
-->
- [ ] Motherboard (SMBus)
- [ ] Motherboard (USB)
- [ ] RAM (SMBus)
- [ ] GPU (I2C)
- [ ] External USB (Peripheral, lighting controller, etc)
- [ ] Internal USB (lighting controller, cooler, fan hub, etc)
- [ ] I don't know (we can help you determine this)
<!-- Please select from one of the following
This determines how the device connects to the PC -->
~"DeviceType::IDK" <!-- I Don't know -->
~"DeviceType::USB" <!-- The device connects to an internal header or external usb port -->
~"DeviceType::GPU::AMD" <!-- The device is an AMD GPU -->
~"DeviceType::GPU::NVidia" <!-- The device is a NVidia GPU -->
~"DeviceType::SMBus" <!-- The device is connected to the SMBus eg. RAM -->
~"DeviceType::WMI" <!-- The device is controlled thru Windows Management Instrumentation -->
<!-- Please delete any lines that are not relevant -->
### ID information:
<!--
For PCI (GPU) devices we will need the Vendor ID, Device ID, Sub-Vendor ID and Sub-Device IDs
In Windows this can be found under the device manager and on Linux this can be found with lspci -vv
To get the Device ID formation for a GPU on Windows run the following command in Powershell:
wmic path Win32_VideoController get name,PNPDeviceID
Linux this can be found using the terminal:
lspci -d 1002: -nnvm | head -6 | tail -n 4 && lspci -d 10DE: -nnvm | head -6 | tail -n 4
-->
<!--
For USB devices we will need the USB VID and PID
Windows Powershell:
gwmi Win32_USBControllerDevice |%{[wmi]($_.Dependent)} | Sort Manufacturer,Description,DeviceID | Ft -GroupBy Manufacturer Description,Service,DeviceID
Linux Terminal:
lsusb
-->
@@ -43,6 +59,28 @@ Screenshots of the official control software should show lists of supported mode
### Please attach device captures here:
<!--
For information on how to capture device packets please see https://gitlab.com/Dr_No/OpenRGB/-/wikis/OpenRGB-doesn%27t-have-my-device
<!-- If you have code examples from other projects please link them here or alternatively
for information on how to capture device packets please refer to the wiki article
https://gitlab.com/Dr_No/OpenRGB/-/wikis/OpenRGB-doesn%27t-have-my-device
-->
<!-- For admin purposes: Please leave this section as is -->
/label ~"Issue Type - New Device"
/label ~"NewDevice::Step0 - Unconfirmed"
# Checklist for Step2
- [ ] Name of device
- [ ] A link to the vendors product page has been included
- [ ] The transport bus has been identified and the appropriate label added to the issue.
- [ ] The device ID's have been included for [USB](https://gitlab.com/Dr_No/OpenRGB/-/wikis/USB-Vendor-Identification-and-Product-Identification) or PCI
- [ ] Screenshots of the OEM Application are included
- [ ] There is either, appropriate code examples linked or suitable device captures attached
<!-- For admin purposes: Please leave this section as is -->
60-openrgb.rules
+414 -4
View File
@@ -9,6 +9,11 @@
#---------------------------------------------------------------#
KERNEL=="i2c-[0-99]*", TAG+="uaccess"
#---------------------------------------------------------------#
# Super I/O Access #
#---------------------------------------------------------------#
KERNEL=="port", TAG+="uaccess"
#---------------------------------------------------------------#
# User hidraw Access #
#---------------------------------------------------------------#
@@ -24,6 +29,15 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0051", TAG+="uacces
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1044", ATTR{idProduct}=="7a42", TAG+="uaccess"
#---------------------------------------------------------------#
# ASRock Devices #
# #
# ASRock Polychrome USB #
# ASRock Deskmini Addressable LED Strip #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="26CE", ATTR{idProduct}=="01A2", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="26CE", ATTR{idProduct}=="01A6", TAG+="uaccess"
#---------------------------------------------------------------#
# ASUS Aura Core Devices #
#---------------------------------------------------------------#
@@ -39,14 +53,58 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1872", TAG+="uacces
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1889", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a3", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18f3", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18a5", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1939", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18af", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18dd", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1845", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1875", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1877", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cd", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18cf", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e5", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="18e3", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0b05", ATTR{idProduct}=="1958", TAG+="uaccess"
#---------------------------------------------------------------#
# ASUS TUF Laptops (faustus) #
#---------------------------------------------------------------#
ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_blue"
ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_flags"
ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_green"
ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_mode"
ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_red"
ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_set"
ACTION=="add", SUBSYSTEM=="platform", KERNEL=="faustus", RUN+="/bin/chmod a+w /sys/bus/platform/devices/%k/kbbl/kbbl_speed"
#---------------------------------------------------------------#
# Cooler Master Peripheral Devices #
# #
# Mousemats: #
# Cooler Master MP750 #
# Controllers: #
# ARGB Device #
# Small ARGB Device #
# Graphics Cards: #
# Radeon RX6000 Series Reference Cards #
# Keyboards: #
# Masterkeys Pro L #
# Masterkeys Pro L White #
# Masterkeys Pro S #
# Masterkeys MK750 #
# Masterkeys SK630 #
# Masterkeys SK650 #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0109", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0105", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1011", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="1000", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="014d", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0047", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="003c", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0067", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="0089", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="2516", ATTR{idProduct}=="008d", TAG+="uaccess"
#---------------------------------------------------------------#
# Corsair Hydro Series Devices #
@@ -59,6 +117,23 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c15", TAG+="uacces
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c13", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c12", TAG+="uaccess"
#---------------------------------------------------------------#
# Corsair Hydro Platinum Series Devices #
# #
# Corsair H100i Platinum RGB #
# Corsair H100i Platinum SE RGB #
# Corsair H115i Platinum RGB #
# Corsair H100i Pro XT RGB #
# Corsair H115i Pro XT RGB #
# Corsair H150i Pro XT RGB #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c18", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c19", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c17", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c20", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c21", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c22", TAG+="uaccess"
#---------------------------------------------------------------#
# Corsair Lighting Node Devices #
# #
@@ -76,7 +151,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c10", TAG+="uacces
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c1e", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1d00", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1d04", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a32", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0c23", TAG+="uaccess"
#---------------------------------------------------------------#
# Corsair Peripheral Devices #
@@ -101,6 +176,12 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a32", TAG+="uacces
# Mice: #
# Corsair M65 Pro #
# Corsair M65 RGB Elite #
# Corsair Glaive RGB #
# Corsair Glaive RGB Pro #
# Corsair Harpoon RGB #
# Corsair Harpoon RGB Pro #
# Corsair Scimitar Pro RGB #
# Corsair Sabre RGB #
# #
# Mousemats: #
# Corsair MM800 RGB Polaris #
@@ -124,29 +205,103 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2d", TAG+="uacces
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b20", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b48", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b34", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b74", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3c", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b75", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2e", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b5a", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3e", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b2f", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b3b", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="0a34", TAG+="uaccess"
#---------------------------------------------------------------#
# Corsair Wireless Devices #
# #
# Keyboards: #
# Corsair K57 RGB Wired #
# Corsair K57 RGB Wireless #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b6e", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1b1c", ATTR{idProduct}=="1b62", TAG+="uaccess"
#---------------------------------------------------------------#
# Creative Devices #
# #
# Devices: #
# Creative SoundblasterX G6 #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="041e", ATTR{idProduct}=="3256", TAG+="uaccess"
#---------------------------------------------------------------#
# Ducky Keyboard Devices #
# #
# Keyboards: #
# Ducky Shine 7 One 2 RGB #
# Ducky One 2 RGB TKL #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="0348", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="0356", TAG+="uaccess"
#---------------------------------------------------------------#
# EK Controller Devices #
# #
# Controllers: #
# EK Loop Connect #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="5750", TAG+="uaccess"
#---------------------------------------------------------------#
# Holtek Devices #
# #
# Mice: #
# Holtek A070 #
# Mousemats: #
# Holtek A1FA #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="a070", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="a1fa", TAG+="uaccess"
#---------------------------------------------------------------#
# HyperX Peripheral Devices #
# #
# Keyboards: #
# HyperX Alloy Elite #
# HyperX Alloy Elite 2 #
# HyperX Alloy FPS RGB #
# HyperX Alloy Origins #
# HyperX Alloy Origins Core #
# #
# Mice: #
# HyperX Pulsefire Surge #
# HyperX Pulsefire FPS Pro #
# HyperX Pulsefire Dart Wireless #
# HyperX Pulsefire Dart Wired #
# #
# Mousemats: #
# HyperX Fury Ultra #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16be", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1711", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16dc", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e5", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e6", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d3", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16d7", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e1", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="16e2", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uaccess"
#---------------------------------------------------------------#
# Lian Li Uni Hub #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="0cf2", ATTR{idProduct}=="7750", TAG+="uaccess"
#---------------------------------------------------------------#
# Logitech Peripheral Devices #
# #
@@ -154,47 +309,87 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="0951", ATTR{idProduct}=="1705", TAG+="uacces
# Logitech G213 #
# Logitech G512 #
# Logitech G512 RGB #
# Logitech G610 #
# Logitech G610 #1 #
# Logitech G610 #2 #
# Logitech G810 #1 #
# Logitech G810 #2 #
# Logitech G813 #
# Logitech G815 #
# #
# Mice: #
# Logitech G203 Prodigy #
# Logitech G203 Lightsync #
# Logitech G303 #
# Logitech G403 Prodigy #
# Logitech G403 Hero #
# Logitech G502 Proteus Spectrum #
# Logitech G502 Hero #
# Logitech G502 Wireless #
# Logitech G703 Wireless #
# Logitech G900 Wireless #
# Logitech G903 Wireless #
# Logitech G Lightspeed Wireless Gaming Mouse #
# Logitech G Pro Wireless Gaming Mouse (Wired) #
# Logitech G Pro Hero Gaming Mouse (Wired) #
# #
# Mousemats: #
# Logitech G Powerplay Mousepad with Lightspeed #
# #
# Speakers: #
# Logitech G560 #
# #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c336", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c342", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33c", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c333", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c338", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c331", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c337", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c232", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c33f", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c084", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c092", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c083", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08f", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c082", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="405d", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c332", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08b", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08d", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="407f", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c087", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4070", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c081", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4053", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c086", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4067", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c539", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c085", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c08c", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c088", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="4079", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="c53a", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="046d", ATTR{idProduct}=="0a78", TAG+="uaccess"
#---------------------------------------------------------------#
# Metadot Das Keyboard 4Q + 5Q #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="24f0", ATTR{idProduct}=="2037", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="24f0", ATTR{idProduct}=="2020", TAG+="uaccess"
#---------------------------------------------------------------#
# MSI Mysticlight #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="3EA4", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="4559", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="4459", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B10", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B12", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B17", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B85", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B93", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B94", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7B96", TAG+="uaccess"
@@ -232,6 +427,7 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C95", TAG+="uacces
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C96", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C98", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7C99", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="7D09", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1462", ATTR{idProduct}=="905D", TAG+="uaccess"
#---------------------------------------------------------------#
@@ -248,15 +444,163 @@ KERNEL=="ttyACM[0-9]*", ATTR{idVendor}=="04D8", ATTR{idProduct}=="00DF", TAG+="u
# NZXT Hue 2 Devices #
# #
# NZXT Hue 2 #
# NZXT Hue 2 Ambient #
# NZXT Motherboard #
# NZXT Smart Device V2 #
# NZXT Kraken X3 #
# NZXT RGB Fan Controller #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2001", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2002", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2005", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2006", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2007", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="2009", TAG+="uaccess"
#---------------------------------------------------------------#
# NZXT Kraken #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="170e", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1e71", ATTR{idProduct}=="1715", TAG+="uaccess"
#---------------------------------------------------------------#
# Razer Devices #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0241", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0203", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0209", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0221", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0228", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0237", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0235", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0211", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0216", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="021A", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="020F", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0224", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0233", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023B", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0240", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023A", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0246", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0245", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024D", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0253", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0255", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="026F", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0210", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0225", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022F", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0234", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024C", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0205", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0220", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022D", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0232", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0239", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="024A", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0252", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0259", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022A", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="023F", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025E", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0204", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0226", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0227", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0243", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0207", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="021E", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="025D", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0208", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="022B", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0020", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005E", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006A", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006B", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0042", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005B", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0062", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0064", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0065", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0083", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0038", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="004F", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0037", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0016", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0054", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0043", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005C", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006E", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0071", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="008C", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0084", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007C", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007D", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="004C", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="002F", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0060", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0059", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="005A", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0070", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006F", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0024", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0025", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0044", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0045", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0073", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0072", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="006C", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0046", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="002E", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0040", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0053", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="003F", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="003E", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0041", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0036", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0050", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0067", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0013", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0039", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0048", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0032", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0034", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="008A", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0078", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007A", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="007B", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0506", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0501", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F19", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0504", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0527", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0510", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F03", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F08", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F20", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F26", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F1F", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F09", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F07", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F0E", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0215", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0068", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C00", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C04", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C02", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0C01", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0F1D", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0517", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1532", ATTR{idProduct}=="0518", TAG+="uaccess"
#---------------------------------------------------------------#
# Roccat Devices #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e2c", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1e7d", ATTR{idProduct}=="2e27", TAG+="uaccess"
#---------------------------------------------------------------#
# Redragon Peripheral Devices #
@@ -296,6 +640,13 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0036", TAG+="uacces
SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0033", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0029", TAG+="uaccess"
#---------------------------------------------------------------#
# Sony Devices #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="05c4", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="09cc", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="054c", ATTR{idProduct}=="0ba0", TAG+="uaccess"
#---------------------------------------------------------------#
# SteelSeries Peripheral Devices #
# #
@@ -311,24 +662,83 @@ SUBSYSTEMS=="usb", ATTR{idVendor}=="258a", ATTR{idProduct}=="0029", TAG+="uacces
# SteelSeries Rival 300 CS:GO Hyperbeast Edition #
# SteelSeries Rival 300 Dota 2 Edition #
# SteelSeries Rival 300 HP Omen Edition #
# SteelSeries Rival 300 Blackops Edition #
# SteelSeries Rival 310 #
# SteelSeries Rival 310 CS:GO Howl Edition #
# SteelSeries Rival 310 PubG Edition #
# SteelSeries Rival Sensei Ten #
# SteelSeries Rival Sensei Ten CS:GO Neon Rider #
# SteelSeries Rival Sensei 310 #
# Headsets: #
# SteelSeries Siberia 350 #
# Keyboards: #
# SteelSeries Apex 5 #
# SteelSeries Apex 7 #
# SteelSeries Apex 7 TKL #
# SteelSeries Apex Pro #
# SteelSeries Apex Pro TKL #
# SteelSeries Apex M750 #
# SteelSeries Apex OG #
# SteelSeries Apex 350 #
# Mousemats: #
# SteelSeries QCK Prism Cloth #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1702", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="170c", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1814", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1729", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1384", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1710", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1714", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1394", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1716", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="171a", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1392", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1718", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1720", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="171e", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1736", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1832", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1834", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1722", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1229", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="161c", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1612", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1618", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1610", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1614", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="0616", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1202", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="1206", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="1038", ATTR{idProduct}=="150d", TAG+="uaccess"
#---------------------------------------------------------------#
# Tecknet Devices #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="04d9", ATTR{idProduct}=="fc05", TAG+="uaccess"
#---------------------------------------------------------------#
# Thermaltake Poseidon Z RGB Keyboard #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="3006", TAG+="uaccess"
#---------------------------------------------------------------#
# Thermaltake Riing Controllers #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[5-9]", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FA[A-F]", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="1FB[0-5]", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="264a", ATTR{idProduct}=="226[0-3]", TAG+="uaccess"
#---------------------------------------------------------------#
# Wooting Devices #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff01", TAG+="uaccess"
SUBSYSTEMS=="usb", ATTR{idVendor}=="03eb", ATTR{idProduct}=="ff02", TAG+="uaccess"
#---------------------------------------------------------------#
# Zalman ZSync Devices #
#---------------------------------------------------------------#
SUBSYSTEMS=="usb", ATTR{idVendor}=="1c57", ATTR{idProduct}=="7ed0", TAG+="uaccess"
Controllers/AMDWraithPrismController/AMDWraithPrismController.cpp
+1 -1
View File
@@ -36,7 +36,7 @@ AMDWraithPrismController::AMDWraithPrismController(hid_device* dev_handle, const
AMDWraithPrismController::~AMDWraithPrismController()
{
hid_close(dev);
}
std::string AMDWraithPrismController::GetLocationString()
Controllers/AMDWraithPrismController/RGBController_AMDWraithPrism.cpp
+1 -1
View File
@@ -97,7 +97,7 @@ RGBController_AMDWraithPrism::RGBController_AMDWraithPrism(AMDWraithPrismControl
RGBController_AMDWraithPrism::~RGBController_AMDWraithPrism()
{
delete wraith;
}
void RGBController_AMDWraithPrism::SetupZones()
Controllers/ASRockPolychromeSMBusController/ASRockPolychromeSMBusControllerDetect.cpp
+2 -2
View File
@@ -44,7 +44,7 @@ bool TestForPolychromeSMBusController(i2c_smbus_interface* bus, unsigned char ad
* *
\******************************************************************************************/
void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses, std::vector<RGBController*>& rgb_controllers)
void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses)
{
PolychromeController* new_polychrome;
RGBController_Polychrome* new_controller;
@@ -61,7 +61,7 @@ void DetectPolychromeSMBusControllers(std::vector<i2c_smbus_interface*>& busses,
if(new_polychrome->GetASRockType() != ASROCK_TYPE_UNKNOWN)
{
new_controller = new RGBController_Polychrome(new_polychrome);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
else
{
Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.cpp
+206 -199
View File
@@ -49,74 +49,74 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
description = "ASRock ASR LED Device";
mode Off;
Off.name = "Off";
Off.value = ASRLED_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
Off.name = "Off";
Off.value = ASRLED_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = ASRLED_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
Static.name = "Static";
Static.value = ASRLED_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = ASRLED_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = ASRLED_SPEED_MIN;
Breathing.speed_max = ASRLED_SPEED_MAX;
Breathing.speed = ASRLED_SPEED_DEFAULT;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.name = "Breathing";
Breathing.value = ASRLED_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = ASRLED_SPEED_MIN;
Breathing.speed_max = ASRLED_SPEED_MAX;
Breathing.speed = ASRLED_SPEED_DEFAULT;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode Strobe;
Strobe.name = "Strobe";
Strobe.value = ASRLED_MODE_STROBE;
Strobe.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Strobe.speed_min = ASRLED_SPEED_MIN;
Strobe.speed_max = ASRLED_SPEED_MAX;
Strobe.speed = ASRLED_SPEED_DEFAULT;
Strobe.color_mode = MODE_COLORS_PER_LED;
Strobe.name = "Strobe";
Strobe.value = ASRLED_MODE_STROBE;
Strobe.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Strobe.speed_min = ASRLED_SPEED_MIN;
Strobe.speed_max = ASRLED_SPEED_MAX;
Strobe.speed = ASRLED_SPEED_DEFAULT;
Strobe.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Strobe);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = ASRLED_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
SpectrumCycle.speed_min = ASRLED_SPEED_MIN;
SpectrumCycle.speed_max = ASRLED_SPEED_MAX;
SpectrumCycle.speed = ASRLED_SPEED_DEFAULT;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = ASRLED_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
SpectrumCycle.speed_min = ASRLED_SPEED_MIN;
SpectrumCycle.speed_max = ASRLED_SPEED_MAX;
SpectrumCycle.speed = ASRLED_SPEED_DEFAULT;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Random;
Random.name = "Random";
Random.value = ASRLED_MODE_RANDOM;
Random.flags = MODE_FLAG_HAS_SPEED;
Random.speed_min = ASRLED_SPEED_MIN;
Random.speed_max = ASRLED_SPEED_MAX;
Random.speed = ASRLED_SPEED_DEFAULT;
Random.color_mode = MODE_COLORS_NONE;
Random.name = "Random";
Random.value = ASRLED_MODE_RANDOM;
Random.flags = MODE_FLAG_HAS_SPEED;
Random.speed_min = ASRLED_SPEED_MIN;
Random.speed_max = ASRLED_SPEED_MAX;
Random.speed = ASRLED_SPEED_DEFAULT;
Random.color_mode = MODE_COLORS_NONE;
modes.push_back(Random);
mode Music;
Music.name = "Music";
Music.value = ASRLED_MODE_MUSIC;
Music.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Music.color_mode = MODE_COLORS_PER_LED;
Music.name = "Music";
Music.value = ASRLED_MODE_MUSIC;
Music.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Music.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Music);
mode Wave;
Wave.name = "Wave";
Wave.value = ASRLED_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED;
Wave.speed_min = ASRLED_SPEED_MIN;
Wave.speed_max = ASRLED_SPEED_MAX;
Wave.speed = ASRLED_SPEED_DEFAULT;
Wave.color_mode = MODE_COLORS_NONE;
Wave.name = "Wave";
Wave.value = ASRLED_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED;
Wave.speed_min = ASRLED_SPEED_MIN;
Wave.speed_max = ASRLED_SPEED_MAX;
Wave.speed = ASRLED_SPEED_DEFAULT;
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
}
break;
@@ -199,75 +199,77 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
/*---------------------------------------------------------------------*\
| Comment out until per zone modes are working. These are only for ARGB |
\*---------------------------------------------------------------------*/
// mode Spring;
// Spring.name = "Spring";
// Spring.value = POLYCHROME_V1_MODE_SPRING;
// Spring.flags = MODE_FLAG_HAS_SPEED;
// Spring.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
// Spring.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
// Spring.speed = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
// Spring.color_mode = MODE_COLORS_PER_LED;
// modes.push_back(Spring);
/*
mode Spring;
Spring.name = "Spring";
Spring.value = POLYCHROME_V1_MODE_SPRING;
Spring.flags = MODE_FLAG_HAS_SPEED;
Spring.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Spring.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Spring.speed = POLYCHROME_V1_SPEED_DEFAULT_SPRING;
Spring.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Spring);
// mode Stack;
// Stack.name = "Stack";
// Stack.value = POLYCHROME_V1_MODE_STACK;
// Stack.flags = MODE_FLAG_HAS_SPEED;
// Stack.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
// Stack.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
// Stack.speed = POLYCHROME_V1_SPEED_DEFAULT_STACK;
// Stack.color_mode = MODE_COLORS_PER_LED;
// modes.push_back(Stack);
mode Stack;
Stack.name = "Stack";
Stack.value = POLYCHROME_V1_MODE_STACK;
Stack.flags = MODE_FLAG_HAS_SPEED;
Stack.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Stack.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Stack.speed = POLYCHROME_V1_SPEED_DEFAULT_STACK;
Stack.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Stack);
// mode Cram;
// Cram.name = "Cram";
// Cram.value = POLYCHROME_V1_MODE_CRAM;
// Cram.flags = MODE_FLAG_HAS_SPEED;
// Cram.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
// Cram.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
// Cram.speed = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
// Cram.color_mode = MODE_COLORS_PER_LED;
// modes.push_back(Cram);
mode Cram;
Cram.name = "Cram";
Cram.value = POLYCHROME_V1_MODE_CRAM;
Cram.flags = MODE_FLAG_HAS_SPEED;
Cram.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Cram.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Cram.speed = POLYCHROME_V1_SPEED_DEFAULT_CRAM;
Cram.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Cram);
// mode Scan;
// Scan.name = "Scan";
// Scan.value = POLYCHROME_V1_MODE_SCAN;
// Scan.flags = MODE_FLAG_HAS_SPEED;
// Scan.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
// Scan.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
// Scan.speed = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
// Scan.color_mode = MODE_COLORS_PER_LED;
// modes.push_back(Scan);
mode Scan;
Scan.name = "Scan";
Scan.value = POLYCHROME_V1_MODE_SCAN;
Scan.flags = MODE_FLAG_HAS_SPEED;
Scan.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Scan.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Scan.speed = POLYCHROME_V1_SPEED_DEFAULT_SCAN;
Scan.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Scan);
// mode Neon;
// Neon.name = "Neon";
// Neon.value = POLYCHROME_V1_MODE_NEON;
// Neon.flags = MODE_FLAG_HAS_SPEED;
// Neon.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
// Neon.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
// Neon.speed = POLYCHROME_V1_SPEED_DEFAULT_NEON;
// Neon.color_mode = MODE_COLORS_PER_LED;
// modes.push_back(Neon);
mode Neon;
Neon.name = "Neon";
Neon.value = POLYCHROME_V1_MODE_NEON;
Neon.flags = MODE_FLAG_HAS_SPEED;
Neon.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Neon.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Neon.speed = POLYCHROME_V1_SPEED_DEFAULT_NEON;
Neon.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Neon);
// mode Water;
// Water.name = "Water";
// Water.value = POLYCHROME_V1_MODE_WATER;
// Water.flags = MODE_FLAG_HAS_SPEED;
// Water.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
// Water.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
// Water.speed = POLYCHROME_V1_SPEED_DEFAULT_WATER;
// Water.color_mode = MODE_COLORS_PER_LED;
// modes.push_back(Water);
mode Water;
Water.name = "Water";
Water.value = POLYCHROME_V1_MODE_WATER;
Water.flags = MODE_FLAG_HAS_SPEED;
Water.speed_min = POLYCHROME_V1_SPEED_MIN_ARGB;
Water.speed_max = POLYCHROME_V1_SPEED_MAX_ARGB;
Water.speed = POLYCHROME_V1_SPEED_DEFAULT_WATER;
Water.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Water);
// mode Rainbow;
// Rainbow.name = "Rainbow";
// Rainbow.value = POLYCHROME_V1_MODE_RAINBOW;
// Rainbow.flags = MODE_FLAG_HAS_SPEED;
// Rainbow.speed_min = POLYCHROME_V1_SPEED_MIN_RAINBOW;
// Rainbow.speed_max = POLYCHROME_V1_SPEED_MAX_RAINBOW;
// Rainbow.speed = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
// Rainbow.color_mode = MODE_COLORS_NONE;
// modes.push_back(Rainbow);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = POLYCHROME_V1_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.speed_min = POLYCHROME_V1_SPEED_MIN_RAINBOW;
Rainbow.speed_max = POLYCHROME_V1_SPEED_MAX_RAINBOW;
Rainbow.speed = POLYCHROME_V1_SPEED_DEFAULT_RAINBOW;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
*/
}
break;
@@ -276,134 +278,134 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
description = "ASRock Polychrome v2 Device";
mode Off;
Off.name = "Off";
Off.value = POLYCHROME_V2_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
Off.name = "Off";
Off.value = POLYCHROME_V2_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = POLYCHROME_V2_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
Static.name = "Static";
Static.value = POLYCHROME_V2_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = POLYCHROME_V2_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = POLYCHROME_V2_SPEED_MIN;
Breathing.speed_max = POLYCHROME_V2_SPEED_MAX;
Breathing.speed = POLYCHROME_V2_SPEED_DEFAULT;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.name = "Breathing";
Breathing.value = POLYCHROME_V2_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = POLYCHROME_V2_SPEED_MIN;
Breathing.speed_max = POLYCHROME_V2_SPEED_MAX;
Breathing.speed = POLYCHROME_V2_SPEED_DEFAULT;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode Strobe;
Strobe.name = "Strobe";
Strobe.value = POLYCHROME_V2_MODE_STROBE;
Strobe.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Strobe.speed_min = POLYCHROME_V2_SPEED_MIN;
Strobe.speed_max = POLYCHROME_V2_SPEED_MAX;
Strobe.speed = POLYCHROME_V2_SPEED_DEFAULT;
Strobe.color_mode = MODE_COLORS_PER_LED;
Strobe.name = "Strobe";
Strobe.value = POLYCHROME_V2_MODE_STROBE;
Strobe.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Strobe.speed_min = POLYCHROME_V2_SPEED_MIN;
Strobe.speed_max = POLYCHROME_V2_SPEED_MAX;
Strobe.speed = POLYCHROME_V2_SPEED_DEFAULT;
Strobe.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Strobe);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = POLYCHROME_V2_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
SpectrumCycle.speed_min = POLYCHROME_V2_SPEED_MIN;
SpectrumCycle.speed_max = POLYCHROME_V2_SPEED_MAX;
SpectrumCycle.speed = POLYCHROME_V2_SPEED_DEFAULT;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = POLYCHROME_V2_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
SpectrumCycle.speed_min = POLYCHROME_V2_SPEED_MIN;
SpectrumCycle.speed_max = POLYCHROME_V2_SPEED_MAX;
SpectrumCycle.speed = POLYCHROME_V2_SPEED_DEFAULT;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Random;
Random.name = "Random";
Random.value = POLYCHROME_V2_MODE_RANDOM;
Random.flags = MODE_FLAG_HAS_SPEED;
Random.speed_min = POLYCHROME_V2_SPEED_MIN;
Random.speed_max = POLYCHROME_V2_SPEED_MAX;
Random.speed = POLYCHROME_V2_SPEED_DEFAULT;
Random.color_mode = MODE_COLORS_NONE;
Random.name = "Random";
Random.value = POLYCHROME_V2_MODE_RANDOM;
Random.flags = MODE_FLAG_HAS_SPEED;
Random.speed_min = POLYCHROME_V2_SPEED_MIN;
Random.speed_max = POLYCHROME_V2_SPEED_MAX;
Random.speed = POLYCHROME_V2_SPEED_DEFAULT;
Random.color_mode = MODE_COLORS_NONE;
modes.push_back(Random);
mode Wave;
Wave.name = "Wave";
Wave.value = POLYCHROME_V2_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED;
Wave.speed_min = POLYCHROME_V2_SPEED_MIN;
Wave.speed_max = POLYCHROME_V2_SPEED_MAX;
Wave.speed = POLYCHROME_V2_SPEED_DEFAULT;
Wave.color_mode = MODE_COLORS_NONE;
Wave.name = "Wave";
Wave.value = POLYCHROME_V2_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED;
Wave.speed_min = POLYCHROME_V2_SPEED_MIN;
Wave.speed_max = POLYCHROME_V2_SPEED_MAX;
Wave.speed = POLYCHROME_V2_SPEED_DEFAULT;
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
mode Spring;
Spring.name = "Spring";
Spring.value = POLYCHROME_V2_MODE_SPRING;
Spring.flags = MODE_FLAG_HAS_SPEED;
Spring.speed_min = POLYCHROME_V2_SPEED_MIN;
Spring.speed_max = POLYCHROME_V2_SPEED_MAX;
Spring.speed = POLYCHROME_V2_SPEED_DEFAULT;
Spring.color_mode = MODE_COLORS_NONE;
Spring.name = "Spring";
Spring.value = POLYCHROME_V2_MODE_SPRING;
Spring.flags = MODE_FLAG_HAS_SPEED;
Spring.speed_min = POLYCHROME_V2_SPEED_MIN;
Spring.speed_max = POLYCHROME_V2_SPEED_MAX;
Spring.speed = POLYCHROME_V2_SPEED_DEFAULT;
Spring.color_mode = MODE_COLORS_NONE;
modes.push_back(Spring);
mode Stack;
Stack.name = "Stack";
Stack.value = POLYCHROME_V2_MODE_STACK;
Stack.flags = MODE_FLAG_HAS_SPEED;
Stack.speed_min = POLYCHROME_V2_SPEED_MIN;
Stack.speed_max = POLYCHROME_V2_SPEED_MAX;
Stack.speed = POLYCHROME_V2_SPEED_DEFAULT;
Stack.color_mode = MODE_COLORS_NONE;
Stack.name = "Stack";
Stack.value = POLYCHROME_V2_MODE_STACK;
Stack.flags = MODE_FLAG_HAS_SPEED;
Stack.speed_min = POLYCHROME_V2_SPEED_MIN;
Stack.speed_max = POLYCHROME_V2_SPEED_MAX;
Stack.speed = POLYCHROME_V2_SPEED_DEFAULT;
Stack.color_mode = MODE_COLORS_NONE;
modes.push_back(Stack);
mode Cram;
Cram.name = "Cram";
Cram.value = POLYCHROME_V2_MODE_CRAM;
Cram.flags = MODE_FLAG_HAS_SPEED;
Cram.speed_min = POLYCHROME_V2_SPEED_MIN;
Cram.speed_max = POLYCHROME_V2_SPEED_MAX;
Cram.speed = POLYCHROME_V2_SPEED_DEFAULT;
Cram.color_mode = MODE_COLORS_NONE;
Cram.name = "Cram";
Cram.value = POLYCHROME_V2_MODE_CRAM;
Cram.flags = MODE_FLAG_HAS_SPEED;
Cram.speed_min = POLYCHROME_V2_SPEED_MIN;
Cram.speed_max = POLYCHROME_V2_SPEED_MAX;
Cram.speed = POLYCHROME_V2_SPEED_DEFAULT;
Cram.color_mode = MODE_COLORS_NONE;
modes.push_back(Cram);
mode Scan;
Scan.name = "Scan";
Scan.value = POLYCHROME_V2_MODE_SCAN;
Scan.flags = MODE_FLAG_HAS_SPEED;
Scan.speed_min = POLYCHROME_V2_SPEED_MIN;
Scan.speed_max = POLYCHROME_V2_SPEED_MAX;
Scan.speed = POLYCHROME_V2_SPEED_DEFAULT;
Scan.color_mode = MODE_COLORS_NONE;
Scan.name = "Scan";
Scan.value = POLYCHROME_V2_MODE_SCAN;
Scan.flags = MODE_FLAG_HAS_SPEED;
Scan.speed_min = POLYCHROME_V2_SPEED_MIN;
Scan.speed_max = POLYCHROME_V2_SPEED_MAX;
Scan.speed = POLYCHROME_V2_SPEED_DEFAULT;
Scan.color_mode = MODE_COLORS_NONE;
modes.push_back(Scan);
mode Neon;
Neon.name = "Neon";
Neon.value = POLYCHROME_V2_MODE_NEON;
Neon.flags = 0;
Neon.color_mode = MODE_COLORS_NONE;
Neon.name = "Neon";
Neon.value = POLYCHROME_V2_MODE_NEON;
Neon.flags = 0;
Neon.color_mode = MODE_COLORS_NONE;
modes.push_back(Neon);
mode Water;
Water.name = "Water";
Water.value = POLYCHROME_V2_MODE_WATER;
Water.flags = MODE_FLAG_HAS_SPEED;
Water.speed_min = POLYCHROME_V2_SPEED_MIN;
Water.speed_max = POLYCHROME_V2_SPEED_MAX;
Water.speed = POLYCHROME_V2_SPEED_DEFAULT;
Water.color_mode = MODE_COLORS_NONE;
Water.name = "Water";
Water.value = POLYCHROME_V2_MODE_WATER;
Water.flags = MODE_FLAG_HAS_SPEED;
Water.speed_min = POLYCHROME_V2_SPEED_MIN;
Water.speed_max = POLYCHROME_V2_SPEED_MAX;
Water.speed = POLYCHROME_V2_SPEED_DEFAULT;
Water.color_mode = MODE_COLORS_NONE;
modes.push_back(Water);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = POLYCHROME_V2_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.speed_min = POLYCHROME_V2_SPEED_MIN;
Rainbow.speed_max = POLYCHROME_V2_SPEED_MAX;
Rainbow.speed = POLYCHROME_V2_SPEED_DEFAULT;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.name = "Rainbow";
Rainbow.value = POLYCHROME_V2_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.speed_min = POLYCHROME_V2_SPEED_MIN;
Rainbow.speed_max = POLYCHROME_V2_SPEED_MAX;
Rainbow.speed = POLYCHROME_V2_SPEED_DEFAULT;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
}
break;
@@ -412,6 +414,11 @@ RGBController_Polychrome::RGBController_Polychrome(PolychromeController* polychr
SetupZones();
}
RGBController_Polychrome::~RGBController_Polychrome()
{
delete polychrome;
}
void RGBController_Polychrome::SetupZones()
{
switch(polychrome->GetASRockType())
Controllers/ASRockPolychromeSMBusController/RGBController_ASRockPolychromeSMBus.h
+1
View File
@@ -16,6 +16,7 @@ class RGBController_Polychrome : public RGBController
{
public:
RGBController_Polychrome(PolychromeController* polychrome_ptr);
~RGBController_Polychrome();
void SetupZones();
Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.cpp
Executable
+356
View File
@@ -0,0 +1,356 @@
/*-----------------------------------------*\
| ASRockPolychromeUSBController.cpp |
| |
| Driver for ASRock Polychrome USB |
| lighting controller |
| |
| Ed Kambulow (dredvard) 12/20/2020 |
\*-----------------------------------------*/
#include "RGBController.h"
#include "ASRockPolychromeUSBController.h"
#include <cstring>
#include <stdio.h>
#include "dependencies/dmiinfo.h"
#define POLYCHROME_USB_READ_ZONE_CONFIG 0x11
#define POLYCHROME_USB_READ_HEADER 0x14
#define POLYCHROME_USB_WRITE_HEADER 0x15
#define POLYCHROME_USB_SET_ZONE 0x10
#define POLYCHROME_USB_INIT 0xA4
#define POLYCHROME_USB_COMMIT 0x12
PolychromeUSBController::PolychromeUSBController(hid_device* dev_handle, const char* path)
{
DMIInfo dmi;
dev = dev_handle;
device_name = "ASRock " + dmi.getMainboard();
location = path;
SetDeviceInfo();
}
PolychromeUSBController::~PolychromeUSBController()
{
}
unsigned int PolychromeUSBController::GetChannelCount()
{
return(device_info.size());
}
std::string PolychromeUSBController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string PolychromeUSBController::GetDeviceName()
{
return(device_name);
}
std::string PolychromeUSBController::GetSerialString()
{
wchar_t serial_string[128];
hid_get_serial_number_string(dev, serial_string, 128);
std::wstring return_wstring = serial_string;
std::string return_string(return_wstring.begin(), return_wstring.end());
return(return_string);
}
void PolychromeUSBController::SetDeviceInfo()
{
PolychromeDeviceInfo newdev_info;
ReadConfigTables();
for (unsigned int zonecnt = 0; zonecnt < POLYCHROME_USB_ZONE_MAX_NUM; zonecnt++)
{
if(configtable[zonecnt] == 0x1E)
{
break;
}
newdev_info.num_leds = configtable[zonecnt];
switch (zonecnt)
{
/*-----------------------------------------*\
| Type: Addressable, configurable |
\*-----------------------------------------*/
case POLYCHROME_USB_ZONE_ARGB1:
case POLYCHROME_USB_ZONE_ARGB2:
newdev_info.device_type = PolychromeDeviceType::ADDRESSABLE;
break;
/*-----------------------------------------*\
| Type: Addressable, not configurable |
\*-----------------------------------------*/
case POLYCHROME_USB_ZONE_PCH:
case POLYCHROME_USB_ZONE_IOCOVER:
case POLYCHROME_USB_ZONE_PCB:
case POLYCHROME_USB_ZONE_AUDIO:
newdev_info.device_type = PolychromeDeviceType::FIXED;
break;
/*-----------------------------------------*\
| Type: Fixed |
\*-----------------------------------------*/
case POLYCHROME_USB_ZONE_RGB1:
case POLYCHROME_USB_ZONE_RGB2:
default:
newdev_info.device_type = PolychromeDeviceType::FIXED;
break;
}
device_info.push_back(newdev_info);
}
}
void PolychromeUSBController::WriteZone
(
unsigned char zone,
unsigned char mode,
unsigned char speed,
RGBColor rgb,
bool allzone = false
)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet with leading 00 |
\*-----------------------------------------------------*/
usb_buf[0x01] = POLYCHROME_USB_SET_ZONE;
usb_buf[0x03] = zone;
usb_buf[0x04] = mode;
usb_buf[0x05] = RGBGetRValue(rgb);
usb_buf[0x06] = RGBGetGValue(rgb);
usb_buf[0x07] = RGBGetBValue(rgb);
usb_buf[0x08] = speed;
usb_buf[0x09] = 0xFF;
usb_buf[0x10] = allzone;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read(dev, usb_buf, 64);
};
void PolychromeUSBController::WriteRGSwap
(
bool ahdr1,
bool ahdr0,
bool hdr1,
bool hdr0
)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet with leading 00 |
\*-----------------------------------------------------*/
usb_buf[0x01] = POLYCHROME_USB_WRITE_HEADER;
usb_buf[0x04] = POLYCHROME_USB_RGSWAP_CFG;
usb_buf[0x05] = ((ahdr1 << 3) & (ahdr0 << 2) & (hdr1 << 1) & hdr0) & 0x40;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read(dev, usb_buf, 64);
}
void PolychromeUSBController::WriteHeader
(
unsigned char cfg,
unsigned char* configstring,
unsigned int configsize
)
{
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet with leading 00 |
\*-----------------------------------------------------*/
usb_buf[0x01] = POLYCHROME_USB_WRITE_HEADER;
usb_buf[0x03] = cfg;
memcpy(&usb_buf[4], configstring, configsize);
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read(dev, usb_buf, 64);
}
PolychromeZoneInfo PolychromeUSBController::GetZoneConfig(unsigned char zone)
{
unsigned char usb_buf[65];
PolychromeZoneInfo zoneinfo;
//unsigned char all;
unsigned char r;
unsigned char g;
unsigned char b;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x01] = POLYCHROME_USB_READ_ZONE_CONFIG;
usb_buf[0x03] = zone;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
/*-----------------------------------------------------*\
| Read response |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
hid_read(dev, usb_buf, 64);
r = usb_buf[0x05];
g = usb_buf[0x06];
b = usb_buf[0x07];
zoneinfo.mode = usb_buf[0x04];
zoneinfo.color = ToRGBColor(r,g,b);
zoneinfo.speed = usb_buf[0x08];
zoneinfo.zone = usb_buf[0x03];
//all = usb_buf[0x10];
return(zoneinfo);
}
void PolychromeUSBController::ReadConfigTables()
{
unsigned char usb_buf[65];
unsigned char maxzoneleds[8];
unsigned char rgbswap;
unsigned char header1;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up max led config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x01] = POLYCHROME_USB_READ_HEADER;
usb_buf[0x03] = POLYCHROME_USB_LEDCOUNT_CFG;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
/*-----------------------------------------------------*\
| Read response |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
hid_read(dev, usb_buf, 64);
/*-----------------------------------------------------*\
| Reads in format: RGB1, RGB2, ARGB1, ARGB2, PCH, IO, |
| PCB, AUDIO |
\*-----------------------------------------------------*/
memcpy(&maxzoneleds,&usb_buf[0x04],8);
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up RGB Swap table request packet |
\*-----------------------------------------------------*/
usb_buf[0x01] = POLYCHROME_USB_READ_HEADER;
usb_buf[0x03] = POLYCHROME_USB_RGSWAP_CFG;
hid_write(dev, usb_buf, 65);
memset(usb_buf, 0x00, sizeof(usb_buf));
hid_read(dev, usb_buf, 64);
/*-----------------------------------------------------*\
| Reads bitwise in format: AUDIO, PCB, IO, PCH, ARGB2, |
| ARGB1, RGB2, RGB1 if available |
\*-----------------------------------------------------*/
rgbswap=usb_buf[4];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Header1 config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x01] = POLYCHROME_USB_READ_HEADER;
usb_buf[0x03] = 0x01;
hid_write(dev, usb_buf, 64);
memset(usb_buf, 0x00, sizeof(usb_buf));
hid_read(dev, usb_buf, 64);
header1=usb_buf[4];
memcpy(configtable,&maxzoneleds,8);
configtable[8]=rgbswap;
configtable[9]=header1;
return;
}
void PolychromeUSBController::Commit()
{
/*-----------------------------------------------------*\
| Saves all Writes in Device - Will keep after powerup |
\*-----------------------------------------------------*/
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet with leading 00 |
\*-----------------------------------------------------*/
usb_buf[0x01] = POLYCHROME_USB_COMMIT;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
hid_read(dev, usb_buf, 64);
};
const std::vector<PolychromeDeviceInfo>& PolychromeUSBController::GetPolychromeDevices() const
{
return(device_info);
};
Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBController.h
Executable
+151
View File
@@ -0,0 +1,151 @@
/*-----------------------------------------*\
| ASRockPolychromeUSBController.h |
| |
| Driver for ASRock Polychrome USB |
| lighting controller |
| |
| Ed Kambulow (dredvard) 12/20/2020 |
\*-----------------------------------------*/
#include "RGBController.h"
#include <hidapi/hidapi.h>
#include <string>
#pragma once
/*----------------------------------------------------------------------------------------------*\
| Definitions for Polychrome USB |
\*----------------------------------------------------------------------------------------------*/
#define POLYCHROME_USB_NUM_MODES 15 /* Number of Polychrome USB modes */
enum
{
POLYCHROME_USB_MODE_OFF = 0x00, /* OFF mode */
POLYCHROME_USB_MODE_STATIC = 0x01, /* Static color mode */
POLYCHROME_USB_MODE_BREATHING = 0x02, /* Breathing effect mode */
POLYCHROME_USB_MODE_STROBE = 0x03, /* Strobe effect mode */
POLYCHROME_USB_MODE_SPECTRUM_CYCLE = 0x04, /* Spectrum Cycle effect mode */
POLYCHROME_USB_MODE_RANDOM = 0x05, /* Random effect mode */
POLYCHROME_USB_MODE_MUSIC = 0x06, /* Random effect mode */
POLYCHROME_USB_MODE_WAVE = 0x07, /* Wave effect mode */
POLYCHROME_USB_MODE_SPRING = 0x08, /* Spring effect mode */
POLYCHROME_USB_MODE_STACK = 0x09, /* Stack effect mode */
POLYCHROME_USB_MODE_CRAM = 0x0A, /* Cram effect mode */
POLYCHROME_USB_MODE_SCAN = 0x0B, /* Scan effect mode */
POLYCHROME_USB_MODE_NEON = 0x0C, /* Neon effect mode */
POLYCHROME_USB_MODE_WATER = 0x0D, /* Water effect mode */
POLYCHROME_USB_MODE_RAINBOW = 0x0E, /* Rainbow effect mode */
};
enum
{
POLYCHROME_USB_SPEED_MIN = 0xFF, /* Slowest speed */
POLYCHROME_USB_SPEED_DEFAULT = 0xE0, /* Default speed */
POLYCHROME_USB_SPEED_MAX = 0x00, /* Fastest speed */
};
enum
{
POLYCHROME_USB_ZONE_MAX_NUM = 0x08, /* Total Max number of zones */
POLYCHROME_USB_ZONE_ADDRESSABLE_MAX = 0x64, /* Maxinum number of ARGB LEDs */
};
enum
{
POLYCHROME_USB_LEDCOUNT_CFG = 0x02, // Config for LED Count
POLYCHROME_USB_RGSWAP_CFG = 0x03, // Config for RGSWAP
POLYCHROME_USB_ZONE_UNAVAILABLE = 0x1E, // Value from LEDCOUNT CFG if zone not present
};
static const char* polychrome_USB_zone_names[] =
{
"RGB LED 1 Header",
"RGB LED 2 Header",
"Addressable Header 1",
"Addressable Header 2",
"PCH",
"IO Cover",
"PCB",
"Audio",
};
enum
{
POLYCHROME_USB_ZONE_RGB1 = 0x00, // RGB Header 1
POLYCHROME_USB_ZONE_RGB2 = 0X01, // RGB Header 2
POLYCHROME_USB_ZONE_ARGB1 = 0X02, // ARGB Header 1
POLYCHROME_USB_ZONE_ARGB2 = 0X03, // ARGB Header 2
POLYCHROME_USB_ZONE_PCH = 0X04, // PCH
POLYCHROME_USB_ZONE_IOCOVER = 0X05, // IOCOVER
POLYCHROME_USB_ZONE_PCB = 0X06, // PCB - Could be mixed swapped with 0x07
POLYCHROME_USB_ZONE_AUDIO = 0X07 // AUDIO
};
enum class PolychromeDeviceType
{
FIXED,
ADDRESSABLE,
};
struct PolychromeZoneInfo
{
unsigned char mode;
unsigned char zone;
unsigned char speed;
RGBColor color;
};
struct PolychromeDeviceInfo
{
unsigned char effect_channel;
unsigned char num_leds;
PolychromeDeviceType device_type;
};
class PolychromeUSBController
{
public:
unsigned char zone_led_count[8];
PolychromeUSBController(hid_device* dev_handle, const char* path);
~PolychromeUSBController();
unsigned int GetChannelCount();
std::string GetDeviceLocation();
std::string GetDeviceName();
const std::vector<PolychromeDeviceInfo>& GetPolychromeDevices() const;
std::string GetSerialString();
PolychromeZoneInfo GetZoneConfig (unsigned char zone);
void WriteZone
(
unsigned char zone,
unsigned char mode,
unsigned char speed,
RGBColor rgb,
bool allzone
);
void WriteHeader
(
unsigned char cfg,
unsigned char* configstring,
unsigned int configsize
);
protected:
hid_device* dev;
std::vector<PolychromeDeviceInfo> device_info;
std::string location;
void WriteRGSwap(bool ahdr1, bool ahdr0, bool hdr1, bool hdr0);
private:
unsigned int led_count;
std::string device_name;
unsigned char configtable[12];
void SetDeviceInfo();
void ReadConfigTables();
void Commit();
};
Controllers/ASRockPolychromeUSBController/ASRockPolychromeUSBControllerDetect.cpp
+36
View File
@@ -0,0 +1,36 @@
#include "Detector.h"
#include "ASRockPolychromeUSBController.h"
#include "RGBController.h"
#include "RGBController_ASRockPolychromeUSB.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <hidapi/hidapi.h>
/*---------------------------------------------------------*\
| ASRock vendor ID |
\*---------------------------------------------------------*/
#define ASROCK_VID 0x26CE
/*---------------------------------------------------------*\
| ASRock product ID |
\*---------------------------------------------------------*/
#define ASROCK_MOTHERBOARD_1_PID 0x01A2
#define ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID 0x01A6
void DetectPolychromeUSBControllers(hid_device_info* info, const std::string& /*name*/)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
PolychromeUSBController* controller = new PolychromeUSBController(dev, info->path);
RGBController_PolychromeUSB* rgb_controller = new RGBController_PolychromeUSB(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR("ASRock Polychrome USB", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_MOTHERBOARD_1_PID);
REGISTER_HID_DETECTOR("ASRock Deskmini Addressable LED Strip", DetectPolychromeUSBControllers, ASROCK_VID, ASROCK_DESKMINI_ADDRESSABLE_LED_STRIP_PID);
Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.cpp
Executable
+338
View File
@@ -0,0 +1,338 @@
/*-----------------------------------------*\
| RGBController_ASRockPolychromeUSB.cpp |
| |
| Generic RGB Interface for OpenRGB |
| ASRock Polychrome USB Driver |
| |
| Ed Kambulow (Dredvard) 12/26/2020 |
\*-----------------------------------------*/
#include "RGBController_ASRockPolychromeUSB.h"
#include <string.h>
#define ASROCK_USB_MAX_ZONES 8
#define ASROCK_ADDRESSABLE_MAX_LEDS 100
RGBController_PolychromeUSB::RGBController_PolychromeUSB(PolychromeUSBController* polychrome_ptr)
{
polychrome = polychrome_ptr;
name = polychrome->GetDeviceName();
description = "ASRock Polychrome USB Device";
vendor = "ASRock";
type = DEVICE_TYPE_MOTHERBOARD;
location = polychrome->GetDeviceLocation();
mode Off;
Off.name = "Off";
Off.value = POLYCHROME_USB_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = POLYCHROME_USB_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = POLYCHROME_USB_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = POLYCHROME_USB_SPEED_MIN;
Breathing.speed_max = POLYCHROME_USB_SPEED_MAX;
Breathing.speed = POLYCHROME_USB_SPEED_DEFAULT;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode Strobe;
Strobe.name = "Strobe";
Strobe.value = POLYCHROME_USB_MODE_STROBE;
Strobe.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Strobe.speed_min = POLYCHROME_USB_SPEED_MIN;
Strobe.speed_max = POLYCHROME_USB_SPEED_MAX;
Strobe.speed = POLYCHROME_USB_SPEED_DEFAULT;
Strobe.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Strobe);
mode SpectrumCycle;
SpectrumCycle.name = "Spectrum Cycle";
SpectrumCycle.value = POLYCHROME_USB_MODE_SPECTRUM_CYCLE;
SpectrumCycle.flags = MODE_FLAG_HAS_SPEED;
SpectrumCycle.speed_min = POLYCHROME_USB_SPEED_MIN;
SpectrumCycle.speed_max = POLYCHROME_USB_SPEED_MAX;
SpectrumCycle.speed = POLYCHROME_USB_SPEED_DEFAULT;
SpectrumCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(SpectrumCycle);
mode Random;
Random.name = "Random";
Random.value = POLYCHROME_USB_MODE_RANDOM;
Random.flags = MODE_FLAG_HAS_SPEED;
Random.speed_min = POLYCHROME_USB_SPEED_MIN;
Random.speed_max = POLYCHROME_USB_SPEED_MAX;
Random.speed = POLYCHROME_USB_SPEED_DEFAULT;
Random.color_mode = MODE_COLORS_NONE;
modes.push_back(Random);
mode Music;
Random.name = "Music";
Random.value = POLYCHROME_USB_MODE_RANDOM;
Random.flags = MODE_FLAG_HAS_BRIGHTNESS;
Random.color_mode = MODE_COLORS_NONE;
modes.push_back(Random);
mode Wave;
Wave.name = "Wave";
Wave.value = POLYCHROME_USB_MODE_WAVE;
Wave.flags = MODE_FLAG_HAS_SPEED;
Wave.speed_min = POLYCHROME_USB_SPEED_MIN;
Wave.speed_max = POLYCHROME_USB_SPEED_MAX;
Wave.speed = POLYCHROME_USB_SPEED_DEFAULT;
Wave.color_mode = MODE_COLORS_NONE;
modes.push_back(Wave);
mode Spring;
Spring.name = "Spring";
Spring.value = POLYCHROME_USB_MODE_SPRING;
Spring.flags = MODE_FLAG_HAS_SPEED;
Spring.speed_min = POLYCHROME_USB_SPEED_MIN;
Spring.speed_max = POLYCHROME_USB_SPEED_MAX;
Spring.speed = POLYCHROME_USB_SPEED_DEFAULT;
Spring.color_mode = MODE_COLORS_NONE;
modes.push_back(Spring);
mode Stack;
Stack.name = "Stack";
Stack.value = POLYCHROME_USB_MODE_STACK;
Stack.flags = MODE_FLAG_HAS_SPEED;
Stack.speed_min = POLYCHROME_USB_SPEED_MIN;
Stack.speed_max = POLYCHROME_USB_SPEED_MAX;
Stack.speed = POLYCHROME_USB_SPEED_DEFAULT;
Stack.color_mode = MODE_COLORS_NONE;
modes.push_back(Stack);
mode Cram;
Cram.name = "Cram";
Cram.value = POLYCHROME_USB_MODE_CRAM;
Cram.flags = MODE_FLAG_HAS_SPEED;
Cram.speed_min = POLYCHROME_USB_SPEED_MIN;
Cram.speed_max = POLYCHROME_USB_SPEED_MAX;
Cram.speed = POLYCHROME_USB_SPEED_DEFAULT;
Cram.color_mode = MODE_COLORS_NONE;
modes.push_back(Cram);
mode Scan;
Scan.name = "Scan";
Scan.value = POLYCHROME_USB_MODE_SCAN;
Scan.flags = MODE_FLAG_HAS_SPEED;
Scan.speed_min = POLYCHROME_USB_SPEED_MIN;
Scan.speed_max = POLYCHROME_USB_SPEED_MAX;
Scan.speed = POLYCHROME_USB_SPEED_DEFAULT;
Scan.color_mode = MODE_COLORS_NONE;
modes.push_back(Scan);
mode Neon;
Neon.name = "Neon";
Neon.value = POLYCHROME_USB_MODE_NEON;
Neon.flags = 0;
Neon.color_mode = MODE_COLORS_NONE;
modes.push_back(Neon);
mode Water;
Water.name = "Water";
Water.value = POLYCHROME_USB_MODE_WATER;
Water.flags = MODE_FLAG_HAS_SPEED;
Water.speed_min = POLYCHROME_USB_SPEED_MIN;
Water.speed_max = POLYCHROME_USB_SPEED_MAX;
Water.speed = POLYCHROME_USB_SPEED_DEFAULT;
Water.color_mode = MODE_COLORS_NONE;
modes.push_back(Water);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = POLYCHROME_USB_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.speed_min = POLYCHROME_USB_SPEED_MIN;
Rainbow.speed_max = POLYCHROME_USB_SPEED_MAX;
Rainbow.speed = POLYCHROME_USB_SPEED_DEFAULT;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
SetupZones();
/*-------------------------------------------------*\
| Initialize active mode |
\*-------------------------------------------------*/
active_mode = GetDeviceMode(1);
}
void RGBController_PolychromeUSB::SetupZones()
{
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
zones.resize(polychrome->GetChannelCount());
/*-------------------------------------------------*\
| Set zones and leds |
\*-------------------------------------------------*/
for(unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
{
PolychromeDeviceInfo device_info = polychrome->GetPolychromeDevices()[channel_idx];
zones[channel_idx].type = ZONE_TYPE_LINEAR;
if(device_info.device_type== PolychromeDeviceType::ADDRESSABLE)
{
zones[channel_idx].name = polychrome_USB_zone_names[channel_idx];
zones[channel_idx].leds_min = 0;
zones[channel_idx].leds_max = ASROCK_ADDRESSABLE_MAX_LEDS;
zones[channel_idx].leds_count = device_info.num_leds;
}
else if(device_info.device_type==PolychromeDeviceType::FIXED)
{
zones[channel_idx].name = polychrome_USB_zone_names[channel_idx];
zones[channel_idx].leds_min = device_info.num_leds;
zones[channel_idx].leds_max = device_info.num_leds;
zones[channel_idx].leds_count = device_info.num_leds;
}
for(unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
{
led new_led;
new_led.name = zones[channel_idx].name;
new_led.name.append(", LED ");
new_led.name.append(std::to_string(led_ch_idx + 1));
new_led.value = channel_idx;
leds.push_back(new_led);
}
zones[channel_idx].matrix_map = NULL;
}
SetupColors();
/*---------------------------------------------------------*\
| Initialize colors for each LED |
\*---------------------------------------------------------*/
for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
{
unsigned char led = (unsigned char)leds[led_idx].value;
colors[led_idx] = polychrome->GetZoneConfig(led).color; // TODO Get addressable instead of zone idx
}
/*---------------------------------------------------------*\
| Initialize zone info to track zone, speed, mode |
| B550 Boards have modes, speed for each zone |
\*---------------------------------------------------------*/
for (unsigned int channel_idx = 0; channel_idx < zones.size(); channel_idx++)
{
PolychromeZoneInfo zoneinfo;
zoneinfo = polychrome->GetZoneConfig(channel_idx);
zones_info.push_back(zoneinfo);
}
}
void RGBController_PolychromeUSB::ResizeZone(int zone, int new_size)
{
unsigned char zonecfg[ASROCK_USB_MAX_ZONES];
/*---------------------------------------------------------*\
| This device does not currently support resizing zones |
\*---------------------------------------------------------*/
zones[zone].leds_count = (unsigned char) new_size;
memset(zonecfg, POLYCHROME_USB_ZONE_UNAVAILABLE, ASROCK_USB_MAX_ZONES);
for(unsigned int i = 0; i < zones.size(); i++)
{
zonecfg[i]=zones[i].leds_count;
}
// unsigned char zonecmd = POLYCHROME_USB_LEDCOUNT_CFG;
// WriteHeader(zonecmd, zonecfg, sizeof(zonecfg));
}
void RGBController_PolychromeUSB::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned char set_mode = zones_info[zone_idx].mode;
if (set_mode>modes.size())
{
set_mode = active_mode;
}
polychrome->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
}
}
void RGBController_PolychromeUSB::UpdateZoneLEDs(int zone)
{
unsigned char set_mode=zones_info[zone].mode;
if(set_mode > modes.size())
{
set_mode = active_mode;
}
polychrome->WriteZone(zone, set_mode, zones_info[zone].speed, zones[zone].colors[0], false);
}
void RGBController_PolychromeUSB::UpdateSingleLED(int led)
{
unsigned int channel = leds[led].value;
unsigned char set_mode = zones_info[channel].mode;
if(set_mode > modes.size())
{
set_mode = active_mode;
}
polychrome->WriteZone(channel, set_mode, zones_info[channel].speed, zones[channel].colors[0], false);
}
unsigned char RGBController_PolychromeUSB::GetDeviceMode(unsigned char zone)
{
int dev_mode;
dev_mode = polychrome->GetZoneConfig(zone).mode;
active_mode = dev_mode;
return(active_mode);
}
void RGBController_PolychromeUSB::SetCustomMode()
{
active_mode = POLYCHROME_USB_MODE_STATIC;
}
void RGBController_PolychromeUSB::DeviceUpdateMode()
{
for(unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
if(zones[zone_idx].leds_count > 0)
{
unsigned char set_mode =(unsigned char) modes[active_mode].value;
zones_info[zone_idx].mode =(unsigned char) modes[active_mode].value;
zones_info[zone_idx].speed =(unsigned char) modes[active_mode].speed;
if(set_mode > modes.size())
{
set_mode = active_mode;
}
polychrome->WriteZone(zone_idx, set_mode, zones_info[zone_idx].speed, zones[zone_idx].colors[0], false);
}
}
}
Controllers/ASRockPolychromeUSBController/RGBController_ASRockPolychromeUSB.h
Executable
+37
View File
@@ -0,0 +1,37 @@
/*-----------------------------------------*\
| RGBController_ASRockPolychromeUSB.h |
| |
| Generic RGB Interface for OpenRGB |
| ASRock Polychrome USB Driver |
| |
| Ed Kambulow (Dredvard) 12/26/2020 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "ASRockPolychromeUSBController.h"
class RGBController_PolychromeUSB : public RGBController
{
public:
RGBController_PolychromeUSB(PolychromeUSBController* polychrome_ptr);
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
bool initializedMode;
PolychromeUSBController* polychrome;
std::vector<PolychromeZoneInfo> zones_info;
unsigned char GetDeviceMode(unsigned char zone);
};
Controllers/AsusAuraCoreController/AsusAuraCoreController.cpp
+321 -58
View File
@@ -10,15 +10,26 @@
#include "AsusAuraCoreController.h"
#include <cstring>
#define AURA_CORE_MAX_MESSAGE_SIZE 64
AuraCoreController::AuraCoreController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
dev = dev_handle;
location = path;
aura_device.aura_type = AURA_CORE_DEVICE_UNKNOWN;
aura_device.buff_size = 0;
aura_device.report_id = 0x5D;
aura_device.num_leds = 4;
aura_device.supports_direct = false;
IdentifyDevice();
Handshake();
}
AuraCoreController::~AuraCoreController()
{
hid_close(dev);
}
std::string AuraCoreController::GetDeviceLocation()
@@ -42,26 +53,29 @@ void AuraCoreController::SendBrightness
unsigned char brightness
)
{
unsigned char usb_buf[17];
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
{
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x5A;
usb_buf[0x01] = AURA_CORE_COMMAND_BRIGHTNESS;
usb_buf[0x02] = 0xC5;
usb_buf[0x03] = 0xC4;
usb_buf[0x04] = brightness;
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x5A;
usb_buf[0x01] = AURA_CORE_COMMAND_BRIGHTNESS;
usb_buf[0x02] = 0xC5;
usb_buf[0x03] = 0xC4;
usb_buf[0x04] = brightness;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, 17);
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
}
}
void AuraCoreController::SendUpdate
@@ -69,60 +83,280 @@ void AuraCoreController::SendUpdate
unsigned char zone,
unsigned char mode,
unsigned char speed,
unsigned char dir,
unsigned char red,
unsigned char green,
unsigned char blue
)
{
unsigned char usb_buf[17];
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
{
if(aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
{
zone += 1;
}
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x5D;
usb_buf[0x01] = AURA_CORE_COMMAND_UPDATE;
usb_buf[0x02] = zone;
usb_buf[0x03] = mode;
usb_buf[0x04] = red;
usb_buf[0x05] = green;
usb_buf[0x06] = blue;
usb_buf[0x07] = speed;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, 17);
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = aura_device.report_id;
usb_buf[0x01] = AURA_CORE_COMMAND_UPDATE;
usb_buf[0x02] = zone;
usb_buf[0x03] = mode;
usb_buf[0x04] = red;
usb_buf[0x05] = green;
usb_buf[0x06] = blue;
usb_buf[0x07] = speed;
usb_buf[0x08] = dir;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
}
}
void AuraCoreController::SendSet()
{
unsigned char usb_buf[17];
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
{
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x5D;
usb_buf[0x01] = AURA_CORE_COMMAND_SET;
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = aura_device.report_id;
usb_buf[0x01] = AURA_CORE_COMMAND_SET;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, 17);
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
}
}
void AuraCoreController::SendApply()
{
unsigned char usb_buf[17];
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
if(aura_device.aura_type != AURA_CORE_DEVICE_UNKNOWN)
{
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = aura_device.report_id;
usb_buf[0x01] = AURA_CORE_COMMAND_APPLY;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
}
}
void AuraCoreController::InitDirectMode()
{
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
unsigned char msg_num = 0;
int led_count = aura_device.num_leds;
if(aura_device.supports_direct)
{
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = aura_device.report_id;
usb_buf[0x01] = AURA_CORE_COMMAND_DIRECT;
usb_buf[0x02] = 0xD0;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
while(led_count > 0)
{
/*-----------------------------------------------------*\
| Set up second message packet |
\*-----------------------------------------------------*/
usb_buf[0x03] = 0x01;
usb_buf[0x04] = 0x02;
usb_buf[0x05] = 0x00;
usb_buf[0x06] = msg_num++;
usb_buf[0x07] = (led_count > aura_device.max_leds_per_message) ? aura_device.max_leds_per_message : led_count;
usb_buf[0x08] = 0x00;
/*-----------------------------------------------------*\
| Send packet 2 |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
led_count -= aura_device.max_leds_per_message;
}
}
}
void AuraCoreController::UpdateDirect(std::vector<AuraColor>& color_set)
{
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
unsigned char msg_num = 0;
unsigned char color_index = 0;
unsigned char set_count = 0;
int led_count = aura_device.num_leds;
if(aura_device.supports_direct)
{
while(led_count > 0)
{
unsigned char msg_index = 0x09;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = aura_device.report_id;
usb_buf[0x01] = AURA_CORE_COMMAND_DIRECT;
usb_buf[0x02] = 0xD0;
usb_buf[0x03] = 0x01;
usb_buf[0x04] = 0x02;
usb_buf[0x05] = 0x00;
usb_buf[0x06] = msg_num++;
usb_buf[0x07] = (led_count > aura_device.max_leds_per_message) ? aura_device.max_leds_per_message : led_count;
usb_buf[0x08] = 0x00;
set_count = 0;
while( (msg_index < sizeof(usb_buf) ) &&
(led_count > 0 ) &&
(set_count < aura_device.max_leds_per_message) )
{
if(color_index < color_set.size())
{
usb_buf[msg_index++] = color_set[color_index].red;
usb_buf[msg_index++] = color_set[color_index].green;
usb_buf[msg_index++] = color_set[color_index].blue;
}
else
{
usb_buf[msg_index++] = 0;
usb_buf[msg_index++] = 0;
usb_buf[msg_index++] = 0;
}
led_count--;
color_index++;
set_count++;
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
}
}
}
void AuraCoreController::IdentifyDevice()
{
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
int num_bytes = 0;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| First, attempt to read the report from the Keyboard |
\*-----------------------------------------------------*/
usb_buf[0x00] = aura_device.report_id;
num_bytes = hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Currently, there is no need to attempt to read the |
| returned data. If the device responded,to the report,|
| we're good. |
\*-----------------------------------------------------*/
if(num_bytes > 0)
{
aura_device.aura_type = AURA_CORE_DEVICE_KEYBOARD;
aura_device.buff_size = 17;
aura_device.report_id = 0x5D;
aura_device.num_leds = 4;
aura_device.supports_direct = false;
}
else if(num_bytes == -1)
{
/*-------------------------------------------------*\
| First, attempt to read the report from the |
| Keyboard |
\*-------------------------------------------------*/
usb_buf[0] = 0x5E;
num_bytes = hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
if(num_bytes > 0)
{
/*---------------------------------------------*\
| Currently, there is no need to attempt to |
| read the returned data. If the device |
| responded,to the report, we're good. |
\*---------------------------------------------*/
aura_device.aura_type = AURA_CORE_DEVICE_GA15DH;
aura_device.buff_size = 64;
aura_device.report_id = 0x5E;
aura_device.num_leds = 20;
aura_device.max_leds_per_message = 16;
aura_device.supports_direct = true;
}
}
}
void AuraCoreController::Handshake()
{
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
if(aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
{
usb_buf[0] = 0x5E;
SendIdString();
hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
SendQuery();
hid_get_feature_report(dev, usb_buf, sizeof(usb_buf));
}
}
void AuraCoreController::SendIdString()
{
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
const char id[] = "ASUS Tech.Inc.";
/*-----------------------------------------------------*\
| Zero out buffer |
@@ -132,11 +366,40 @@ void AuraCoreController::SendApply()
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x5D;
usb_buf[0x01] = AURA_CORE_COMMAND_APPLY;
usb_buf[0x00] = aura_device.report_id;
/*-----------------------------------------------------*\
| Copy in string data |
\*-----------------------------------------------------*/
memcpy(&usb_buf[0x01], id, sizeof(id));
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, 17);
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
}
void AuraCoreController::SendQuery()
{
unsigned char usb_buf[AURA_CORE_MAX_MESSAGE_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = aura_device.report_id;
usb_buf[0x01] = 0x05;
usb_buf[0x02] = 0x20;
usb_buf[0x03] = 0x31;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = 0x10;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_send_feature_report(dev, usb_buf, aura_device.buff_size);
}
Controllers/AsusAuraCoreController/AsusAuraCoreController.h
+46 -3
View File
@@ -14,11 +14,24 @@
#pragma once
enum AuraCoreDeviceType
{
AURA_CORE_DEVICE_UNKNOWN = 0,
AURA_CORE_DEVICE_KEYBOARD = 1,
AURA_CORE_DEVICE_GA15DH = 2
};
enum
{
AURA_CORE_MODE_STATIC = 0, /* Static color mode */
AURA_CORE_MODE_BREATHING = 1, /* Breathing effect mode */
AURA_CORE_MODE_SPECTRUM_CYCLE = 2, /* Spectrum Cycle mode */
AURA_CORE_MODE_STATIC = 0, /* Static color mode */
AURA_CORE_MODE_BREATHING = 1, /* Breathing effect mode */
AURA_CORE_MODE_SPECTRUM_CYCLE = 2, /* Spectrum Cycle mode */
AURA_CORE_MODE_RAINBOW = 3, /* Rainbow mode */
AURA_CORE_MODE_STROBE = 10, /* Strobe mode */
AURA_CORE_MODE_COMET = 11, /* Comet mode */
AURA_CORE_MODE_FLASHNDASH = 12, /* Flash & Dash mode */
AURA_CORE_MODE_IRRADIATION = 17, /* Irradiation mode */
AURA_CORE_MODE_DIRECT = 255 /* Not a real mode - but need a way to differentiate */
};
enum
@@ -27,6 +40,7 @@ enum
AURA_CORE_COMMAND_SET = 0xB5, /* Set command */
AURA_CORE_COMMAND_APPLY = 0xB4, /* Apply command */
AURA_CORE_COMMAND_BRIGHTNESS = 0xBA, /* Brightness command */
AURA_CORE_COMMAND_DIRECT = 0xBC /* Set LEDs directly */
};
enum
@@ -45,9 +59,28 @@ enum
AURA_CORE_SPEED_FAST = 0xF5, /* Fastest speed */
};
struct AuraDeviceDescriptor
{
AuraCoreDeviceType aura_type;
unsigned char buff_size;
unsigned char report_id;
unsigned char num_leds;
unsigned char max_leds_per_message;
bool supports_direct;
};
struct AuraColor
{
unsigned char red;
unsigned char green;
unsigned char blue;
};
class AuraCoreController
{
public:
AuraDeviceDescriptor aura_device;
AuraCoreController(hid_device* dev_handle, const char* path);
~AuraCoreController();
@@ -64,6 +97,7 @@ public:
unsigned char zone,
unsigned char mode,
unsigned char speed,
unsigned char dir,
unsigned char red,
unsigned char green,
unsigned char blue
@@ -73,8 +107,17 @@ public:
void SendApply();
void InitDirectMode();
void UpdateDirect(std::vector<AuraColor>& color_set);
private:
hid_device* dev;
std::string location;
void IdentifyDevice();
void Handshake();
void SendIdString();
void SendQuery();
};
Controllers/AsusAuraCoreController/AsusAuraCoreControllerDetect.cpp
+5 -2
View File
@@ -19,10 +19,13 @@ void DetectAsusAuraCoreControllers(hid_device_info* info, const std::string&)
hid_device* dev = hid_open_path(info->path);
if( dev )
{
AuraCoreController* controller = new AuraCoreController(dev, info->path);
AuraCoreController* controller = new AuraCoreController(dev, info->path);
RGBController_AuraCore* rgb_controller = new RGBController_AuraCore(controller);
// Constructor sets the name
ResourceManager::get()->RegisterRGBController(rgb_controller);
if(rgb_controller->type != DEVICE_TYPE_UNKNOWN)
{
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
}
Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.cpp
+232 -24
View File
@@ -10,14 +10,33 @@
RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* aura_ptr)
{
aura = aura_ptr;
aura = aura_ptr;
name = "ASUS Aura Core";
name = "ASUS Aura Core Device";
vendor = "ASUS";
location = aura->GetDeviceLocation();
serial = aura->GetSerialString();
description = "ASUS Aura Core Device";
type = DEVICE_TYPE_UNKNOWN;
if(aura->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
{
SetupKeyboard();
}
else if(aura->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
{
SetupGA15DH();
}
SetupZones();
}
void RGBController_AuraCore::SetupKeyboard()
{
name = "ASUS Aura Keyboard";
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Core Device";
location = aura->GetDeviceLocation();
serial = aura->GetSerialString();
mode Static;
Static.name = "Static";
@@ -39,25 +58,142 @@ RGBController_AuraCore::RGBController_AuraCore(AuraCoreController* aura_ptr)
ColorCycle.flags = 0;
ColorCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(ColorCycle);
}
SetupZones();
void RGBController_AuraCore::SetupGA15DH()
{
name = "ASUS Aura GA15DH";
vendor = "ASUS";
type = DEVICE_TYPE_LEDSTRIP;
description = "ASUS Aura Core Device";
mode Static;
Static.name = "Static";
Static.value = AURA_CORE_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors.resize(1);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = AURA_CORE_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Breathing.speed_min = AURA_CORE_SPEED_SLOW;
Breathing.speed_max = AURA_CORE_SPEED_FAST;
Breathing.speed = AURA_CORE_SPEED_NORMAL;
Breathing.colors_min = 1;
Breathing.colors_max = 2;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors.resize(2);
modes.push_back(Breathing);
mode ColorCycle;
ColorCycle.name = "Color Cycle";
ColorCycle.value = AURA_CORE_MODE_SPECTRUM_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_SPEED;
ColorCycle.speed_min = AURA_CORE_SPEED_SLOW;
ColorCycle.speed_max = AURA_CORE_SPEED_FAST;
ColorCycle.speed = AURA_CORE_SPEED_NORMAL;
ColorCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(ColorCycle);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = AURA_CORE_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR;
Rainbow.speed_min = AURA_CORE_SPEED_SLOW;
Rainbow.speed_max = AURA_CORE_SPEED_FAST;
Rainbow.speed = AURA_CORE_SPEED_NORMAL;
Rainbow.direction = MODE_DIRECTION_RIGHT;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode Strobe;
Strobe.name = "Strobe";
Strobe.value = AURA_CORE_MODE_STROBE;
Strobe.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Strobe.colors_min = 1;
Strobe.colors_max = 1;
Strobe.color_mode = MODE_COLORS_MODE_SPECIFIC;
Strobe.colors.resize(1);
modes.push_back(Strobe);
mode Comet;
Comet.name = "Comet";
Comet.value = AURA_CORE_MODE_COMET;
Comet.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Comet.colors_min = 1;
Comet.colors_max = 1;
Comet.color_mode = MODE_COLORS_MODE_SPECIFIC;
Comet.colors.resize(1);
modes.push_back(Comet);
mode Flash;
Flash.name = "Flash & Dash";
Flash.value = AURA_CORE_MODE_FLASHNDASH;
Flash.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Flash.colors_min = 1;
Flash.colors_max = 1;
Flash.color_mode = MODE_COLORS_MODE_SPECIFIC;
Flash.colors.resize(1);
modes.push_back(Flash);
mode Irradiation;
Irradiation.name = "Irradiation";
Irradiation.value = AURA_CORE_MODE_IRRADIATION;
Irradiation.flags = 0;
Irradiation.color_mode = MODE_COLORS_NONE;
modes.push_back(Irradiation);
mode Direct;
Static.name = "Direct";
Static.value = AURA_CORE_MODE_DIRECT;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
}
RGBController_AuraCore::~RGBController_AuraCore()
{
delete aura;
}
void RGBController_AuraCore::SetupZones()
{
zone Keyboard;
Keyboard.name = "Keyboard";
Keyboard.type = ZONE_TYPE_SINGLE;
Keyboard.leds_min = 4;
Keyboard.leds_max = 4;
Keyboard.leds_count = 4;
Keyboard.matrix_map = NULL;
zones.push_back(Keyboard);
zone auraZone;
for(unsigned int led_idx = 0; led_idx < Keyboard.leds_count; led_idx++)
if(aura->aura_device.aura_type == AURA_CORE_DEVICE_KEYBOARD)
{
auraZone.name = "Keyboard";
auraZone.type = ZONE_TYPE_SINGLE;
auraZone.leds_min = 4;
auraZone.leds_max = 4;
auraZone.leds_count = 4;
auraZone.matrix_map = NULL;
}
else if(aura->aura_device.aura_type == AURA_CORE_DEVICE_GA15DH)
{
auraZone.name = "GA15DH";
auraZone.type = ZONE_TYPE_LINEAR;
auraZone.leds_min = 20;
auraZone.leds_max = 20;
auraZone.leds_count = 20;
auraZone.matrix_map = NULL;
}
else
{
auraZone.leds_count = 0;
}
zones.push_back(auraZone);
for(unsigned int led_idx = 0; led_idx < auraZone.leds_count; led_idx++)
{
led KeyLED;
KeyLED.name = "Keyboard LED ";
KeyLED.name = auraZone.name + " ";
KeyLED.name.append(std::to_string(led_idx + 1));
leds.push_back(KeyLED);
}
@@ -79,23 +215,88 @@ void RGBController_AuraCore::DeviceUpdateLEDs()
void RGBController_AuraCore::UpdateZoneLEDs(int /*zone*/)
{
for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
{
UpdateSingleLED(led_idx);
std::vector<AuraColor> aura_colors;
std::vector<RGBColor>& color_set = colors;
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
color_set = modes[active_mode].colors;
}
for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
{
AuraColor new_color;
new_color.red = RGBGetRValue(color_set[led_idx]);
new_color.green = RGBGetGValue(color_set[led_idx]);
new_color.blue = RGBGetBValue(color_set[led_idx]);
aura_colors.push_back(new_color);
}
aura->UpdateDirect(aura_colors);
}
else if(modes[active_mode].color_mode == MODE_COLORS_PER_LED)
{
for(unsigned int led_idx = 0; led_idx < leds.size(); led_idx++)
{
UpdateSingleLED(led_idx);
}
}
else
{
UpdateSingleLED(0);
}
}
void RGBController_AuraCore::UpdateSingleLED(int led)
{
unsigned char speed = 0xFF;
unsigned char red = 0;
unsigned char green = 0;
unsigned char blue = 0;
unsigned char dir = 0;
mode& curr_mode = modes[active_mode];
if(curr_mode.color_mode == MODE_COLORS_PER_LED)
{
red = RGBGetRValue(colors[led]);
green = RGBGetGValue(colors[led]);
blue = RGBGetBValue(colors[led]);
}
else if(curr_mode.color_mode == MODE_COLORS_MODE_SPECIFIC)
{
red = RGBGetRValue(curr_mode.colors[led]);
green = RGBGetGValue(curr_mode.colors[led]);
blue = RGBGetBValue(curr_mode.colors[led]);
}
if(curr_mode.flags & MODE_FLAG_HAS_SPEED)
{
speed = curr_mode.speed;
}
if(curr_mode.flags & MODE_FLAG_HAS_DIRECTION_LR)
{
if(curr_mode.direction == MODE_DIRECTION_RIGHT)
{
dir = 1;
}
}
aura->SendUpdate
(
led + 1,
modes[active_mode].value,
AURA_CORE_SPEED_NORMAL,
RGBGetRValue(colors[led]),
RGBGetGValue(colors[led]),
RGBGetBValue(colors[led])
led,
curr_mode.value,
speed,
dir,
red,
green,
blue
);
aura->SendSet();
aura->SendApply();
}
@@ -107,5 +308,12 @@ void RGBController_AuraCore::SetCustomMode()
void RGBController_AuraCore::DeviceUpdateMode()
{
DeviceUpdateLEDs();
if(modes[active_mode].value == AURA_CORE_MODE_DIRECT)
{
aura->InitDirectMode();
}
else
{
DeviceUpdateLEDs();
}
}
Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.h
+3 -1
View File
@@ -15,7 +15,10 @@ class RGBController_AuraCore : public RGBController
{
public:
RGBController_AuraCore(AuraCoreController* aura_ptr);
~RGBController_AuraCore();
void SetupKeyboard();
void SetupGA15DH();
void SetupZones();
void ResizeZone(int zone, int new_size);
@@ -29,5 +32,4 @@ public:
private:
AuraCoreController* aura;
};
Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp
+41 -21
View File
@@ -11,24 +11,41 @@
#include "RGBController.h"
#include "RGBController_AsusAuraGPU.h"
#include "i2c_smbus.h"
#include "pci_ids.h"
#include <vector>
#include <stdio.h>
#include <stdlib.h>
using namespace std::chrono_literals;
/*-------------------------------------------------------------*\
| This list contains the available I2C addresses for Aura GPUs |
\*-------------------------------------------------------------*/
#define AURA_GPU_ADDRESS_COUNT 3
static const unsigned char aura_gpu_addresses[] =
typedef struct
{
0x29,
0x2A,
0x60
};
int pci_vendor;
int pci_device;
int pci_subsystem_vendor;
int pci_subsystem_device;
unsigned char controller_address;
const char * name;
} gpu_pci_device;
#define GPU_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ]))
static const gpu_pci_device device_list[] =
{
{ NVIDIA_VEN, NVIDIA_GTX1060_DEV, ASUS_SUB_VEN, ASUS_GTX1060_STRIX, 0x29, "ASUS GTX 1060 Strix" },
{ NVIDIA_VEN, NVIDIA_GTX1070_DEV, ASUS_SUB_VEN, ASUS_GTX1070_STRIX, 0x29, "ASUS GTX 1070 Strix OC" },
{ NVIDIA_VEN, NVIDIA_GTX1080_DEV, ASUS_SUB_VEN, ASUS_GTX1080_STRIX, 0x29, "ASUS GTX 1080 Strix OC" },
{ NVIDIA_VEN, NVIDIA_GTX1080_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_GTX1080_A8G_GAMING, 0x29, "ASUS ROG Strix GTX1080 A8G Gaming" },
{ NVIDIA_VEN, NVIDIA_GTX1080TI_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_GTX1080TI_GAMING, 0x29, "ASUS ROG Strix GTX1080 Ti Gaming" },
{ NVIDIA_VEN, NVIDIA_GTX1660TI_DEV, ASUS_SUB_VEN, ASUS_ROG_GTX1660TI_OC, 0x2A, "ASUS ROG GTX 1660 Ti OC 6G" },
{ NVIDIA_VEN, NVIDIA_RTX2060_TU106_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2060_EVO_GAMING, 0x2A, "ASUS ROG STRIX RTX 2060 EVO Gaming 6G" },
{ NVIDIA_VEN, NVIDIA_RTX2070S_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2070S_A8G_GAMING, 0x2A, "ASUS ROG STRIX RTX 2070S A8G Gaming 8G" },
{ NVIDIA_VEN, NVIDIA_RTX2080_A_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080_O8G_GAMING, 0x2A, "ASUS ROG STRIX RTX 2080 O8G Gaming" },
{ NVIDIA_VEN, NVIDIA_RTX2080TI_DEV, ASUS_SUB_VEN, ASUS_ROG_STRIX_RTX2080TI_O11G_GAMING, 0x2A, "ASUS ROG STRIX RTX 2080 Ti O11G Gaming" },
{ AMD_GPU_VEN, AMD_VEGA10_DEV, ASUS_SUB_VEN, ASUS_VEGA64_STRIX, 0x29, "ASUS Vega 64 Strix" },
{ AMD_GPU_VEN, AMD_NAVI10_DEV, ASUS_SUB_VEN, ASUS_RX5700XT_STRIX_GAMING_OC, 0x2A, "ASUS RX 5700XT Strix Gaming OC" },
{ AMD_GPU_VEN, AMD_POLARIS_DEV, ASUS_SUB_VEN, ASUS_RX580_STRIX_GAMING_OC, 0x29, "ASUS RX 580 Strix Gaming OC" }
};
/******************************************************************************************\
* *
@@ -54,7 +71,6 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
} /* TestForAuraGPUController() */
/******************************************************************************************\
* *
* DetectAuraGPUControllers *
@@ -63,26 +79,30 @@ bool TestForAsusAuraGPUController(i2c_smbus_interface* bus, unsigned char addres
* *
\******************************************************************************************/
void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
void DetectAsusAuraGPUControllers(std::vector<i2c_smbus_interface*> &busses)
{
AuraGPUController* new_aura_gpu;
RGBController_AuraGPU* new_controller;
for (unsigned int bus = 0; bus < busses.size(); bus++)
{
// Add Aura-enabled GPU controllers
for (unsigned int address_list_idx = 0; address_list_idx < AURA_GPU_ADDRESS_COUNT; address_list_idx++)
for(unsigned int dev_idx = 0; dev_idx < GPU_NUM_DEVICES; dev_idx++)
{
if (TestForAsusAuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]))
if(busses[bus]->pci_vendor == device_list[dev_idx].pci_vendor &&
busses[bus]->pci_device == device_list[dev_idx].pci_device &&
busses[bus]->pci_subsystem_vendor == device_list[dev_idx].pci_subsystem_vendor &&
busses[bus]->pci_subsystem_device == device_list[dev_idx].pci_subsystem_device)
{
new_aura_gpu = new AuraGPUController(busses[bus], aura_gpu_addresses[address_list_idx]);
new_controller = new RGBController_AuraGPU(new_aura_gpu);
rgb_controllers.push_back(new_controller);
if (TestForAsusAuraGPUController(busses[bus], device_list[dev_idx].controller_address))
{
new_aura_gpu = new AuraGPUController(busses[bus], device_list[dev_idx].controller_address);
new_controller = new RGBController_AuraGPU(new_aura_gpu);
new_controller->name = device_list[dev_idx].name;
ResourceManager::get()->RegisterRGBController(new_controller);
}
}
std::this_thread::sleep_for(1ms);
}
}
} /* DetectAuraGPUControllers() */
} /* DetectAsusAuraGPUControllers() */
REGISTER_I2C_DETECTOR("ASUS Aura GPU", DetectAsusAuraGPUControllers);
Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp
+5
View File
@@ -100,6 +100,11 @@ RGBController_AuraGPU::RGBController_AuraGPU(AuraGPUController * aura_gpu_ptr)
active_mode = GetDeviceMode();
}
RGBController_AuraGPU::~RGBController_AuraGPU()
{
delete aura_gpu;
}
void RGBController_AuraGPU::SetupZones()
{
/*---------------------------------------------------------*\
Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h
+1
View File
@@ -15,6 +15,7 @@ class RGBController_AuraGPU : public RGBController
{
public:
RGBController_AuraGPU(AuraGPUController* aura_gpu_ptr);
~RGBController_AuraGPU();
void SetupZones();
Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp
+15 -15
View File
@@ -194,38 +194,38 @@ unsigned char AuraSMBusController::GetLEDBlue(unsigned int led)
return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1));
}
void AuraSMBusController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue)
void AuraSMBusController::SetAllColorsDirect(RGBColor* colors)
{
unsigned char* colors = new unsigned char[led_count * 3];
unsigned char* color_buf = new unsigned char[led_count * 3];
for (unsigned int i = 0; i < (led_count * 3); i += 3)
{
colors[i + 0] = red;
colors[i + 1] = blue;
colors[i + 2] = green;
color_buf[i + 0] = RGBGetRValue(colors[i / 3]);
color_buf[i + 1] = RGBGetBValue(colors[i / 3]);
color_buf[i + 2] = RGBGetGValue(colors[i / 3]);
}
AuraRegisterWriteBlock(direct_reg, colors, led_count * 3);
AuraRegisterWriteBlock(direct_reg, color_buf, led_count * 3);
delete colors;
delete color_buf;
}
void AuraSMBusController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
void AuraSMBusController::SetAllColorsEffect(RGBColor* colors)
{
unsigned char* colors = new unsigned char[led_count * 3];
unsigned char* color_buf = new unsigned char[led_count * 3];
for (unsigned int i = 0; i < (led_count * 3); i += 3)
{
colors[i + 0] = red;
colors[i + 1] = blue;
colors[i + 2] = green;
color_buf[i + 0] = RGBGetRValue(colors[i / 3]);
color_buf[i + 1] = RGBGetBValue(colors[i / 3]);
color_buf[i + 2] = RGBGetGValue(colors[i / 3]);
}
AuraRegisterWriteBlock(effect_reg, colors, led_count * 3);
AuraRegisterWriteBlock(effect_reg, color_buf, led_count * 3);
AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL);
delete[] colors;
delete[] color_buf;
}
void AuraSMBusController::SetDirect(unsigned char direct)
Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h
+4 -2
View File
@@ -7,6 +7,8 @@
| Adam Honse (CalcProgrammer1) 8/19/2018 |
\*-----------------------------------------*/
#include "RGBController.h"
#include <string>
#include "i2c_smbus.h"
@@ -87,8 +89,8 @@ public:
unsigned char GetLEDRed(unsigned int led);
unsigned char GetLEDGreen(unsigned int led);
unsigned char GetLEDBlue(unsigned int led);
void SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
void SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
void SetAllColorsDirect(RGBColor* colors);
void SetAllColorsEffect(RGBColor* colors);
void SetDirect(unsigned char direct);
void SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
void SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue);
Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp
+45 -14
View File
@@ -1,5 +1,6 @@
#include "Detector.h"
#include "AsusAuraSMBusController.h"
#include "LogManager.h"
#include "RGBController.h"
#include "RGBController_AsusAuraSMBus.h"
#include "i2c_smbus.h"
@@ -7,6 +8,7 @@
#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include "dependencies/dmiinfo.h"
using namespace std::chrono_literals;
@@ -87,21 +89,32 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
{
bool pass = false;
LOG_DEBUG("Testing address %02X for Aura SMBus controller", address);
int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE);
if (res >= 0)
{
pass = true;
LOG_DEBUG("Detected an I2C device at address %02X, testing register range for Aura SMBus", address);
for (int i = 0xA0; i < 0xB0; i++)
{
res = bus->i2c_smbus_read_byte_data(address, i);
if (res != (i - 0xA0))
{
LOG_DEBUG("Detection failed testing register %02X. Expected %02X, got %02X.", i, (i - 0xA0), res);
pass = false;
}
}
if(pass)
{
LOG_DEBUG("Detection successful, address %02X appears to be an Aura SMBus controller", address);
}
}
return(pass);
@@ -110,7 +123,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
/******************************************************************************************\
* *
* DetectAuraSMBusControllers *
* DetectAuraSMBusControllers *
* *
* Detect Aura controllers on the enumerated I2C busses. Searches for Aura-enabled *
* RAM at 0x77 and tries to initialize their slot addresses, then searches for them *
@@ -122,24 +135,24 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr
* *
\******************************************************************************************/
void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
void DetectAsusAuraSMBusDRAMControllers(std::vector<i2c_smbus_interface*> &busses)
{
AuraSMBusController* new_aura;
RGBController_AuraSMBus* new_controller;
for (unsigned int bus = 0; bus < busses.size(); bus++)
{
int address_list_idx = -1;
IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
{
// Remap Aura-enabled RAM modules on 0x77
LOG_DEBUG("Remapping Aura SMBus RAM modules on 0x77");
for (unsigned int slot = 0; slot < 8; slot++)
{
int res = busses[bus]->i2c_smbus_write_quick(0x77, I2C_SMBUS_WRITE);
if (res < 0)
{
LOG_DEBUG("No device detected at address 0x77, aborting remap");
break;
}
@@ -149,6 +162,8 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
{
LOG_DEBUG("Testing address %02X to see if there is a device there", aura_ram_addresses[address_list_idx]);
res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE);
}
else
@@ -159,6 +174,8 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
if(address_list_idx < AURA_RAM_ADDRESS_COUNT)
{
LOG_DEBUG("Remapping slot %d to address %02X", slot, aura_ram_addresses[address_list_idx]);
AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot);
AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1));
}
@@ -169,14 +186,25 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
{
if (TestForAsusAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]))
{
new_aura = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
new_controller = new RGBController_AuraSMBus(new_aura);
rgb_controllers.push_back(new_controller);
AuraSMBusController* controller = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]);
RGBController_AuraSMBus* rgb_controller = new RGBController_AuraSMBus(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
std::this_thread::sleep_for(1ms);
}
}
}
} /* DetectAuraSMBusDRAMControllers() */
void DetectAsusAuraSMBusMotherboardControllers(std::vector<i2c_smbus_interface*> &busses)
{
AuraSMBusController* new_aura;
RGBController_AuraSMBus* new_controller;
for (unsigned int bus = 0; bus < busses.size(); bus++)
{
int address_list_idx = -1;
// Add Aura-enabled motherboard controllers
IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
@@ -185,9 +213,11 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
{
if (TestForAsusAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]))
{
new_aura = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
new_controller = new RGBController_AuraSMBus(new_aura);
rgb_controllers.push_back(new_controller);
DMIInfo dmi;
AuraSMBusController* controller = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]);
RGBController_AuraSMBus* rgb_controller = new RGBController_AuraSMBus(controller);
rgb_controller->name = "ASUS " + dmi.getMainboard();
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
std::this_thread::sleep_for(1ms);
@@ -195,6 +225,7 @@ void DetectAsusAuraSMBusControllers(std::vector<i2c_smbus_interface*> &busses, s
}
}
} /* DetectAuraSMBusControllers() */
} /* DetectAuraSMBusMotherboardControllers() */
REGISTER_I2C_DETECTOR("ASUS Aura SMBus", DetectAsusAuraSMBusControllers);
REGISTER_I2C_DETECTOR("ASUS Aura SMBus DRAM", DetectAsusAuraSMBusDRAMControllers);
REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard", DetectAsusAuraSMBusMotherboardControllers);
Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp
+6 -13
View File
@@ -58,20 +58,13 @@ int RGBController_AuraSMBus::GetDeviceMode()
void RGBController_AuraSMBus::DeviceUpdateLEDs()
{
for(std::size_t led = 0; led < colors.size(); led++)
if(GetMode() == 0)
{
unsigned char red = RGBGetRValue(colors[led]);
unsigned char grn = RGBGetGValue(colors[led]);
unsigned char blu = RGBGetBValue(colors[led]);
if (GetMode() == 0)
{
aura->SetLEDColorDirect(led, red, grn, blu);
}
else
{
aura->SetLEDColorEffect(led, red, grn, blu);
}
aura->SetAllColorsDirect(&colors[0]);
}
else
{
aura->SetAllColorsEffect(&colors[0]);
}
}
Controllers/AsusAuraUSBController/AsusAuraAddressableController.cpp
+1 -1
View File
@@ -17,7 +17,7 @@ AuraAddressableController::AuraAddressableController(hid_device* dev_handle, con
\*-----------------------------------------------------*/
for(int i = 0; i < config_table[0x02]; ++i)
{
device_info.push_back({0x01, (unsigned char)i, 0x01, AuraDeviceType::ADDRESSABLE});
device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
}
}
Controllers/AsusAuraUSBController/AsusAuraKeyboardController.cpp
+110
View File
@@ -0,0 +1,110 @@
/*-----------------------------------------*\
| AsusAuraKeyboardController.cpp |
| |
| Driver for ASUS Aura RGB USB |
| lighting controller |
| |
| Adam Honse (CalcProgrammer1) 3/19/2020 |
\*-----------------------------------------*/
#include "AsusAuraKeyboardController.h"
#include <cstring>
AuraKeyboardController::AuraKeyboardController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
}
AuraKeyboardController::~AuraKeyboardController()
{
hid_close(dev);
}
std::string AuraKeyboardController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AuraKeyboardController::GetSerialString()
{
wchar_t serial_string[128];
hid_get_serial_number_string(dev, serial_string, 128);
std::wstring return_wstring = serial_string;
std::string return_string(return_wstring.begin(), return_wstring.end());
return(return_string);
}
void AuraKeyboardController::SendDirect
(
unsigned char frame_count,
unsigned char * frame_data
)
{
unsigned char usb_buf[65];
unsigned int packet_count = frame_count / 15 + (((frame_count % 15) == 0) ? 0 : 1);
unsigned int total_frame_idx = 0;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xC0;
usb_buf[0x02] = 0x81;
usb_buf[0x03] = packet_count * 15;
usb_buf[0x04] = 0x00;
/*-----------------------------------------------------*\
| Copy in frame data and send packets until all data |
| has been sent |
\*-----------------------------------------------------*/
for(unsigned int packet_idx = 0; packet_idx < packet_count; packet_idx++)
{
unsigned int packet_data_size = 15 * 4;
if((frame_count - total_frame_idx) < 15)
{
packet_data_size = (frame_count - total_frame_idx) * 4;
memset(&usb_buf[0x05 + packet_data_size], 0xFF, (15*4) - packet_data_size);
}
memcpy(&usb_buf[0x05], &frame_data[packet_idx * 15 * 4], packet_data_size);
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, 65);
/*-----------------------------------------------------*\
| Decrement remaining frame count |
\*-----------------------------------------------------*/
usb_buf[0x03] -= 0x0F;
total_frame_idx += 0x0F;
}
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0xC0;
usb_buf[0x02] = 0x81;
usb_buf[0x03] = 0x90;
/*-----------------------------------------------------*\
| Read to apply |
\*-----------------------------------------------------*/
hid_read(dev,usb_buf, 65);
}
Controllers/AsusAuraUSBController/AsusAuraKeyboardController.h
+36
View File
@@ -0,0 +1,36 @@
/*-----------------------------------------*\
| AsusAuraKeyboardController.h |
| |
| Definitions and types for ASUS Aura |
| USB RGB lighting controller |
| |
| Adam Honse (CalcProgrammer1) 3/19/2020 |
\*-----------------------------------------*/
#include "RGBController.h"
#include <string>
#include <vector>
#include <hidapi/hidapi.h>
#pragma once
class AuraKeyboardController
{
public:
AuraKeyboardController(hid_device* dev_handle, const char* path);
virtual ~AuraKeyboardController();
std::string GetDeviceLocation();
std::string GetSerialString();
void SendDirect
(
unsigned char frame_count,
unsigned char * frame_data
);
private:
hid_device* dev;
std::string location;
};
Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp
+23 -14
View File
@@ -12,17 +12,26 @@
AuraMainboardController::AuraMainboardController(hid_device* dev_handle, const char* path) : AuraUSBController(dev_handle, path), mode(AURA_MODE_DIRECT)
{
unsigned char num_total_mainboard_leds = config_table[0x1B];
unsigned char num_rgb_headers = config_table[0x1D];
unsigned char num_addressable_headers = config_table[0x02];
if(num_total_mainboard_leds < num_rgb_headers)
{
num_rgb_headers = 0;
}
/*-----------------------------------------------------*\
| Add mainboard device |
\*-----------------------------------------------------*/
device_info.push_back({0x00, 0x04, config_table[0x1B], AuraDeviceType::FIXED});
device_info.push_back({0x00, 0x04, num_total_mainboard_leds, num_rgb_headers, AuraDeviceType::FIXED});
/*-----------------------------------------------------*\
| Add addressable devices |
\*-----------------------------------------------------*/
for(int i = 0; i < config_table[0x02]; ++i)
for(int i = 0; i < num_addressable_headers; i++)
{
device_info.push_back({0x01, (unsigned char)i, 0x01, AuraDeviceType::ADDRESSABLE});
device_info.push_back({0x01, (unsigned char)i, 0x01, 0, AuraDeviceType::ADDRESSABLE});
}
}
@@ -62,8 +71,6 @@ void AuraMainboardController::SetChannelLEDs(unsigned char channel, RGBColor * c
leds_sent += leds_to_send;
}
SendCommit();
}
void AuraMainboardController::SetMode
@@ -104,11 +111,13 @@ void AuraMainboardController::SetMode
channel,
start_led,
device_info[channel].num_leds,
led_data,
device_info[channel].device_type == AuraDeviceType::FIXED
led_data
);
}
SendCommit();
unsigned short AuraMainboardController::GetMask(int start, int size)
{
return(((1 << size) - 1) << start);
}
void AuraMainboardController::SendEffect
@@ -142,14 +151,14 @@ void AuraMainboardController::SendEffect
void AuraMainboardController::SendColor
(
unsigned char channel,
unsigned char /*channel*/,
unsigned char start_led,
unsigned char led_count,
unsigned char* led_data,
bool fixed
unsigned char* led_data
)
{
unsigned char usb_buf[65];
unsigned short mask = GetMask(start_led, led_count);
unsigned char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
@@ -161,8 +170,8 @@ void AuraMainboardController::SendColor
\*-----------------------------------------------------*/
usb_buf[0x00] = 0xEC;
usb_buf[0x01] = AURA_MAINBOARD_CONTROL_MODE_EFFECT_COLOR;
usb_buf[0x02] = channel;
usb_buf[0x03] = fixed ? 0xFF : 0x00;
usb_buf[0x02] = mask >> 8;
usb_buf[0x03] = mask & 0xff;
usb_buf[0x04] = 0x00;
/*-----------------------------------------------------*\
Controllers/AsusAuraUSBController/AsusAuraMainboardController.h
+3 -2
View File
@@ -47,6 +47,8 @@ public:
private:
unsigned int mode;
unsigned short GetMask(int start, int size);
void SendEffect
(
unsigned char channel,
@@ -58,8 +60,7 @@ private:
unsigned char channel,
unsigned char start_led,
unsigned char led_count,
unsigned char* led_data,
bool fixed
unsigned char* led_data
);
void SendCommit();
Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp
+1 -1
View File
@@ -19,7 +19,7 @@ AuraMouseController::AuraMouseController(hid_device* dev_handle, const char* pat
AuraMouseController::~AuraMouseController()
{
hid_close(dev);
}
std::string AuraMouseController::GetDeviceLocation()
Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp
+4 -7
View File
@@ -22,9 +22,8 @@ AuraUSBController::AuraUSBController(hid_device* dev_handle, const char* path)
AuraUSBController::~AuraUSBController()
{
hid_close(dev);
}
unsigned int AuraUSBController::GetChannelCount()
{
return(device_info.size());
@@ -95,11 +94,9 @@ void AuraUSBController::GetConfigTable()
}
}
else
{
if(dev)
{
hid_close(dev);
}
{
hid_close(dev);
throw std::runtime_error("Could not read config table");
}
}
Controllers/AsusAuraUSBController/AsusAuraUSBController.h
+1
View File
@@ -53,6 +53,7 @@ struct AuraDeviceInfo
unsigned char effect_channel;
unsigned char direct_channel;
unsigned char num_leds;
unsigned char num_headers;
AuraDeviceType device_type;
};
Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
+56 -12
View File
@@ -1,12 +1,15 @@
#include "Detector.h"
#include "AsusAuraAddressableController.h"
#include "AsusAuraKeyboardController.h"
#include "AsusAuraMainboardController.h"
#include "AsusAuraMouseController.h"
#include "RGBController.h"
#include "RGBController_AsusAuraUSB.h"
#include "RGBController_AsusAuraKeyboard.h"
#include "RGBController_AsusAuraMouse.h"
#include <stdexcept>
#include <hidapi/hidapi.h>
#include "dependencies/dmiinfo.h"
#define AURA_USB_VID 0x0B05
#define AURA_TERMINAL_PID 0x1889
@@ -16,11 +19,18 @@
#define AURA_ADDRESSABLE_4_PID 0x18A5
#define AURA_MOTHERBOARD_1_PID 0x18F3
#define AURA_MOTHERBOARD_2_PID 0x1939
#define AURA_MOTHERBOARD_3_PID 0x19AF
#define AURA_ROG_GLADIUS_II_CORE_PID 0x18DD
#define AURA_ROG_GLADIUS_II_PID 0x1845
#define AURA_ROG_STRIX_FLARE_PID 0x1875
#define AURA_ROG_GLADIUS_II_ORIGIN_PID 0x1877
#define AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID 0x18CD
#define AURA_ROG_STRIX_FLARE_PNK_LTD_PID 0x18CF
#define AURA_ROG_CHAKRAM_WIRELESS_PID 0x18E5
#define AURA_ROG_CHAKRAM_WIRED_1_PID 0x18E3
#define AURA_ROG_CHAKRAM_WIRED_2_PID 0x1958
void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name)
void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
@@ -33,6 +43,20 @@ void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name
}
}
void DetectAsusAuraUSBAddressable(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
DMIInfo dmi;
AuraAddressableController* controller = new AuraAddressableController(dev, info->path);
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
rgb_controller->name = "ASUS " + dmi.getMainboard() + " Addressable";
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
@@ -40,9 +64,10 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& nam
{
try
{
DMIInfo dmi;
AuraMainboardController* controller = new AuraMainboardController(dev, info->path);
RGBController_AuraUSB* rgb_controller = new RGBController_AuraUSB(controller);
rgb_controller->name = name;
rgb_controller->name = "ASUS " + dmi.getMainboard();
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
catch(std::runtime_error&)
@@ -52,6 +77,18 @@ void DetectAsusAuraUSBMotherboards(hid_device_info* info, const std::string& nam
}
}
void DetectAsusAuraUSBKeyboards(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
AuraKeyboardController* controller = new AuraKeyboardController(dev, info->path);
RGBController_AuraKeyboard* rgb_controller = new RGBController_AuraKeyboard(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
@@ -64,13 +101,20 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
}
}
REGISTER_HID_DETECTOR ("ASUS ROG AURA Terminal", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_TERMINAL_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR ("ASUS ROG AURA Terminal", DetectAsusAuraUSBTerminal, AURA_USB_VID, AURA_TERMINAL_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_3_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Addressable", DetectAsusAuraUSBAddressable, AURA_USB_VID, AURA_ADDRESSABLE_4_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_1_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_2_PID);
REGISTER_HID_DETECTOR ("ASUS Aura Motherboard", DetectAsusAuraUSBMotherboards, AURA_USB_VID, AURA_MOTHERBOARD_3_PID);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Core", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_CORE_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Gladius II Origin PNK LTD", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_GLADIUS_II_ORIGIN_PNK_LTD_PID, 2, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_WIRELESS_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)", DetectAsusAuraUSBMice, AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_2_PID, 0, 0xFF01);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID, 1, 0xFF00);
REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD", DetectAsusAuraUSBKeyboards, AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID, 1, 0xFF00);
Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp
+276
View File
@@ -0,0 +1,276 @@
/*-----------------------------------------*\
| RGBController_AsusAuraKeyboard.cpp |
| |
| Generic RGB Interface for Asus Aura |
| USB controller driver |
| |
| Adam Honse (CalcProgrammer1) 3/19/2020 |
\*-----------------------------------------*/
#include "RGBController_AsusAuraKeyboard.h"
//0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
static unsigned int matrix_map[6][22] =
{ { 0, NA, 13, 18, 23, 28, 38, 43, 49, 54, 60, 65, 69, 70, NA, 76, 80, 85, NA, NA, NA, NA },
{ 1, 8, 14, 19, 24, 29, 34, 39, 44, 50, 55, 61, 66, 71, NA, 77, 81, 86, 89, 94, 98, 103 },
{ 2, NA, 9, 15, 20, 25, 30, 35, 40, 45, 51, 56, 62, 67, 72, 78, 82, 87, 90, 95, 99, 104 },
{ 3, NA, 10, 16, 21, 26, 31, 36, 41, 46, 52, 57, 63, 68, 73, NA, NA, NA, 91, 96, 100, NA },
{ 4, 6, 11, 17, 22, 27, 32, 37, 42, 47, 53, 58, NA, NA, 74, NA, 83, NA, 92, 97, 101, 105 },
{ 5, 7, 12, NA, NA, NA, NA, 33, NA, 48, NA, 59, 64, 75, NA, 79, 84, 88, 93, NA, 102, NA } };
static const char* zone_names[] =
{
"Keyboard",
"Logo",
"Underglow"
};
static zone_type zone_types[] =
{
ZONE_TYPE_MATRIX,
ZONE_TYPE_SINGLE,
ZONE_TYPE_SINGLE
};
static const unsigned int zone_sizes[] =
{
106,
1,
2,
};
typedef struct
{
const char * name;
const unsigned char idx;
} led_type;
static const led_type led_names[] =
{
/* Key Label Index */
{ "Key: Escape", 0x00 },
{ "Key: `", 0x01 },
{ "Key: Tab", 0x02 },
{ "Key: Caps Lock", 0x03 },
{ "Key: Left Shift", 0x04 },
{ "Key: Left Control", 0x05 },
{ "Key: \\ (ISO)", 0x0C },
{ "Key: Left Windows", 0x0D },
{ "Key: 1", 0x11 },
{ "Key: Q", 0x12 },
{ "Key: A", 0x13 },
{ "Key: Z", 0x14 },
{ "Key: Left Alt", 0x15 },
{ "Key: F1", 0x18 },
{ "Key: 2", 0x19 },
{ "Key: W", 0x1A },
{ "Key: S", 0x1B },
{ "Key: X", 0x1C },
{ "Key: F2", 0x20 },
{ "Key: 3", 0x21 },
{ "Key: E", 0x22 },
{ "Key: D", 0x23 },
{ "Key: C", 0x24 },
{ "Key: F3", 0x28 },
{ "Key: 4", 0x29 },
{ "Key: R", 0x2A },
{ "Key: F", 0x2B },
{ "Key: V", 0x2C },
{ "Key: F4", 0x30 },
{ "Key: 5", 0x31 },
{ "Key: T", 0x32 },
{ "Key: G", 0x33 },
{ "Key: B", 0x34 },
{ "Key: Space", 0x35 },
{ "Key: 6", 0x39 },
{ "Key: Y", 0x3A },
{ "Key: H", 0x3B },
{ "Key: N", 0x3C },
{ "Key: F5", 0x40 },
{ "Key: 7", 0x41 },
{ "Key: U", 0x42 },
{ "Key: J", 0x43 },
{ "Key: M", 0x44 },
{ "Key: F6", 0x48 },
{ "Key: 8", 0x49 },
{ "Key: I", 0x4A },
{ "Key: K", 0x4B },
{ "Key: ,", 0x4C },
{ "Key: Right Alt", 0x4D },
{ "Key: F7", 0x50 },
{ "Key: 9", 0x51 },
{ "Key: O", 0x52 },
{ "Key: L", 0x53 },
{ "Key: .", 0x54 },
{ "Key: F8", 0x58 },
{ "Key: 0", 0x59 },
{ "Key: P", 0x5A },
{ "Key: ;", 0x5B },
{ "Key: /", 0x5C },
{ "Key: Right Fn", 0x5D },
{ "Key: F9", 0x60 },
{ "Key: -", 0x61 },
{ "Key: [", 0x62 },
{ "Key: '", 0x63 },
{ "Key: Menu", 0x65 },
{ "Key: F10", 0x68 },
{ "Key: =", 0x69 },
{ "Key: ]", 0x6A },
{ "Key: #", 0x6B },
{ "Key: F11", 0x70 },
{ "Key: F12", 0x78 },
{ "Key: Backspace", 0x79 },
{ "Key: \\ (ANSI)", 0x7A },
{ "Key: Enter", 0x7B },
{ "Key: Right Shift", 0x7C },
{ "Key: Right Control", 0x7D },
{ "Key: Print Screen", 0x80 },
{ "Key: Insert", 0x81 },
{ "Key: Delete", 0x82 },
{ "Key: Left Arrow", 0x85 },
{ "Key: Scroll Lock", 0x88 },
{ "Key: Home", 0x89 },
{ "Key: End", 0x8A },
{ "Key: Up Arrow", 0x8C },
{ "Key: Down Arrow", 0x8D },
{ "Key: Pause/Break", 0x90 },
{ "Key: Page Up", 0x91 },
{ "Key: Page Down", 0x92 },
{ "Key: Right Arrow", 0x95 },
{ "Key: Num Lock", 0x99 },
{ "Key: Number Pad 7", 0x9A },
{ "Key: Number Pad 4", 0x9B },
{ "Key: Number Pad 1", 0x9C },
{ "Key: Number Pad 0", 0x9D },
{ "Key: Number Pad /", 0xA1 },
{ "Key: Number Pad 8", 0xA2 },
{ "Key: Number Pad 5", 0xA3 },
{ "Key: Number Pad 2", 0xA4 },
{ "Key: Number Pad *", 0xA9 },
{ "Key: Number Pad 9", 0xAA },
{ "Key: Number Pad 6", 0xAB },
{ "Key: Number Pad 3", 0xAC },
{ "Key: Number Pad .", 0xAD },
{ "Key: Number Pad -", 0xB1 },
{ "Key: Number Pad +", 0xB2 },
{ "Key: Number Pad Enter", 0xB4 },
{ "Logo", 0xB8 },
{ "Left Underglow", 0xB9 },
{ "Right Underglow", 0xBA },
};
RGBController_AuraKeyboard::RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr)
{
aura = aura_ptr;
name = "ASUS Aura Keyboard";
vendor = "ASUS";
type = DEVICE_TYPE_KEYBOARD;
description = "ASUS Aura Keyboard Device";
location = aura->GetDeviceLocation();
serial = aura->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_AuraKeyboard::~RGBController_AuraKeyboard()
{
delete aura;
}
void RGBController_AuraKeyboard::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
unsigned int total_led_count = 0;
for(unsigned int zone_idx = 0; zone_idx < 3; zone_idx++)
{
zone new_zone;
new_zone.name = zone_names[zone_idx];
new_zone.type = zone_types[zone_idx];
new_zone.leds_min = zone_sizes[zone_idx];
new_zone.leds_max = zone_sizes[zone_idx];
new_zone.leds_count = zone_sizes[zone_idx];
if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
{
new_zone.matrix_map = new matrix_map_type;
new_zone.matrix_map->height = 6;
new_zone.matrix_map->width = 22;
new_zone.matrix_map->map = (unsigned int *)&matrix_map;
}
else
{
new_zone.matrix_map = NULL;
}
zones.push_back(new_zone);
total_led_count += zone_sizes[zone_idx];
}
for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
{
led new_led;
new_led.name = led_names[led_idx].name;
new_led.value = led_names[led_idx].idx;
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_AuraKeyboard::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_AuraKeyboard::DeviceUpdateLEDs()
{
unsigned char frame_buf[109 * 4];
/*---------------------------------------------------------*\
| TODO: Send packets with multiple LED frames |
\*---------------------------------------------------------*/
for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++)
{
frame_buf[(led_idx * 4) + 0] = leds[led_idx].value;
frame_buf[(led_idx * 4) + 1] = RGBGetRValue(colors[led_idx]);
frame_buf[(led_idx * 4) + 2] = RGBGetGValue(colors[led_idx]);
frame_buf[(led_idx * 4) + 3] = RGBGetBValue(colors[led_idx]);
}
aura->SendDirect(109, frame_buf);
}
void RGBController_AuraKeyboard::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraKeyboard::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_AuraKeyboard::SetCustomMode()
{
active_mode = 0;
}
void RGBController_AuraKeyboard::DeviceUpdateMode()
{
}
Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h
+33
View File
@@ -0,0 +1,33 @@
/*-----------------------------------------*\
| RGBController_AsusAuraKeyboard.h |
| |
| Generic RGB Interface for Asus Aura |
| USB controller driver |
| |
| Adam Honse (CalcProgrammer1) 3/19/2021 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "AsusAuraKeyboardController.h"
class RGBController_AuraKeyboard : public RGBController
{
public:
RGBController_AuraKeyboard(AuraKeyboardController* aura_ptr);
~RGBController_AuraKeyboard();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
AuraKeyboardController* aura;
};
Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp
+1 -1
View File
@@ -53,7 +53,7 @@ RGBController_AuraMouse::RGBController_AuraMouse(AuraMouseController* aura_ptr)
RGBController_AuraMouse::~RGBController_AuraMouse()
{
delete aura;
}
void RGBController_AuraMouse::SetupZones()
Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp
+15 -4
View File
@@ -105,7 +105,7 @@ RGBController_AuraUSB::RGBController_AuraUSB(AuraUSBController* aura_ptr) :
RGBController_AuraUSB::~RGBController_AuraUSB()
{
delete aura;
}
void RGBController_AuraUSB::SetupZones()
@@ -159,13 +159,24 @@ void RGBController_AuraUSB::SetupZones()
}
}
unsigned int num_mainboard_leds = device_info.num_leds - device_info.num_headers;
for (unsigned int led_ch_idx = 0; led_ch_idx < zones[channel_idx].leds_count; led_ch_idx++)
{
unsigned led_idx = led_ch_idx + 1;
led new_led;
new_led.name = zones[channel_idx].name;
new_led.name.append(", LED ");
new_led.name.append(std::to_string(led_ch_idx + 1));
if(device_info.device_type == AuraDeviceType::FIXED && led_ch_idx >= num_mainboard_leds)
{
new_led.name.append(", RGB Header ");
led_idx -= num_mainboard_leds;
}
else
{
new_led.name.append(", LED ");
}
new_led.name.append(std::to_string(led_idx));
new_led.value = channel_idx;
leds.push_back(new_led);
Controllers/CoolerMasterController/CMARGBcontroller.cpp
+121 -96
View File
@@ -18,12 +18,6 @@ static unsigned char argb_colour_index_data[2][2][2] =
{ 0x04, 0x07 }, } //G1 R1
};
static unsigned char argb_mode_data[2][9] =
{
{ 0x05, 0x01, 0x02, 0x03, 0x04, 0x01, 0x01, 0x01, 0x01 }, //12v RGB Mode values
{ 0x0A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08, 0x09 } //5v ARGB Mode values
};
CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx)
{
const int szTemp = 256;
@@ -32,7 +26,6 @@ CMARGBController::CMARGBController(hid_device* dev_handle, char *_path, unsigned
dev = dev_handle;
location = _path;
zone_index = _zone_idx;
current_speed = CM_ARGB_SPEED_NORMAL;
hid_get_manufacturer_string(dev, tmpName, szTemp);
std::wstring wName = std::wstring(tmpName);
@@ -56,28 +49,37 @@ CMARGBController::~CMARGBController()
void CMARGBController::GetStatus()
{
unsigned char buffer[0x40] = { 0x00 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
int header = zone_index - 1;
unsigned char buffer[CM_ARGB_PACKET_SIZE] = { 0x00, 0x80, 0x0B, 0x01 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
int rgb_offset = 0;
int zone;
/*buffer[CM_ARGB_REPORT_BYTE] = 0x80;
buffer[CM_ARGB_COMMAND_BYTE] = 0x01;
buffer[CM_ARGB_FUNCTION_BYTE] = 0x01;
if (argb_header_data[zone_index].digital)
{
zone = argb_header_data[zone_index].header;
buffer[CM_ARGB_COMMAND_BYTE] = 0x0B;
}
else
{
zone = 0x00;
buffer[CM_ARGB_COMMAND_BYTE] = 0x0A;
rgb_offset = 1;
}
/*---------------------------------------------------------*\
| If this is the group then just return the first status |
\*---------------------------------------------------------*/
buffer[CM_ARGB_ZONE_BYTE] = ( zone > 0x08 ) ? 0x01 : zone;
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
buffer[CM_ARGB_COMMAND_BYTE] = 0x0b;
buffer[CM_ARGB_FUNCTION_BYTE] = 0x03;
buffer[CM_ARGB_ZONE_BYTE] = 0xFF;
hid_write(dev, buffer, buffer_size);
int i = 0;
do{
hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
i++;
}while( (i < 4) );
current_mode = argb_mode_data[1][buffer[4]];
current_speed = buffer[5];*/
current_mode = buffer[4 - rgb_offset];
bool_random = ( buffer[5 - rgb_offset] == 0x00 );
current_speed = buffer[6 - rgb_offset];
current_brightness = buffer[7 - rgb_offset];
current_red = buffer[8 - rgb_offset];
current_green = buffer[9 - rgb_offset];
current_blue = buffer[10 - rgb_offset];
}
std::string CMARGBController::GetDeviceName()
@@ -125,6 +127,11 @@ unsigned char CMARGBController::GetLedSpeed()
return current_speed;
}
bool CMARGBController::GetRandomColours()
{
return bool_random;
}
unsigned int CMARGBController::GetLargestColour(unsigned int red, unsigned int green, unsigned int blue)
{
unsigned int largest;
@@ -142,65 +149,79 @@ unsigned int CMARGBController::GetLargestColour(unsigned int red, unsigned int g
unsigned char CMARGBController::GetColourIndex(unsigned char red, unsigned char green, unsigned char blue)
{
//The Coolermaster ARGB controller uses a limited colour pallette referenced by an index
//Starting at 0x00 Random, 0x01 Red, 0x02 Green, 0x03 Blue, 0x04 Yellow, 0x05 Purple, 0x06 Cyan, 0x07 White
//The index can be calculated by normalising the input colour, rounding those values
//and using them as the indicies of a 3d array containing the correct index
/*---------------------------------------------------------------------------------------------------------*\
| The Cooler Master ARGB controller V0008 uses a limited colour pallette referenced by an index |
| Starting at 0x00 Random, 0x01 Red, 0x02 Green, 0x03 Blue, 0x04 Yellow, 0x05 Purple, 0x06 Cyan, 0x07 White |
| The index can be calculated by normalising the input colour, rounding those values |
| and using them as the indicies of a 3d array containing the correct index |
\*---------------------------------------------------------------------------------------------------------*/
unsigned int divisor = GetLargestColour( red, green, blue);
unsigned int r = round( red / divisor );
unsigned int g = round( green / divisor );
unsigned int b = round( blue / divisor );
unsigned char idx = argb_colour_index_data[r][g][b];
return idx;
}
void CMARGBController::SetMode(unsigned char mode, unsigned char speed)
void CMARGBController::SetLedCount(int zone, int led_count)
{
current_mode = mode;
current_speed = speed;
unsigned char buffer[CM_ARGB_PACKET_SIZE] = { 0x00, 0x80, 0x0D, 0x02 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
SendUpdate();
buffer[CM_ARGB_ZONE_BYTE] = zone;
buffer[CM_ARGB_MODE_BYTE] = led_count;
buffer[CM_ARGB_COLOUR_INDEX_BYTE] = (0x0F - led_count > 0) ? 0x0F - led_count : 0x01;
hid_write(dev, buffer, buffer_size);
}
void CMARGBController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
void CMARGBController::SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours)
{
current_red = red;
current_green = green;
current_blue = blue;
bool needs_update = !( (current_mode == mode) && (current_speed == speed) && (current_brightness == 0xFF) && (ToRGBColor(current_red, current_green, current_blue) == colour));
SendUpdate();
if (needs_update)
{
current_mode = mode;
current_speed = speed;
current_brightness = 0xFF;
current_red = RGBGetRValue(colour);
current_green = RGBGetGValue(colour);
current_blue = RGBGetBValue(colour);
bool_random = random_colours;
SendUpdate();
}
}
void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_count)
{
const unsigned char buffer_size = 0x41;
unsigned char buffer[buffer_size] = { 0x00 };
unsigned char packet_count = 0x00;
const unsigned char buffer_size = CM_ARGB_PACKET_SIZE;
unsigned char buffer[buffer_size] = { 0x00, 0x10, 0x02 };
unsigned char packet_count = 0;
std::vector<unsigned char> colours;
//Set up the RGB triplets to send
for(int i = 0; i < led_count; i++)
/*---------------------------------------------*\
| Set up the RGB triplets to send |
\*---------------------------------------------*/
for(unsigned int i = 0; i < led_count; i++)
{
RGBColor colour = led_colours[i];
unsigned char r = RGBGetRValue(colour);
unsigned char g = RGBGetGValue(colour);
unsigned char b = RGBGetBValue(colour);
colours.push_back(r);
colours.push_back(g);
colours.push_back(b);
colours.push_back( RGBGetRValue(colour) );
colours.push_back( RGBGetGValue(colour) );
colours.push_back( RGBGetBValue(colour) );
}
//buffer[CM_ARGB_REPORT_BYTE] = packet_count;
buffer[CM_ARGB_COMMAND_BYTE] = 0x10;
buffer[CM_ARGB_FUNCTION_BYTE] = 0x02;
buffer[CM_ARGB_ZONE_BYTE] = argb_header_data[zone_index].header;
buffer[CM_ARGB_MODE_BYTE] = 0x30; //30 might be the LED count??
unsigned char buffer_idx = CM_ARGB_MODE_BYTE + 1; //Start colour info from
buffer[CM_ARGB_MODE_BYTE] = led_count;
unsigned char buffer_idx = CM_ARGB_MODE_BYTE + 1;
for (std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
for(std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
{
//Fill the write buffer till its full or the colour buffer is empty
/*-----------------------------------------------------------------*\
| Fill the write buffer till its full or the colour buffer is empty |
\*-----------------------------------------------------------------*/
buffer[CM_ARGB_REPORT_BYTE] = packet_count;
while (( buffer_idx < buffer_size) && ( it != colours.end() ))
{
@@ -212,17 +233,20 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
//reset the write buffer
memset(buffer, 0x00, sizeof(buffer) );
/*-----------------------------------------------------------------*\
| Reset the write buffer |
\*-----------------------------------------------------------------*/
memset(buffer, 0x00, buffer_size );
packet_count++;
}
buffer[CM_ARGB_REPORT_BYTE] = 0x82;
buffer[CM_ARGB_COMMAND_BYTE] = 0x62;
/*buffer[CM_ARGB_COMMAND_BYTE] = 0x62;
buffer[CM_ARGB_FUNCTION_BYTE] = 0x00;
buffer[CM_ARGB_ZONE_BYTE] = 0x73;
buffer[CM_ARGB_MODE_BYTE] = 0x00;
buffer[CM_ARGB_COLOUR_INDEX_BYTE] = 0x33;
buffer[CM_ARGB_SPEED_BYTE] = 0x1B;
buffer[CM_ARGB_SPEED_BYTE] = 0x1B;*/
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
@@ -230,52 +254,53 @@ void CMARGBController::SetLedsDirect(RGBColor *led_colours, unsigned int led_cou
void CMARGBController::SendUpdate()
{
unsigned char buffer[0x40] = { 0x00 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
bool boolARGB_header = argb_header_data[zone_index].digital;
bool boolPassthru = ( current_mode == CM_ARGB_MODE_PASSTHRU );
bool boolDirect = ( current_mode == CM_ARGB_MODE_DIRECT );
unsigned char function = boolPassthru ? 0x02 : ( boolARGB_header ? 0x03 : 0x01);
buffer[CM_ARGB_REPORT_BYTE] = 0x80;
buffer[CM_ARGB_COMMAND_BYTE] = boolDirect ? 0x10 : 0x01;
buffer[CM_ARGB_FUNCTION_BYTE] = boolDirect ? 0x01 : function;
unsigned char buffer[CM_ARGB_PACKET_SIZE] = { 0x00 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
bool boolARGB_header = argb_header_data[zone_index].digital;
bool boolPassthru = ( current_mode == CM_ARGB_MODE_PASSTHRU ) || ( current_mode == CM_RGB_MODE_PASSTHRU );
bool boolDirect = ( current_mode == CM_ARGB_MODE_DIRECT );
unsigned char function = boolPassthru ? (boolARGB_header ? 0x02 : 0x04) : (boolARGB_header ? 0x01 : 0x03);
buffer[CM_ARGB_REPORT_BYTE] = 0x80;
buffer[CM_ARGB_COMMAND_BYTE] = 0x01;
buffer[CM_ARGB_FUNCTION_BYTE] = boolDirect ? 0x01 : function;
if ( boolDirect )
{
buffer[CM_ARGB_COMMAND_BYTE] = 0x10;
buffer[CM_ARGB_FUNCTION_BYTE] = 0x01;
buffer[CM_ARGB_ZONE_BYTE] = argb_header_data[zone_index].header;
buffer[CM_ARGB_MODE_BYTE] = 0x30; //30 might be the LED count??
//hid_write(dev, buffer, buffer_size);
//hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
}
else
{
buffer[CM_ARGB_COMMAND_BYTE] = 0x01;
buffer[CM_ARGB_FUNCTION_BYTE] = function;
}
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
if ( boolARGB_header )
/*-----------------------------------------------------------------*\
| Direct mode is now set up and no other mode packet is required |
\*-----------------------------------------------------------------*/
if(boolDirect)
{
buffer[CM_ARGB_COMMAND_BYTE] = 0x0b; //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
buffer[CM_ARGB_FUNCTION_BYTE] = (false) ? 0x01 : 0x02; //This controls custom mode TODO
buffer[CM_ARGB_ZONE_BYTE] = argb_header_data[zone_index].header;
buffer[CM_ARGB_MODE_BYTE] = argb_mode_data[1][current_mode];
buffer[CM_ARGB_COLOUR_INDEX_BYTE] = GetColourIndex( current_red, current_green, current_blue );
buffer[CM_ARGB_SPEED_BYTE] = current_speed;
return;
}
if(boolARGB_header)
{
buffer[CM_ARGB_COMMAND_BYTE] = 0x0b; //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
buffer[CM_ARGB_FUNCTION_BYTE] = (false) ? 0x01 : 0x02; //This controls direct mode TODO
buffer[CM_ARGB_ZONE_BYTE] = argb_header_data[zone_index].header;
buffer[CM_ARGB_MODE_BYTE] = current_mode;
buffer[CM_ARGB_COLOUR_INDEX_BYTE] = bool_random ? 0x00 : 0x10;
buffer[CM_ARGB_SPEED_BYTE] = current_speed;
buffer[CM_ARGB_BRIGHTNESS_BYTE] = current_brightness;
buffer[CM_ARGB_RED_BYTE] = current_red;
buffer[CM_ARGB_GREEN_BYTE] = current_green;
buffer[CM_ARGB_BLUE_BYTE] = current_blue;
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
}
else
{
buffer[CM_ARGB_COMMAND_BYTE] = 0x04; //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET] = argb_mode_data[0][current_mode];
buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET] = GetColourIndex( current_red, current_green, current_blue );
buffer[CM_ARGB_COMMAND_BYTE] = boolPassthru ? 0x01 : 0x04; //ARGB sends 0x0b (1011) RGB sends 0x04 (0100)
buffer[CM_ARGB_MODE_BYTE + CM_RGB_OFFSET] = current_mode;
buffer[CM_ARGB_COLOUR_INDEX_BYTE + CM_RGB_OFFSET] = bool_random ? 0x00 : 0x10;
buffer[CM_ARGB_SPEED_BYTE + CM_RGB_OFFSET] = current_speed;
buffer[CM_ARGB_BRIGHTNESS_BYTE + CM_RGB_OFFSET] = current_brightness;
buffer[CM_ARGB_RED_BYTE + CM_RGB_OFFSET] = current_red;
buffer[CM_ARGB_GREEN_BYTE + CM_RGB_OFFSET] = current_green;
buffer[CM_ARGB_BLUE_BYTE + CM_RGB_OFFSET] = current_blue;
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_ARGB_INTERRUPT_TIMEOUT);
Controllers/CoolerMasterController/CMARGBcontroller.h
+29 -19
View File
@@ -20,6 +20,7 @@
#define CM_ARGB_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
#define CM_ARGB_HEADER_DATA_SIZE (sizeof(argb_header_data) / sizeof(argb_headers) )
#define CM_ARGB_INTERRUPT_TIMEOUT 250
#define CM_ARGB_PACKET_SIZE 65
#define CM_ARGB_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
#define CM_RGB_OFFSET -2
#define HID_MAX_STR 255
@@ -32,7 +33,11 @@ enum
CM_ARGB_ZONE_BYTE = 4,
CM_ARGB_MODE_BYTE = 5,
CM_ARGB_COLOUR_INDEX_BYTE = 6,
CM_ARGB_SPEED_BYTE = 7
CM_ARGB_SPEED_BYTE = 7,
CM_ARGB_BRIGHTNESS_BYTE = 8,
CM_ARGB_RED_BYTE = 9,
CM_ARGB_GREEN_BYTE = 10,
CM_ARGB_BLUE_BYTE = 11
};
struct argb_headers
@@ -45,7 +50,7 @@ struct argb_headers
static argb_headers argb_header_data[6] =
{
{ "RGB Header", 0xFF, false, 1 },
{ "RGB Header", 0xFE, false, 1 },
{ "Digital ARGB1", 0x01, true, 12 },
{ "Digital ARGB2", 0x02, true, 12 },
{ "Digital ARGB3", 0x04, true, 12 },
@@ -55,24 +60,26 @@ static argb_headers argb_header_data[6] =
enum
{
CM_RGB_MODE_OFF = 0, //Turn off
CM_RGB_MODE_COLOUR_CYCLE = 1, //Colour Cycle
CM_RGB_MODE_FLASH = 2, //Flash
CM_RGB_MODE_BREATHING = 3, //Breathing
CM_RGB_MODE_PASSTHRU = 4 //Motherboard Pass Thru Mode
CM_RGB_MODE_MIRAGE = 0x01, //Mirage
CM_RGB_MODE_FLASH = 0x02, //Flash
CM_RGB_MODE_BREATHING = 0x03, //Breathing
CM_RGB_MODE_STATIC = 0x05, //Static
CM_RGB_MODE_OFF = 0x06, //Turn off
CM_RGB_MODE_PASSTHRU = 0xFF //Motherboard Pass Thru Mode
};
enum
{
CM_ARGB_MODE_OFF = 0, //Turn off
CM_ARGB_MODE_SPECTRUM = 1, //Spectrum Mode
CM_ARGB_MODE_RELOAD = 2, //Reload Mode
CM_ARGB_MODE_RECOIL = 3, //Recoil Mode
CM_ARGB_MODE_BREATHING = 4, //Breathing Mode
CM_ARGB_MODE_REFILL = 5, //Refill Mode
CM_ARGB_MODE_DEMO = 6, //Demo Mode
CM_ARGB_MODE_FILLFLOW = 7, //Fill Flow Mode
CM_ARGB_MODE_RAINBOW = 8, //Rainbow Mode
CM_ARGB_MODE_OFF = 0x0B, //Turn off
CM_ARGB_MODE_SPECTRUM = 0x01, //Spectrum Mode
CM_ARGB_MODE_RELOAD = 0x02, //Reload Mode
CM_ARGB_MODE_RECOIL = 0x03, //Recoil Mode
CM_ARGB_MODE_BREATHING = 0x04, //Breathing Mode
CM_ARGB_MODE_REFILL = 0x05, //Refill Mode
CM_ARGB_MODE_DEMO = 0x06, //Demo Mode
CM_ARGB_MODE_FILLFLOW = 0x08, //Fill Flow Mode
CM_ARGB_MODE_RAINBOW = 0x09, //Rainbow Mode
CM_ARGB_MODE_STATIC = 0x0A, //Static Mode
CM_ARGB_MODE_DIRECT = 0xFE, //Direct Led Control
CM_ARGB_MODE_PASSTHRU = 0xFF //Motherboard Pass Thru Mode
};
@@ -102,9 +109,11 @@ public:
unsigned char GetLedGreen();
unsigned char GetLedBlue();
unsigned char GetLedSpeed();
void SetMode(unsigned char mode, unsigned char speed);
void SetColor(unsigned char red, unsigned char green, unsigned char blue);
bool GetRandomColours();
void SetLedCount(int zone, int led_count);
void SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours);
void SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
private:
std::string device_name;
std::string serial;
@@ -118,10 +127,11 @@ private:
unsigned char current_red;
unsigned char current_green;
unsigned char current_blue;
unsigned char current_brightness;
bool bool_random;
unsigned int GetLargestColour(unsigned int red, unsigned int green, unsigned int blue);
unsigned char GetColourIndex(unsigned char red, unsigned char green, unsigned char blue);
void GetStatus();
void SendUpdate();
};
Controllers/CoolerMasterController/CMMKController.cpp
+167
View File
@@ -0,0 +1,167 @@
/*-------------------------------------------------------------------*\
| CMMKController.cpp |
| |
| Driver for Coolermaster MasterKeys Keyboards |
| |
| Lukas N (chmod222) 28th Jun 2020 |
| Tam D (too.manyhobbies) 25th Apr 2021 |
| |
\*-------------------------------------------------------------------*/
#include "CMMKController.h"
CMMKController::CMMKController(hid_device* dev, hid_device_info* dev_info)
{
location = dev_info->path;
const int szTemp = 256;
wchar_t tmpName[szTemp];
hid_get_manufacturer_string(dev, tmpName, szTemp);
std::wstring wName = std::wstring(tmpName);
device_name = std::string(wName.begin(), wName.end());
hid_get_product_string(dev, tmpName, szTemp);
wName = std::wstring(tmpName);
device_name.append(" ").append(std::string(wName.begin(), wName.end()));
cmmk_attach_path(&cmmk_handle, dev_info->path, dev_info->product_id, -1);
char buf[32] = {0};
cmmk_get_firmware_version(&cmmk_handle, buf, 32);
firmware_version = buf;
}
CMMKController::~CMMKController()
{
cmmk_detach(&cmmk_handle);
}
std::string CMMKController::GetDeviceName()
{
return device_name;
}
std::string CMMKController::GetLocation()
{
return location;
}
std::string CMMKController::GetFirmwareVersion()
{
return firmware_version;
}
void CMMKController::SetFirmwareControl()
{
ActivateMode(CMMK_FIRMWARE);
}
void CMMKController::SetManualControl()
{
ActivateMode(CMMK_MANUAL);
}
void CMMKController::SetSingle(int row, int col, struct rgb color)
{
cmmk_set_single_key(&cmmk_handle, row, col, &color);
}
void CMMKController::SetAll(struct cmmk_color_matrix const& colors)
{
cmmk_set_leds(&cmmk_handle, &colors);
}
void CMMKController::SetAllSingle(struct rgb color)
{
cmmk_set_all_single(&cmmk_handle, &color);
}
void CMMKController::SetMode(cmmk_effect_fully_lit eff)
{
ActivateEffect(CMMK_EFFECT_FULLY_LIT);
cmmk_set_effect_fully_lit(&cmmk_handle, &eff);
}
void CMMKController::SetMode(cmmk_effect_breathe eff)
{
ActivateEffect(CMMK_EFFECT_BREATHE);
cmmk_set_effect_breathe(&cmmk_handle, &eff);
}
void CMMKController::SetMode(cmmk_effect_cycle eff)
{
ActivateEffect(CMMK_EFFECT_CYCLE);
cmmk_set_effect_cycle(&cmmk_handle, &eff);
}
void CMMKController::SetMode(cmmk_effect_single eff)
{
ActivateEffect(CMMK_EFFECT_SINGLE);
cmmk_set_effect_single(&cmmk_handle, &eff);
}
void CMMKController::SetMode(cmmk_effect_wave eff)
{
ActivateEffect(CMMK_EFFECT_WAVE);
cmmk_set_effect_wave(&cmmk_handle, &eff);
}
void CMMKController::SetMode(cmmk_effect_ripple eff)
{
ActivateEffect(CMMK_EFFECT_RIPPLE);
cmmk_set_effect_ripple(&cmmk_handle, &eff);
}
void CMMKController::SetMode(cmmk_effect_cross eff)
{
ActivateEffect(CMMK_EFFECT_CROSS);
cmmk_set_effect_cross(&cmmk_handle, &eff);
}
void CMMKController::SetMode(cmmk_effect_raindrops eff)
{
ActivateEffect(CMMK_EFFECT_RAINDROPS);
cmmk_set_effect_raindrops(&cmmk_handle, &eff);
}
void CMMKController::SetMode(cmmk_effect_stars eff)
{
ActivateEffect(CMMK_EFFECT_STARS);
cmmk_set_effect_stars(&cmmk_handle, &eff);
}
void CMMKController::SetMode(cmmk_effect_snake eff)
{
ActivateEffect(CMMK_EFFECT_SNAKE);
cmmk_set_effect_snake(&cmmk_handle, &eff);
}
bool CMMKController::PositionValid(int y, int x)
{
return(cmmk_lookup_key_id(&cmmk_handle, y, x) >= 0);
}
void CMMKController::ActivateMode(int mode)
{
if (current_mode != mode)
{
cmmk_set_control_mode(&cmmk_handle, mode);
current_mode = mode;
current_effect = -1;
}
}
void CMMKController::ActivateEffect(int effect)
{
ActivateMode(CMMK_EFFECT);
if (current_effect != effect)
{
cmmk_set_active_effect(&cmmk_handle, (enum cmmk_effect_id)effect);
current_effect = effect;
}
}
Controllers/CoolerMasterController/CMMKController.h
+58
View File
@@ -0,0 +1,58 @@
/*-------------------------------------------------------------------*\
| CMMKController.h |
| |
| Driver for Coolermaster MasterKeys keyboards |
| |
| Lukas N (chmod222) 28th Jun 2020 |
| |
\*-------------------------------------------------------------------*/
#include <string>
#include <hidapi/hidapi.h>
#include <libcmmk/libcmmk.h>
#pragma once
class CMMKController
{
public:
CMMKController(hid_device* dev_handle, hid_device_info* dev_info);
~CMMKController();
std::string GetDeviceName();
std::string GetLocation();
std::string GetFirmwareVersion();
void SetFirmwareControl();
void SetManualControl();
void SetSingle(int row, int col, struct rgb color);
void SetAll(struct cmmk_color_matrix const& colors);
void SetAllSingle(struct rgb color);
void SetMode(cmmk_effect_fully_lit eff);
void SetMode(cmmk_effect_breathe eff);
void SetMode(cmmk_effect_cycle eff);
void SetMode(cmmk_effect_single eff);
void SetMode(cmmk_effect_wave eff);
void SetMode(cmmk_effect_ripple eff);
void SetMode(cmmk_effect_cross eff);
void SetMode(cmmk_effect_raindrops eff);
void SetMode(cmmk_effect_stars eff);
void SetMode(cmmk_effect_snake eff);
bool PositionValid(int y, int x);
private:
void ActivateMode(int mode);
void ActivateEffect(int effect);
int current_mode = -1;
int current_effect = -1;
std::string device_name;
std::string location;
std::string firmware_version;
mutable struct cmmk cmmk_handle;
};
Controllers/CoolerMasterController/CMMP750Controller.cpp
+18 -21
View File
@@ -11,20 +11,17 @@
static unsigned char colour_mode_data[][6] =
{
{ 0x01, 0x04, 0xFF, 0x00, 0xFF, 0x00 }, /* Static */
{ 0x02, 0x04, 0xFF, 0x00, 0xFF, 0x80 }, /* Blinking */
{ 0x03, 0x04, 0xFF, 0x00, 0xFF, 0x80 }, /* Breathing */
{ 0x04, 0x04, 0x80, 0x00, 0x00, 0x00 }, /* Colour Cycle */
{ 0x05, 0x04, 0x80, 0x00, 0x00, 0x00 } /* Colour Breath */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* Off */
{ 0x01, 0x04, 0xFF, 0x00, 0xFF, 0x00 }, /* Static */
{ 0x02, 0x04, 0xFF, 0x00, 0xFF, 0x80 }, /* Blinking */
{ 0x03, 0x04, 0xFF, 0x00, 0xFF, 0x80 }, /* Breathing */
{ 0x04, 0x04, 0x80, 0x00, 0x00, 0x00 }, /* Colour Cycle */
{ 0x05, 0x04, 0x80, 0x00, 0x00, 0x00 } /* Colour Breath */
};
static unsigned char speed_mode_data[][9] =
static unsigned char speed_mode_data[9] =
{
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },/* Static */
{ 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 },/* Blinking */
{ 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 },/* Breathing */
{ 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 },/* Colour Cycle */
{ 0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 } /* Colour Breath */
0xFF, 0xE0, 0xC0, 0xA0, 0x80, 0x60, 0x40, 0x20, 0x00 /* Speed Definition */
};
CMMP750Controller::CMMP750Controller(hid_device* dev_handle, char *_path)
@@ -57,21 +54,21 @@ CMMP750Controller::~CMMP750Controller()
void CMMP750Controller::GetStatus()
{
unsigned char buffer[0x40] = { 0x00 };
unsigned char buffer[0x41] = { 0x00 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
buffer[0] = 0x07;
buffer[1] = 0x07;
hid_write(dev, buffer, buffer_size);
hid_read(dev, buffer, buffer_size);
if((buffer[0] == 0x80) && (buffer[1] == 0x05))
{
current_mode = buffer[2] - 1;
current_mode = buffer[2];
current_red = buffer[3];
current_green = buffer[4];
current_blue = buffer[5];
for(int i = 0; speed_mode_data[current_mode][i] >= buffer[6]; i++)
for(int i = 0; (speed_mode_data[i] >= buffer[6] && i <= MP750_SPEED_FASTEST); i++)
{
current_speed = i;
}
@@ -79,7 +76,7 @@ void CMMP750Controller::GetStatus()
else
{
//Code should never reach here however just in case there is a failure set something
current_mode = MP750_MODE_COLOR_CYCLE; //Unicorn Spew
current_mode = CM_MP750_MODE_COLOR_CYCLE; //Unicorn Spew
current_red = 0xFF;
current_green = 0xFF;
current_blue = 0xFF;
@@ -146,18 +143,18 @@ void CMMP750Controller::SetColor(unsigned char red, unsigned char green, unsigne
void CMMP750Controller::SendUpdate()
{
unsigned char buffer[0x40] = { 0x00 };
unsigned char buffer[0x41] = { 0x00 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
for(std::size_t i = 0; i < CM_COLOUR_MODE_DATA_SIZE; i++)
{
buffer[i] = colour_mode_data[current_mode][i];
buffer[i+1] = colour_mode_data[current_mode][i];
}
if(current_mode > MP750_MODE_BREATHING)
if(current_mode > CM_MP750_MODE_BREATHING)
{
//If the mode is random colours set SPEED at BYTE2
buffer[CM_RED_BYTE] = speed_mode_data[current_mode][current_speed];
buffer[CM_RED_BYTE] = speed_mode_data[current_speed];
}
else
{
@@ -165,7 +162,7 @@ void CMMP750Controller::SendUpdate()
buffer[CM_RED_BYTE] = current_red;
buffer[CM_GREEN_BYTE] = current_green;
buffer[CM_BLUE_BYTE] = current_blue;
buffer[CM_SPEED_BYTE] = speed_mode_data[current_mode][current_speed];
buffer[CM_SPEED_BYTE] = speed_mode_data[current_speed];
}
hid_write(dev, buffer, buffer_size);
Controllers/CoolerMasterController/CMMP750Controller.h
+12 -10
View File
@@ -28,20 +28,22 @@
enum
{
CM_MODE_BYTE = 0,
CM_RED_BYTE = 2,
CM_GREEN_BYTE = 3,
CM_BLUE_BYTE = 4,
CM_SPEED_BYTE = 5
CM_MODE_BYTE = 1,
CM_LENGTH_BYTE = 2,
CM_RED_BYTE = 3,
CM_GREEN_BYTE = 4,
CM_BLUE_BYTE = 5,
CM_SPEED_BYTE = 6
};
enum
{
MP750_MODE_STATIC = 0x00, //Static Mode
MP750_MODE_BLINK = 0x01, //Blinking Mode
MP750_MODE_BREATHING = 0x02, //Breathing Mode
MP750_MODE_COLOR_CYCLE = 0x03, //Color Cycle Mode
MP750_MODE_BREATH_CYCLE = 0x04 //Breathing Cycle Mode
CM_MP750_MODE_OFF = 0x00, //Off
CM_MP750_MODE_STATIC = 0x01, //Static Mode
CM_MP750_MODE_BLINK = 0x02, //Blinking Mode
CM_MP750_MODE_BREATHING = 0x03, //Breathing Mode
CM_MP750_MODE_COLOR_CYCLE = 0x04, //Color Cycle Mode
CM_MP750_MODE_BREATH_CYCLE = 0x05 //Breathing Cycle Mode
};
enum
Controllers/CoolerMasterController/CMR6000Controller.cpp
+196
View File
@@ -0,0 +1,196 @@
/*-------------------------------------------------------------------*\
| CMR6000Controller.cpp |
| |
| Driver for Coolermaster based AMD Radeon GPU (6000 series) |
| |
| Eric S (edbgon) 2nd Feb 2021 |
\*-------------------------------------------------------------------*/
#include "CMR6000Controller.h"
#include <cstring>
CMR6000Controller::CMR6000Controller(hid_device* dev_handle, char *_path)
{
dev = dev_handle;
location = _path;
const int szTemp = 256;
wchar_t tmpName[szTemp];
hid_get_manufacturer_string(dev, tmpName, szTemp);
std::wstring wName = std::wstring(tmpName);
device_name = std::string(wName.begin(), wName.end());
hid_get_product_string(dev, tmpName, szTemp);
wName = std::wstring(tmpName);
device_name.append(" ").append(std::string(wName.begin(), wName.end()));
hid_get_serial_number_string(dev, tmpName, szTemp);
wName = std::wstring(tmpName);
serial = std::string(wName.begin(), wName.end());
GetStatus(); //When setting up device get current status
}
CMR6000Controller::~CMR6000Controller()
{
if(dev)
{
hid_close(dev);
}
}
void CMR6000Controller::GetStatus()
{
unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x52, 0xA0, 0x01, 0x00, 0x00, 0x03 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
// Request mode
hid_write(dev, buffer, buffer_size);
hid_read(dev, buffer, buffer_size);
unsigned char cmdbuffer[CM_6K_PACKET_SIZE] = { 0x00, 0x52, 0x2C, 0x01, 0x00 };
int cmdbuffer_size = (sizeof(cmdbuffer) / sizeof(cmdbuffer[0]));
current_mode = buffer[0x0A];
cmdbuffer[0x05] = current_mode;
hid_write(dev, cmdbuffer, cmdbuffer_size);
hid_read(dev, cmdbuffer, cmdbuffer_size);
current_speed = cmdbuffer[0x05];
current_brightness = cmdbuffer[0x09];
current_red = cmdbuffer[0x0A];
current_green = cmdbuffer[0x0B];
current_blue = cmdbuffer[0x0C];
}
std::string CMR6000Controller::GetDeviceName()
{
return device_name;
}
std::string CMR6000Controller::GetSerial()
{
return serial;
}
std::string CMR6000Controller::GetLocation()
{
return("HID: " + location);
}
unsigned char CMR6000Controller::GetMode()
{
return current_mode;
}
unsigned char CMR6000Controller::GetLedRed()
{
return current_red;
}
unsigned char CMR6000Controller::GetLedGreen()
{
return current_green;
}
unsigned char CMR6000Controller::GetLedBlue()
{
return current_blue;
}
unsigned char CMR6000Controller::GetLedSpeed()
{
return current_speed;
}
bool CMR6000Controller::GetRandomColours()
{
return current_random;
}
void CMR6000Controller::SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random)
{
current_mode = mode;
current_speed = speed;
current_red = red;
current_green = green;
current_blue = blue;
current_random = random;
current_brightness = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0x7F : 0xFF; //Color_Cycle brightness needs to be clamped to 0x7F to avoid wash out
SendUpdate();
}
void CMR6000Controller::SendUpdate()
{
if(current_mode == CM_MR6000_MODE_OFF)
{
unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x41, 0x43 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
hid_write(dev, buffer, buffer_size);
}
else
{
SendEnableCommand();
unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
memset(buffer, 0xFF, buffer_size);
buffer[0x00] = 0x00;
buffer[0x01] = 0x51;
buffer[0x02] = 0x2C;
buffer[0x03] = 0x01;
buffer[0x04] = 0x00;
buffer[0x05] = current_mode;
buffer[0x06] = (current_mode == CM_MR6000_MODE_STATIC) ? 0xFF: current_speed;
buffer[0x07] = (current_mode == CM_MR6000_MODE_BREATHE)? current_random : 0x00; //random (A0)
buffer[0x08] = (current_mode == CM_MR6000_MODE_BREATHE)? 0x03 : 0xFF;
//buffer[0x09] = 0xFF;
buffer[0x0A] = current_brightness;
buffer[0x0B] = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0xFF : current_red;
buffer[0x0C] = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0xFF : current_green;
buffer[0x0D] = (current_mode == CM_MR6000_MODE_COLOR_CYCLE) ? 0xFF : current_blue;
buffer[0x0E] = 0x00;
buffer[0x0F] = 0x00;
buffer[0x10] = 0x00;
hid_write(dev, buffer, buffer_size);
SendColourConfig();
SendApplyCommand();
}
}
void CMR6000Controller::SendEnableCommand()
{
unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x41, 0x80 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_6K_INTERRUPT_TIMEOUT);
}
void CMR6000Controller::SendApplyCommand()
{
unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x51, 0x28, 0x00, 0x00, 0xE0 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_6K_INTERRUPT_TIMEOUT);
}
void CMR6000Controller::SendColourConfig()
{
unsigned char buffer[CM_6K_PACKET_SIZE] = { 0x00, 0x51, 0xA0, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x05, 0x06 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
for(int i = 0x0B; i < 0x1A; i++)
{
buffer[i] = current_mode;
}
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_6K_INTERRUPT_TIMEOUT);
}
Controllers/CoolerMasterController/CMR6000Controller.h
+82
View File
@@ -0,0 +1,82 @@
/*-------------------------------------------------------------------*\
| CMR6000Controller.h |
| |
| Driver for Coolermaster based AMD Radeon GPU (6000 series) |
| |
| Eric S (edbgon) 2nd Feb 2021 |
\*-------------------------------------------------------------------*/
#include <string>
#include <array>
#include <hidapi/hidapi.h>
#pragma once
#define CM_6K_PACKET_SIZE 65 //Includes extra first byte for non HID Report packets
#define CM_6K_INTERRUPT_TIMEOUT 250
#define CM_6K_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
#define CM_6K_SERIAL_SIZE (sizeof(serial) / sizeof(serial[ 0 ]))
#define HID_MAX_STR 255
enum
{
CM_MR6000_MODE_STATIC = 0x00, //Static Mode
CM_MR6000_MODE_BREATHE = 0x01, //Breathe Mode
CM_MR6000_MODE_COLOR_CYCLE = 0x02, //Color cycle
CM_MR6000_MODE_OFF = 0xFF, //Off
};
enum
{
MR6000_CYCLE_SPEED_SLOWEST = 0x96, /* Slowest speed */
MR6000_CYCLE_SPEED_SLOW = 0x8C, /* Slow speed */
MR6000_CYCLE_SPEED_NORMAL = 0x80, /* Normal speed */
MR6000_CYCLE_SPEED_FAST = 0x6E, /* Fast speed */
MR6000_CYCLE_SPEED_FASTEST = 0x68, /* Fastest speed */
MR6000_BREATHE_SPEED_SLOWEST = 0x3C, /* Slowest speed */
MR6000_BREATHE_SPEED_SLOW = 0x37, /* Slow speed */
MR6000_BREATHE_SPEED_NORMAL = 0x31, /* Normal speed */
MR6000_BREATHE_SPEED_FAST = 0x2C, /* Fast speed */
MR6000_BREATHE_SPEED_FASTEST = 0x26, /* Fastest speed */
};
class CMR6000Controller
{
public:
CMR6000Controller(hid_device* dev_handle, char *_path);
~CMR6000Controller();
std::string GetDeviceName();
std::string GetSerial();
std::string GetLocation();
unsigned char GetMode();
unsigned char GetLedRed();
unsigned char GetLedGreen();
unsigned char GetLedBlue();
unsigned char GetLedSpeed();
bool GetRandomColours();
void SetMode(unsigned char mode, unsigned char speed, unsigned char red, unsigned char green, unsigned char blue, unsigned char random);
private:
std::string device_name;
std::string serial;
std::string location;
hid_device* dev;
unsigned char current_mode;
unsigned char current_speed;
unsigned char current_random;
unsigned char current_red;
unsigned char current_green;
unsigned char current_blue;
unsigned char current_brightness;
void GetStatus();
void SendUpdate();
void SendEnableCommand();
void SendApplyCommand();
void SendColourConfig();
};
Controllers/CoolerMasterController/CMSmallARGBController.cpp
+237
View File
@@ -0,0 +1,237 @@
/*-------------------------------------------------------------------*\
| CMSmallARGBController.cpp |
| |
| Driver for Coolermaster Small ARGB USB Controller |
| |
| Chris M (Dr_No) 31st Jan 2021 |
| |
| Simple RGB device with 5 modes |
| |
\*-------------------------------------------------------------------*/
#include "CMSmallARGBController.h"
#include <cstring>
CMSmallARGBController::CMSmallARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx)
{
const int szTemp = 256;
wchar_t tmpName[szTemp];
dev = dev_handle;
location = _path;
zone_index = _zone_idx;
current_speed = CM_SMALL_ARGB_SPEED_NORMAL;
hid_get_manufacturer_string(dev, tmpName, szTemp);
std::wstring wName = std::wstring(tmpName);
device_name = std::string(wName.begin(), wName.end());
hid_get_product_string(dev, tmpName, szTemp);
wName = std::wstring(tmpName);
device_name.append(" ").append(std::string(wName.begin(), wName.end()));
hid_get_serial_number_string(dev, tmpName, szTemp);
wName = std::wstring(tmpName);
serial = std::string(wName.begin(), wName.end());
GetStatus();
}
CMSmallARGBController::~CMSmallARGBController()
{
if(dev)
{
hid_close(dev);
}
}
void CMSmallARGBController::GetStatus()
{
unsigned char buffer[CM_SMALL_ARGB_PACKET_SIZE] = { 0x00, 0x80, 0x01, 0x01 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
int header = zone_index - 1;
buffer[CM_SMALL_ARGB_ZONE_BYTE] = header;
buffer[CM_SMALL_ARGB_MODE_BYTE] = 0x01;
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
memset(buffer, 0x00, buffer_size );
buffer[CM_SMALL_ARGB_COMMAND_BYTE] = 0x0B;
buffer[CM_SMALL_ARGB_FUNCTION_BYTE] = 0x01;
buffer[CM_SMALL_ARGB_ZONE_BYTE] = 0x01;
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
current_mode = buffer[4];
current_speed = buffer[5];
bool_random = buffer[6] == 0x00;
current_brightness = buffer[7];
current_red = buffer[8];
current_green = buffer[9];
current_blue = buffer[10];
}
std::string CMSmallARGBController::GetDeviceName()
{
return device_name;
}
std::string CMSmallARGBController::GetSerial()
{
return serial;
}
std::string CMSmallARGBController::GetLocation()
{
return("HID: " + location);
}
unsigned char CMSmallARGBController::GetZoneIndex()
{
return zone_index;
}
unsigned char CMSmallARGBController::GetMode()
{
return current_mode;
}
unsigned char CMSmallARGBController::GetLedRed()
{
return current_red;
}
unsigned char CMSmallARGBController::GetLedGreen()
{
return current_green;
}
unsigned char CMSmallARGBController::GetLedBlue()
{
return current_blue;
}
unsigned char CMSmallARGBController::GetLedSpeed()
{
return current_speed;
}
bool CMSmallARGBController::GetRandomColours()
{
return bool_random;
}
void CMSmallARGBController::SetLedCount(int zone, int led_count)
{
unsigned char buffer[CM_SMALL_ARGB_PACKET_SIZE] = { 0x00, 0x80, 0x0D, 0x02 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
buffer[CM_SMALL_ARGB_ZONE_BYTE] = zone;
buffer[CM_SMALL_ARGB_MODE_BYTE] = (0x0F - led_count > 0) ? 0x0F - led_count : 0x01;
buffer[CM_SMALL_ARGB_SPEED_BYTE] = led_count;
hid_write(dev, buffer, buffer_size);
}
void CMSmallARGBController::SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours)
{
current_mode = mode;
current_speed = speed;
current_red = RGBGetRValue(colour);
current_green = RGBGetGValue(colour);
current_blue = RGBGetBValue(colour);
bool_random = random_colours;
SendUpdate();
}
void CMSmallARGBController::SetLedsDirect(RGBColor* /*led_colours*/, unsigned int /*led_count*/)
{
// Mode not yet Tested
/*
const unsigned char buffer_size = 0x41;
unsigned char buffer[buffer_size] = { 0x00 };
unsigned char packet_count = 0x00;
std::vector<unsigned char> colours;
//Set up the RGB triplets to send
for(int i = 0; i < led_count; i++)
{
RGBColor colour = led_colours[i];
unsigned char r = RGBGetRValue(colour);
unsigned char g = RGBGetGValue(colour);
unsigned char b = RGBGetBValue(colour);
colours.push_back(r);
colours.push_back(g);
colours.push_back(b);
}
//buffer[CM_ARGB_REPORT_BYTE] = packet_count;
buffer[CM_SMALL_ARGB_COMMAND_BYTE] = 0x10;
buffer[CM_SMALL_ARGB_FUNCTION_BYTE] = 0x02;
buffer[CM_SMALL_ARGB_ZONE_BYTE] = small_argb_header_data[zone_index].header;
buffer[CM_SMALL_ARGB_MODE_BYTE] = 0x30; //30 might be the LED count??
unsigned char buffer_idx = CM_SMALL_ARGB_MODE_BYTE + 1; //Start colour info from
for (std::vector<unsigned char>::iterator it = colours.begin(); it != colours.end(); buffer_idx = 0)
{
//Fill the write buffer till its full or the colour buffer is empty
buffer[CM_SMALL_ARGB_REPORT_BYTE] = packet_count;
while (( buffer_idx < buffer_size) && ( it != colours.end() ))
{
buffer[buffer_idx] = *it;
buffer_idx++;
it++;
}
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
//reset the write buffer
memset(buffer, 0x00, sizeof(buffer) );
packet_count++;
}
buffer[CM_SMALL_ARGB_REPORT_BYTE] = 0x82;
buffer[CM_SMALL_ARGB_COMMAND_BYTE] = 0x62;
buffer[CM_SMALL_ARGB_FUNCTION_BYTE] = 0x00;
buffer[CM_SMALL_ARGB_ZONE_BYTE] = 0x73;
buffer[CM_SMALL_ARGB_MODE_BYTE] = 0x00;
buffer[CM_SMALL_ARGB_SPEED_BYTE] = 0x33;
buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE] = 0x18;
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
*/
}
void CMSmallARGBController::SendUpdate()
{
unsigned char buffer[CM_SMALL_ARGB_PACKET_SIZE] = { 0x00 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
bool boolPassthru = ( current_mode == CM_SMALL_ARGB_MODE_PASSTHRU );
bool boolDirect = ( current_mode == CM_SMALL_ARGB_MODE_DIRECT );
unsigned char function = boolPassthru ? 0x02 : 0x01;
buffer[CM_SMALL_ARGB_REPORT_BYTE] = 0x80;
buffer[CM_SMALL_ARGB_COMMAND_BYTE] = boolDirect ? 0x10 : 0x01;
buffer[CM_SMALL_ARGB_FUNCTION_BYTE] = boolDirect ? 0x01 : function;
buffer[CM_SMALL_ARGB_MODE_BYTE] = boolPassthru ? 0x00 : 0x02;
hid_write(dev, buffer, buffer_size);
buffer[CM_SMALL_ARGB_COMMAND_BYTE] = 0x0b;
buffer[CM_SMALL_ARGB_FUNCTION_BYTE] = (false) ? 0x01 : 0x02; //This controls custom mode TODO
buffer[CM_SMALL_ARGB_ZONE_BYTE] = small_argb_header_data[zone_index].header;
buffer[CM_SMALL_ARGB_MODE_BYTE] = current_mode;
buffer[CM_SMALL_ARGB_SPEED_BYTE] = current_speed;
buffer[CM_SMALL_ARGB_COLOUR_INDEX_BYTE] = (bool_random) ? 0x00 : 0x10; //This looks to still be the colour index and controls random colours
buffer[CM_SMALL_ARGB_BRIGHTNESS_BYTE] = 0xFF;
buffer[CM_SMALL_ARGB_RED_BYTE] = current_red;
buffer[CM_SMALL_ARGB_GREEN_BYTE] = current_green;
buffer[CM_SMALL_ARGB_BLUE_BYTE] = current_blue;
hid_write(dev, buffer, buffer_size);
hid_read_timeout(dev, buffer, buffer_size, CM_SMALL_ARGB_INTERRUPT_TIMEOUT);
}
Controllers/CoolerMasterController/CMSmallARGBController.h
+113
View File
@@ -0,0 +1,113 @@
/*-------------------------------------------------------------------*\
| CMSmallARGBController.h |
| |
| Driver for Coolermaster Small ARGB USB Controller |
| |
| Chris M (Dr_No) 31st Jan 2021 |
| |
| Simple RGB device with 5 modes |
| |
\*-------------------------------------------------------------------*/
#include <string>
#include <array>
#include <hidapi/hidapi.h>
#include "RGBController.h" //Needed to set the direct mode
#pragma once
#define CM_SMALL_ARGB_PACKET_SIZE 65
#define CM_SMALL_ARGB_INTERRUPT_TIMEOUT 250
enum
{
CM_SMALL_ARGB_REPORT_BYTE = 1,
CM_SMALL_ARGB_COMMAND_BYTE = 2,
CM_SMALL_ARGB_FUNCTION_BYTE = 3,
CM_SMALL_ARGB_ZONE_BYTE = 4,
CM_SMALL_ARGB_MODE_BYTE = 5,
CM_SMALL_ARGB_SPEED_BYTE = 6,
CM_SMALL_ARGB_COLOUR_INDEX_BYTE = 7, //Not used on the small controller
CM_SMALL_ARGB_BRIGHTNESS_BYTE = 8, //0x00 thru 0xFF
CM_SMALL_ARGB_RED_BYTE = 9,
CM_SMALL_ARGB_GREEN_BYTE = 10,
CM_SMALL_ARGB_BLUE_BYTE = 11,
};
struct _argb_headers
{
const char* name;
unsigned char header;
bool digital;
unsigned int count;
};
static _argb_headers small_argb_header_data[1] =
{
{ "CM Small ARGB", 0x01, true, 12 }
};
enum
{
CM_SMALL_ARGB_MODE_SPECTRUM = 0x01, //Spectrum Mode
CM_SMALL_ARGB_MODE_RELOAD = 0x02, //Reload Mode
CM_SMALL_ARGB_MODE_RECOIL = 0x03, //Recoil Mode
CM_SMALL_ARGB_MODE_BREATHING = 0x04, //Breathing Mode
CM_SMALL_ARGB_MODE_REFILL = 0x05, //Refill Mode
CM_SMALL_ARGB_MODE_DEMO = 0x06, //Demo Mode
CM_SMALL_ARGB_MODE_OFF = 0x09, //Turn off
CM_SMALL_ARGB_MODE_DIRECT = 0xFE, //Direct Led Control (possibly N?A for small controller)
CM_SMALL_ARGB_MODE_PASSTHRU = 0xFF //Motherboard Pass Thru Mode
};
enum
{
CM_SMALL_ARGB_SPEED_SLOWEST = 0x00, // Slowest speed
CM_SMALL_ARGB_SPEED_SLOW = 0x01, // Slower speed
CM_SMALL_ARGB_SPEED_NORMAL = 0x02, // Normal speed
CM_SMALL_ARGB_SPEED_FAST = 0x03, // Fast speed
CM_SMALL_ARGB_SPEED_FASTEST = 0x04, // Fastest speed
};
class CMSmallARGBController
{
public:
CMSmallARGBController(hid_device* dev_handle, char *_path, unsigned char _zone_idx);
~CMSmallARGBController();
std::string GetDeviceName();
std::string GetSerial();
std::string GetLocation();
unsigned char GetZoneIndex();
unsigned char GetMode();
unsigned char GetLedRed();
unsigned char GetLedGreen();
unsigned char GetLedBlue();
unsigned char GetLedSpeed();
bool GetRandomColours();
void SetLedCount(int zone, int led_count);
void SetMode(unsigned char mode, unsigned char speed, RGBColor colour, bool random_colours);
void SetLedsDirect(RGBColor * led_colours, unsigned int led_count);
private:
std::string device_name;
std::string serial;
std::string location;
hid_device* dev;
unsigned char zone_index;
unsigned char current_mode;
unsigned char current_speed;
unsigned char current_red;
unsigned char current_green;
unsigned char current_blue;
unsigned char current_brightness;
bool bool_random;
unsigned int GetLargestColour(unsigned int red, unsigned int green, unsigned int blue);
unsigned char GetColourIndex(unsigned char red, unsigned char green, unsigned char blue);
void GetStatus();
void SendUpdate();
};
Controllers/CoolerMasterController/CoolerMasterControllerDetect.cpp
+66 -7
View File
@@ -1,16 +1,30 @@
#include "Detector.h"
#include "CMMP750Controller.h"
#include "CMARGBcontroller.h"
#include "CMSmallARGBController.h"
#include "CMR6000Controller.h"
#include "CMMKController.h"
#include "RGBController.h"
#include "RGBController_CMMP750Controller.h"
#include "RGBController_CMARGBController.h"
#include "RGBController_CMSmallARGBController.h"
#include "RGBController_CMR6000Controller.h"
#include "RGBController_CMMKController.h"
#include <hidapi/hidapi.h>
#define COOLERMASTER_VID 0x2516
#define COOLERMASTER_VID 0x2516
#define COOLERMASTER_MP750_XL_PID 0x0109
#define COOLERMASTER_MP750_MEDIUM_PID 0x0105
#define COOLERMASTER_ARGB_PID 0x1011
#define COOLERMASTER_MP750_XL_PID 0x0109
#define COOLERMASTER_MP750_MEDIUM_PID 0x0105
#define COOLERMASTER_ARGB_PID 0x1011
#define COOLERMASTER_SMALL_ARGB_PID 0x1000
#define COOLERMASTER_RADEON_6000_PID 0x014D
#define COOLERMASTER_MASTERKEYS_PRO_L_PID CMMK_USB_MASTERKEYS_MK750
#define COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID CMMK_USB_MASTERKEYS_PRO_L_WHITE
#define COOLERMASTER_MASTERKEYS_PRO_S_PID CMMK_USB_MASTERKEYS_PRO_S
#define COOLERMASTER_MASTERKEYS_MK750_PID CMMK_USB_MASTERKEYS_MK750
#define COOLERMASTER_MASTERKEYS_SK630_PID CMMK_USB_MASTERKEYS_SK630
#define COOLERMASTER_MASTERKEYS_SK650_PID CMMK_USB_MASTERKEYS_SK650
/******************************************************************************************\
* *
@@ -47,6 +61,51 @@ void DetectCoolerMasterARGB(hid_device_info* info, const std::string&)
}
}
REGISTER_HID_DETECTOR_IPU("Cooler Master MP750 XL", DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_XL_PID, 0, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master MP750 Medium", DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_MEDIUM_PID, 0, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB", DetectCoolerMasterARGB, COOLERMASTER_VID, COOLERMASTER_ARGB_PID, 0, 0xFF00, 1);
void DetectCoolerMasterSmallARGB(hid_device_info* info, const std::string&)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
CMSmallARGBController* controller = new CMSmallARGBController(dev, info->path, 0);
RGBController_CMSmallARGBController* rgb_controller = new RGBController_CMSmallARGBController(controller);
// Constructor sets the name
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectCoolerMasterGPU(hid_device_info* info, const std::string&)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
CMR6000Controller* controller = new CMR6000Controller(dev, info->path);
RGBController_CMR6000Controller* rgb_controller = new RGBController_CMR6000Controller(controller);
// Constructor sets the name
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
void DetectCoolerMasterKeyboards(hid_device_info* info, const std::string&)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
CMMKController* controller = new CMMKController(dev, info);
RGBController_CMMKController* rgb_controller = new RGBController_CMMKController(controller);
// Constructor sets the name
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 XL", DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_XL_PID, 0xFF00, 1 );
REGISTER_HID_DETECTOR_PU ("Cooler Master MP750 Medium", DetectCoolerMasterMousemats, COOLERMASTER_VID, COOLERMASTER_MP750_MEDIUM_PID, 0xFF00, 1 );
REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L", DetectCoolerMasterKeyboards, COOLERMASTER_VID, COOLERMASTER_MASTERKEYS_PRO_L_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro L White", DetectCoolerMasterKeyboards, COOLERMASTER_VID, COOLERMASTER_MASTERKEYS_PRO_L_WHITE_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master MasterKeys Pro S", DetectCoolerMasterKeyboards, COOLERMASTER_VID, COOLERMASTER_MASTERKEYS_PRO_S_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master MK570", DetectCoolerMasterKeyboards, COOLERMASTER_VID, COOLERMASTER_MASTERKEYS_MK750_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master SK630", DetectCoolerMasterKeyboards, COOLERMASTER_VID, COOLERMASTER_MASTERKEYS_SK630_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master SK650", DetectCoolerMasterKeyboards, COOLERMASTER_VID, COOLERMASTER_MASTERKEYS_SK650_PID, 1, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master ARGB", DetectCoolerMasterARGB, COOLERMASTER_VID, COOLERMASTER_ARGB_PID, 0, 0xFF00, 1);
REGISTER_HID_DETECTOR_IPU("Cooler Master Smalll ARGB", DetectCoolerMasterSmallARGB, COOLERMASTER_VID, COOLERMASTER_SMALL_ARGB_PID, 0, 0xFF00, 1);
REGISTER_HID_DETECTOR_I ("Cooler Master Radeon 6000 GPU", DetectCoolerMasterGPU, COOLERMASTER_VID, COOLERMASTER_RADEON_6000_PID, 1 );
Controllers/CoolerMasterController/RGBController_CMARGBController.cpp
+144 -73
View File
@@ -18,11 +18,11 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
vendor = "Cooler Master";
type = DEVICE_TYPE_LEDSTRIP;
description = cmargb->GetDeviceName();
version = "1.0";
version = "2.0 for FW0023";
serial = cmargb->GetSerial();
location = cmargb->GetLocation();
if ( argb_header_data[cmargb->GetZoneIndex()].digital)
if(argb_header_data[cmargb->GetZoneIndex()].digital)
{
mode Off;
Off.name = "Turn Off";
@@ -39,7 +39,7 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
Reload.colors.resize(Reload.colors_max);
Reload.speed_min = CM_ARGB_SPEED_SLOWEST;
Reload.speed_max = CM_ARGB_SPEED_FASTEST;
Reload.color_mode = MODE_COLORS_RANDOM;
Reload.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reload.speed = speed;
modes.push_back(Reload);
@@ -49,10 +49,10 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
Recoil.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Recoil.colors_min = 1;
Recoil.colors_max = 1;
Recoil.colors.resize(Reload.colors_max);
Recoil.colors.resize(Recoil.colors_max);
Recoil.speed_min = CM_ARGB_SPEED_SLOWEST;
Recoil.speed_max = CM_ARGB_SPEED_FASTEST;
Recoil.color_mode = MODE_COLORS_RANDOM;
Recoil.color_mode = MODE_COLORS_MODE_SPECIFIC;
Recoil.speed = speed;
modes.push_back(Recoil);
@@ -62,10 +62,10 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(Reload.colors_max);
Breathing.colors.resize(Breathing.colors_max);
Breathing.speed_min = CM_ARGB_SPEED_SLOWEST;
Breathing.speed_max = CM_ARGB_SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_RANDOM;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed = speed;
modes.push_back(Breathing);
@@ -75,10 +75,10 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
Refill.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Refill.colors_min = 1;
Refill.colors_max = 1;
Refill.colors.resize(Reload.colors_max);
Refill.colors.resize(Refill.colors_max);
Refill.speed_min = CM_ARGB_SPEED_SLOWEST;
Refill.speed_max = CM_ARGB_SPEED_FASTEST;
Refill.color_mode = MODE_COLORS_RANDOM;
Refill.color_mode = MODE_COLORS_MODE_SPECIFIC;
Refill.speed = speed;
modes.push_back(Refill);
@@ -122,6 +122,19 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
Rainbow.speed = speed;
modes.push_back(Rainbow);
mode Static;
Static.name = "Static";
Static.value = CM_ARGB_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(Static.colors_max);
Static.speed_min = CM_ARGB_SPEED_SLOWEST;
Static.speed_max = CM_ARGB_SPEED_FASTEST;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.speed = speed;
modes.push_back(Static);
mode Direct;
Direct.name = "Direct";
Direct.value = CM_ARGB_MODE_DIRECT;
@@ -132,16 +145,22 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
mode PassThru;
PassThru.name = "Pass Thru";
PassThru.value = CM_ARGB_MODE_PASSTHRU;
PassThru.flags = 0;
PassThru.color_mode = MODE_COLORS_NONE;
modes.push_back(PassThru);
}
else
{
mode Off;
Off.name = "Turn Off";
Off.value = CM_RGB_MODE_OFF;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = CM_RGB_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(Static.colors_max);
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.speed = 0;
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
@@ -152,61 +171,93 @@ RGBController_CMARGBController::RGBController_CMARGBController(CMARGBController
Breathing.colors.resize(Breathing.colors_max);
Breathing.speed_min = CM_ARGB_SPEED_SLOWEST;
Breathing.speed_max = CM_ARGB_SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_RANDOM;
Breathing.speed = speed;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.speed = CM_ARGB_SPEED_NORMAL;
modes.push_back(Breathing);
mode Flash;
Breathing.name = "Flash";
Breathing.value = CM_RGB_MODE_FLASH;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(Breathing.colors_max);
Breathing.speed_min = CM_ARGB_SPEED_SLOWEST;
Breathing.speed_max = CM_ARGB_SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_RANDOM;
Breathing.speed = speed;
modes.push_back(Breathing);
Flash.name = "Flash";
Flash.value = CM_RGB_MODE_FLASH;
Flash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Flash.colors_min = 1;
Flash.colors_max = 1;
Flash.colors.resize(Flash.colors_max);
Flash.speed_min = CM_ARGB_SPEED_SLOWEST;
Flash.speed_max = CM_ARGB_SPEED_FASTEST;
Flash.color_mode = MODE_COLORS_MODE_SPECIFIC;
Flash.speed = CM_ARGB_SPEED_NORMAL;
modes.push_back(Flash);
mode ColourCycle;
ColourCycle.name = "Colour Cycle";
ColourCycle.value = CM_RGB_MODE_COLOUR_CYCLE;
ColourCycle.flags = MODE_FLAG_HAS_SPEED;
ColourCycle.speed_min = CM_ARGB_SPEED_SLOWEST;
ColourCycle.speed_max = CM_ARGB_SPEED_FASTEST;
ColourCycle.color_mode = MODE_COLORS_NONE;
ColourCycle.speed = speed;
modes.push_back(ColourCycle);
mode Mirage;
Mirage.name = "Mirage";
Mirage.value = CM_RGB_MODE_MIRAGE;
Mirage.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Mirage.colors_min = 1;
Mirage.colors_max = 1;
Mirage.colors.resize(Mirage.colors_max);
Mirage.speed_min = CM_ARGB_SPEED_SLOWEST;
Mirage.speed_max = CM_ARGB_SPEED_FASTEST;
Mirage.color_mode = MODE_COLORS_MODE_SPECIFIC;
Mirage.speed = CM_ARGB_SPEED_NORMAL;
modes.push_back(Mirage);
mode PassThru;
PassThru.name = "Pass Thru";
PassThru.value = CM_RGB_MODE_PASSTHRU;
PassThru.color_mode = MODE_COLORS_NONE;
modes.push_back(PassThru);
mode Off;
Off.name = "Turn Off";
Off.value = CM_RGB_MODE_OFF;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
}
Init_Controller(); //Only processed on first run
Init_Controller();
SetupZones();
//active_mode = cmargb->GetMode();
int temp_mode = cmargb->GetMode();
for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
{
if (temp_mode == modes[mode_idx].value)
{
active_mode = mode_idx;
break;
}
}
if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
{
modes[active_mode].colors[0] = ToRGBColor(cmargb->GetLedRed(), cmargb->GetLedGreen(), cmargb->GetLedBlue());
}
modes[active_mode].color_mode = (cmargb->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
{
modes[active_mode].speed = cmargb->GetLedSpeed();
}
}
RGBController_CMARGBController::~RGBController_CMARGBController()
{
delete cmargb;
}
void RGBController_CMARGBController::Init_Controller()
{
int zone_idx = cmargb->GetZoneIndex();
int zone_led_count = argb_header_data[zone_idx].count;
bool boolSingleLED = ( zone_led_count == 1 ); //If argb_header_data[zone_idx].count == 1 then the zone is ZONE_TYPE_SINGLE
/*-------------------------------------------------*\
| If argb_header_data[zone_idx].count == 1 then the |
| zone is ZONE_TYPE_SINGLE |
\*-------------------------------------------------*/
bool boolSingleLED = ( zone_led_count == 1 );
zone ARGB_zone;
ARGB_zone.name = std::to_string(zone_idx);
ARGB_zone.type = (boolSingleLED) ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
ARGB_zone.leds_min = 0;
ARGB_zone.leds_max = 64;
ARGB_zone.leds_min = 4;
ARGB_zone.leds_max = 48;
ARGB_zone.leds_count = zone_led_count;
ARGB_zone.matrix_map = NULL;
zones.push_back(ARGB_zone);
@@ -225,7 +276,12 @@ void RGBController_CMARGBController::SetupZones()
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE); //Calculated for later use
bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE);
if (!boolSingleLED)
{
cmargb->SetLedCount( std::stoi(zones[zone_idx].name), zones[zone_idx].leds_count);
}
for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
{
@@ -257,59 +313,74 @@ void RGBController_CMARGBController::ResizeZone(int zone, int new_size)
{
return;
}
uint8_t end_zone = last_zone(zone);
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
for(std::size_t zone_idx = first_zone(zone); zone_idx < end_zone; zone_idx++)
{
zones[zone].leds_count = new_size;
SetupZones();
if(((unsigned int)new_size >= zones[zone_idx].leds_min) && ((unsigned int)new_size <= zones[zone_idx].leds_max))
{
zones[zone_idx].leds_count = new_size;
}
}
SetupZones();
}
void RGBController_CMARGBController::DeviceUpdateLEDs()
{
/*unsigned char red = RGBGetRValue(colors[0]);
unsigned char grn = RGBGetGValue(colors[0]);
unsigned char blu = RGBGetBValue(colors[0]);
cmargb->SetColor(red, grn, blu);*/
uint8_t end_zone = last_zone(cmargb->GetZoneIndex());
//this one
cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
for(std::size_t zone_idx = first_zone(cmargb->GetZoneIndex()); zone_idx < end_zone; zone_idx++)
{
UpdateZoneLEDs(zone_idx);
}
}
void RGBController_CMARGBController::UpdateZoneLEDs(int zone)
void RGBController_CMARGBController::UpdateZoneLEDs(int /*zone*/)
{
RGBColor colour = colors[zone];
unsigned char red = RGBGetRValue(colour);
unsigned char grn = RGBGetGValue(colour);
unsigned char blu = RGBGetBValue(colour);
cmargb->SetColor(red, grn, blu);
//cmargb->SetLedsDirect( zones[zone].colors, zones[zone].leds_count );
}
void RGBController_CMARGBController::UpdateSingleLED(int led)
{
//cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
//cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
UpdateZoneLEDs(GetLED_Zone(led));
}
void RGBController_CMARGBController::SetCustomMode()
{
active_mode = CM_ARGB_MODE_DIRECT;
for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
{
if (modes[mode_idx].value == CM_ARGB_MODE_DIRECT)
{
active_mode = mode_idx;
break;
}
}
}
void RGBController_CMARGBController::DeviceUpdateMode()
{
if( modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC )
bool random_colours = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
RGBColor colour = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed, colour, random_colours );
}
int RGBController_CMARGBController::GetLED_Zone(int led_idx)
{
/*---------------------------------------------------------*\
| This may be more useful in the abstract RGBController.cpp |
\*---------------------------------------------------------*/
for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
unsigned char red = RGBGetRValue(modes[active_mode].colors[0]);
unsigned char grn = RGBGetGValue(modes[active_mode].colors[0]);
unsigned char blu = RGBGetBValue(modes[active_mode].colors[0]);
cmargb->SetColor(red, grn, blu);
int zone_start = zones[zone_idx].start_idx;
int zone_end = zone_start + zones[zone_idx].leds_count - 1;
if( zone_start <= led_idx && zone_end >= led_idx)
{
return(zone_idx);
}
}
else
{
cmargb->SetColor(0, 0, 0); //If the mode is not colour specific then set colour to black for the random index
}
cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
return -1;
}
Controllers/CoolerMasterController/RGBController_CMARGBController.h
+5
View File
@@ -12,6 +12,9 @@
#include "CMARGBcontroller.h"
#include <vector>
#define first_zone(zn) ((zones.size() > 1) ? 1 : 0)
#define last_zone(zn) ((zones.size() > 1) ? 4 : 1)
class RGBController_CMARGBController : public RGBController
{
public:
@@ -27,9 +30,11 @@ public:
void SetCustomMode();
void DeviceUpdateMode();
private:
void Init_Controller();
int GetDeviceMode();
int GetLED_Zone(int led_idx);
CMARGBController* cmargb;
};
Controllers/CoolerMasterController/RGBController_CMMKController.cpp
+467
View File
@@ -0,0 +1,467 @@
/*-------------------------------------------------------------------*\
| RGBController_CMMKController.cpp |
| |
| Driver for Coolermaster MasterKeys keyboards |
| |
| Lukas N (chmod222) 28th Jun 2020 |
| Tam D (too.manyhobbies) 25th Apr 2021 |
| |
\*-------------------------------------------------------------------*/
#include "RGBController_CMMKController.h"
#include <sstream>
using namespace std::chrono_literals;
#define CMMK_SPEED_MIN CMMK_SPEED0
#define CMMK_SPEED_MID CMMK_SPEED2
#define CMMK_SPEED_MAX CMMK_SPEED4
#define CMMK_MODE_FIRMWARE 0xFF
#define CMMK_MODE_MANUAL 0x7F
RGBController_CMMKController::RGBController_CMMKController(CMMKController* cmmk_ctrl)
{
cmmk = cmmk_ctrl;
name = cmmk->GetDeviceName();
type = DEVICE_TYPE_KEYBOARD;
description = "Cooler Master MasterKeys Device";
version = cmmk->GetFirmwareVersion();
serial = "";
location = cmmk->GetLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = CMMK_MODE_MANUAL;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = CMMK_EFFECT_FULLY_LIT;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(1);
modes.push_back(Static);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = CMMK_EFFECT_BREATHE;
Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Breathing.speed_min = 0x20;
Breathing.speed_max = 0x20;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(1);
modes.push_back(Breathing);
mode Cycle;
Cycle.name = "Spectrum Cycle";
Cycle.value = CMMK_EFFECT_CYCLE;
Cycle.flags = MODE_FLAG_HAS_SPEED;
Cycle.speed_min = CMMK_SPEED_MIN;
Cycle.speed_max = CMMK_SPEED_MAX;
Cycle.color_mode = MODE_COLORS_NONE;
modes.push_back(Cycle);
mode Reactive;
Reactive.name = "Reactive";
Reactive.value = CMMK_EFFECT_SINGLE;
Reactive.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Reactive.speed_min = CMMK_SPEED_MIN;
Reactive.speed_max = CMMK_SPEED_MAX;
Reactive.color_mode = MODE_COLORS_MODE_SPECIFIC;
Reactive.colors_min = 2;
Reactive.colors_max = 2;
Reactive.colors.resize(2);
modes.push_back(Reactive);
mode Wave;
Wave.name = "Rainbow Wave";
Wave.value = CMMK_EFFECT_WAVE;
Wave.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_DIRECTION_LR | MODE_FLAG_HAS_DIRECTION_UD;
Wave.speed_min = CMMK_SPEED_MIN;
Wave.speed_max = CMMK_SPEED_MAX;
Wave.color_mode = MODE_COLORS_MODE_SPECIFIC;
Wave.colors_min = 1;
Wave.colors_max = 1;
Wave.colors.resize(1);
modes.push_back(Wave);
mode Ripple;
Ripple.name = "Ripple Effect";
Ripple.value = CMMK_EFFECT_RIPPLE;
Ripple.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_SPEED;
Ripple.speed_min = CMMK_SPEED_MIN;
Ripple.speed_max = CMMK_SPEED_MAX;
Ripple.colors_min = 2;
Ripple.colors_max = 2;
Ripple.colors.resize(2);
modes.push_back(Ripple);
mode Cross;
Cross.name = "Cross";
Cross.value = CMMK_EFFECT_CROSS;
Cross.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Cross.speed_min = CMMK_SPEED_MIN;
Cross.speed_max = CMMK_SPEED_MAX;
Cross.colors_min = 2;
Cross.colors_max = 2;
Cross.colors.resize(2);
modes.push_back(Cross);
mode Raindrops;
Raindrops.name = "Raindrops";
Raindrops.value = CMMK_EFFECT_RAINDROPS;
Raindrops.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Raindrops.speed_min = CMMK_SPEED_MIN;
Raindrops.speed_max = CMMK_SPEED_MAX;
Raindrops.colors_min = 2;
Raindrops.colors_max = 2;
Raindrops.colors.resize(2);
modes.push_back(Raindrops);
mode Stars;
Stars.name = "Starfield";
Stars.value = CMMK_EFFECT_STARS;
Stars.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_SPEED;
Stars.speed_min = CMMK_SPEED_MIN;
Stars.speed_max = CMMK_SPEED_MAX;
Stars.colors_min = 2;
Stars.colors_max = 2;
Stars.colors.resize(2);
modes.push_back(Stars);
mode Snake;
Snake.name = "Snake";
Snake.value = CMMK_EFFECT_SNAKE;
Snake.flags = MODE_FLAG_HAS_SPEED;
Snake.speed_min = CMMK_SPEED_MIN;
Snake.speed_max = CMMK_SPEED_MAX;
modes.push_back(Snake);
mode FirmwareControl;
FirmwareControl.name = "Firmware Controlled";
FirmwareControl.value = 0xFF;
FirmwareControl.flags = 0;
modes.push_back(FirmwareControl);
SetupZones();
}
RGBController_CMMKController::~RGBController_CMMKController()
{
delete cmmk;
}
void RGBController_CMMKController::SetupMatrixMap()
{
for(int y = 0; y < CMMK_ROWS_MAX; y++)
{
for(int x = 0; x < CMMK_COLS_MAX; x++)
{
matrix_map[y][x] = 0xFFFFFFFF;
}
}
for(size_t i = 0; i < leds.size(); i++)
{
led& l = leds[i];
int y = (l.value & 0xFF00) >> 8;
int x = (l.value & 0xFF);
matrix_map[y][x] = i;
}
}
void RGBController_CMMKController::SetupZones()
{
for(int y = 0; y < CMMK_ROWS_MAX; y++)
{
for(int x = 0; x < CMMK_COLS_MAX; x++)
{
if(!cmmk->PositionValid(y, x))
{
continue;
}
std::stringstream namestrm;
led key;
namestrm << "Key @ Row " << (y + 1) << ", Column" << (x + 1);
key.name = namestrm.str();
key.value = (y & 0xFF) << 8 | (x & 0xFF);
leds.push_back(key);
}
}
zone KeyboardZone;
KeyboardZone.name = "Keyboard";
KeyboardZone.type = ZONE_TYPE_MATRIX;
KeyboardZone.leds_min = leds.size();
KeyboardZone.leds_max = leds.size();
KeyboardZone.leds_count = leds.size();
KeyboardZone.matrix_map = new matrix_map_type;
KeyboardZone.matrix_map->height = CMMK_ROWS_MAX;
KeyboardZone.matrix_map->width = CMMK_COLS_MAX;
KeyboardZone.matrix_map->map = (unsigned int *)&matrix_map;
zones.push_back(KeyboardZone);
SetupMatrixMap();
SetupColors();
}
void RGBController_CMMKController::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
struct rgb map_to_cmmk_rgb(RGBColor input)
{
return rgb
{
(uint8_t)RGBGetRValue(input),
(uint8_t)RGBGetGValue(input),
(uint8_t)RGBGetBValue(input)
};
}
enum cmmk_wave_direction map_to_cmmk_dir(int input)
{
switch(input)
{
case MODE_DIRECTION_LEFT:
return CMMK_RIGHT_TO_LEFT;
case MODE_DIRECTION_RIGHT:
return CMMK_LEFT_TO_RIGHT;
case MODE_DIRECTION_UP:
return CMMK_FRONT_TO_BACK;
case MODE_DIRECTION_DOWN:
return CMMK_BACK_TO_FRONT;
default:
return CMMK_RIGHT_TO_LEFT;
}
}
void copy_buffers(led* buf, RGBColor* colbuf, size_t n, struct cmmk_color_matrix& mat, std::atomic<bool>& dirty)
{
dirty.store(false);
for(size_t i = 0; i < n; i++)
{
led const& selected_led = buf[i];
int y = (selected_led.value & 0xFF00) >> 8;
int x = selected_led.value & 0xFF;
struct rgb col = map_to_cmmk_rgb(colbuf[i]);
struct rgb ecol = mat.data[y][x];
if(ecol.R != col.R || ecol.G != col.G || ecol.B != col.B)
{
dirty.store(true);
mat.data[y][x] = col;
}
}
}
void RGBController_CMMKController::DeviceUpdateLEDs()
{
copy_buffers(leds.data(), colors.data(), leds.size(), current_matrix, dirty);
if(force_update.load() || dirty.load())
{
cmmk->SetAll(current_matrix);
force_update.store(false);
}
}
void RGBController_CMMKController::UpdateZoneLEDs(int zone_idx)
{
zone& z = zones[zone_idx];
copy_buffers(z.leds, z.colors, z.leds_count, current_matrix, dirty);
if(force_update.load() || dirty.load())
{
cmmk->SetAll(current_matrix);
force_update.store(false);
}
}
void RGBController_CMMKController::UpdateSingleLED(int led_idx)
{
led& selected_led = leds[led_idx];
int y = (selected_led.value & 0xFF00) >> 8;
int x = selected_led.value & 0xFF;
current_matrix.data[y][x] = map_to_cmmk_rgb(colors[led_idx]);
cmmk->SetSingle(y, x, map_to_cmmk_rgb(colors[led_idx]));
dirty.store(false);
}
void RGBController_CMMKController::SetCustomMode()
{
active_mode = 1;
}
void RGBController_CMMKController::DeviceUpdateMode()
{
force_update.store(true);
switch(modes[active_mode].value)
{
case CMMK_MODE_FIRMWARE:
cmmk->SetFirmwareControl();
break;
case CMMK_MODE_MANUAL:
cmmk->SetManualControl();
break;
case CMMK_EFFECT_FULLY_LIT:
{
cmmk_effect_fully_lit fully_lit_effect;
fully_lit_effect.color = map_to_cmmk_rgb(modes[active_mode].colors[0]);
cmmk->SetMode(fully_lit_effect);
}
break;
case CMMK_EFFECT_BREATHE:
{
cmmk_effect_breathe breathe_effect;
breathe_effect.speed = (uint8_t)modes[active_mode].speed;
breathe_effect.color = map_to_cmmk_rgb(modes[active_mode].colors[0]);
cmmk->SetMode(breathe_effect);
}
break;
case CMMK_EFFECT_CYCLE:
{
cmmk_effect_cycle cycle_effect;
cycle_effect.speed = (uint8_t)modes[active_mode].speed;
cmmk->SetMode(cycle_effect);
}
break;
case CMMK_EFFECT_SINGLE:
{
cmmk_effect_single single_effect;
single_effect.speed = (uint8_t)modes[active_mode].speed;
single_effect.active = map_to_cmmk_rgb(modes[active_mode].colors[0]);
single_effect.rest = map_to_cmmk_rgb(modes[active_mode].colors[1]);
cmmk->SetMode(single_effect);
}
break;
case CMMK_EFFECT_WAVE:
{
cmmk_effect_wave wave_effect;
wave_effect.speed = (uint8_t)modes[active_mode].speed;
wave_effect.direction = map_to_cmmk_dir(modes[active_mode].direction);
wave_effect.start = map_to_cmmk_rgb(modes[active_mode].colors[0]);
cmmk->SetMode(wave_effect);
}
break;
case CMMK_EFFECT_RIPPLE:
{
cmmk_effect_ripple ripple_effect;
ripple_effect.speed = (uint8_t)modes[active_mode].speed;
ripple_effect.active = map_to_cmmk_rgb(modes[active_mode].colors[0]);
ripple_effect.rest = map_to_cmmk_rgb(modes[active_mode].colors[1]);
if(modes[active_mode].color_mode == MODE_COLORS_RANDOM)
{
ripple_effect.ripple_type = CMMK_RIPPLE_RANDOM_COLOR;
}
else
{
ripple_effect.ripple_type = CMMK_RIPPLE_GIVEN_COLOR;
}
cmmk->SetMode(ripple_effect);
}
break;
case CMMK_EFFECT_CROSS:
{
cmmk_effect_cross cross_effect;
cross_effect.speed = (uint8_t)modes[active_mode].speed;
cross_effect.active = map_to_cmmk_rgb(modes[active_mode].colors[0]);
cross_effect.rest = map_to_cmmk_rgb(modes[active_mode].colors[1]);
cmmk->SetMode(cross_effect);
}
break;
case CMMK_EFFECT_RAINDROPS:
{
cmmk_effect_raindrops raindrops_effect;
raindrops_effect.speed = (uint8_t)modes[active_mode].speed;
raindrops_effect.interval = CMMK_SPEED_MID;
raindrops_effect.active = map_to_cmmk_rgb(modes[active_mode].colors[0]);
raindrops_effect.rest = map_to_cmmk_rgb(modes[active_mode].colors[1]);
cmmk->SetMode(raindrops_effect);
}
break;
case CMMK_EFFECT_STARS:
{
cmmk_effect_stars stars_effect;
stars_effect.speed = (uint8_t)modes[active_mode].speed;
stars_effect.interval = CMMK_SPEED_MID;
stars_effect.active = map_to_cmmk_rgb(modes[active_mode].colors[0]);
stars_effect.rest = map_to_cmmk_rgb(modes[active_mode].colors[1]);
cmmk->SetMode(stars_effect);
}
break;
case CMMK_EFFECT_SNAKE:
{
cmmk_effect_snake snake_effect;
snake_effect.speed = (uint8_t)modes[active_mode].speed;
cmmk->SetMode(snake_effect);
}
break;
}
}
Controllers/CoolerMasterController/RGBController_CMMKController.h
+42
View File
@@ -0,0 +1,42 @@
/*-------------------------------------------------------------------*\
| RGBController_CMMKController.h |
| |
| Driver for Coolermaster MasterKeys keyboards |
| |
| Lukas N (chmod222) 28th Jun 2020 |
| Tam D (too.manyhobbies) 25th Apr 2021 |
| |
\*-------------------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "CMMKController.h"
class RGBController_CMMKController : public RGBController
{
public:
RGBController_CMMKController(CMMKController* cmmk_ptr);
~RGBController_CMMKController();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
void SetupMatrixMap();
CMMKController* cmmk;
int matrix_map[CMMK_ROWS_MAX][CMMK_COLS_MAX];
struct cmmk_color_matrix current_matrix;
std::atomic<bool> dirty;
std::atomic<bool> force_update;
};
Controllers/CoolerMasterController/RGBController_CMMP750Controller.cpp
+62 -42
View File
@@ -11,71 +11,91 @@
RGBController_CMMP750Controller::RGBController_CMMP750Controller(CMMP750Controller* cmmp_ptr)
{
cmmp750 = cmmp_ptr;
unsigned char speed = cmmp750->GetLedSpeed();
cmmp750 = cmmp_ptr;
unsigned char speed = cmmp750->GetLedSpeed();
name = cmmp750->GetDeviceName();
vendor = "Cooler Master";
type = DEVICE_TYPE_MOUSEMAT;
description = cmmp750->GetDeviceName();
version = "1.0";
serial = cmmp750->GetSerial();
location = cmmp750->GetLocation();
name = cmmp750->GetDeviceName();
vendor = "Cooler Master";
type = DEVICE_TYPE_MOUSEMAT;
description = cmmp750->GetDeviceName();
version = "1.0";
serial = cmmp750->GetSerial();
location = cmmp750->GetLocation();
mode Static;
Static.name = "Static";
Static.value = MP750_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
Static.name = "Static";
Static.value = CM_MP750_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Blink;
Blink.name = "Blink";
Blink.value = MP750_MODE_BLINK;
Blink.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Blink.speed_min = MP750_SPEED_SLOWEST;
Blink.speed_max = MP750_SPEED_FASTEST;
Blink.color_mode = MODE_COLORS_PER_LED;
Blink.speed = speed;
Blink.name = "Blink";
Blink.value = CM_MP750_MODE_BLINK;
Blink.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Blink.speed_min = MP750_SPEED_SLOWEST;
Blink.speed_max = MP750_SPEED_FASTEST;
Blink.color_mode = MODE_COLORS_PER_LED;
Blink.speed = speed;
modes.push_back(Blink);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = MP750_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = MP750_SPEED_SLOWEST;
Breathing.speed_max = MP750_SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.speed = speed;
Breathing.name = "Breathing";
Breathing.value = CM_MP750_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = MP750_SPEED_SLOWEST;
Breathing.speed_max = MP750_SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.speed = speed;
modes.push_back(Breathing);
mode ColorCycle;
ColorCycle.name = "Color Cycle";
ColorCycle.value = MP750_MODE_COLOR_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_SPEED;
ColorCycle.speed_min = MP750_SPEED_SLOWEST;
ColorCycle.speed_max = MP750_SPEED_FASTEST;
ColorCycle.color_mode = MODE_COLORS_NONE;
ColorCycle.speed = speed;
ColorCycle.name = "Color Cycle";
ColorCycle.value = CM_MP750_MODE_COLOR_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_SPEED;
ColorCycle.speed_min = MP750_SPEED_SLOWEST;
ColorCycle.speed_max = MP750_SPEED_FASTEST;
ColorCycle.color_mode = MODE_COLORS_NONE;
ColorCycle.speed = speed;
modes.push_back(ColorCycle);
mode BreathCycle;
BreathCycle.name = "Breath Cycle";
BreathCycle.value = MP750_MODE_BREATH_CYCLE;
BreathCycle.flags = MODE_FLAG_HAS_SPEED;
BreathCycle.speed_min = MP750_SPEED_SLOWEST;
BreathCycle.speed_max = MP750_SPEED_FASTEST;
BreathCycle.color_mode = MODE_COLORS_NONE;
BreathCycle.speed = speed;
BreathCycle.name = "Breath Cycle";
BreathCycle.value = CM_MP750_MODE_BREATH_CYCLE;
BreathCycle.flags = MODE_FLAG_HAS_SPEED;
BreathCycle.speed_min = MP750_SPEED_SLOWEST;
BreathCycle.speed_max = MP750_SPEED_FASTEST;
BreathCycle.color_mode = MODE_COLORS_NONE;
BreathCycle.speed = speed;
modes.push_back(BreathCycle);
mode Off;
Off.name = "Turn Off";
Off.value = CM_MP750_MODE_OFF;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
SetupZones();
active_mode = cmmp750->GetMode();
active_mode = GetDeviceMode();
}
RGBController_CMMP750Controller::~RGBController_CMMP750Controller()
{
delete cmmp750;
}
int RGBController_CMMP750Controller::GetDeviceMode()
{
int temp_mode = cmmp750->GetMode();
for(unsigned int i = 0; i < modes.size(); i++)
{
if (temp_mode == modes[i].value)
{
return i;
}
}
//If not found return 0
return 0;
}
void RGBController_CMMP750Controller::SetupZones()
Controllers/CoolerMasterController/RGBController_CMR6000Controller.cpp
+149
View File
@@ -0,0 +1,149 @@
/*-------------------------------------------------------------------*\
| RGBController_CMR6000Controller.cpp |
| |
| Driver for Coolermaster based AMD Radeon GPU (6000 series) |
| |
| Eric S (edbgon) 2nd Feb 2021 |
\*-------------------------------------------------------------------*/
#include "RGBController_CMR6000Controller.h"
RGBController_CMR6000Controller::RGBController_CMR6000Controller(CMR6000Controller* cmmp_ptr)
{
cmr6000 = cmmp_ptr;
unsigned char speed = cmr6000->GetLedSpeed();
name = "AMD RX 6xxx GPU";
vendor = "Cooler Master";
type = DEVICE_TYPE_GPU;
description = cmr6000->GetDeviceName();
version = "1.0";
serial = cmr6000->GetSerial();
location = cmr6000->GetLocation();
mode Off;
Off.name = "Off";
Off.flags = 0;
Off.value = CM_MR6000_MODE_OFF;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Static;
Static.name = "Static";
Static.value = CM_MR6000_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
Static.colors_min = 1;
Static.colors_max = 1;
Static.colors.resize(1);
modes.push_back(Static);
mode ColorCycle;
ColorCycle.name = "Color Cycle";
ColorCycle.value = CM_MR6000_MODE_COLOR_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_SPEED;
ColorCycle.speed_min = MR6000_CYCLE_SPEED_SLOWEST;
ColorCycle.speed = MR6000_CYCLE_SPEED_NORMAL;
ColorCycle.speed_max = MR6000_CYCLE_SPEED_FASTEST;
ColorCycle.color_mode = MODE_COLORS_NONE;
ColorCycle.speed = speed;
modes.push_back(ColorCycle);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = CM_MR6000_MODE_BREATHE;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.speed_min = MR6000_BREATHE_SPEED_SLOWEST;
Breathing.speed = MR6000_BREATHE_SPEED_NORMAL;
Breathing.speed_max = MR6000_BREATHE_SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(1);
Breathing.speed = speed;
modes.push_back(Breathing);
SetupZones();
active_mode = cmr6000->GetMode();
if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
{
modes[active_mode].colors[0] = ToRGBColor(cmr6000->GetLedRed(), cmr6000->GetLedGreen(), cmr6000->GetLedBlue());
}
if (modes[active_mode].flags & MODE_FLAG_HAS_RANDOM_COLOR)
{
modes[active_mode].color_mode = (cmr6000->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
}
if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
{
modes[active_mode].speed = cmr6000->GetLedSpeed();
}
}
RGBController_CMR6000Controller::~RGBController_CMR6000Controller()
{
delete cmr6000;
}
void RGBController_CMR6000Controller::SetupZones()
{
zone GP_zone;
GP_zone.name = "GPU";
GP_zone.type = ZONE_TYPE_SINGLE;
GP_zone.leds_min = 1;
GP_zone.leds_max = 1;
GP_zone.leds_count = 1;
GP_zone.matrix_map = NULL;
zones.push_back(GP_zone);
led GP_led;
GP_led.name = "Logo";
leds.push_back(GP_led);
SetupColors();
}
void RGBController_CMR6000Controller::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_CMR6000Controller::DeviceUpdateLEDs()
{
unsigned char red = 0;
unsigned char grn = 0;
unsigned char blu = 0;
if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC)
{
red = RGBGetRValue(modes[active_mode].colors[0]);
grn = RGBGetGValue(modes[active_mode].colors[0]);
blu = RGBGetBValue(modes[active_mode].colors[0]);
}
unsigned char rnd = (modes[active_mode].color_mode == MODE_COLORS_RANDOM) ? 0xA0 : 0x20;
cmr6000->SetMode(modes[active_mode].value, modes[active_mode].speed, red, grn, blu, rnd);
}
void RGBController_CMR6000Controller::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_CMR6000Controller::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_CMR6000Controller::SetCustomMode()
{
active_mode = 1;
}
void RGBController_CMR6000Controller::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
Controllers/CoolerMasterController/RGBController_CMR6000Controller.h
+32
View File
@@ -0,0 +1,32 @@
/*-------------------------------------------------------------------*\
| RGBController_CMR6000Controller.h |
| |
| Driver for Coolermaster based AMD Radeon GPU (6000 series) |
| |
| Eric S (edbgon) 2nd Feb 2021 |
\*-------------------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "CMR6000Controller.h"
class RGBController_CMR6000Controller : public RGBController
{
public:
RGBController_CMR6000Controller(CMR6000Controller* cmmp_ptr);
~RGBController_CMR6000Controller();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
CMR6000Controller* cmr6000;
int GetDeviceMode();
};
Controllers/CoolerMasterController/RGBController_CMSmallARGBController.cpp
+251
View File
@@ -0,0 +1,251 @@
/*-------------------------------------------------------------------*\
| RGBController_CMSmallARGBController.cpp |
| |
| Driver for Coolermaster Small ARGB USB Controller |
| |
| Chris M (Dr_No) 31st Jan 2021 |
| |
\*-------------------------------------------------------------------*/
#include "RGBController_CMSmallARGBController.h"
RGBController_CMSmallARGBController::RGBController_CMSmallARGBController(CMSmallARGBController *cmargb_ptr)
{
cmargb = cmargb_ptr;
unsigned char speed = cmargb->GetLedSpeed();
name = small_argb_header_data[cmargb->GetZoneIndex()].name;
vendor = "Cooler Master";
type = DEVICE_TYPE_LEDSTRIP;
description = cmargb->GetDeviceName();
version = "1.0";
serial = cmargb->GetSerial();
location = cmargb->GetLocation();
mode Off;
Off.name = "Turn Off";
Off.value = CM_SMALL_ARGB_MODE_OFF;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
mode Reload;
Reload.name = "Reload";
Reload.value = CM_SMALL_ARGB_MODE_RELOAD;
Reload.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Reload.colors_min = 1;
Reload.colors_max = 1;
Reload.colors.resize(Reload.colors_max);
Reload.speed_min = CM_SMALL_ARGB_SPEED_SLOWEST;
Reload.speed_max = CM_SMALL_ARGB_SPEED_FASTEST;
Reload.color_mode = MODE_COLORS_RANDOM;
Reload.speed = speed;
modes.push_back(Reload);
mode Recoil;
Recoil.name = "Recoil";
Recoil.value = CM_SMALL_ARGB_MODE_RECOIL;
Recoil.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Recoil.colors_min = 1;
Recoil.colors_max = 1;
Recoil.colors.resize(Recoil.colors_max);
Recoil.speed_min = CM_SMALL_ARGB_SPEED_SLOWEST;
Recoil.speed_max = CM_SMALL_ARGB_SPEED_FASTEST;
Recoil.color_mode = MODE_COLORS_RANDOM;
Recoil.speed = speed;
modes.push_back(Recoil);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = CM_SMALL_ARGB_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Breathing.colors_min = 1;
Breathing.colors_max = 1;
Breathing.colors.resize(Breathing.colors_max);
Breathing.speed_min = CM_SMALL_ARGB_SPEED_SLOWEST;
Breathing.speed_max = CM_SMALL_ARGB_SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_RANDOM;
Breathing.speed = speed;
modes.push_back(Breathing);
mode Refill;
Refill.name = "Refill";
Refill.value = CM_SMALL_ARGB_MODE_REFILL;
Refill.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_RANDOM_COLOR;
Refill.colors_min = 1;
Refill.colors_max = 1;
Refill.colors.resize(Refill.colors_max);
Refill.speed_min = CM_SMALL_ARGB_SPEED_SLOWEST;
Refill.speed_max = CM_SMALL_ARGB_SPEED_FASTEST;
Refill.color_mode = MODE_COLORS_RANDOM;
Refill.speed = speed;
modes.push_back(Refill);
mode Demo;
Demo.name = "Demo";
Demo.value = CM_SMALL_ARGB_MODE_DEMO;
Demo.flags = MODE_FLAG_HAS_SPEED;
Demo.speed_min = CM_SMALL_ARGB_SPEED_SLOWEST;
Demo.speed_max = CM_SMALL_ARGB_SPEED_FASTEST;
Demo.color_mode = MODE_COLORS_NONE;
Demo.speed = speed;
modes.push_back(Demo);
mode Spectrum;
Spectrum.name = "Spectrum";
Spectrum.value = CM_SMALL_ARGB_MODE_SPECTRUM;
Spectrum.flags = MODE_FLAG_HAS_SPEED;
Spectrum.speed_min = CM_SMALL_ARGB_SPEED_SLOWEST;
Spectrum.speed_max = CM_SMALL_ARGB_SPEED_FASTEST;
Spectrum.color_mode = MODE_COLORS_NONE;
Spectrum.speed = speed;
modes.push_back(Spectrum);
mode Direct;
Direct.name = "Direct";
Direct.value = CM_SMALL_ARGB_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode PassThru;
PassThru.name = "Pass Thru";
PassThru.value = CM_SMALL_ARGB_MODE_PASSTHRU;
PassThru.color_mode = MODE_COLORS_NONE;
modes.push_back(PassThru);
Init_Controller(); //Only processed on first run
SetupZones();
int temp_mode = cmargb->GetMode();
for(std::size_t mode_idx = 0; mode_idx < modes.size() ; mode_idx++)
{
if (temp_mode == modes[mode_idx].value)
{
active_mode = mode_idx;
break;
}
}
if (modes[active_mode].flags & MODE_FLAG_HAS_MODE_SPECIFIC_COLOR)
{
modes[active_mode].colors[0] = ToRGBColor(cmargb->GetLedRed(), cmargb->GetLedGreen(), cmargb->GetLedBlue());
}
modes[active_mode].color_mode = (cmargb->GetRandomColours()) ? MODE_COLORS_RANDOM : MODE_COLORS_MODE_SPECIFIC;
if (modes[active_mode].flags & MODE_FLAG_HAS_SPEED)
{
modes[active_mode].speed = cmargb->GetLedSpeed();
}
}
RGBController_CMSmallARGBController::~RGBController_CMSmallARGBController()
{
delete cmargb;
}
void RGBController_CMSmallARGBController::Init_Controller()
{
int zone_idx = cmargb->GetZoneIndex();
int zone_led_count = small_argb_header_data[zone_idx].count;
bool boolSingleLED = ( zone_led_count == 1 ); //If argb_header_data[zone_idx].count == 1 then the zone is ZONE_TYPE_SINGLE
zone ARGB_zone;
ARGB_zone.name = std::to_string(zone_idx);
ARGB_zone.type = (boolSingleLED) ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
ARGB_zone.leds_min = CM_SMALL_ARGB_MIN_LEDS;
ARGB_zone.leds_max = CM_SMALL_ARGB_MAX_LEDS;
ARGB_zone.leds_count = zone_led_count;
ARGB_zone.matrix_map = NULL;
zones.push_back(ARGB_zone);
}
void RGBController_CMSmallARGBController::SetupZones()
{
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
bool boolSingleLED = (zones[zone_idx].type == ZONE_TYPE_SINGLE); //Calculated for later use
if (!boolSingleLED)
{
cmargb->SetLedCount(small_argb_header_data[zone_idx].header, zones[zone_idx].leds_count);
}
for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
{
led new_led;
unsigned int i = std::stoi(zones[zone_idx].name);
if(boolSingleLED)
{
new_led.name = i;
new_led.value = small_argb_header_data[i].header;
}
else
{
new_led.name = i;
new_led.name.append(" LED " + std::to_string(lp_idx));
new_led.value = small_argb_header_data[i].header;
}
leds.push_back(new_led);
}
}
SetupColors();
}
void RGBController_CMSmallARGBController::ResizeZone(int zone, int new_size)
{
if((size_t) zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
}
}
void RGBController_CMSmallARGBController::DeviceUpdateLEDs()
{
for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
UpdateZoneLEDs(zone_idx);
}
}
void RGBController_CMSmallARGBController::UpdateZoneLEDs(int /*zone*/)
{
//bool random_colours = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
//cmargb->SetLedsDirect(zones[zone].colors, random_colours);
}
void RGBController_CMSmallARGBController::UpdateSingleLED(int /*led*/)
{
//cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed );
//cmargb->SetLedsDirect( zones[0].colors, zones[0].leds_count );
}
void RGBController_CMSmallARGBController::SetCustomMode()
{
active_mode = CM_SMALL_ARGB_MODE_DIRECT; //The small ARGB may not support "Direct" mode
}
void RGBController_CMSmallARGBController::DeviceUpdateMode()
{
bool random_colours = (modes[active_mode].color_mode == MODE_COLORS_RANDOM);
RGBColor colour = (modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) ? modes[active_mode].colors[0] : 0;
cmargb->SetMode( modes[active_mode].value, modes[active_mode].speed, colour, random_colours );
}
Controllers/CoolerMasterController/RGBController_CMSmallARGBController.h
+38
View File
@@ -0,0 +1,38 @@
/*-------------------------------------------------------------------*\
| RGBController_CMSmallARGBController.h |
| |
| Driver for Coolermaster Small ARGB USB Controller |
| |
| Chris M (Dr_No) 31st Jan 2021 |
| |
\*-------------------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "CMSmallARGBController.h"
#include <vector>
#define CM_SMALL_ARGB_MIN_LEDS 4
#define CM_SMALL_ARGB_MAX_LEDS 48
class RGBController_CMSmallARGBController : public RGBController
{
public:
RGBController_CMSmallARGBController(CMSmallARGBController* cmargb_ptr);
~RGBController_CMSmallARGBController();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
void Init_Controller();
int GetDeviceMode();
CMSmallARGBController* cmargb;
};
Controllers/CorsairDominatorPlatinumController/CorsairDominatorPlatinumControllerDetect.cpp
+2 -2
View File
@@ -47,7 +47,7 @@ bool TestForCorsairDominatorPlatinumController(i2c_smbus_interface *bus, unsigne
* *
\******************************************************************************************/
void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses, std::vector<RGBController *> &rgb_controllers)
void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *> &busses)
{
for(unsigned int bus = 0; bus < busses.size(); bus++)
{
@@ -59,7 +59,7 @@ void DetectCorsairDominatorPlatinumControllers(std::vector<i2c_smbus_interface *
{
CorsairDominatorPlatinumController* new_controller = new CorsairDominatorPlatinumController(busses[bus], addr);
RGBController_CorsairDominatorPlatinum* new_rgbcontroller = new RGBController_CorsairDominatorPlatinum(new_controller);
rgb_controllers.push_back(new_rgbcontroller);
ResourceManager::get()->RegisterRGBController(new_rgbcontroller);
}
std::this_thread::sleep_for(10ms);
}
Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.cpp
+5
View File
@@ -33,6 +33,11 @@ RGBController_CorsairDominatorPlatinum::RGBController_CorsairDominatorPlatinum(C
active_mode = 0;
}
RGBController_CorsairDominatorPlatinum::~RGBController_CorsairDominatorPlatinum()
{
delete corsair;
}
void RGBController_CorsairDominatorPlatinum::SetupZones()
{
/*---------------------------------------------------------*\
Controllers/CorsairDominatorPlatinumController/RGBController_CorsairDominatorPlatinum.h
+1
View File
@@ -15,6 +15,7 @@ class RGBController_CorsairDominatorPlatinum : public RGBController
{
public:
RGBController_CorsairDominatorPlatinum(CorsairDominatorPlatinumController* corsair_ptr);
~RGBController_CorsairDominatorPlatinum();
void SetupZones();
Controllers/CorsairHydroController/CorsairHydroController.cpp
+8
View File
@@ -29,6 +29,14 @@ CorsairHydroController::CorsairHydroController(libusb_device_handle* dev_handle)
SendFirmwareRequest();
}
CorsairHydroController::~CorsairHydroController()
{
if(dev)
{
libusb_close(dev);
}
}
std::string CorsairHydroController::GetFirmwareString()
{
return(firmware_version);
Controllers/CorsairHydroController/CorsairHydroControllerDetect.cpp
+3 -4
View File
@@ -47,16 +47,15 @@ static const corsair_hydro_device device_list[] =
void DetectCorsairHydroControllers(std::vector<RGBController*>& rgb_controllers)
{
libusb_context * ctx;
libusb_init(&ctx);
libusb_init(NULL);
#ifdef _WIN32
libusb_set_option(ctx, LIBUSB_OPTION_USE_USBDK);
libusb_set_option(NULL, LIBUSB_OPTION_USE_USBDK);
#endif
for(std::size_t device_idx = 0; device_idx < CORSAIR_NUM_DEVICES; device_idx++)
{
libusb_device_handle * dev = libusb_open_device_with_vid_pid(ctx, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
libusb_device_handle * dev = libusb_open_device_with_vid_pid(NULL, device_list[device_idx].usb_vid, device_list[device_idx].usb_pid);
//Look for Corsair RGB Peripheral
if(dev)
Controllers/CorsairHydroController/RGBController_CorsairHydro.cpp
+5
View File
@@ -68,6 +68,11 @@ RGBController_CorsairHydro::RGBController_CorsairHydro(CorsairHydroController* c
SetupZones();
}
RGBController_CorsairHydro::~RGBController_CorsairHydro()
{
delete corsair;
}
void RGBController_CorsairHydro::SetupZones()
{
zone new_zone;
Controllers/CorsairHydroController/RGBController_CorsairHydro.h
+1
View File
@@ -15,6 +15,7 @@ class RGBController_CorsairHydro : public RGBController
{
public:
RGBController_CorsairHydro(CorsairHydroController* corsair_ptr);
~RGBController_CorsairHydro();
void SetupZones();
Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumController.cpp
+245
View File
@@ -0,0 +1,245 @@
/*-------------------------------------------------------------------*\
| CorsairHydroPlatinumController.cpp |
| |
| Driver for Corsair Hydro Platinum AIO Coolers |
| |
| Kasper 28th March 2021 |
| |
\*-------------------------------------------------------------------*/
#include "CorsairHydroPlatinumController.h"
#include <cstring>
static const uint8_t CRC_TABLE[256] =
{
0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
};
static const uint8_t MAGIC_1[61] =
{
0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,
0x7f, 0x7f, 0x7f, 0xff, 0x00, 0xff, 0xff, 0xff,
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff,
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff,
0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff
};
static const uint8_t MAGIC_2[61] =
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff
};
static const uint8_t MAGIC_3[61] =
{
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff
};
CorsairHydroPlatinumController::CorsairHydroPlatinumController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
SendMagic(MAGIC_1, CORSAIR_HYDRO_PLATINUM_MAGIC_1);
SendMagic(MAGIC_2, CORSAIR_HYDRO_PLATINUM_MAGIC_2);
SendMagic(MAGIC_3, CORSAIR_HYDRO_PLATINUM_MAGIC_3);
}
CorsairHydroPlatinumController::~CorsairHydroPlatinumController()
{
hid_close(dev);
}
std::string CorsairHydroPlatinumController::GetLocation()
{
return location;
}
std::string CorsairHydroPlatinumController::GetFirmwareString()
{
return firmware_version;
}
void CorsairHydroPlatinumController::SetupColors(std::vector<RGBColor> colors)
{
unsigned int end_led = colors.size() >= 20 ? 20 : colors.size();
SendColors(colors, 0, end_led, CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_1);
if(colors.size() > 20)
{
end_led = colors.size() >= 40 ? 40 : colors.size();
SendColors(colors, 20, end_led, CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_2);
}
if(colors.size() > 40)
{
end_led = colors.size() >= 48 ? 48 : colors.size();
SendColors(colors, 40, end_led, CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_3);
}
}
void CorsairHydroPlatinumController::SendMagic(const uint8_t* magic, unsigned int command)
{
unsigned char usb_buf[CORSAIR_HYDRO_PLATINUM_PACKET_SIZE];
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x3F;
usb_buf[0x02] = (GetSequenceNumber()) | command;
/*-----------------------------------------------------*\
| Copy the magic bytes into the buffer |
\*-----------------------------------------------------*/
memcpy(&usb_buf[3], magic, 61 * sizeof magic[0]);
/*-----------------------------------------------------*\
| The data sent to the PEC function should not contain |
| the first (report id), second (prefix) and |
| last (checksum) bytes |
\*-----------------------------------------------------*/
std::vector<unsigned char> checksum_array;
checksum_array.insert(checksum_array.begin(), std::begin(usb_buf) + 2, std::end(usb_buf) - 1);
usb_buf[64] = ComputePEC(static_cast<void*>(checksum_array.data()), 62);
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
hid_read(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
if(firmware_version.empty())
{
firmware_version =
std::to_string(usb_buf[2] >> 4) + "."
+ std::to_string(usb_buf[2] & 0xf) + "."
+ std::to_string(usb_buf[3]);
}
/*-----------------------------------------------------*\
| This delay prevents the AIO from soft-locking when |
| using an EE. |
\*-----------------------------------------------------*/
std::this_thread::sleep_for(std::chrono::milliseconds(CORSAIR_HYDRO_PLATINUM_PACKET_DELAY));
}
void CorsairHydroPlatinumController::SendColors(std::vector<RGBColor> colors, unsigned int start, unsigned int end, unsigned int command)
{
unsigned char usb_buf[CORSAIR_HYDRO_PLATINUM_PACKET_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
/*-----------------------------------------------------*\
| Set up config table request packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x3F;
usb_buf[0x02] = (GetSequenceNumber()) | command;
unsigned int i = 0;
for(std::size_t color_idx = start; color_idx < end; color_idx++)
{
usb_buf[(i * 3) + 3] = RGBGetBValue(colors[color_idx]);
usb_buf[(i * 3) + 4] = RGBGetGValue(colors[color_idx]);
usb_buf[(i * 3) + 5] = RGBGetRValue(colors[color_idx]);
i++;
}
/*-----------------------------------------------------*\
| The data sent to the PEC function should not contain |
| the first (report id), second (prefix) and |
| last (checksum) bytes |
\*-----------------------------------------------------*/
std::vector<unsigned char> checksum_array;
checksum_array.insert(checksum_array.begin(), std::begin(usb_buf) + 2, std::end(usb_buf) - 1);
usb_buf[64] = ComputePEC(static_cast<void*>(checksum_array.data()), 62);
hid_write(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
hid_read(dev, usb_buf, CORSAIR_HYDRO_PLATINUM_PACKET_SIZE);
/*-----------------------------------------------------*\
| This delay prevents the AIO from soft-locking when |
| using an EE. |
\*-----------------------------------------------------*/
std::this_thread::sleep_for(std::chrono::milliseconds(CORSAIR_HYDRO_PLATINUM_PACKET_DELAY));
}
unsigned int CorsairHydroPlatinumController::GetSequenceNumber()
{
if(sequence_number < 31)
{
sequence_number++;
}
else
{
sequence_number = 1;
}
return(sequence_number << 3);
}
uint8_t CorsairHydroPlatinumController::ComputePEC(const void * data, size_t size)
{
uint8_t val = 0;
uint8_t * pos = (uint8_t *) data;
uint8_t * end = pos + size;
while (pos < end)
{
val = CRC_TABLE[val ^ *pos];
pos++;
}
return val;
}
Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumController.h
+52
View File
@@ -0,0 +1,52 @@
/*-------------------------------------------------------------------*\
| CorsairHydroPlatinumController.h |
| |
| Driver for Corsair Hydro Platinum AIO Coolers |
| |
| Kasper 28th March 2021 |
| |
\*-------------------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include <vector>
#include <string>
#include <hidapi/hidapi.h>
#define CORSAIR_HYDRO_PLATINUM_PACKET_SIZE 65
#define CORSAIR_HYDRO_PLATINUM_PACKET_DELAY 5
enum
{
CORSAIR_HYDRO_PLATINUM_MAGIC_1 = 0b001,
CORSAIR_HYDRO_PLATINUM_MAGIC_2 = 0b010,
CORSAIR_HYDRO_PLATINUM_MAGIC_3 = 0b011,
CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_1 = 0b100,
CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_2 = 0b101,
CORSAIR_HYDRO_PLATINUM_SET_LIGHTING_3 = 0b110,
};
class CorsairHydroPlatinumController
{
public:
CorsairHydroPlatinumController(hid_device* dev_handle, const char* path);
~CorsairHydroPlatinumController();
std::string GetLocation();
std::string GetFirmwareString();
void SetupColors(std::vector<RGBColor> colors);
private:
hid_device* dev;
std::string location;
std::string firmware_version;
std::atomic<unsigned int> sequence_number;
void SendMagic(const uint8_t* magic, unsigned int command);
void SendColors(std::vector<RGBColor> colors, unsigned int start, unsigned int end, unsigned int command);
unsigned int GetSequenceNumber();
uint8_t ComputePEC(const void * data, size_t size);
};
Controllers/CorsairHydroPlatinumController/CorsairHydroPlatinumControllerDetect.cpp
+49
View File
@@ -0,0 +1,49 @@
/*-------------------------------------------------------------------*\
| CorsairHydroPlatinumControllerDetect.cpp |
| |
| Driver for Corsair Hydro Platinum AIO Coolers |
| |
| Kasper 28th March 2021 |
| |
\*-------------------------------------------------------------------*/
#include "Detector.h"
#include "CorsairHydroPlatinumController.h"
#include "RGBController.h"
#include "RGBController_CorsairHydroPlatinum.h"
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
| Corsair vendor ID |
\*-----------------------------------------------------*/
#define CORSAIR_VID 0x1B1C
/*-----------------------------------------------------*\
| Product IDs |
\*-----------------------------------------------------*/
#define CORSAIR_HYDRO_H100I_PLATINUM_PID 0x0c18
#define CORSAIR_HYDRO_H100I_PLATINUM_SE_PID 0x0C19
#define CORSAIR_HYDRO_H115I_PLATINUM_PID 0x0c17
#define CORSAIR_HYDRO_H100I_PRO_XT_PID 0x0c20
#define CORSAIR_HYDRO_H115I_PRO_XT_PID 0x0c21
#define CORSAIR_HYDRO_H150I_PRO_XT_PID 0x0c22
void DetectCorsairHydroPlatinumControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if( dev )
{
CorsairHydroPlatinumController* controller = new CorsairHydroPlatinumController(dev, info->path);
RGBController_CorsairHydroPlatinum* rgb_controller = new RGBController_CorsairHydroPlatinum(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR("Corsair Hydro H100i Platinum", DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PLATINUM_PID );
REGISTER_HID_DETECTOR("Corsair Hydro H100i Platinum SE", DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PLATINUM_SE_PID );
REGISTER_HID_DETECTOR("Corsair Hydro H115i Platinum", DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H115I_PLATINUM_PID );
REGISTER_HID_DETECTOR("Corsair Hydro H100i Pro XT", DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H100I_PRO_XT_PID );
REGISTER_HID_DETECTOR("Corsair Hydro H115i Pro XT", DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H115I_PRO_XT_PID );
REGISTER_HID_DETECTOR("Corsair Hydro H150i Pro XT", DetectCorsairHydroPlatinumControllers, CORSAIR_VID, CORSAIR_HYDRO_H150I_PRO_XT_PID );
Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.cpp
+127
View File
@@ -0,0 +1,127 @@
/*-------------------------------------------------------------------*\
| RGBController_CorsairHydroPlatinum.cpp |
| |
| Driver for Corsair Hydro Platinum AIO Coolers |
| |
| Kasper 28th March 2021 |
| |
\*-------------------------------------------------------------------*/
#include "RGBController_CorsairHydroPlatinum.h"
#define NA 0xFFFFFFFF
static unsigned int matrix_map[5][5] =
{
{ NA, 11, 12, 13, NA },
{ 10, NA, 1, NA, 14 },
{ 9, 0, NA, 2, 15 },
{ 8, NA, 3, NA, 4 },
{ NA, 7, 6, 5, NA }
};
RGBController_CorsairHydroPlatinum::RGBController_CorsairHydroPlatinum(CorsairHydroPlatinumController* corsair_ptr)
{
corsair = corsair_ptr;
name = "Corsair Hydro Platinum Series Device";
vendor = "Corsair";
description = "Corsair Hydro Platinum Series Device";
type = DEVICE_TYPE_COOLER;
location = corsair->GetLocation();
version = corsair->GetFirmwareString();
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
Init_Controller();
SetupZones();
}
void RGBController_CorsairHydroPlatinum::Init_Controller()
{
zone cpu_block_zone;
cpu_block_zone.name = "CPU Block";
cpu_block_zone.type = ZONE_TYPE_MATRIX;
cpu_block_zone.leds_min = 16;
cpu_block_zone.leds_max = 16;
cpu_block_zone.leds_count = 16;
cpu_block_zone.matrix_map = new matrix_map_type;
cpu_block_zone.matrix_map->height = 5;
cpu_block_zone.matrix_map->width = 5;
cpu_block_zone.matrix_map->map = (unsigned int *)&matrix_map;
zones.push_back(cpu_block_zone);
zone fans_zone;
fans_zone.name = "Fans";
fans_zone.type = ZONE_TYPE_LINEAR;
fans_zone.leds_min = 0;
fans_zone.leds_max = 32;
fans_zone.leds_count = 0;
fans_zone.matrix_map = NULL;
zones.push_back(fans_zone);
}
void RGBController_CorsairHydroPlatinum::SetupZones()
{
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
for (unsigned int zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
for (unsigned int led_idx = 0; led_idx < zones[zone_idx].leds_count; led_idx++)
{
led new_led;
new_led.name = zones[zone_idx].name + " " + std::to_string(led_idx);;
leds.push_back(new_led);
}
}
SetupColors();
}
void RGBController_CorsairHydroPlatinum::ResizeZone(int zone, int new_size)
{
if((size_t) zone >= zones.size())
{
return;
}
if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max))
{
zones[zone].leds_count = new_size;
SetupZones();
}
}
void RGBController_CorsairHydroPlatinum::DeviceUpdateLEDs()
{
corsair->SetupColors(colors);
}
void RGBController_CorsairHydroPlatinum::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_CorsairHydroPlatinum::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_CorsairHydroPlatinum::SetCustomMode()
{
active_mode = 0;
}
void RGBController_CorsairHydroPlatinum::DeviceUpdateMode()
{
}
Controllers/CorsairHydroPlatinumController/RGBController_CorsairHydroPlatinum.h
+34
View File
@@ -0,0 +1,34 @@
/*-------------------------------------------------------------------*\
| RGBController_CorsairHydroPlatinum.h |
| |
| Driver for Corsair Hydro Platinum AIO Coolers |
| |
| Kasper 28th March 2021 |
| |
\*-------------------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "CorsairHydroPlatinumController.h"
class RGBController_CorsairHydroPlatinum : public RGBController
{
public:
RGBController_CorsairHydroPlatinum(CorsairHydroPlatinumController* corsair_ptr);
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
CorsairHydroPlatinumController* corsair;
void Init_Controller();
};
Controllers/CorsairLightingNodeController/CorsairLightingNodeController.cpp
+2
View File
@@ -35,6 +35,8 @@ CorsairLightingNodeController::~CorsairLightingNodeController()
keepalive_thread_run = 0;
keepalive_thread->join();
delete keepalive_thread;
hid_close(dev);
}
void CorsairLightingNodeController::KeepaliveThread()
Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.cpp
+5
View File
@@ -167,6 +167,11 @@ RGBController_CorsairLightingNode::RGBController_CorsairLightingNode(CorsairLigh
SetupZones();
}
RGBController_CorsairLightingNode::~RGBController_CorsairLightingNode()
{
delete corsair;
}
void RGBController_CorsairLightingNode::SetupZones()
{
/*-------------------------------------------------*\
Controllers/CorsairLightingNodeController/RGBController_CorsairLightingNode.h
+1
View File
@@ -15,6 +15,7 @@ class RGBController_CorsairLightingNode : public RGBController
{
public:
RGBController_CorsairLightingNode(CorsairLightingNodeController* corsair_ptr);
~RGBController_CorsairLightingNode();
void SetupZones();
Controllers/CorsairPeripheralController/CorsairPeripheralController.cpp
+181 -29
View File
@@ -20,7 +20,7 @@ static unsigned int keys[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x
79, 80, 81, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 96, 97,
98, 99, 100, 101, 102, 103, 104, 105, 108, 109, 110, 111, 112, 113, 115,
116, 117, 120, 121, 122, 123, 124, 126, 127, 128, 129, 132, 133, 134, 135,
136, 137, 139, 140, 141};
136, 137, 139, 140, 141, 0x10, 114};
static unsigned int keys_k95_plat[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0C, 0x0D, 0x0E, 0x0F, 0x11, 0x12,
@@ -31,7 +31,7 @@ static unsigned int keys_k95_plat[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
98, 99, 100, 101, 102, 103, 104, 105, 108, 109, 110, 111, 112, 113, 115,
116, 117, 120, 121, 122, 123, 124, 126, 127, 128, 129, 132, 133, 134, 135,
136, 137, 139, 140, 141,
0x10, 114, 0x0a, 0x16, 0x22, 0x2e, 0x3a, 0x46,
0x10, 114, 0x0a, 0x16, 0x22, 0x2e, 0x3a, 0x46, 125,
144, 145, 146, 158, 160, 147, 148, 149, 150, 151, 152, 153,
154, 155, 159, 162, 161, 156, 157};
@@ -48,6 +48,9 @@ static unsigned int keys_k95[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
static unsigned int st100[] = { 0x00, 0x01, 0x02, 0x03, 0x05, 0x06, 0x07, 0x08, 0x04 };
static unsigned int key_mapping_k95_plat_ansi[] = { 0x31, 0x3f, 0x41, 0x42, 0x51, 0x53, 0x55, 0x6f, 0x7e, 0x7f, 0x80, 0x81 };
static unsigned int key_mapping_k95_plat_iso[] = { 0x3f, 0x41, 0x42, 0x48, 0x50, 0x53, 0x55, 0x6f, 0x7e, 0x7f, 0x80, 0x81 };
CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
@@ -55,15 +58,25 @@ CorsairPeripheralController::CorsairPeripheralController(hid_device* dev_handle,
ReadFirmwareInfo();
/*-----------------------------------------------------*\
| K55 and K95 Platinum require additional steps |
\*-----------------------------------------------------*/
if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT)
{
SpecialFunctionControl();
}
LightingControl();
if (logical_layout == CORSAIR_TYPE_K55 || logical_layout == CORSAIR_TYPE_K95_PLAT)
{
SetupK55AndK95LightingControl();
}
}
CorsairPeripheralController::~CorsairPeripheralController()
{
if(dev)
{
hid_close(dev);
}
hid_close(dev);
}
device_type CorsairPeripheralController::GetDeviceType()
@@ -112,7 +125,14 @@ void CorsairPeripheralController::SetLEDs(std::vector<RGBColor>colors)
switch(type)
{
case DEVICE_TYPE_KEYBOARD:
SetLEDsKeyboardFull(colors);
if (logical_layout == CORSAIR_TYPE_K55)
{
SubmitKeyboardZonesColors(colors[0], colors[1], colors[2]);
}
else
{
SetLEDsKeyboardFull(colors);
}
break;
case DEVICE_TYPE_MOUSE:
@@ -150,6 +170,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
unsigned char red_val[168];
unsigned char grn_val[168];
unsigned char blu_val[168];
unsigned char data_sz = 24;
/*-----------------------------------------------------*\
| Zero out buffers |
@@ -169,12 +190,14 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
red_val[keys_k95_plat[color_idx]] = RGBGetRValue(color);
grn_val[keys_k95_plat[color_idx]] = RGBGetGValue(color);
blu_val[keys_k95_plat[color_idx]] = RGBGetBValue(color);
data_sz = 48;
}
else if (logical_layout == CORSAIR_TYPE_K95)
{
red_val[keys_k95[color_idx]] = RGBGetRValue(color);
grn_val[keys_k95[color_idx]] = RGBGetGValue(color);
blu_val[keys_k95[color_idx]] = RGBGetBValue(color);
data_sz = 48; //untested
}
else
{
@@ -189,7 +212,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
\*-----------------------------------------------------*/
StreamPacket(1, 60, &red_val[0]);
StreamPacket(2, 60, &red_val[60]);
StreamPacket(3, 48, &red_val[120]);
StreamPacket(3, data_sz, &red_val[120]);
SubmitKeyboardFullColors(1, 3, 1);
/*-----------------------------------------------------*\
@@ -197,7 +220,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
\*-----------------------------------------------------*/
StreamPacket(1, 60, &grn_val[0]);
StreamPacket(2, 60, &grn_val[60]);
StreamPacket(3, 48, &grn_val[120]);
StreamPacket(3, data_sz, &grn_val[120]);
SubmitKeyboardFullColors(2, 3, 1);
/*-----------------------------------------------------*\
@@ -205,7 +228,7 @@ void CorsairPeripheralController::SetLEDsKeyboardFull(std::vector<RGBColor> colo
\*-----------------------------------------------------*/
StreamPacket(1, 60, &blu_val[0]);
StreamPacket(2, 60, &blu_val[60]);
StreamPacket(3, 48, &blu_val[120]);
StreamPacket(3, data_sz, &blu_val[120]);
SubmitKeyboardFullColors(3, 3, 2);
}
@@ -320,7 +343,7 @@ void CorsairPeripheralController::LightingControl()
{
default:
case DEVICE_TYPE_KEYBOARD:
usb_buf[0x05] = 0x03;
usb_buf[0x05] = 0x03; // On K95 Platinum, this controls keyboard brightness
break;
case DEVICE_TYPE_MOUSE:
@@ -342,6 +365,80 @@ void CorsairPeripheralController::LightingControl()
hid_write(dev, (unsigned char *)usb_buf, 65);
}
/*-----------------------------------------------------*\
| Probably a key mapping packet? |
\*-----------------------------------------------------*/
void CorsairPeripheralController::SetupK55AndK95LightingControl()
{
char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up a packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = CORSAIR_COMMAND_WRITE;
usb_buf[0x02] = CORSAIR_PROPERTY_LIGHTING_CONTROL;
usb_buf[0x03] = 0x08;
usb_buf[0x05] = 0x01;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
unsigned int* skipped_identifiers = key_mapping_k95_plat_ansi;
int skipped_identifiers_count = sizeof(key_mapping_k95_plat_ansi) / sizeof(key_mapping_k95_plat_ansi[0]);
if (physical_layout == CORSAIR_LAYOUT_ISO)
{
skipped_identifiers = key_mapping_k95_plat_iso;
skipped_identifiers_count = sizeof(key_mapping_k95_plat_iso) / sizeof(key_mapping_k95_plat_iso[0]);
}
unsigned int identifier = 0;
for (int i = 0; i < 4; i++)
{
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up a packet - a sequence of 120 ids |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = CORSAIR_COMMAND_WRITE;
usb_buf[0x02] = 0x40;
usb_buf[0x03] = 0x1E;
for (int j = 0; j < 30; j++)
{
for (int j = 0; j < skipped_identifiers_count; j++)
{
if (identifier == skipped_identifiers[j])
{
identifier++;
}
}
usb_buf[5 + 2 * j] = identifier++;
usb_buf[5 + 2 * j + 1] = 0xC0;
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
}
}
void CorsairPeripheralController::SpecialFunctionControl()
{
char usb_buf[65];
@@ -365,7 +462,6 @@ void CorsairPeripheralController::SpecialFunctionControl()
hid_write(dev, (unsigned char *)usb_buf, 65);
}
void CorsairPeripheralController::ReadFirmwareInfo()
{
int actual;
@@ -421,11 +517,14 @@ void CorsairPeripheralController::ReadFirmwareInfo()
{
case 0xC0:
{
unsigned short pid = (unsigned short)(usb_buf[0x0F] << 8) + (unsigned char)(usb_buf[0x0E]);
unsigned short pid = (unsigned short)(usb_buf[0x0E] << 8) + (unsigned char)(usb_buf[0x0F]);
/*-----------------------------------------------------*\
| Get the correct Keyboard Type |
\*-----------------------------------------------------*/
switch(pid)
{
case 0x2D1B:
case 0x1B2D:
logical_layout = CORSAIR_TYPE_K95_PLAT;
break;
@@ -433,9 +532,39 @@ void CorsairPeripheralController::ReadFirmwareInfo()
logical_layout = CORSAIR_TYPE_K95;
break;
case 0x1B3D:
logical_layout = CORSAIR_TYPE_K55;
break;
default:
logical_layout = CORSAIR_TYPE_NORMAL;
}
/*-----------------------------------------------------*\
| Get the correct Keyboard Layout. |
| Currently unused but can be implemented in the future.|
\*-----------------------------------------------------*/
switch((unsigned char)usb_buf[0x17 + offset])
{
case CORSAIR_LAYOUT_ANSI:
physical_layout = CORSAIR_LAYOUT_ANSI;
break;
case CORSAIR_LAYOUT_ISO:
physical_layout = CORSAIR_LAYOUT_ISO;
break;
case CORSAIR_LAYOUT_ABNT:
physical_layout = CORSAIR_LAYOUT_ABNT;
break;
case CORSAIR_LAYOUT_JIS:
physical_layout = CORSAIR_LAYOUT_JIS;
break;
case CORSAIR_LAYOUT_DUBEOLSIK:
physical_layout = CORSAIR_LAYOUT_DUBEOLSIK;
break;
default:
physical_layout = CORSAIR_LAYOUT_ANSI;
}
}
type = DEVICE_TYPE_KEYBOARD;
break;
@@ -476,21 +605,6 @@ void CorsairPeripheralController::ReadFirmwareInfo()
{
firmware_version = std::to_string(usb_buf[0x09 + offset]) + "." + std::to_string(usb_buf[0x08 + offset]);
}
/*-----------------------------------------------------*\
| Get the correct Keyboard Layout |
\*-----------------------------------------------------*/
switch((unsigned char)usb_buf[0x17 + offset])
{
case CORSAIR_LAYOUT_ANSI:
physical_layout = CORSAIR_LAYOUT_ANSI;
break;
case CORSAIR_LAYOUT_ISO:
physical_layout = CORSAIR_LAYOUT_ISO;
break;
default:
physical_layout = CORSAIR_LAYOUT_ANSI;
}
}
void CorsairPeripheralController::StreamPacket
@@ -556,6 +670,44 @@ void CorsairPeripheralController::SubmitKeyboardFullColors
hid_write(dev, (unsigned char *)usb_buf, 65);
}
void CorsairPeripheralController::SubmitKeyboardZonesColors
(
RGBColor left,
RGBColor mid,
RGBColor right
)
{
char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Submit Keyboard 24-Bit Colors packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = CORSAIR_COMMAND_WRITE;
usb_buf[0x02] = CORSAIR_PROPERTY_SUBMIT_KBZONES_COLOR_24;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = RGBGetRValue(left);
usb_buf[0x06] = RGBGetGValue(left);
usb_buf[0x07] = RGBGetBValue(left);
usb_buf[0x08] = RGBGetRValue(mid);
usb_buf[0x09] = RGBGetGValue(mid);
usb_buf[0x0A] = RGBGetBValue(mid);
usb_buf[0x0B] = RGBGetRValue(right);
usb_buf[0x0C] = RGBGetGValue(right);
usb_buf[0x0D] = RGBGetBValue(right);
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
}
void CorsairPeripheralController::SubmitKeyboardLimitedColors
(
unsigned char byte_count
Controllers/CorsairPeripheralController/CorsairPeripheralController.h
+12 -1
View File
@@ -30,6 +30,7 @@ enum
CORSAIR_PROPERTY_LIGHTING_CONTROL = 0x05,
CORSAIR_PROPERTY_HARDWARE_PROFILE = 0x13,
CORSAIR_PROPERTY_SUBMIT_MOUSE_COLOR = 0x22,
CORSAIR_PROPERTY_SUBMIT_KBZONES_COLOR_24 = 0x25,
CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_9 = 0x27,
CORSAIR_PROPERTY_SUBMIT_KEYBOARD_COLOR_24 = 0x28,
};
@@ -60,7 +61,8 @@ enum
{
CORSAIR_TYPE_NORMAL = 0,
CORSAIR_TYPE_K95_PLAT = 1,
CORSAIR_TYPE_K95 = 2
CORSAIR_TYPE_K95 = 2,
CORSAIR_TYPE_K55 = 3
};
class CorsairPeripheralController
@@ -95,6 +97,7 @@ private:
int logical_layout; //Normal, K95 or K95 Platinum
void LightingControl();
void SetupK55AndK95LightingControl();
void SpecialFunctionControl();
void ReadFirmwareInfo();
@@ -113,6 +116,14 @@ private:
unsigned char finish_val
);
void SubmitKeyboardZonesColors
(
RGBColor left,
RGBColor mid,
RGBColor right
);
void SubmitKeyboardLimitedColors
(
unsigned char byte_count
Controllers/CorsairPeripheralController/CorsairPeripheralControllerDetect.cpp
+3 -1
View File
@@ -39,6 +39,7 @@
| Mouse product IDs |
| List taken from ckb-next |
\*-----------------------------------------------------*/
#define CORSAIR_GLAIVE_RGB_PID 0x1B34
#define CORSAIR_GLAIVE_RGB_PRO_PID 0x1B74
#define CORSAIR_HARPOON_RGB_PID 0x1B3C
#define CORSAIR_HARPOON_RGB_PRO_PID 0x1B75
@@ -90,7 +91,7 @@ void DetectCorsairPeripheralControllers(hid_device_info* info, const std::string
/*-----------------------------------------------------------------------------------------------------*\
| Keyboards |
\*-----------------------------------------------------------------------------------------------------*/
//REGISTER_HID_DETECTOR_IP("Corsair K55 RGB", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID, 1, 0xFFC2); // Not per-key, disabled for now
REGISTER_HID_DETECTOR_IP("Corsair K55 RGB", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K55_RGB_PID, 1, 0xFFC2);
REGISTER_HID_DETECTOR_IP("Corsair K65 RGB", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_PID, 1, 0xFFC2);
REGISTER_HID_DETECTOR_IP("Corsair K65 LUX RGB", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_LUX_RGB_PID, 1, 0xFFC2);
REGISTER_HID_DETECTOR_IP("Corsair K65 RGB RAPIDFIRE", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_K65_RGB_RAPIDFIRE_PID, 1, 0xFFC2);
@@ -108,6 +109,7 @@ REGISTER_HID_DETECTOR_IP("Corsair Strafe MK.2", DetectCorsairPeriph
/*-----------------------------------------------------------------------------------------------------*\
| Mice |
\*-----------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PID, 1, 0xFFC2);
REGISTER_HID_DETECTOR_IP("Corsair Glaive RGB PRO", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_GLAIVE_RGB_PRO_PID, 1, 0xFFC2);
REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PID, 1, 0xFFC2);
REGISTER_HID_DETECTOR_IP("Corsair Harpoon RGB PRO", DetectCorsairPeripheralControllers, CORSAIR_VID, CORSAIR_HARPOON_RGB_PRO_PID, 1, 0xFFC2);
Controllers/CorsairPeripheralController/RGBController_CorsairPeripheral.cpp
+53 -2
View File
@@ -21,7 +21,7 @@ static unsigned int matrix_map[6][23] =
{ 5, 14, 23, NA, NA, NA, NA, 41, NA, NA, NA, NA, 69, 79, 89, 71, 90, 99, 108, 101, NA, 110, NA } };
static unsigned int matrix_map_k95_platinum[7][24] =
{ { NA, NA, NA, NA, 107, 8, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 16, NA, NA, NA,},
{ { NA, NA, NA, 119, 107, 8, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 16, NA, NA, NA,},
{ 113, 0, NA, 10, 18, 28, 36, NA, 46, 55, 64, 74, NA, 84, 93, 102, 6, 15, 24, 33, 26, 35, 44, 53 },
{ 114, 1, 11, 19, 29, 37, 47, 56, 65, 75, 85, 94, NA, 103, 7, 25, NA, 42, 51, 60, 62, 72, 82, 91 },
{ 115, 2, NA, 12, 20, 30, 38, NA, 48, 57, 66, 76, 86, 95, 104, 70, 80, 34, 43, 52, 9, 17, 27, 100 },
@@ -67,7 +67,7 @@ static const char* zone_names_k95_platinum[] =
static const unsigned int zone_sizes_k95_platinum[] =
{
119,
120,
19
};
@@ -95,6 +95,29 @@ static const zone_type zone_types_k95[] =
ZONE_TYPE_MATRIX
};
/*---------------------------------------------------------*\
| K55 |
\*---------------------------------------------------------*/
static const char* zone_names_k55[] =
{
"Left",
"Middle",
"Right",
};
static const unsigned int zone_sizes_k55[] =
{
1,
1,
1
};
static const zone_type zone_types_k55[] =
{
ZONE_TYPE_SINGLE,
ZONE_TYPE_SINGLE,
ZONE_TYPE_SINGLE
};
static const char* led_names[] =
{
@@ -334,6 +357,7 @@ static const char* led_names_k95_plat[] =
"Key: Macro G4",
"Key: Macro G5",
"Key: Macro G6",
"Key: Preset",
"Light Bar 1",
"Light Bar 2",
"Light Bar 3",
@@ -513,6 +537,13 @@ static const char* corsair_mouse_leds[] =
"Mouse LED 15",
};
static const char* led_names_k55[] =
{
"LEFT",
"MIDDLE",
"RIGHT",
};
static const char* corsair_m65_elite_leds[] =
{
"",
@@ -607,6 +638,8 @@ RGBController_CorsairPeripheral::~RGBController_CorsairPeripheral()
delete zones[zone_index].matrix_map;
}
}
delete corsair;
}
void RGBController_CorsairPeripheral::SetupZones()
@@ -625,6 +658,11 @@ void RGBController_CorsairPeripheral::SetupZones()
num_zones = 2;
break;
}
if (logical_layout == CORSAIR_TYPE_K55)
{
num_zones = 3;
break;
}
num_zones = 1;
break;
@@ -688,6 +726,15 @@ void RGBController_CorsairPeripheral::SetupZones()
new_zone.matrix_map = NULL;
}
}
else if (logical_layout == CORSAIR_TYPE_K55)
{
new_zone.name = zone_names_k55[zone_idx];
new_zone.type = zone_types_k55[zone_idx];
new_zone.leds_min = zone_sizes_k55[zone_idx];
new_zone.leds_max = zone_sizes_k55[zone_idx];
new_zone.leds_count = zone_sizes_k55[zone_idx];
new_zone.matrix_map = NULL;
}
else //default layout
{
new_zone.name = zone_names[zone_idx];
@@ -771,6 +818,10 @@ void RGBController_CorsairPeripheral::SetupZones()
{
new_led.name = led_names_k95[led_idx];
}
else if(logical_layout == CORSAIR_TYPE_K55)
{
new_led.name = led_names_k55[led_idx];
}
else
{
new_led.name = led_names[led_idx];
Controllers/CorsairVengeanceController/CorsairVengeanceControllerDetect.cpp
+9 -9
View File
@@ -52,7 +52,7 @@ bool TestForCorsairVengeanceController(i2c_smbus_interface* bus, unsigned char a
* *
\******************************************************************************************/
void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses)
{
CorsairVengeanceController* new_corsair;
RGBController_CorsairVengeance* new_controller;
@@ -66,7 +66,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
{
new_corsair = new CorsairVengeanceController(busses[bus], 0x58);
new_controller = new RGBController_CorsairVengeance(new_corsair);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x59
@@ -74,7 +74,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
{
new_corsair = new CorsairVengeanceController(busses[bus], 0x59);
new_controller = new RGBController_CorsairVengeance(new_corsair);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5A
@@ -82,7 +82,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
{
new_corsair = new CorsairVengeanceController(busses[bus], 0x5A);
new_controller = new RGBController_CorsairVengeance(new_corsair);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5B
@@ -90,7 +90,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
{
new_corsair = new CorsairVengeanceController(busses[bus], 0x5B);
new_controller = new RGBController_CorsairVengeance(new_corsair);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5C
@@ -98,7 +98,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
{
new_corsair = new CorsairVengeanceController(busses[bus], 0x5C);
new_controller = new RGBController_CorsairVengeance(new_corsair);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5D
@@ -106,7 +106,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
{
new_corsair = new CorsairVengeanceController(busses[bus], 0x5D);
new_controller = new RGBController_CorsairVengeance(new_corsair);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5E
@@ -114,7 +114,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
{
new_corsair = new CorsairVengeanceController(busses[bus], 0x5E);
new_controller = new RGBController_CorsairVengeance(new_corsair);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5F
@@ -122,7 +122,7 @@ void DetectCorsairVengeanceControllers(std::vector<i2c_smbus_interface*> &busses
{
new_corsair = new CorsairVengeanceController(busses[bus], 0x5F);
new_controller = new RGBController_CorsairVengeance(new_corsair);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
}
}
Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.cpp
+5
View File
@@ -43,6 +43,11 @@ RGBController_CorsairVengeance::RGBController_CorsairVengeance(CorsairVengeanceC
SetupZones();
}
RGBController_CorsairVengeance::~RGBController_CorsairVengeance()
{
delete corsair;
}
void RGBController_CorsairVengeance::SetupZones()
{
/*---------------------------------------------------------*\
Controllers/CorsairVengeanceController/RGBController_CorsairVengeance.h
+1
View File
@@ -16,6 +16,7 @@ class RGBController_CorsairVengeance : public RGBController
{
public:
RGBController_CorsairVengeance(CorsairVengeanceController* corsair_ptr);
~RGBController_CorsairVengeance();
void SetupZones();
Controllers/CorsairVengeanceProController/CorsairVengeanceProController.cpp
+63 -16
View File
@@ -20,6 +20,7 @@ CorsairVengeanceProController::CorsairVengeanceProController(i2c_smbus_interface
strcpy(device_name, "Corsair Vengeance Pro RGB");
led_count = CORSAIR_PRO_LED_COUNT;
direct_mode = false;
effect_mode = CORSAIR_PRO_MODE_STATIC;
for (unsigned int i = 0; i < led_count; i++)
@@ -79,20 +80,49 @@ void CorsairVengeanceProController::SetLEDColor(unsigned int led, unsigned char
void CorsairVengeanceProController::ApplyColors()
{
bus->i2c_smbus_write_byte_data(dev, 0x26, 0x02);
std::this_thread::sleep_for(1ms);
bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
std::this_thread::sleep_for(1ms);
for (int i = 0; i < 10; i++)
if(direct_mode)
{
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_red[i]);
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_green[i]);
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_blue[i]);
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
}
unsigned char full_packet[32];
unsigned char crc_packet[31];
bus->i2c_smbus_write_byte_data(dev, 0x82, 0x02);
full_packet[0] = 0x0A;
crc_packet[0] = 0x0A;
for (int i = 0; i < 10; i++)
{
crc_packet[(i * 3) + 1] = led_red[i];
full_packet[(i * 3) + 1] = led_red[i];
crc_packet[(i * 3) + 2] = led_green[i];
full_packet[(i * 3) + 2] = led_green[i];
crc_packet[(i * 3) + 3] = led_blue[i];
full_packet[(i * 3) + 3] = led_blue[i];
}
uint8_t footer = CRCPP::CRC::Calculate(crc_packet, 31, CRCPP::CRC::CRC_8());
full_packet[31] = footer;
bus->i2c_smbus_write_block_data(dev, CORSAIR_PRO_DIRECT_COMMAND, 32, full_packet);
}
else
{
bus->i2c_smbus_write_byte_data(dev, 0x26, 0x02);
std::this_thread::sleep_for(1ms);
bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
std::this_thread::sleep_for(1ms);
for (int i = 0; i < 10; i++)
{
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_red[i]);
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_green[i]);
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, led_blue[i]);
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, 0xFF);
}
bus->i2c_smbus_write_byte_data(dev, 0x82, 0x02);
}
}
void CorsairVengeanceProController::SetEffect(unsigned char mode,
@@ -107,8 +137,20 @@ void CorsairVengeanceProController::SetEffect(unsigned char mode,
unsigned char blu2
)
{
if(mode == effect_mode)
{
return;
}
effect_mode = mode;
direct_mode = (effect_mode == CORSAIR_PRO_MODE_DIRECT);
if(direct_mode)
{
return;
}
bus->i2c_smbus_write_byte_data(dev, 0x26, 0x01);
std::this_thread::sleep_for(1ms);
bus->i2c_smbus_write_byte_data(dev, 0x21, 0x00);
@@ -125,10 +167,10 @@ void CorsairVengeanceProController::SetEffect(unsigned char mode,
random_byte = CORSAIR_PRO_EFFECT_CUSTOM_COLORS;
}
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, effect_mode); //Mode
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, speed); //Speed
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, random_byte); //Custom color
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, direction); //Direction
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, effect_mode); // Mode
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, speed); // Speed
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, random_byte); // Custom color
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, direction); // Direction
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, red1); // Custom color 1 red
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, grn1); // Custom color 1 green
bus->i2c_smbus_write_byte_data(dev, CORSAIR_PRO_REG_COMMAND, blu1); // Custom color 1 blue
@@ -161,3 +203,8 @@ bool CorsairVengeanceProController::WaitReady()
return false;
}
void CorsairVengeanceProController::SetDirect(bool direct)
{
direct_mode = direct;
}
Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h
+16 -10
View File
@@ -9,6 +9,7 @@
#include <string>
#include "i2c_smbus.h"
#include "CRC.h"
#pragma once
@@ -19,20 +20,22 @@ typedef unsigned char corsair_dev_id;
enum
{
CORSAIR_PRO_REG_COMMAND = 0x20, /* Command write register */
CORSAIR_PRO_DIRECT_COMMAND = 0x31, /* Where it writes direct mode colors */
};
enum
{
CORSAIR_PRO_MODE_COLOR_SHIFT = 0x00, /* Color Shift mode */
CORSAIR_PRO_MODE_COLOR_PULSE = 0x01, /* Color Pulse mode */
CORSAIR_PRO_MODE_RAINBOW_WAVE = 0x03, /* Rainbow Wave mode */
CORSAIR_PRO_MODE_COLOR_WAVE = 0x04, /* Color Wave mode */
CORSAIR_PRO_MODE_VISOR = 0x05, /* Visor mode */
CORSAIR_PRO_MODE_RAIN = 0x06, /* Rain mode */
CORSAIR_PRO_MODE_MARQUEE = 0x07, /* Marquee mode */
CORSAIR_PRO_MODE_RAINBOW = 0x08, /* Rainbow mode */
CORSAIR_PRO_MODE_SEQUENTIAL = 0x09, /* Sequential mode */
CORSAIR_PRO_MODE_STATIC = 0x10, /* Static mode */
CORSAIR_PRO_MODE_DIRECT = 0xDD, /* Arbitrary value to compare against later. Not the actual packet */
CORSAIR_PRO_MODE_COLOR_SHIFT = 0x00, /* Color Shift mode */
CORSAIR_PRO_MODE_COLOR_PULSE = 0x01, /* Color Pulse mode */
CORSAIR_PRO_MODE_RAINBOW_WAVE = 0x03, /* Rainbow Wave mode */
CORSAIR_PRO_MODE_COLOR_WAVE = 0x04, /* Color Wave mode */
CORSAIR_PRO_MODE_VISOR = 0x05, /* Visor mode */
CORSAIR_PRO_MODE_RAIN = 0x06, /* Rain mode */
CORSAIR_PRO_MODE_MARQUEE = 0x07, /* Marquee mode */
CORSAIR_PRO_MODE_RAINBOW = 0x08, /* Rainbow mode */
CORSAIR_PRO_MODE_SEQUENTIAL = 0x09, /* Sequential mode */
CORSAIR_PRO_MODE_STATIC = 0x10, /* Static mode */
CORSAIR_PRO_NUMBER_MODES = 10, /* Number of Corsair Pro modes */
};
@@ -87,9 +90,12 @@ public:
void ApplyColors();
bool WaitReady();
void SetDirect(bool direct);
private:
char device_name[32];
unsigned int led_count;
bool direct_mode;
unsigned char effect_mode;
unsigned char led_red[CORSAIR_PRO_LED_COUNT];
unsigned char led_green[CORSAIR_PRO_LED_COUNT];
Controllers/CorsairVengeanceProController/CorsairVengeanceProControllerDetect.cpp
+9 -9
View File
@@ -60,7 +60,7 @@ bool TestForCorsairVengeanceProController(i2c_smbus_interface* bus, unsigned cha
* *
\******************************************************************************************/
void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &busses)
{
CorsairVengeanceProController* new_corsair_pro;
RGBController_CorsairVengeancePro* new_controller;
@@ -74,7 +74,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
{
new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x58);
new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x59
@@ -82,7 +82,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
{
new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x59);
new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5A
@@ -90,7 +90,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
{
new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5A);
new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5B
@@ -98,7 +98,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
{
new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5B);
new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5C
@@ -106,7 +106,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
{
new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5C);
new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5D
@@ -114,7 +114,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
{
new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5D);
new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5E
@@ -122,7 +122,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
{
new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5E);
new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
// Check for Corsair controller at 0x5F
@@ -130,7 +130,7 @@ void DetectCorsairVengeanceProControllers(std::vector<i2c_smbus_interface*> &bus
{
new_corsair_pro = new CorsairVengeanceProController(busses[bus], 0x5F);
new_controller = new RGBController_CorsairVengeancePro(new_corsair_pro);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
}
}
Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.cpp
+27 -1
View File
@@ -21,7 +21,7 @@ RGBController_CorsairVengeancePro::RGBController_CorsairVengeancePro(CorsairVeng
mode Direct;
Direct.name = "Direct";
Direct.value = CORSAIR_PRO_MODE_STATIC;
Direct.value = CORSAIR_PRO_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.speed_min = 0;
Direct.speed_max = 0;
@@ -29,6 +29,16 @@ RGBController_CorsairVengeancePro::RGBController_CorsairVengeancePro(CorsairVeng
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Static;
Static.name = "Static";
Static.value = CORSAIR_PRO_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.speed_min = 0;
Static.speed_max = 0;
Static.speed = 0;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode ColorShift;
ColorShift.name = "Color Shift";
ColorShift.value = CORSAIR_PRO_MODE_COLOR_SHIFT;
@@ -150,6 +160,11 @@ RGBController_CorsairVengeancePro::RGBController_CorsairVengeancePro(CorsairVeng
active_mode = 9;
}
RGBController_CorsairVengeancePro::~RGBController_CorsairVengeancePro()
{
delete corsair;
}
void RGBController_CorsairVengeancePro::SetupZones()
{
/*---------------------------------------------------------*\
@@ -269,6 +284,15 @@ void RGBController_CorsairVengeancePro::DeviceUpdateMode()
}
}
if (modes[active_mode].name == "Direct")
{
corsair->SetDirect(true);
}
else
{
corsair->SetDirect(false);
}
corsair->SetEffect(modes[active_mode].value,
modes[active_mode].speed,
corsair_direction,
@@ -279,4 +303,6 @@ void RGBController_CorsairVengeancePro::DeviceUpdateMode()
mode_colors[3],
mode_colors[4],
mode_colors[5]);
std::this_thread::sleep_for(std::chrono::milliseconds(15));
}
Controllers/CorsairVengeanceProController/RGBController_CorsairVengeancePro.h
+1
View File
@@ -16,6 +16,7 @@ class RGBController_CorsairVengeancePro : public RGBController
{
public:
RGBController_CorsairVengeancePro(CorsairVengeanceProController* corsair_ptr);
~RGBController_CorsairVengeancePro();
void SetupZones();
Controllers/CorsairWirelessController/CorsairWirelessController.cpp
+217
View File
@@ -0,0 +1,217 @@
/*-----------------------------------------*\
| CorsairWirelessController.cpp |
| |
| Driver for Corsair RGB wireless keyboard |
| lighting controller |
| |
| Adam Honse (CalcProgrammer1) 5/8/2021 |
\*-----------------------------------------*/
#include "CorsairWirelessController.h"
#include <cstring>
using namespace std::chrono_literals;
CorsairWirelessController::CorsairWirelessController(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
type = DEVICE_TYPE_KEYBOARD;
EnterDirectMode();
}
CorsairWirelessController::~CorsairWirelessController()
{
hid_close(dev);
}
device_type CorsairWirelessController::GetDeviceType()
{
return type;
}
std::string CorsairWirelessController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string CorsairWirelessController::GetFirmwareString()
{
return firmware_version;
}
std::string CorsairWirelessController::GetName()
{
return name;
}
std::string CorsairWirelessController::GetSerialString()
{
wchar_t serial_string[128];
hid_get_serial_number_string(dev, serial_string, 128);
std::wstring return_wstring = serial_string;
std::string return_string(return_wstring.begin(), return_wstring.end());
return(return_string);
}
void CorsairWirelessController::SetLEDs(std::vector<RGBColor>colors)
{
unsigned char buf[3 * 137];
for(int color = 0; color < 137; color++)
{
buf[0 + color] = RGBGetRValue(colors[color]);
buf[137 + color] = RGBGetGValue(colors[color]);
buf[274+color] = RGBGetBValue(colors[color]);
}
StartDirectMode();
SendDirectFrame(true, &buf[0]);
SendDirectFrame(false, &buf[57]);
SendDirectFrame(false, &buf[118]);
SendDirectFrame(false, &buf[179]);
SendDirectFrame(false, &buf[240]);
SendDirectFrame(false, &buf[301]);
SendDirectFrame(false, &buf[362]);
}
void CorsairWirelessController::SetLEDsKeyboardFull(std::vector<RGBColor> colors)
{
}
void CorsairWirelessController::SetName(std::string device_name)
{
name = device_name;
}
/*-------------------------------------------------------------------------------------------------*\
| Private packet sending functions. |
\*-------------------------------------------------------------------------------------------------*/
void CorsairWirelessController::EnterDirectMode()
{
char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Submit Mouse Colors packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x80;
usb_buf[0x02] = 0x01;
usb_buf[0x03] = 0x03;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = 0x02;
/*-----------------------------------------------------*\
| Send packet using feature reports, as headset stand |
| seems to not update completely using HID writes |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
}
void CorsairWirelessController::StartDirectMode()
{
char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Submit Mouse Colors packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x80;
usb_buf[0x02] = 0x0D;
usb_buf[0x03] = 0x00;
usb_buf[0x04] = 0x01;
/*-----------------------------------------------------*\
| Send packet using feature reports, as headset stand |
| seems to not update completely using HID writes |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
}
void CorsairWirelessController::ExitDirectMode()
{
char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Submit Mouse Colors packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x80;
usb_buf[0x02] = 0x01;
usb_buf[0x03] = 0x03;
usb_buf[0x04] = 0x00;
usb_buf[0x05] = 0x01;
/*-----------------------------------------------------*\
| Send packet using feature reports, as headset stand |
| seems to not update completely using HID writes |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
}
void CorsairWirelessController::SendDirectFrame(bool first_frame, unsigned char* data)
{
char usb_buf[65];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up Submit Mouse Colors packet |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x80;
usb_buf[0x02] = first_frame ? 0x06 : 0x07;
usb_buf[0x03] = 0x00;
if(first_frame)
{
usb_buf[0x04] = 0x9B;
usb_buf[0x05] = 0x01;
}
/*-----------------------------------------------------*\
| Copy in colors in <RED> <GREEN> <BLUE> order |
\*-----------------------------------------------------*/
if(first_frame)
{
memcpy(&usb_buf[0x08], data, 57);
}
else
{
memcpy(&usb_buf[0x04], data, 61);
}
/*-----------------------------------------------------*\
| Send packet using feature reports, as headset stand |
| seems to not update completely using HID writes |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 65);
}
Controllers/CorsairWirelessController/CorsairWirelessController.h
+45
View File
@@ -0,0 +1,45 @@
/*-----------------------------------------*\
| CorsairWirelessController.h |
| |
| Definitions and types for Corsair RGB |
| wireless keyboard lighting controller |
| |
| Adam Honse (CalcProgrammer1) 5/8/2021 |
\*-----------------------------------------*/
#include "RGBController.h"
#include <string>
#include <hidapi/hidapi.h>
#pragma once
class CorsairWirelessController
{
public:
CorsairWirelessController(hid_device* dev_handle, const char* path);
~CorsairWirelessController();
device_type GetDeviceType();
std::string GetDeviceLocation();
std::string GetFirmwareString();
std::string GetName();
std::string GetSerialString();
void SetLEDs(std::vector<RGBColor> colors);
void SetLEDsKeyboardFull(std::vector<RGBColor> colors);
void SetName(std::string device_name);
private:
hid_device* dev;
std::string firmware_version;
std::string location;
std::string name;
device_type type;
void EnterDirectMode();
void ExitDirectMode();
void StartDirectMode();
void SendDirectFrame(bool first_frame, unsigned char* data);
};
Controllers/CorsairWirelessController/CorsairWirelessControllerDetect.cpp
+50
View File
@@ -0,0 +1,50 @@
#include "Detector.h"
#include "CorsairWirelessController.h"
#include "RGBController.h"
#include "RGBController_CorsairWireless.h"
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
| Corsair vendor ID |
\*-----------------------------------------------------*/
#define CORSAIR_VID 0x1B1C
/*-----------------------------------------------------*\
| Keyboard product IDs |
\*-----------------------------------------------------*/
#define CORSAIR_K57_RGB_WIRED_PID 0x1B6E
#define CORSAIR_K57_RGB_WIRELESS_PID 0x1B62
/******************************************************************************************\
* *
* DetectCorsairWirelessControllers *
* *
* Tests the USB address to see if a Corsair RGB Keyboard controller exists there. *
* *
\******************************************************************************************/
void DetectCorsairWirelessControllers(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if( dev )
{
CorsairWirelessController* controller = new CorsairWirelessController(dev, info->path);
controller->SetName(name);
if(controller->GetDeviceType() != DEVICE_TYPE_UNKNOWN)
{
RGBController_CorsairWireless* rgb_controller = new RGBController_CorsairWireless(controller);
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
else
{
delete controller;
}
}
} /* DetectCorsairWirelessControllers() */
/*-----------------------------------------------------------------------------------------------------*\
| Keyboards |
\*-----------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_IPU("Corsair K57 RGB (Wired)", DetectCorsairWirelessControllers, CORSAIR_VID, CORSAIR_K57_RGB_WIRED_PID, 1, 0xFF42, 1);
//REGISTER_HID_DETECTOR_IPU("Corsair K57 RGB (Wireless)", DetectCorsairWirelessControllers, CORSAIR_VID, CORSAIR_K57_RGB_WIRELESS_PID, 1, 0xFF42, 1);
Controllers/CorsairWirelessController/RGBController_CorsairWireless.cpp
+326
View File
@@ -0,0 +1,326 @@
/*-----------------------------------------*\
| RGBController_CorsairWireless.cpp |
| |
| Generic RGB Interface for Corsair RGB |
| wireless keyboard devices |
| |
| Adam Honse (CalcProgrammer1) 5/8/2021 |
\*-----------------------------------------*/
#include "RGBController_CorsairWireless.h"
using namespace std::chrono_literals;
//0xFFFFFFFF indicates an unused entry in matrix
#define NA 0xFFFFFFFF
static unsigned int matrix_map[7][24] =
{ { NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 0, 1, NA, NA, NA },
{ 131, 41, NA, 58, 59, 60, 61, NA, 62, 63, 64, 65, NA, 66, 67, 68, 69, 70, 71, 72, NA, NA, NA, NA },
{ 132, 53, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, NA, 45, 46, 42, NA, 73, 74, 75, 83, 84, 85, 86 },
{ 133, 43, NA, 20, 26, 8, 21, NA, 23, 28, 24, 12, 18, 19, 47, 48, 49, 76, 77, 78, 95, 96, 97, 87 },
{ 134, 57, NA, 4, 22, 7, 9, NA, 10, 11, 13, 14, 15, 51, 52, NA, 40, NA, NA, NA, 92, 93, 94, NA },
{ 135, 106, NA, 29, 27, 6, 25, NA, 5, NA, 17, 16, 54, 55, 56, 110, NA, NA, 82, NA, 89, 90, 91, 88 },
{ 136, 105, 108, 107, NA, NA, NA, NA, 44, NA, NA, NA, NA, 111, 122, 101, 109, 80, 81, 79, 98, NA, 99, NA } };
static const char* zone_names[] =
{
"Keyboard",
};
static const unsigned int zone_sizes[] =
{
137
};
static const zone_type zone_types[] =
{
ZONE_TYPE_MATRIX,
};
static const char* led_names[] =
{
"Power/Wireless Indicator",
"Lock/Macro Indicator",
"N/A",
"N/A",
"Key: A",
"Key: B",
"Key: C",
"Key: D",
"Key: E",
"Key: F",
"Key: G",
"Key: H",
"Key: I",
"Key: J",
"Key: K",
"Key: L",
"Key: M",
"Key: N",
"Key: O",
"Key: P",
"Key: Q",
"Key: R",
"Key: S",
"Key: T",
"Key: U",
"Key: V",
"Key: W",
"Key: X",
"Key: Y",
"Key: Z",
"Key: 1",
"Key: 2",
"Key: 3",
"Key: 4",
"Key: 5",
"Key: 6",
"Key: 7",
"Key: 8",
"Key: 9",
"Key: 0",
"Key: Enter",
"Key: Escape",
"Key: Backspace",
"Key: Tab",
"Key: Space",
"Key: -",
"Key: =",
"Key: [",
"Key: ]",
"Key: \\ (ANSI)",
"Unused",
"Key: ;",
"Key: '",
"Key: `",
"Key: ,",
"Key: .",
"Key: /",
"Key: Caps Lock",
"Key: F1",
"Key: F2",
"Key: F3",
"Key: F4",
"Key: F5",
"Key: F6",
"Key: F7",
"Key: F8",
"Key: F9",
"Key: F10",
"Key: F11",
"Key: F12",
"Key: Print Screen",
"Key: Scroll Lock",
"Key: Pause/Break",
"Key: Insert",
"Key: Home",
"Key: Page Up",
"Key: Delete",
"Key: End",
"Key: Page Down",
"Key: Right Arrow",
"Key: Left Arrow",
"Key: Down Arrow",
"Key: Up Arrow",
"Key: Num Lock",
"Key: Number Pad /",
"Key: Number Pad *",
"Key: Number Pad -",
"Key: Number Pad +",
"Key: Number Pad Enter",
"Key: Number Pad 1",
"Key: Number Pad 2",
"Key: Number Pad 3",
"Key: Number Pad 4",
"Key: Number Pad 5",
"Key: Number Pad 6",
"Key: Number Pad 7",
"Key: Number Pad 8",
"Key: Number Pad 9",
"Key: Number Pad 0",
"Key: Number Pad .",
"Unused",
"Key: Menu",
"Unused",
"Unused",
"Unused",
"Left Control",
"Left Shift",
"Left Alt",
"Left Windows",
"Right Control",
"Right Shift",
"Right Alt",
"Unused",
"Unused",
"Unused",
"Unused",
"Unused",
"Unused",
"Unused",
"Unused",
"Unused",
"Unused",
"Key: Right Fn",
"Unused",
"Unused",
"Unused",
"Unused",
"Unused",
"Unused",
"Unused",
"Unused",
"Key: G1",
"Key: G2",
"Key: G3",
"Key: G4",
"Key: G5",
"Key: G6",
};
RGBController_CorsairWireless::RGBController_CorsairWireless(CorsairWirelessController* corsair_ptr)
{
corsair = corsair_ptr;
name = corsair->GetName();
vendor = "Corsair";
description = "Corsair RGB Peripheral Device";
type = corsair->GetDeviceType();
version = corsair->GetFirmwareString();
location = corsair->GetDeviceLocation();
serial = corsair->GetSerialString();
mode Direct;
Direct.name = "Direct";
Direct.value = 0;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
/*-----------------------------------------------------*\
| The Corsair Lighting Node Pro requires a packet within|
| 20 seconds of sending the lighting change in order |
| to not revert back into rainbow mode. Start a thread |
| to continuously send a keepalive packet every 5s |
\*-----------------------------------------------------*/
keepalive_thread_run = 1;
keepalive_thread = new std::thread(&RGBController_CorsairWireless::KeepaliveThread, this);
}
RGBController_CorsairWireless::~RGBController_CorsairWireless()
{
/*---------------------------------------------------------*\
| Delete the matrix map |
\*---------------------------------------------------------*/
for(unsigned int zone_index = 0; zone_index < zones.size(); zone_index++)
{
if(zones[zone_index].matrix_map != NULL)
{
delete zones[zone_index].matrix_map;
}
}
delete corsair;
}
void RGBController_CorsairWireless::SetupZones()
{
/*---------------------------------------------------------*\
| Determine number of zones |
| For now, keyboard has 2 zones and mousemat has 1 |
\*---------------------------------------------------------*/
unsigned int num_zones = 1;
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
unsigned int total_led_count = 0;
for(unsigned int zone_idx = 0; zone_idx < num_zones; zone_idx++)
{
zone new_zone;
new_zone.name = zone_names[zone_idx];
new_zone.type = zone_types[zone_idx];
new_zone.leds_min = zone_sizes[zone_idx];
new_zone.leds_max = zone_sizes[zone_idx];
new_zone.leds_count = zone_sizes[zone_idx];
if(zone_types[zone_idx] == ZONE_TYPE_MATRIX)
{
new_zone.matrix_map = new matrix_map_type;
new_zone.matrix_map->height = 7;
new_zone.matrix_map->width = 24;
new_zone.matrix_map->map = (unsigned int *)&matrix_map;
}
else
{
new_zone.matrix_map = NULL;
}
zones.push_back(new_zone);
total_led_count += new_zone.leds_count;
}
for(unsigned int led_idx = 0; led_idx < total_led_count; led_idx++)
{
led new_led;
new_led.name = led_names[led_idx];
leds.push_back(new_led);
}
SetupColors();
}
void RGBController_CorsairWireless::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_CorsairWireless::DeviceUpdateLEDs()
{
last_update_time = std::chrono::steady_clock::now();
corsair->SetLEDs(colors);
}
void RGBController_CorsairWireless::UpdateZoneLEDs(int /*zone*/)
{
corsair->SetLEDs(colors);
}
void RGBController_CorsairWireless::UpdateSingleLED(int /*led*/)
{
corsair->SetLEDs(colors);
}
void RGBController_CorsairWireless::SetCustomMode()
{
active_mode = 0;
}
void RGBController_CorsairWireless::DeviceUpdateMode()
{
}
void RGBController_CorsairWireless::KeepaliveThread()
{
while(keepalive_thread_run.load())
{
if(active_mode == 0)
{
if((std::chrono::steady_clock::now() - last_update_time) > std::chrono::milliseconds(5000))
{
DeviceUpdateLEDs();
}
}
std::this_thread::sleep_for(1000ms);
}
}
Controllers/CorsairWirelessController/RGBController_CorsairWireless.h
+41
View File
@@ -0,0 +1,41 @@
/*-----------------------------------------*\
| RGBController_CorsairWireless.h |
| |
| Generic RGB Interface for Corsair RGB |
| wireless keyboard devices |
| |
| Adam Honse (CalcProgrammer1) 5/8/2021 |
\*-----------------------------------------*/
#pragma once
#include "RGBController.h"
#include "CorsairWirelessController.h"
class RGBController_CorsairWireless : public RGBController
{
public:
RGBController_CorsairWireless(CorsairWirelessController* corsair_ptr);
~RGBController_CorsairWireless();
int physical_layout;
int logical_layout;
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
void KeepaliveThread();
private:
CorsairWirelessController* corsair;
std::thread* keepalive_thread;
std::atomic<bool> keepalive_thread_run;
std::chrono::time_point<std::chrono::steady_clock> last_update_time;
};
Controllers/CreativeController/CreativeControllerDetect.cpp
+30
View File
@@ -0,0 +1,30 @@
#include "CreativeSoundBlasterXG6Controller.h"
#include "RGBController_CreativeSoundBlasterXG6.h"
#include "Detector.h"
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
| Creative vendor ID |
\*-----------------------------------------------------*/
#define CREATIVE_VID 0x041E
/*-----------------------------------------------------*\
| SoundCards |
\*-----------------------------------------------------*/
#define CREATIVE_SOUNDBLASTERX_G6_PID 0x3256
void DetectCreativeDevice(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
CreativeSoundBlasterXG6Controller* controller = new CreativeSoundBlasterXG6Controller(dev, info->path);
RGBController_CreativeSoundBlasterXG6* rgb_controller = new RGBController_CreativeSoundBlasterXG6(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
/*-------------------------------------------------------------------------------------------------------------------------------------------------*\
| Sound Cards |
\*-------------------------------------------------------------------------------------------------------------------------------------------------*/
REGISTER_HID_DETECTOR_I("Creative SoundBlasterX G6", DetectCreativeDevice, CREATIVE_VID, CREATIVE_SOUNDBLASTERX_G6_PID, 4);
Controllers/CreativeController/CreativeSoundBlasterXG6Controller.cpp
+82
View File
@@ -0,0 +1,82 @@
#include "CreativeSoundBlasterXG6Controller.h"
CreativeSoundBlasterXG6Controller::CreativeSoundBlasterXG6Controller(hid_device* dev_handle, const char* path)
{
dev = dev_handle;
location = path;
}
CreativeSoundBlasterXG6Controller::~CreativeSoundBlasterXG6Controller()
{
hid_close(dev);
}
std::string CreativeSoundBlasterXG6Controller::GetDeviceLocation()
{
return("HID " + location);
}
void CreativeSoundBlasterXG6Controller::SetLedColor (unsigned char red, unsigned char green, unsigned char blue)
{
unsigned char usb_buf[64];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
//5A 3A 02 06 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
usb_buf[0x01] = 0x5A;
usb_buf[0x02] = 0x3A;
usb_buf[0x03] = 0x02;
usb_buf[0x04] = 0x06;
usb_buf[0x05] = 0x01;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 64);
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
//5A 3A 06 04 00 03 01 00 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
usb_buf[0x01] = 0x5A;
usb_buf[0x02] = 0x3A;
usb_buf[0x03] = 0x06;
usb_buf[0x04] = 0x04;
usb_buf[0x06] = 0x03;
usb_buf[0x07] = 0x01;
usb_buf[0x09] = 0x01;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 64);
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
//5A 3A 09 0A 00 03 01 01 FF BB GG RR
usb_buf[0x01] = 0x5A;
usb_buf[0x02] = 0x3A;
usb_buf[0x03] = 0x09;
usb_buf[0x04] = 0x0A;
usb_buf[0x06] = 0x03;
usb_buf[0x07] = 0x01;
usb_buf[0x08] = 0x01;
usb_buf[0x09] = 0x0FF;
usb_buf[0x0A] = blue;
usb_buf[0x0B] = green;
usb_buf[0x0C] = red;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
hid_write(dev, (unsigned char *)usb_buf, 64);
}
Controllers/CreativeController/CreativeSoundBlasterXG6Controller.h
+20
View File
@@ -0,0 +1,20 @@
#include "RGBController.h"
#include <cstring>
#include <hidapi/hidapi.h>
#pragma once
class CreativeSoundBlasterXG6Controller
{
public:
CreativeSoundBlasterXG6Controller(hid_device* dev_handle, const char* path);
~CreativeSoundBlasterXG6Controller();
void SetLedColor (unsigned char red, unsigned char green, unsigned char blue);
std::string GetDeviceLocation();
std::string GetSerialString();
private:
hid_device* dev;
std::string location;
};
Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.cpp
+81
View File
@@ -0,0 +1,81 @@
#include "RGBController_CreativeSoundBlasterXG6.h"
RGBController_CreativeSoundBlasterXG6::RGBController_CreativeSoundBlasterXG6(CreativeSoundBlasterXG6Controller* creative_device)
{
creative = creative_device;
name = "Creative SoundBlasterX G6 Device";
vendor = "Creative";
type = DEVICE_TYPE_HEADSET;
description = "Creative SoundBlasterX G6 Device";
location = creative_device->GetDeviceLocation();
serial = "";
mode Static;
Static.name = "Direct";
Static.value = 0;
Static.flags = MODE_COLORS_PER_LED;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
SetupZones();
}
RGBController_CreativeSoundBlasterXG6::~RGBController_CreativeSoundBlasterXG6()
{
delete creative;
}
void RGBController_CreativeSoundBlasterXG6::SetupZones()
{
zone logo_zone;
logo_zone.name = "Logo";
logo_zone.type = ZONE_TYPE_SINGLE;
logo_zone.leds_min = 1;
logo_zone.leds_max = 1;
logo_zone.leds_count = 1;
logo_zone.matrix_map = NULL;
zones.push_back(logo_zone);
led logo_led;
logo_led.name = "Logo";
leds.push_back(logo_led);
SetupColors();
}
void RGBController_CreativeSoundBlasterXG6::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_CreativeSoundBlasterXG6::DeviceUpdateLEDs()
{
unsigned char red = RGBGetRValue(colors[0]);
unsigned char grn = RGBGetGValue(colors[0]);
unsigned char blu = RGBGetBValue(colors[0]);
creative->SetLedColor(red, grn, blu);
}
void RGBController_CreativeSoundBlasterXG6::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_CreativeSoundBlasterXG6::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_CreativeSoundBlasterXG6::SetCustomMode()
{
active_mode = 0;
}
void RGBController_CreativeSoundBlasterXG6::DeviceUpdateMode()
{
DeviceUpdateLEDs();
}
Controllers/CreativeController/RGBController_CreativeSoundBlasterXG6.h
+24
View File
@@ -0,0 +1,24 @@
#pragma once
#include "RGBController.h"
#include "CreativeSoundBlasterXG6Controller.h"
class RGBController_CreativeSoundBlasterXG6: public RGBController
{
public:
RGBController_CreativeSoundBlasterXG6(CreativeSoundBlasterXG6Controller* creative_device);
~RGBController_CreativeSoundBlasterXG6();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
private:
CreativeSoundBlasterXG6Controller* creative;
};
Controllers/CrucialController/CrucialControllerDetect.cpp
+59 -2
View File
@@ -8,6 +8,8 @@
#include <stdio.h>
#include <stdlib.h>
using namespace std::chrono_literals;
/*----------------------------------------------------------------------*\
| This list contains the available SMBus addresses for Crucial RAM |
\*----------------------------------------------------------------------*/
@@ -15,6 +17,16 @@
static const unsigned char crucial_addresses[] =
{
/*-----------------------------------------------------*\
| These addresses have been disabled due to conflict |
| with ASUS Aura DRAM. Since the detection scheme is |
| the same, Aura RAM will be detected as Crucial. |
| We need to improve the Crucial detection scheme. |
\*-----------------------------------------------------*/
// 0x39,
// 0x3A,
// 0x3B,
// 0x3C,
0x20,
0x21,
0x22,
@@ -57,6 +69,15 @@ bool TestForCrucialController(i2c_smbus_interface* bus, unsigned char address)
} /* TestForCrucialController() */
void CrucialRegisterWrite(i2c_smbus_interface* bus, unsigned char dev, unsigned short reg, unsigned char val)
{
//Write Crucial register
bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF));
//Write Crucial value
bus->i2c_smbus_write_byte_data(dev, 0x01, val);
}
/******************************************************************************************\
* *
* DetectCrucialControllers *
@@ -68,15 +89,51 @@ bool TestForCrucialController(i2c_smbus_interface* bus, unsigned char address)
* *
\******************************************************************************************/
void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses, std::vector<RGBController*> &rgb_controllers)
void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses)
{
CrucialController* new_crucial;
RGBController_Crucial* new_controller;
for (unsigned int bus = 0; bus < busses.size(); bus++)
{
int address_list_idx = -1;
IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device)
{
// Remap Crucial RAM modules on 0x27
for (unsigned int slot = 0; slot < 4; slot++)
{
int res = busses[bus]->i2c_smbus_write_quick(0x27, I2C_SMBUS_WRITE);
if (res < 0)
{
break;
}
do
{
address_list_idx++;
if(address_list_idx < CRUCIAL_ADDRESS_COUNT)
{
res = busses[bus]->i2c_smbus_write_quick(crucial_addresses[address_list_idx], I2C_SMBUS_WRITE);
}
else
{
break;
}
} while (res >= 0);
if(address_list_idx < CRUCIAL_ADDRESS_COUNT)
{
CrucialRegisterWrite(busses[bus], 0x27, 0x82EE, slot);
CrucialRegisterWrite(busses[bus], 0x27, 0x82EF, (crucial_addresses[address_list_idx] << 1));
CrucialRegisterWrite(busses[bus], 0x27, 0x82F0, 0xF0);
}
std::this_thread::sleep_for(1ms);
}
// Add Crucial controllers
for (unsigned int address_list_idx = 0; address_list_idx < CRUCIAL_ADDRESS_COUNT; address_list_idx++)
{
@@ -84,7 +141,7 @@ void DetectCrucialControllers(std::vector<i2c_smbus_interface*> &busses, std::ve
{
new_crucial = new CrucialController(busses[bus], crucial_addresses[address_list_idx]);
new_controller = new RGBController_Crucial(new_crucial);
rgb_controllers.push_back(new_controller);
ResourceManager::get()->RegisterRGBController(new_controller);
}
}
}
Controllers/CrucialController/RGBController_Crucial.cpp
+5
View File
@@ -116,6 +116,11 @@ RGBController_Crucial::RGBController_Crucial(CrucialController * crucial_ptr)
SetupZones();
}
RGBController_Crucial::~RGBController_Crucial()
{
delete crucial;
}
void RGBController_Crucial::SetupZones()
{
/*---------------------------------------------------------*\

Some files were not shown because too many files have changed in this diff Show More