From f7af8a432e08c40824c91b701678e8a9b720fe81 Mon Sep 17 00:00:00 2001 From: Kasper Date: Wed, 11 Nov 2020 04:04:53 +0200 Subject: [PATCH] Implemented a qmk rgb matrix controller --- .../QMKRGBMatrixController.cpp | 465 ++++++++++++++ .../QMKRGBMatrixController.h | 129 ++++ .../QMKRGBMatrixControllerDetect.cpp | 81 +++ .../RGBController_QMKRGBMatrix.cpp | 568 ++++++++++++++++++ .../RGBController_QMKRGBMatrix.h | 31 + OpenRGB.pro | 6 + 6 files changed, 1280 insertions(+) create mode 100644 Controllers/QMKRGBMatrixController/QMKRGBMatrixController.cpp create mode 100644 Controllers/QMKRGBMatrixController/QMKRGBMatrixController.h create mode 100644 Controllers/QMKRGBMatrixController/QMKRGBMatrixControllerDetect.cpp create mode 100644 Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.cpp create mode 100644 Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.h diff --git a/Controllers/QMKRGBMatrixController/QMKRGBMatrixController.cpp b/Controllers/QMKRGBMatrixController/QMKRGBMatrixController.cpp new file mode 100644 index 000000000..3ba801857 --- /dev/null +++ b/Controllers/QMKRGBMatrixController/QMKRGBMatrixController.cpp @@ -0,0 +1,465 @@ +/*-------------------------------------------------------------------*\ +| QMKRGBMatrixController.cpp | +| | +| Driver for QMK keybaords using RGB Matrix | +| | +| Kasper 10th Octobber 2020 | +| | +\*-------------------------------------------------------------------*/ + +#include "QMKRGBMatrixController.h" + +QMKRGBMatrixController::QMKRGBMatrixController(hid_device* dev_handle, const char* path) +{ + dev = dev_handle; + location = path; +} + +QMKRGBMatrixController::~QMKRGBMatrixController() +{ + hid_close(dev); +} + +void QMKRGBMatrixController::SetSingleLED(unsigned int led, unsigned char red, unsigned char green, unsigned char blue) +{ + unsigned char usb_buf[65]; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_SET_SINGLE_LED; + usb_buf[0x02] = led; + usb_buf[0x03] = red; + usb_buf[0x04] = green; + usb_buf[0x05] = blue; + + /*-----------------------------------------------------*\ + | Send packet | + \*-----------------------------------------------------*/ + hid_write(dev, usb_buf, 65); + hid_read(dev, usb_buf, 65); +} + +void QMKRGBMatrixController::SetLEDs(RGBColor* colors, unsigned int num_colors) +{ + unsigned int leds_sent = 0; + + while(leds_sent < num_colors) + { + unsigned int leds_to_send = 2; + + if((num_colors - leds_sent) < leds_to_send) + { + leds_to_send = num_colors - leds_sent; + } + + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_SET_LEDS; + usb_buf[0x02] = leds_sent; + usb_buf[0x03] = leds_to_send; + + for(unsigned int led_idx = 0; led_idx < leds_to_send; led_idx++) + { + usb_buf[(led_idx * 3) + 4] = RGBGetRValue(colors[led_idx + leds_sent]); + usb_buf[(led_idx * 3) + 5] = RGBGetGValue(colors[led_idx + leds_sent]); + usb_buf[(led_idx * 3) + 6] = RGBGetBValue(colors[led_idx + leds_sent]); + } + + hid_write(dev, usb_buf, 65); + + leds_sent += leds_to_send; + } +} + +void QMKRGBMatrixController::SetMode(unsigned char mode) +{ + unsigned char usb_buf[65]; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_SET_MODE; + usb_buf[0x02] = QMK_RGBMATRIX_EEPROM_DONT_SAVE; + usb_buf[0x03] = mode; + + /*-----------------------------------------------------*\ + | Send packet | + \*-----------------------------------------------------*/ + hid_write(dev, usb_buf, 65); + hid_read(dev, usb_buf, 65); +} + +void QMKRGBMatrixController::SetModeAndSpeed(unsigned char mode, unsigned char speed) +{ + unsigned char usb_buf[65]; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_SET_MODE_AND_SPEED; + usb_buf[0x02] = QMK_RGBMATRIX_EEPROM_DONT_SAVE; + usb_buf[0x03] = mode; + usb_buf[0x04] = speed; + + /*-----------------------------------------------------*\ + | Send packet | + \*-----------------------------------------------------*/ + hid_write(dev, usb_buf, 65); + hid_read(dev, usb_buf, 65); +} + +void QMKRGBMatrixController::SetColorModeAndSpeed(hsv_t hsv_color, unsigned char mode, unsigned char speed) +{ + unsigned char usb_buf[65]; + + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_SET_COLOR_MODE_AND_SPEED; + usb_buf[0x02] = QMK_RGBMATRIX_EEPROM_DONT_SAVE; + + // qmk hue range is between 0-255, instead of the regular 0-359, so hue needs to be converted + unsigned int oldRange = 359; + unsigned int newRange = 255; + unsigned int convertedHue = (hsv_color.hue * newRange / oldRange); + + usb_buf[0x03] = convertedHue; + usb_buf[0x04] = hsv_color.saturation; + usb_buf[0x05] = hsv_color.value; + usb_buf[0x06] = mode; + usb_buf[0x07] = speed; + + /*-----------------------------------------------------*\ + | Send packet | + \*-----------------------------------------------------*/ + hid_write(dev, usb_buf, 65); + hid_read(dev, usb_buf, 65); +} + +std::string QMKRGBMatrixController::GetLocation() +{ + return location; +} + +std::string QMKRGBMatrixController::GetVersion() +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_QMK_VERSION; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + int i = 1; + std::string name; + while(usb_buf[i] != 0) + { + name.push_back(usb_buf[i]); + i++; + } + + return name; +} + +std::string QMKRGBMatrixController::GetName() +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_DEVICE_NAME; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + int i = 1; + std::string name; + while(usb_buf[i] != 0) + { + name.push_back(usb_buf[i]); + i++; + } + + return name; +} + +unsigned int QMKRGBMatrixController::GetZonesCount() +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_ZONES_COUNT; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + return usb_buf[1]; +} + +std::string QMKRGBMatrixController::GetZoneName(int zone) +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_ZONE_NAME; + usb_buf[0x02] = zone; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + int i = 1; + std::string name; + while(usb_buf[i] != 0) + { + name.push_back(usb_buf[i]); + i++; + } + + return name; +} + +unsigned int QMKRGBMatrixController::GetZoneType(int zone) +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_ZONE_TYPE; + usb_buf[0x02] = zone; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + return usb_buf[1]; +} + +unsigned int QMKRGBMatrixController::GetZoneSize(int zone) +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_ZONE_SIZE; + usb_buf[0x02] = zone; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + return usb_buf[1]; +} + +std::string QMKRGBMatrixController::GetLEDName(int led) +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_LED_NAME; + usb_buf[0x02] = led; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + int i = 1; + std::string name; + while(usb_buf[i] != 0) + { + name.push_back(usb_buf[i]); + i++; + } + + return name; +} + +unsigned int QMKRGBMatrixController::GetLEDMatirxRows() +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_LED_MATRIX_ROWS; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + return usb_buf[1]; +} + +unsigned int QMKRGBMatrixController::GetLEDMatirxColumns() +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_LED_MATRIX_COLUMNS; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + return usb_buf[1]; +} + +unsigned int QMKRGBMatrixController::GetLEDValueInMatrix(int column, int row) +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_LED_VALUE_IN_MATRIX; + usb_buf[0x02] = column; + usb_buf[0x03] = row; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + return usb_buf[1]; +} + +RGBColor QMKRGBMatrixController::GetLEDColor(unsigned int led) +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_LED_COLOR; + usb_buf[0x02] = led; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + return ToRGBColor(usb_buf[1], usb_buf[2], usb_buf[3]); +} + +unsigned int QMKRGBMatrixController::GetHSV() +{ + unsigned char usb_buf[65]; + /*-----------------------------------------------------*\ + | Zero out buffer | + \*-----------------------------------------------------*/ + memset(usb_buf, 0x00, sizeof(usb_buf)); + + /*-----------------------------------------------------*\ + | Set up config table request packet | + \*-----------------------------------------------------*/ + usb_buf[0x00] = 0x00; + usb_buf[0x01] = QMK_RGBMATRIX_GET_HSV; + + hid_write(dev, (unsigned char*)usb_buf, 65); + hid_read_timeout(dev, (unsigned char*)usb_buf, 65, 1000); + + // qmk hue range is between 0-255, instead of the regular 0-359, so hue needs to be converted + unsigned int oldRange = 255; + unsigned int newRange = 359; + unsigned int convertedHue = (usb_buf[1] * newRange / oldRange); + + hsv_t hsv; + hsv.hue = convertedHue; + hsv.saturation = usb_buf[2]; + hsv.value = usb_buf[3]; + + return hsv2rgb(&hsv); +} \ No newline at end of file diff --git a/Controllers/QMKRGBMatrixController/QMKRGBMatrixController.h b/Controllers/QMKRGBMatrixController/QMKRGBMatrixController.h new file mode 100644 index 000000000..da50a8731 --- /dev/null +++ b/Controllers/QMKRGBMatrixController/QMKRGBMatrixController.h @@ -0,0 +1,129 @@ +/*-------------------------------------------------------------------*\ +| QMKRGBMatrixController.h | +| | +| Driver for QMK keybaords using RGB Matrix | +| | +| Kasper 10th Octobber 2020 | +| | +\*-------------------------------------------------------------------*/ + +#include +#include +#include +#include "RGBController.h" +#include "hsv.h" + +#pragma once + +enum CommandsId +{ + QMK_RGBMATRIX_SET_SINGLE_LED = 3, + QMK_RGBMATRIX_SET_LEDS, + + QMK_RGBMATRIX_SET_MODE, + QMK_RGBMATRIX_SET_MODE_AND_SPEED, + QMK_RGBMATRIX_SET_COLOR_MODE_AND_SPEED, + + QMK_RGBMATRIX_GET_QMK_VERSION, + QMK_RGBMATRIX_GET_DEVICE_NAME, + QMK_RGBMATRIX_GET_ZONES_COUNT, + QMK_RGBMATRIX_GET_ZONE_NAME, + QMK_RGBMATRIX_GET_ZONE_TYPE, + QMK_RGBMATRIX_GET_ZONE_SIZE, + QMK_RGBMATRIX_GET_LED_NAME, + QMK_RGBMATRIX_GET_LED_MATRIX_COLUMNS, + QMK_RGBMATRIX_GET_LED_MATRIX_ROWS, + QMK_RGBMATRIX_GET_LED_VALUE_IN_MATRIX, + QMK_RGBMATRIX_GET_LED_COLOR, + QMK_RGBMATRIX_GET_HSV +}; + +enum EEPROMCommands +{ + QMK_RGBMATRIX_EEPROM_SAVE, + QMK_RGBMATRIX_EEPROM_DONT_SAVE +}; + +enum ModeCommands +{ + QMK_RGBMATRIX_MODE_HID_DIRECT = 1, + QMK_RGBMATRIX_MODE_STATIC, + QMK_RGBMATRIX_MODE_ALPHA_MOD, + QMK_RGBMATRIX_MODE_STATIC_GRADIENT_LEFT_RIGHT, + QMK_RGBMATRIX_MODE_STATIC_GRADIENT_UP_DOWN, + QMK_RGBMATRIX_MODE_BREATHING, + QMK_RGBMATRIX_MODE_BAND_SAT, + QMK_RGBMATRIX_MODE_BAND_VAL, + QMK_RGBMATRIX_MODE_BAND_PINWHEEL_SAT, + QMK_RGBMATRIX_MODE_BAND_PINWHEEL_VAL, + QMK_RGBMATRIX_MODE_BAND_SPIRAL_SAT, + QMK_RGBMATRIX_MODE_BAND_SPIRAL_VAL, + QMK_RGBMATRIX_MODE_CYCLE_ALL, + QMK_RGBMATRIX_MODE_CYCLE_LEFT_RIGHT, + QMK_RGBMATRIX_MODE_CYCLE_UP_DOWN, + QMK_RGBMATRIX_MODE_CYCLE_OUT_IN, + QMK_RGBMATRIX_MODE_CYCLE_OUT_IN_DUAL, + QMK_RGBMATRIX_MODE_RAINBOW_MOVING_CHEVRON, + QMK_RGBMATRIX_MODE_DUAL_BEACON, + QMK_RGBMATRIX_MODE_CYCLE_PINWHEEL, + QMK_RGBMATRIX_MODE_CYCLE_SPIRAL, + QMK_RGBMATRIX_MODE_RAINBOW_BEACON, + QMK_RGBMATRIX_MODE_RAINBOW_PINWHEELS, + QMK_RGBMATRIX_MODE_RAINDROPS, + QMK_RGBMATRIX_MODE_JELLYBEAN_RAINDROPS, + QMK_RGBMATRIX_MODE_TYPING_HEATMAP, + QMK_RGBMATRIX_MODE_DIGITAL_RAIN, + QMK_RGBMATRIX_MODE_SOLID_REACTIVE, + QMK_RGBMATRIX_MODE_SOLID_REACTIVE_SIMPLE, + QMK_RGBMATRIX_MODE_SOLID_REACTIVE_WIDE, + QMK_RGBMATRIX_MODE_SOLID_REACTIVE_MULTIWIDE, + QMK_RGBMATRIX_MODE_SOLID_REACTIVE_CROSS, + QMK_RGBMATRIX_MODE_SOLID_REACTIVE_MULTICROSS, + QMK_RGBMATRIX_MODE_SOLID_REACTIVE_NEXUS, + QMK_RGBMATRIX_MODE_SOLID_REACTIVE_MULTINEXUS, + QMK_RGBMATRIX_MODE_SPLASH, + QMK_RGBMATRIX_MODE_MULTISPLASH, + QMK_RGBMATRIX_MODE_SOLID_SPLASH, + QMK_RGBMATRIX_MODE_SOLID_MULTISPLASH, +}; + +enum SpeedCommands +{ + QMK_RGBMATRIX_SPEED_SLOWEST = 0x00, /* Slowest speed */ + QMK_RGBMATRIX_SPEED_NORMAL = 0x7F, /* Normal speed */ + QMK_RGBMATRIX_SPEED_FASTEST = 0xFF, /* Fastest speed */ +}; + +class QMKRGBMatrixController +{ +public: + QMKRGBMatrixController(hid_device* dev_handle, const char* path); + ~QMKRGBMatrixController(); + + void SetSingleLED(unsigned int led, unsigned char red, unsigned char green, unsigned char blue); + void SetLEDs(RGBColor* colors, unsigned int num_colors); + + void SetMode(unsigned char mode); + void SetModeAndSpeed(unsigned char mode, unsigned char speed); + void SetColorModeAndSpeed(hsv_t hsv_color, unsigned char mode, unsigned char speed); + + std::string GetLocation(); + + std::string GetVersion(); + std::string GetName(); + unsigned int GetZonesCount(); + std::string GetZoneName(int zone); + unsigned int GetZoneType(int zone); + unsigned int GetZoneSize(int zone); + std::string GetLEDName(int led); + unsigned int GetLEDMatirxRows(); + unsigned int GetLEDMatirxColumns(); + unsigned int GetLEDValueInMatrix(int column, int row); + RGBColor GetLEDColor(unsigned int led); + unsigned int GetHSV(); + +protected: + hid_device* dev; +private: + std::string location; +}; diff --git a/Controllers/QMKRGBMatrixController/QMKRGBMatrixControllerDetect.cpp b/Controllers/QMKRGBMatrixController/QMKRGBMatrixControllerDetect.cpp new file mode 100644 index 000000000..66db0ba27 --- /dev/null +++ b/Controllers/QMKRGBMatrixController/QMKRGBMatrixControllerDetect.cpp @@ -0,0 +1,81 @@ +/*-------------------------------------------------------------------*\ +| QMKRGBMatrixControllerDetect.cpp | +| | +| Driver for QMK keybaords using RGB Matrix | +| | +| Kasper24 11th November 2020 | +| | +\*-------------------------------------------------------------------*/ + +#include "Detector.h" +#include "QMKRGBMatrixController.h" +#include "RGBController.h" +#include "RGBController_QMKRGBMatrix.h" +#include + +#define MASSDROP_VID 0x04D8 +#define MASSDROP_ALT_PID 0xEED3 +#define MASSDROP_CTRL_PID 0xEED2 + +typedef struct +{ + unsigned short usb_vid; + unsigned short usb_pid; + unsigned char usb_interface; + const char * name; +} qmk_rgb_matrix_device; + +#define QMK_RGB_MATRIX_NUM_DEVICES (sizeof(device_list) / sizeof(device_list[ 0 ])) + +static const qmk_rgb_matrix_device device_list[] = +{ + { MASSDROP_VID, MASSDROP_ALT_PID, 1, "Massdrop Alt" }, + { MASSDROP_VID, MASSDROP_CTRL_PID, 1, "Massdrop Ctrl" }, +}; + +/******************************************************************************************\ +* * +* DetectQMKRGBMatrixControllers * +* * +* Tests the USB address to see if any QMK RGB Matrix controllers exists there. * +* * +\******************************************************************************************/ + +void DetectQMKRGBMatrixControllers(std::vector& rgb_controllers) +{ + hid_device_info* info; + hid_device* dev = NULL; + + hid_init(); + + for(std::size_t device_idx = 0; device_idx < QMK_RGB_MATRIX_NUM_DEVICES; device_idx++) + { + dev = NULL; + + info = hid_enumerate(device_list[device_idx].usb_vid, device_list[device_idx].usb_pid); + + while(info) + { + if + ( + info->vendor_id == device_list[device_idx].usb_vid && + info->product_id == device_list[device_idx].usb_pid && + info->interface_number == device_list[device_idx].usb_interface + ) + { + dev = hid_open_path(info->path); + if(dev) + { + QMKRGBMatrixController* controller = new QMKRGBMatrixController(dev, info->path); + + RGBController_QMKRGBMatrix* rgb_controller = new RGBController_QMKRGBMatrix(controller); + + rgb_controllers.push_back(rgb_controller); + } + } + info = info->next; + } + } +} + +REGISTER_DETECTOR("QMKRGBMatrix", DetectQMKRGBMatrixControllers); diff --git a/Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.cpp b/Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.cpp new file mode 100644 index 000000000..74693f381 --- /dev/null +++ b/Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.cpp @@ -0,0 +1,568 @@ +/*-------------------------------------------------------------------*\ +| RGBController_QMKRGBMatrix.cpp | +| | +| Driver for QMK keybaords using RGB Matrix | +| | +| Kasper24 11th November 2020 | +| | +\*-------------------------------------------------------------------*/ + +#include "hsv.h" +#include "RGBController_QMKRGBMatrix.h" + +RGBController_QMKRGBMatrix::RGBController_QMKRGBMatrix(QMKRGBMatrixController* qmk_rgb_matrix_ptr) +{ + qmk_rgb_matrix = qmk_rgb_matrix_ptr; + + name = qmk_rgb_matrix_ptr->GetName(); + description = "QMK RGB Matrix Device"; + type = DEVICE_TYPE_KEYBOARD; + location = qmk_rgb_matrix_ptr->GetLocation(); + version = qmk_rgb_matrix_ptr->GetVersion(); + + mode Direct; + Direct.name = "Direct"; + Direct.value = QMK_RGBMATRIX_MODE_HID_DIRECT; + 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 = QMK_RGBMATRIX_MODE_STATIC; + Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + Static.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + Static.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + Static.colors_min = 1; + Static.colors_max = 1; + Static.speed = QMK_RGBMATRIX_SPEED_NORMAL; + Static.color_mode = MODE_COLORS_MODE_SPECIFIC; + Static.colors.resize(1); + Static.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(Static); + + /*mode AlphaMod; + AlphaMod.name = "Alpha Mod"; + AlphaMod.value = QMK_RGBMATRIX_MODE_ALPHA_MOD; + AlphaMod.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_SPEED; + AlphaMod.color_mode = MODE_COLORS_PER_LED; + AlphaMod.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + AlphaMod.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + AlphaMod.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(AlphaMod); + + mode StaticHorizontalGradient; + StaticHorizontalGradient.name = "Static Horizontal Gradient"; + StaticHorizontalGradient.value = QMK_RGBMATRIX_MODE_STATIC_GRADIENT_LEFT_RIGHT; + StaticHorizontalGradient.flags = 0; + modes.push_back(StaticHorizontalGradient); + + mode StaticVerticalGradient; + StaticVerticalGradient.name = "Static Vertical Gradient"; + StaticVerticalGradient.value = QMK_RGBMATRIX_MODE_STATIC_GRADIENT_UP_DOWN; + StaticVerticalGradient.flags = 0; + modes.push_back(StaticVerticalGradient);*/ + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = QMK_RGBMATRIX_MODE_BREATHING; + Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + Breathing.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + Breathing.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + Breathing.colors_min = 1; + Breathing.colors_max = 1; + Breathing.speed = QMK_RGBMATRIX_SPEED_NORMAL; + Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + Breathing.colors.resize(1); + Breathing.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(Breathing); + + mode ScrollOnWhite; + ScrollOnWhite.name = "Scroll On White"; + ScrollOnWhite.value = QMK_RGBMATRIX_MODE_BAND_SAT; + ScrollOnWhite.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + ScrollOnWhite.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + ScrollOnWhite.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + ScrollOnWhite.colors_min = 1; + ScrollOnWhite.colors_max = 1; + ScrollOnWhite.speed = QMK_RGBMATRIX_SPEED_NORMAL; + ScrollOnWhite.color_mode = MODE_COLORS_MODE_SPECIFIC; + ScrollOnWhite.colors.resize(1); + ScrollOnWhite.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(ScrollOnWhite); + + mode Scroll; + Scroll.name = "Scroll"; + Scroll.value = QMK_RGBMATRIX_MODE_BAND_VAL; + Scroll.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + Scroll.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + Scroll.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + Scroll.colors_min = 1; + Scroll.colors_max = 1; + Scroll.speed = QMK_RGBMATRIX_SPEED_NORMAL; + Scroll.color_mode = MODE_COLORS_MODE_SPECIFIC; + Scroll.colors.resize(1); + Scroll.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(Scroll); + + mode PinWheelSpinOnWhite; + PinWheelSpinOnWhite.name = "PinWheel Spin On White"; + PinWheelSpinOnWhite.value = QMK_RGBMATRIX_MODE_BAND_PINWHEEL_SAT; + PinWheelSpinOnWhite.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + PinWheelSpinOnWhite.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + PinWheelSpinOnWhite.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + PinWheelSpinOnWhite.colors_min = 1; + PinWheelSpinOnWhite.colors_max = 1; + PinWheelSpinOnWhite.speed = QMK_RGBMATRIX_SPEED_NORMAL; + PinWheelSpinOnWhite.color_mode = MODE_COLORS_MODE_SPECIFIC; + PinWheelSpinOnWhite.colors.resize(1); + PinWheelSpinOnWhite.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(PinWheelSpinOnWhite); + + mode PinWheelSpin; + PinWheelSpin.name = "PinWheel Spin"; + PinWheelSpin.value = QMK_RGBMATRIX_MODE_BAND_PINWHEEL_VAL; + PinWheelSpin.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + PinWheelSpin.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + PinWheelSpin.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + PinWheelSpin.colors_min = 1; + PinWheelSpin.colors_max = 1; + PinWheelSpin.speed = QMK_RGBMATRIX_SPEED_NORMAL; + PinWheelSpin.color_mode = MODE_COLORS_MODE_SPECIFIC; + PinWheelSpin.colors.resize(1); + PinWheelSpin.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(PinWheelSpin); + + mode SpiralSpinOnWhite; + SpiralSpinOnWhite.name = "Spiral Spin On White"; + SpiralSpinOnWhite.value = QMK_RGBMATRIX_MODE_BAND_SPIRAL_SAT; + SpiralSpinOnWhite.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SpiralSpinOnWhite.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SpiralSpinOnWhite.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SpiralSpinOnWhite.colors_min = 1; + SpiralSpinOnWhite.colors_max = 1; + SpiralSpinOnWhite.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SpiralSpinOnWhite.color_mode = MODE_COLORS_MODE_SPECIFIC; + SpiralSpinOnWhite.colors.resize(1); + SpiralSpinOnWhite.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(SpiralSpinOnWhite); + + mode SpiralSpin; + SpiralSpin.name = "Spiral Spin"; + SpiralSpin.value = QMK_RGBMATRIX_MODE_BAND_SPIRAL_VAL; + SpiralSpin.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SpiralSpin.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SpiralSpin.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SpiralSpin.colors_min = 1; + SpiralSpin.colors_max = 1; + SpiralSpin.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SpiralSpin.color_mode = MODE_COLORS_MODE_SPECIFIC; + SpiralSpin.colors.resize(1); + SpiralSpin.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(SpiralSpin); + + mode ColorCycle; + ColorCycle.name = "Color Cycle"; + ColorCycle.value = QMK_RGBMATRIX_MODE_CYCLE_ALL; + ColorCycle.flags = MODE_FLAG_HAS_SPEED; + ColorCycle.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + ColorCycle.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + ColorCycle.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(ColorCycle); + + mode RainbowHorizontal; + RainbowHorizontal.name = "Rainbow Horizontal"; + RainbowHorizontal.value = QMK_RGBMATRIX_MODE_CYCLE_LEFT_RIGHT; + RainbowHorizontal.flags = MODE_FLAG_HAS_SPEED; + RainbowHorizontal.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + RainbowHorizontal.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + RainbowHorizontal.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(RainbowHorizontal); + + mode RainbowVertical; + RainbowVertical.name = "Rainbow Vertical"; + RainbowVertical.value = QMK_RGBMATRIX_MODE_CYCLE_UP_DOWN; + RainbowVertical.flags = MODE_FLAG_HAS_SPEED; + RainbowVertical.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + RainbowVertical.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + RainbowVertical.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(RainbowVertical); + + mode RainbowOutIn; + RainbowOutIn.name = "Rainbow Out In"; + RainbowOutIn.value = QMK_RGBMATRIX_MODE_CYCLE_OUT_IN; + RainbowOutIn.flags = MODE_FLAG_HAS_SPEED; + RainbowOutIn.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + RainbowOutIn.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + RainbowOutIn.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(RainbowOutIn); + + mode RainbowOutInDual; + RainbowOutInDual.name = "Rainbow Out In Dual"; + RainbowOutInDual.value = QMK_RGBMATRIX_MODE_CYCLE_OUT_IN_DUAL; + RainbowOutInDual.flags = MODE_FLAG_HAS_SPEED; + RainbowOutInDual.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + RainbowOutInDual.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + RainbowOutInDual.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(RainbowOutInDual); + + mode RainbowMovingChevron; + RainbowMovingChevron.name = "Rainbow Moving Chevron"; + RainbowMovingChevron.value = QMK_RGBMATRIX_MODE_RAINBOW_MOVING_CHEVRON; + RainbowMovingChevron.flags = MODE_FLAG_HAS_SPEED; + RainbowMovingChevron.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + RainbowMovingChevron.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + RainbowMovingChevron.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(RainbowMovingChevron); + + mode RainbowDualBeacon; + RainbowDualBeacon.name = "Rainbow Dual Beacons"; + RainbowDualBeacon.value = QMK_RGBMATRIX_MODE_DUAL_BEACON; + RainbowDualBeacon.flags = MODE_FLAG_HAS_SPEED; + RainbowDualBeacon.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + RainbowDualBeacon.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + RainbowDualBeacon.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(RainbowDualBeacon); + + mode RainbowPinWheel; + RainbowPinWheel.name = "Rainbow Pin Wheel"; + RainbowPinWheel.value = QMK_RGBMATRIX_MODE_CYCLE_PINWHEEL; + RainbowPinWheel.flags = MODE_FLAG_HAS_SPEED; + RainbowPinWheel.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + RainbowPinWheel.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + RainbowPinWheel.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(RainbowPinWheel); + + mode RainbowCycleSpiral; + RainbowCycleSpiral.name = "Rainbow Spiral"; + RainbowCycleSpiral.value = QMK_RGBMATRIX_MODE_CYCLE_SPIRAL; + RainbowCycleSpiral.flags = MODE_FLAG_HAS_SPEED; + RainbowCycleSpiral.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + RainbowCycleSpiral.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + RainbowCycleSpiral.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(RainbowCycleSpiral); + + mode RainbowBeacon; + RainbowBeacon.name = "Rainbow Beacon"; + RainbowBeacon.value = QMK_RGBMATRIX_MODE_RAINBOW_BEACON; + RainbowBeacon.flags = MODE_FLAG_HAS_SPEED; + RainbowBeacon.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + RainbowBeacon.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + RainbowBeacon.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(RainbowBeacon); + + mode RainbowDualPinWheels; + RainbowDualPinWheels.name = "Rainbow Dual Pin Wheels"; + RainbowDualPinWheels.value = QMK_RGBMATRIX_MODE_RAINBOW_PINWHEELS; + RainbowDualPinWheels.flags = MODE_FLAG_HAS_SPEED; + RainbowDualPinWheels.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + RainbowDualPinWheels.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + RainbowDualPinWheels.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(RainbowDualPinWheels); + + mode Raindrops; + Raindrops.name = "Raindrops"; + Raindrops.value = QMK_RGBMATRIX_MODE_RAINDROPS; + Raindrops.flags = 0; + modes.push_back(Raindrops); + + mode JellybeanRaindrops; + JellybeanRaindrops.name = "Jellybean Raindrops"; + JellybeanRaindrops.value = QMK_RGBMATRIX_MODE_JELLYBEAN_RAINDROPS; + JellybeanRaindrops.flags = 0; + modes.push_back(JellybeanRaindrops); + + mode TypingHeatmap; + TypingHeatmap.name = "Typing Heatmap"; + TypingHeatmap.value = QMK_RGBMATRIX_MODE_TYPING_HEATMAP; + TypingHeatmap.flags = 0; + modes.push_back(TypingHeatmap); + + mode DigitalRain; + DigitalRain.name = "Digital Rain"; + DigitalRain.value = QMK_RGBMATRIX_MODE_DIGITAL_RAIN; + DigitalRain.flags = 0; + modes.push_back(DigitalRain); + + mode SolidReactive; + SolidReactive.name = "Solid Reactive"; + SolidReactive.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE; + SolidReactive.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SolidReactive.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SolidReactive.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SolidReactive.colors_min = 1; + SolidReactive.colors_max = 1; + SolidReactive.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SolidReactive.color_mode = MODE_COLORS_MODE_SPECIFIC; + SolidReactive.colors.resize(1); + SolidReactive.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(SolidReactive); + + mode SolidReactiveSimple; + SolidReactiveSimple.name = "Solid Reactive Simple"; + SolidReactiveSimple.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_SIMPLE; + SolidReactiveSimple.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SolidReactiveSimple.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SolidReactiveSimple.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SolidReactiveSimple.colors_min = 1; + SolidReactiveSimple.colors_max = 1; + SolidReactiveSimple.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SolidReactiveSimple.color_mode = MODE_COLORS_MODE_SPECIFIC; + SolidReactiveSimple.colors.resize(1); + SolidReactiveSimple.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(SolidReactiveSimple); + + mode SolidReactiveWide; + SolidReactiveWide.name = "Solid Reactive Wide"; + SolidReactiveWide.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_WIDE; + SolidReactiveWide.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SolidReactiveWide.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SolidReactiveWide.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SolidReactiveWide.colors_min = 1; + SolidReactiveWide.colors_max = 1; + SolidReactiveWide.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SolidReactiveWide.color_mode = MODE_COLORS_MODE_SPECIFIC; + SolidReactiveWide.colors.resize(1); + SolidReactiveWide.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(SolidReactiveWide); + + + /*mode SolidReactiveMultiWide; + SolidReactiveMultiWide.name = "Solid Reactive Multi Wide"; + SolidReactiveMultiWide.value = QMK_RGBMATRIX_MODE_BREATHING; + SolidReactiveMultiWide.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SolidReactiveMultiWide.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SolidReactiveMultiWide.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SolidReactiveMultiWide.colors_min = 2; + SolidReactiveMultiWide.colors_max = 2; + SolidReactiveMultiWide.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SolidReactiveMultiWide.color_mode = MODE_COLORS_MODE_SPECIFIC; + SolidReactiveMultiWide.colors.resize(2); + modes.push_back(SolidReactiveMultiWide);*/ + + mode SolidReactiveCross; + SolidReactiveCross.name = "Solid Reactive Cross"; + SolidReactiveCross.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_CROSS; + SolidReactiveCross.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SolidReactiveCross.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SolidReactiveCross.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SolidReactiveCross.colors_min = 1; + SolidReactiveCross.colors_max = 1; + SolidReactiveCross.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SolidReactiveCross.color_mode = MODE_COLORS_MODE_SPECIFIC; + SolidReactiveCross.colors.resize(1); + SolidReactiveCross.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(SolidReactiveCross); + + /*mode SolidReactiveMultiCross; + SolidReactiveMultiCross.name = "Solid Reactive Multi Cross"; + SolidReactiveMultiCross.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_MULTICROSS; + SolidReactiveMultiCross.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SolidReactiveMultiCross.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SolidReactiveMultiCross.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SolidReactiveMultiCross.colors_min = 2; + SolidReactiveMultiCross.colors_max = 2; + SolidReactiveMultiCross.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SolidReactiveMultiCross.color_mode = MODE_COLORS_MODE_SPECIFIC; + SolidReactiveMultiCross.colors.resize(2); + modes.push_back(SolidReactiveMultiCross)*/ + + mode SolidReactiveNexus; + SolidReactiveNexus.name = "Solid Reactive Nexus"; + SolidReactiveNexus.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_NEXUS; + SolidReactiveNexus.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SolidReactiveNexus.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SolidReactiveNexus.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SolidReactiveNexus.colors_min = 1; + SolidReactiveNexus.colors_max = 1; + SolidReactiveNexus.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SolidReactiveNexus.color_mode = MODE_COLORS_MODE_SPECIFIC; + SolidReactiveNexus.colors.resize(1); + SolidReactiveNexus.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(SolidReactiveNexus); + + /*mode SolidReactiveMultiNexus; + SolidReactiveMultiNexus.name = "Solid Reactive Multi Nexus"; + SolidReactiveMultiNexus.value = QMK_RGBMATRIX_MODE_SOLID_REACTIVE_MULTINEXUS; + SolidReactiveMultiNexus.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SolidReactiveMultiNexus.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SolidReactiveMultiNexus.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SolidReactiveMultiNexus.colors_min = 2; + SolidReactiveMultiNexus.colors_max = 2; + SolidReactiveMultiNexus.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SolidReactiveMultiNexus.color_mode = MODE_COLORS_MODE_SPECIFIC; + SolidReactiveMultiNexus.colors.resize(2); + modes.push_back(SolidReactiveMultiNexus);*/ + + mode Splash; + Splash.name = "Rainbow Reactive Splash"; + Splash.value = QMK_RGBMATRIX_MODE_SPLASH; + Splash.flags = MODE_FLAG_HAS_SPEED; + Splash.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + Splash.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + Splash.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(Splash); + + /*mode MultiSplash; + MultiSplash.name = "Rainbow Reactive Multi Splash"; + MultiSplash.value = QMK_RGBMATRIX_MODE_MULTISPLASH; + MultiSplash.flags = MODE_FLAG_HAS_SPEED; + MultiSplash.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + MultiSplash.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + MultiSplash.speed = QMK_RGBMATRIX_SPEED_NORMAL; + modes.push_back(MultiSplash);*/ + + mode SolidSplash; + SolidSplash.name = "Solid Reactive Splash"; + SolidSplash.value = QMK_RGBMATRIX_MODE_SOLID_SPLASH; + SolidSplash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SolidSplash.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SolidSplash.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SolidSplash.colors_min = 1; + SolidSplash.colors_max = 1; + SolidSplash.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SolidSplash.color_mode = MODE_COLORS_MODE_SPECIFIC; + SolidSplash.colors.resize(1); + SolidSplash.colors[0] = qmk_rgb_matrix->GetHSV(); + modes.push_back(SolidSplash); + + /*mode SolidMultiSplash; + SolidMultiSplash.name = "Solid Reactive Multi Splash"; + SolidMultiSplash.value = QMK_RGBMATRIX_MODE_SOLID_MULTISPLASH; + SolidMultiSplash.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR; + SolidMultiSplash.speed_min = QMK_RGBMATRIX_SPEED_SLOWEST; + SolidMultiSplash.speed_max = QMK_RGBMATRIX_SPEED_FASTEST; + SolidMultiSplash.colors_min = 2; + SolidMultiSplash.colors_max = 2; + SolidMultiSplash.speed = QMK_RGBMATRIX_SPEED_NORMAL; + SolidMultiSplash.color_mode = MODE_COLORS_MODE_SPECIFIC; + SolidMultiSplash.colors.resize(2); + modes.push_back(SolidMultiSplash);*/ + + SetupZones(); +} + +RGBController_QMKRGBMatrix::~RGBController_QMKRGBMatrix() +{ + 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; + } + } +} + +void RGBController_QMKRGBMatrix::SetupZones() +{ + int led_index = 0; + int zone_count = qmk_rgb_matrix->GetZonesCount(); + + for(int i = 0; i < zone_count; i++) + { + unsigned int zone_led_count = qmk_rgb_matrix->GetZoneSize(i); + + zone keyboard_zone; + keyboard_zone.name = qmk_rgb_matrix->GetZoneName(i); + keyboard_zone.type = qmk_rgb_matrix->GetZoneType(i); + keyboard_zone.leds_min = zone_led_count; + keyboard_zone.leds_max = zone_led_count; + keyboard_zone.leds_count = zone_led_count; + + if(keyboard_zone.type == ZONE_TYPE_MATRIX) + { + unsigned int led_matrix_columns = qmk_rgb_matrix->GetLEDMatirxColumns(); + unsigned int led_matrix_rows = qmk_rgb_matrix->GetLEDMatirxRows(); + + keyboard_zone.matrix_map = new matrix_map_type; + keyboard_zone.matrix_map->height = led_matrix_columns; + keyboard_zone.matrix_map->width = led_matrix_rows; + + unsigned int* matrix_map = new unsigned int[led_matrix_rows * led_matrix_columns]; + for(unsigned int y = 0; y < led_matrix_columns; y++) + { + for(unsigned int x = 0; x < led_matrix_rows; x++) + { + matrix_map[led_matrix_rows * y + x] = qmk_rgb_matrix->GetLEDValueInMatrix(y, x); + } + } + + keyboard_zone.matrix_map->map = matrix_map; + } + else + { + keyboard_zone.matrix_map = NULL; + } + + zones.push_back(keyboard_zone); + + for(std::size_t led_idx = 0; led_idx < zone_led_count; led_idx++) + { + led keyboard_led; + keyboard_led.name = qmk_rgb_matrix->GetLEDName(led_index); + leds.push_back(keyboard_led); + led_index++; + } + } + + SetupColors(); + + for(int i = 0; i < led_index; i++) + { + colors[i] = qmk_rgb_matrix->GetLEDColor(i); + } +} + +void RGBController_QMKRGBMatrix::ResizeZone(int /*zone*/, int /*new_size*/) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_QMKRGBMatrix::DeviceUpdateLEDs() +{ + for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++) + { + qmk_rgb_matrix->SetLEDs(zones[zone_idx].colors, zones[zone_idx].leds_count); + } +} + +void RGBController_QMKRGBMatrix::UpdateZoneLEDs(int /*zone*/) +{ + DeviceUpdateLEDs(); +} + +void RGBController_QMKRGBMatrix::UpdateSingleLED(int led) +{ + RGBColor color = colors[led]; + unsigned char red = RGBGetRValue(color); + unsigned char grn = RGBGetGValue(color); + unsigned char blu = RGBGetBValue(color); + qmk_rgb_matrix->SetSingleLED(led, red, grn, blu); +} + +void RGBController_QMKRGBMatrix::SetCustomMode() +{ + active_mode = 0; +} + +void RGBController_QMKRGBMatrix::DeviceUpdateMode() +{ + if(modes[active_mode].color_mode == MODE_COLORS_PER_LED) + { + qmk_rgb_matrix->SetMode(modes[active_mode].value); + } + else if(modes[active_mode].color_mode == MODE_COLORS_NONE) + { + qmk_rgb_matrix->SetModeAndSpeed(modes[active_mode].value, modes[active_mode].speed); + } + else if(modes[active_mode].color_mode == MODE_COLORS_MODE_SPECIFIC) + { + RGBColor color = modes[active_mode].colors[0]; + hsv_t hsv_color; + rgb2hsv(color, &hsv_color); + qmk_rgb_matrix->SetColorModeAndSpeed(hsv_color, modes[active_mode].value, modes[active_mode].speed); + } +} + diff --git a/Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.h b/Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.h new file mode 100644 index 000000000..8382750a8 --- /dev/null +++ b/Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.h @@ -0,0 +1,31 @@ +/*-------------------------------------------------------------------*\ +| RGBController_QMKRGBMatrix.h | +| | +| Driver for QMK keybaords using RGB Matrix | +| | +| Kasper24 11th November 2020 | +| | +\*-------------------------------------------------------------------*/ + +#pragma once +#include "RGBController.h" +#include "QMKRGBMatrixController.h" + +class RGBController_QMKRGBMatrix : public RGBController +{ +public: + RGBController_QMKRGBMatrix(QMKRGBMatrixController* qmk_rgb_matrix_ptr); + ~RGBController_QMKRGBMatrix(); + + void SetupZones(); + void ResizeZone(int zone, int new_size); + + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + + void SetCustomMode(); + void DeviceUpdateMode(); +private: + QMKRGBMatrixController* qmk_rgb_matrix; +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index f983b32cd..79d8fe15e 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -90,6 +90,7 @@ INCLUDEPATH += Controllers/PhilipsWizController/ \ Controllers/PolychromeController/ \ Controllers/PoseidonZRGBController/ \ + Controllers/QMKRGBMatrixController/ \ Controllers/RedragonController/ \ Controllers/RGBFusionController/ \ Controllers/RGBFusion2DRAMController/ \ @@ -234,6 +235,8 @@ HEADERS += Controllers/PolychromeController/RGBController_Polychrome.h \ Controllers/PoseidonZRGBController/PoseidonZRGBController.h \ Controllers/PoseidonZRGBController/RGBController_PoseidonZRGB.h \ + Controllers/QMKRGBMatrixController/QMKRGBMatrixController.h \ + Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.h \ Controllers/RedragonController/RedragonK556Controller.h \ Controllers/RedragonController/RedragonM711Controller.h \ Controllers/RedragonController/RGBController_RedragonK556.h \ @@ -437,6 +440,9 @@ SOURCES += Controllers/PoseidonZRGBController/PoseidonZRGBController.cpp \ Controllers/PoseidonZRGBController/PoseidonZRGBControllerDetect.cpp \ Controllers/PoseidonZRGBController/RGBController_PoseidonZRGB.cpp \ + Controllers/QMKRGBMatrixController/QMKRGBMatrixController.cpp \ + Controllers/QMKRGBMatrixController/QMKRGBMatrixControllerDetect.cpp \ + Controllers/QMKRGBMatrixController/RGBController_QMKRGBMatrix.cpp \ Controllers/RedragonController/RedragonK556Controller.cpp \ Controllers/RedragonController/RedragonM711Controller.cpp \ Controllers/RedragonController/RedragonControllerDetect.cpp \