jalr/OpenRGB
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial commit for the EK Loop Connect Support

Browse source 
* Implemented Static & Breathing modes
This commit is contained in:
Chris 2020-07-16 10:33:01 +10:00 • committed by Adam Honse
parent 607d83b795
commit 95ded7b871
8 changed files with 402 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Controllers/CoolerMasterController/CMMP750Controller.h
View file

@ -20,7 +20,7 @@
#pragma once
#define CM_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data) / sizeof(colour_mode_data[0]))
#define CM_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
#define CM_INTERRUPT_TIMEOUT 250
#define CM_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
#define CM_SERIAL_SIZE (sizeof(serial) / sizeof(serial[ 0 ]))

88
Controllers/EKController/EKController.cpp Normal file
View file

@ -0,0 +1,88 @@
/*-------------------------------------------------------------------*\
| EKController.cpp |
| |
| Driver for EK Loop Connect |
| |
| Chris M (Dr_No) 16th Jul 2020 |
| |
\*-------------------------------------------------------------------*/
#include "EKController.h"
EKController::EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path)
{
int tmp_size = wcslen(_vendor);
dev = dev_handle;
for(int i=0; (i < tmp_size) && (i < EK_DEVICE_NAME_SIZE); i++)
{
device_name[i] = (char)_vendor[i];
}
for(int j=0; (j < wcslen(_vendor)) && ((tmp_size + j) < EK_DEVICE_NAME_SIZE); j++)
{
device_name[tmp_size+j] = (char)_device_name[j];
}
location = _path;
current_mode = EK_MODE_STATIC;
current_speed = EK_SPEED_NORMAL;
}
EKController::~EKController()
{
hid_close(dev);
}
char* EKController::GetDeviceName()
{
return device_name;
}
char* EKController::GetSerial()
{
return serial;
}
std::string EKController::GetLocation()
{
return location;
}
void EKController::SetMode(unsigned char mode, unsigned char speed)
{
current_mode = mode;
current_speed = speed;
SendUpdate();
}
void EKController::SetColor(unsigned char red, unsigned char green, unsigned char blue)
{
current_red = red;
current_green = green;
current_blue = blue;
SendUpdate();
}
void EKController::SendUpdate()
{
unsigned char buffer[EK_PACKET_LENGTH] = { 0x00 };
int buffer_size = (sizeof(buffer) / sizeof(buffer[0]));
for(int i = 0; i < EK_COLOUR_MODE_DATA_SIZE; i++)
{
buffer[i] = colour_mode_data[current_mode][i];
}
//Set the relevant colour info
buffer[EK_RED_BYTE] = current_red;
buffer[EK_GREEN_BYTE] = current_green;
buffer[EK_BLUE_BYTE] = current_blue;
buffer[EK_SPEED_BYTE] = speed_mode_data[current_mode][current_speed];
hid_write(dev, buffer, buffer_size);
}

103
Controllers/EKController/EKController.h Normal file
View file

@ -0,0 +1,103 @@
/*-------------------------------------------------------------------*\
| EKController.h |
| |
| Driver for EK Loop Connect |
| |
| Chris M (Dr_No) 16th Jul 2020 |
| |
\*-------------------------------------------------------------------*/
#ifndef EKCONTROLLER_H
#define EKCONTROLLER_H
#include <string>
#include <hidapi/hidapi.h>
#define EK_COLOUR_MODE_DATA_SIZE (sizeof(colour_mode_data[0]) / sizeof(colour_mode_data[0][0]))
#define EK_DEVICE_NAME_SIZE (sizeof(device_name) / sizeof(device_name[ 0 ]))
#define EK_PACKET_LENGTH 0x3F
enum
{
EK_MODE_BYTE = 12,
EK_SPEED_BYTE = 14,
EK_RED_BYTE = 16,
EK_GREEN_BYTE = 17,
EK_BLUE_BYTE = 18
};
enum
{
EK_MODE_STATIC = 0x00, //Static Mode
EK_MODE_BREATHING = 0x01, //Breathing Mode
EK_MODE_FADING = 0x02, //Fading Mode
EK_MODE_MARQUEE = 0x03, //Marquee Mode
EK_MODE_COVERING_MARQUEE = 0x04 //Covering Marquee Mode
};
static unsigned char colour_mode_data[][16] =
{
{ 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
0x00, 0x10, 0x20, 0x01, 0x01, 0x00, 0xFF, 0x64}, /* Static */
{ 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
0x00, 0x10, 0x20, 0x01, 0x02, 0x00, 0xFF, 0x64}, /* Breathing */
{ 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
0x00, 0x10, 0x20, 0x01, 0x03, 0x00, 0xFF, 0x64}, /* Fading */
{ 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
0x00, 0x10, 0x20, 0x01, 0x04, 0x00, 0xFF, 0x64}, /* Marquee */
{ 0x10, 0x12, 0x29, 0xAA, 0x01, 0x10, 0xA2, 0x60,
0x00, 0x10, 0x20, 0x01, 0x05, 0x00, 0xFF, 0x64}, /* Covering Marquee */
};
static unsigned char speed_mode_data[][9] =
{
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },// Static
{ 0x40, 0x38, 0x30, 0x28, 0x20, 0x18, 0x10, 0x08, 0x00 },// Breathing
{ 0x40, 0x38, 0x30, 0x28, 0x20, 0x18, 0x10, 0x08, 0x00 },// Fading
{ 0x40, 0x38, 0x30, 0x28, 0x20, 0x18, 0x10, 0x08, 0x00 },// Marquee
{ 0x40, 0x38, 0x30, 0x28, 0x20, 0x18, 0x10, 0x08, 0x00 } // Covering Marquee
};
enum
{
EK_SPEED_SLOWEST = 0x00, // Slowest speed
EK_SPEED_SLOWER = 0x01, // Slower speed
EK_SPEED_SLOW = 0x02, // Slow speed
EK_SPEED_SLOWISH = 0x03, // Slowish speed
EK_SPEED_NORMAL = 0x04, // Normal speed
EK_SPEED_FASTISH = 0x05, // Fastish speed
EK_SPEED_FAST = 0x06, // Fast speed
EK_SPEED_FASTER = 0x07, // Faster speed
EK_SPEED_FASTEST = 0x08, // Fastest speed
};
class EKController
{
public:
EKController(hid_device* dev_handle, wchar_t *_vendor, wchar_t *_device_name, char *_path);
~EKController();
char* GetDeviceName();
char* GetSerial();
std::string GetLocation();
void SetMode(unsigned char mode, unsigned char speed);
void SetColor(unsigned char red, unsigned char green, unsigned char blue);
private:
char device_name[32];
char serial[32];
std::string location;
hid_device* dev;
unsigned char current_mode;
unsigned char current_speed;
unsigned char current_red;
unsigned char current_green;
unsigned char current_blue;
void SendUpdate();
};
#endif // EKCONTROLLER_H

64
Controllers/EKController/EKControllerdetect.cpp Normal file
View file

@ -0,0 +1,64 @@
#include "EKController.h"
#include "RGBController.h"
#include "RGBController_EKController.h"
#include <hidapi/hidapi.h>
#define EK_VID 0x0483
#define EK_LOOP_CONNECT 0x5750
#define EK_NUM_DEVICES (sizeof(ek_pids) / sizeof(ek_pids[ 0 ]))
enum
{
EK_PID = 0,
EK_INTERFACE = 1
};
static const unsigned int ek_pids[][2] =
{ // PID, Interface
{ EK_LOOP_CONNECT, 0x00 } //EK Loop Connect
};
/******************************************************************************************\
* *
* DetectEKControllers *
* *
* Tests the USB address to see if any EK Controllers exists there. *
* *
\******************************************************************************************/
void DetectEKControllers(std::vector<RGBController*>& rgb_controllers)
{
hid_device_info* info;
//Look for the passed in cm_pids
hid_init();
info = hid_enumerate(0x0, 0x0);
while(info)
{
hid_device* dev = NULL;
if(info->vendor_id == EK_VID)
{
for(int ek_pid_idx = 0; ek_pid_idx < EK_NUM_DEVICES; ek_pid_idx++)
{
if((info->product_id == ek_pids[ek_pid_idx][EK_PID])
&&(info->interface_number == ek_pids[ek_pid_idx][EK_INTERFACE]))
{
dev = hid_open_path(info->path);
break;
}
}
}
if(dev)
{
EKController* controller = new EKController(dev, info->manufacturer_string, info->product_string, info->path);
RGBController_EKController* rgb_controller = new RGBController_EKController(controller);
rgb_controllers.push_back(rgb_controller);
}
info = info->next;
}
hid_free_enumeration(info);
}

2
OpenRGB.cpp
View file

@ -450,6 +450,7 @@ void DetectNZXTKrakenControllers(std::vector<RGBController*>& rgb_controllers);
void DetectSteelSeriesControllers(std::vector<RGBController*>& rgb_controllers);
void DetectGloriousModelOControllers(std::vector<RGBController*>& rgb_controllers);
void DetectDuckyKeyboardControllers(std::vector<RGBController*>& rgb_controllers);
void DetectEKControllers(std::vector<RGBController*>& rgb_controllers);
/******************************************************************************************\
* *
@ -504,6 +505,7 @@ void DetectRGBControllers(void)
DetectSteelSeriesControllers(rgb_controllers);
DetectGloriousModelOControllers(rgb_controllers);
DetectDuckyKeyboardControllers(rgb_controllers);
DetectEKControllers(rgb_controllers);
DetectE131Controllers(rgb_controllers);

5
OpenRGB.pro
View file

@ -122,6 +122,7 @@ HEADERS += \
Controllers/CorsairVengeanceProController/CorsairVengeanceProController.h \
Controllers/CrucialController/CrucialController.h \
Controllers/DuckyKeyboardController/DuckyKeyboardController.h \
Controllers/EKController/EKController.h \
Controllers/GloriousModelOController/GloriousModelOController.h \
Controllers/HuePlusController/HuePlusController.h \
Controllers/HyperXDRAMController/HyperXDRAMController.h \
@ -166,6 +167,7 @@ HEADERS += \
RGBController/RGBController_Crucial.h \
RGBController/RGBController_DuckyKeyboard.h \
RGBController/RGBController_Dummy.h \
RGBController/RGBController_EKController.h \
RGBController/RGBController_E131.h \
RGBController/RGBController_GloriousModelO.h \
RGBController/RGBController_HuePlus.h \
@ -252,6 +254,8 @@ SOURCES += \
Controllers/CrucialController/CrucialControllerDetect.cpp \
Controllers/DuckyKeyboardController/DuckyKeyboardController.cpp \
Controllers/DuckyKeyboardController/DuckyKeyboardControllerDetect.cpp \
Controllers/EKController/EKControllerDetect.cpp \
Controllers/EKController/EKController.cpp \
Controllers/GloriousModelOController/GloriousModelOController.cpp \
Controllers/GloriousModelOController/GloriousModelOControllerDetect.cpp \
Controllers/HuePlusController/HuePlusController.cpp \
@ -321,6 +325,7 @@ SOURCES += \
RGBController/RGBController_Crucial.cpp \
RGBController/RGBController_DuckyKeyboard.cpp \
RGBController/RGBController_Dummy.cpp \
RGBController/RGBController_EKController.cpp \
RGBController/RGBController_GloriousModelO.cpp \
RGBController/RGBController_HuePlus.cpp \
RGBController/RGBController_HyperXAlloyOrigins.cpp \

104
RGBController/RGBController_EKController.cpp Normal file
View file

@ -0,0 +1,104 @@
/*-------------------------------------------------------------------*\
| RGBController_EKController.cpp |
| |
| Driver for EK Loop Connect |
| |
| Chris M (Dr_No) 16th Jul 2020 |
| |
\*-------------------------------------------------------------------*/
#include "RGBController_EKController.h"
RGBController_EKController::RGBController_EKController(EKController* _dev)
{
EK_dev = _dev;
name = EK_dev->GetDeviceName();
type = DEVICE_TYPE_LEDSTRIP;
description = EK_dev->GetDeviceName();
version = "1.0";
serial = EK_dev->GetSerial();
location = EK_dev->GetLocation();
mode Static;
Static.name = "Static";
Static.value = EK_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 = EK_MODE_BREATHING;
Breathing.flags = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.speed_min = EK_SPEED_SLOWEST;
Breathing.speed_max = EK_SPEED_FASTEST;
Breathing.color_mode = MODE_COLORS_PER_LED;
Breathing.speed = EK_SPEED_NORMAL;
modes.push_back(Breathing);
SetupZones();
}
RGBController_EKController::~RGBController_EKController()
{
}
void RGBController_EKController::SetupZones()
{
zone EK_zone;
EK_zone.name = "Loop Connect";
EK_zone.type = ZONE_TYPE_SINGLE;
EK_zone.leds_min = 1;
EK_zone.leds_max = 1;
EK_zone.leds_count = 1;
EK_zone.matrix_map = NULL;
zones.push_back(EK_zone);
led EK_led;
EK_led.name = "EK LED";
leds.push_back(EK_led);
SetupColors();
}
void RGBController_EKController::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| ToDo |
\*---------------------------------------------------------*/
}
void RGBController_EKController::DeviceUpdateLEDs()
{
unsigned char red = RGBGetRValue(colors[0]);
unsigned char grn = RGBGetGValue(colors[0]);
unsigned char blu = RGBGetBValue(colors[0]);
EK_dev->SetColor(red, grn, blu);
}
void RGBController_EKController::UpdateZoneLEDs(int zone)
{
RGBColor color = colors[zone];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
EK_dev->SetColor(red, grn, blu);
}
void RGBController_EKController::UpdateSingleLED(int led)
{
UpdateZoneLEDs(led);
}
void RGBController_EKController::SetCustomMode()
{
active_mode = 0;
}
void RGBController_EKController::UpdateMode()
{
EK_dev->SetMode(modes[active_mode].value, modes[active_mode].speed);
}

35
RGBController/RGBController_EKController.h Normal file
View file

@ -0,0 +1,35 @@
/*-------------------------------------------------------------------*\
| RGBController_EKController.h |
| |
| Driver for EK Loop Connect |
| |
| Chris M (Dr_No) 16th Jul 2020 |
| |
\*-------------------------------------------------------------------*/
#ifndef RGBCONTROLLER_EKCONTROLLER_H
#define RGBCONTROLLER_EKCONTROLLER_H
#include "RGBController.h"
#include "Controllers/EKController/EKController.h"
class RGBController_EKController : public RGBController
{
public:
RGBController_EKController(EKController *_dev);
~RGBController_EKController();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void UpdateMode();
private:
EKController* EK_dev;
};
#endif // RGBCONTROLLER_EKCONTROLLER_H