mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-01-25 23:47:56 -05:00
Code Issues Packages Projects Releases Wiki Activity

Revert MSI Mystic Light 162-byte controller to release_0.6 tag version

Browse Source
This commit is contained in:
Adam Honse
2023-11-22 00:17:06 -06:00
parent a5b4938bbb
commit 564bbd9fda
5 changed files with 239 additions and 625 deletions
Download Patch File Download Diff File Expand all files Collapse all files

407
Controllers/MSIMysticLightController/MSIMysticLight162Controller.cpp
View File

@@ -13,78 +13,7 @@
#include <array>
#include <bitset>
#define BITSET(val, bit, pos) ((unsigned char)std::bitset<8>(val).set((pos), (bit)).to_ulong())
struct mystic_light_162_config
{
unsigned short pid; // PID of the board
size_t numof_onboard_leds; // number of onboard leds
const std::vector<MSI_ZONE>* supported_zones; // pointer to vector of supported zones
};
const std::vector<MSI_ZONE> zones_set0 =
{
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RGB_2,
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_J_CORSAIR,
MSI_ZONE_ON_BOARD_LED_0
};
const std::vector<MSI_ZONE> zones_set1 =
{
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RGB_2,
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_ON_BOARD_LED_0
};
const std::vector<MSI_ZONE> zones_set2 =
{
MSI_ZONE_J_RGB_1,
MSI_ZONE_J_RGB_2,
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_J_RAINBOW_2,
MSI_ZONE_ON_BOARD_LED_0
};
const std::vector<MSI_ZONE> zones_set3 =
{
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_ON_BOARD_LED_0
};
/*-----------------------------------------------------------------------------------------------------------------------------*\
| Definition of the board sepcific configurations (number of onboard LEDs and supported zones). |
| |
| Only tested boards are listed here (refer to MSIMysticLightControllerDetect.cpp). If more boards |
| are tested the list must be extended here. Otherwise the default settings will be used (7 onboard LEDs, all zones supported). |
| Boards with yet unknown supported zones are configured to support all zones. |
\*-----------------------------------------------------------------------------------------------------------------------------*/
#define NUMOF_CONFIGS (sizeof(board_configs) / sizeof(mystic_light_162_config))
static const mystic_light_162_config board_configs[] =
{
{ 0x1720, 10, &zones_set0 }, // MPG Z390 GAMING EDGE AC
{ 0x7B12, 10, &zones_set0 }, // MEG Z390 ACE
{ 0x7B17, 10, &zones_set0 }, // MPG Z390 GAMING PRO CARBON
{ 0x7B18, 6, &zones_set1 }, // MAG Z390 TOMAHAWK
{ 0x7B50, 6, &zones_set2 }, // MPG Z390M GAMING EDGE AC
{ 0x7B85, 7, &zones_set0 }, // B450 GAMING PRO CARBON
{ 0xB926, 3, &zones_set3 }, // MPG B460 TRIDENT AS
};
MSIMysticLight162Controller::MSIMysticLight162Controller
(
hid_device* handle,
const char *path,
unsigned short pid
)
MSIMysticLight162Controller::MSIMysticLight162Controller(hid_device* handle, const char *path)
{
dev = handle;
@@ -102,64 +31,6 @@ MSIMysticLight162Controller::MSIMysticLight162Controller
| Initialize save flag |
\*-----------------------------------------*/
data.save_data = 0;
data.on_board_led.colorFlags = 0x81; // force MS bit of color flags to 1 to have expectd zone control
/*-----------------------------------------*\
| Initialize zone based per LED data |
\*-----------------------------------------*/
const mystic_light_162_config* board_config = nullptr;
for(std::size_t i = 0; i < NUMOF_CONFIGS; ++i)
{
if (board_configs[i].pid == pid)
{
board_config = &board_configs[i];
break;
}
}
if(board_config != nullptr)
{
numof_onboard_leds = board_config->numof_onboard_leds;
supported_zones = board_config->supported_zones;
}
else
{
numof_onboard_leds = 10;
supported_zones = &zones_set0;
}
zone_based_per_led_data.j_rgb_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.j_rgb_1.colorFlags = BITSET(zone_based_per_led_data.j_rgb_1.colorFlags, true, 7u);
zone_based_per_led_data.j_rainbow_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.j_rainbow_1.colorFlags = BITSET(zone_based_per_led_data.j_rainbow_1.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led.colorFlags = BITSET(zone_based_per_led_data.on_board_led.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_1.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_1.colorFlags = BITSET(zone_based_per_led_data.on_board_led_1.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_2.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_2.colorFlags = BITSET(zone_based_per_led_data.on_board_led_2.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_3.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_3.colorFlags = BITSET(zone_based_per_led_data.on_board_led_3.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_4.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_4.colorFlags = BITSET(zone_based_per_led_data.on_board_led_4.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_5.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_5.colorFlags = BITSET(zone_based_per_led_data.on_board_led_5.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_6.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2 << 2;
zone_based_per_led_data.on_board_led_6.colorFlags = BITSET(zone_based_per_led_data.on_board_led_6.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_7.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100;
zone_based_per_led_data.on_board_led_7.colorFlags = BITSET(zone_based_per_led_data.on_board_led_7.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_8.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_8.colorFlags = BITSET(zone_based_per_led_data.on_board_led_8.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_9.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_9.colorFlags = BITSET(zone_based_per_led_data.on_board_led_9.colorFlags, true, 7u);
zone_based_per_led_data.on_board_led_10.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.on_board_led_10.colorFlags = BITSET(zone_based_per_led_data.on_board_led_9.colorFlags, true, 7u);
zone_based_per_led_data.j_rgb_2.speedAndBrightnessFlags = MSI_BRIGHTNESS_LEVEL_100 << 2;
zone_based_per_led_data.j_rgb_2.colorFlags = BITSET(zone_based_per_led_data.j_rgb_2.colorFlags, true, 7u);
zone_based_per_led_data.save_data = 0;
direct_mode = false;
}
MSIMysticLight162Controller::~MSIMysticLight162Controller()
@@ -169,51 +40,23 @@ MSIMysticLight162Controller::~MSIMysticLight162Controller()
void MSIMysticLight162Controller::SetMode
(
MSI_ZONE zone,
MSI_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
bool rainbow_color
MSI_ZONE zone,
MSI_MODE mode,
MSI_SPEED speed,
MSI_BRIGHTNESS brightness,
bool rainbow_color
)
{
ZoneData* zone_data = GetZoneData(data, zone);
if(zone_data == nullptr)
ZoneData* zoneData = GetZoneData(zone);
if(!zoneData)
{
return;
}
if (zone <= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data->effect = mode;
zone_data->speedAndBrightnessFlags = (brightness << 2) | (speed & 0x03);
zone_data->colorFlags = BITSET(zone_data->colorFlags, !rainbow_color, 7u);
zone_data->padding = 0x00;
if(mode > MSI_MODE_DOUBLE_FLASHING)
{
zone_data->speedAndBrightnessFlags |= SYNC_SETTING_JRGB;
zone_data->colorFlags |= SYNC_SETTING_ONBOARD;
}
else
{
zone_data->speedAndBrightnessFlags &= ~SYNC_SETTING_JRGB;
zone_data->colorFlags &= ~SYNC_SETTING_ONBOARD;
}
}
if((zone >= MSI_ZONE_ON_BOARD_LED_0) && (mode <= MSI_MODE_DOUBLE_FLASHING))
{
zone_data = GetZoneData(data, (MSI_ZONE)((int)zone + 1));
if(zone_data != nullptr)
{
zone_data->effect = mode;
zone_data->speedAndBrightnessFlags = (brightness << 2) | (speed & 0x03);
zone_data->colorFlags = BITSET(zone_data->colorFlags, !rainbow_color, 7u);
zone_data->padding = 0x00;
}
}
zoneData->effect = mode;
zoneData->speedAndBrightnessFlags = ( brightness << 2 ) | ( speed & 0x03 );
zoneData->colorFlags = 0x00;// BitSet(zoneData->colorFlags, !rainbow_color, 7u);
zoneData->padding = 0x00;
}
std::string MSIMysticLight162Controller::GetDeviceName()
@@ -243,145 +86,99 @@ bool MSIMysticLight162Controller::ReadSettings()
/*-----------------------------------------------------*\
| Read packet from hardware, return true if successful |
\*-----------------------------------------------------*/
return(hid_get_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof data);
return(hid_get_feature_report(dev, (unsigned char *)&data, sizeof(data)) == sizeof data);
}
bool MSIMysticLight162Controller::Update
(
bool save
)
bool MSIMysticLight162Controller::Update()
{
/*-----------------------------------------------------*\
| Send packet to hardware, return true if successful |
\*-----------------------------------------------------*/
if(direct_mode)
{
return (hid_send_feature_report(dev, (unsigned char*)&zone_based_per_led_data, sizeof(zone_based_per_led_data)) == sizeof(zone_based_per_led_data));
}
else
{
data.save_data = save;
return (hid_send_feature_report(dev, (unsigned char*)&data, sizeof(data)) == sizeof(data));
}
return(hid_send_feature_report(dev, (unsigned char *)&data, sizeof(data)) == sizeof data);
}
void MSIMysticLight162Controller::SetZoneColor
void MSIMysticLight162Controller::SetLEDColor
(
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
MSI_ZONE zone,
unsigned char red1,
unsigned char grn1,
unsigned char blu1,
unsigned char red2,
unsigned char grn2,
unsigned char blu2
)
{
ZoneData* zone_data = GetZoneData(data, zone);
ZoneData* zoneData = GetZoneData(zone);
if(zone_data == nullptr)
if(!zoneData)
{
return;
}
if (zone <= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data->color.R = red1;
zone_data->color.G = grn1;
zone_data->color.B = blu1;
zone_data->color2.R = red2;
zone_data->color2.G = grn2;
zone_data->color2.B = blu2;
}
zoneData->color.R = red1;
zoneData->color.G = grn1;
zoneData->color.B = blu1;
if(zone >= MSI_ZONE_ON_BOARD_LED_0)
{
zone_data = GetZoneData(data, (MSI_ZONE)((int)zone + 1));
if(zone_data != nullptr)
{
zone_data->color.R = red1;
zone_data->color.G = grn1;
zone_data->color.B = blu1;
zone_data->color2.R = red2;
zone_data->color2.G = grn2;
zone_data->color2.B = blu2;
}
}
}
void MSIMysticLight162Controller::SetLedColor
(
MSI_ZONE zone,
unsigned char red,
unsigned char grn,
unsigned char blu
)
{
if(zone >= MSI_ZONE_ON_BOARD_LED_0)
{
zone = (MSI_ZONE)((int)zone + 1);
}
ZoneData *zone_data = GetZoneData(zone_based_per_led_data, zone);
if(zone_data == nullptr)
{
return;
}
zone_data->color.R = red;
zone_data->color.G = grn;
zone_data->color.B = blu;
zone_data->color2.R = red;
zone_data->color2.G = grn;
zone_data->color2.B = blu;
zoneData->color2.R = red2;
zoneData->color2.G = grn2;
zoneData->color2.B = blu2;
}
ZoneData *MSIMysticLight162Controller::GetZoneData
(
FeaturePacket_162& data_packet,
MSI_ZONE zone
)
{
switch(zone)
{
case MSI_ZONE_J_RGB_1:
return &data.j_rgb_1;
case MSI_ZONE_J_RGB_2:
return &data.j_rgb_2;
case MSI_ZONE_J_RAINBOW_1:
return &data.j_rainbow_1;
case MSI_ZONE_ON_BOARD_LED_0:
return &data.on_board_led;
case MSI_ZONE_ON_BOARD_LED_1:
return &data.on_board_led_1;
case MSI_ZONE_ON_BOARD_LED_2:
return &data.on_board_led_2;
case MSI_ZONE_ON_BOARD_LED_3:
return &data.on_board_led_3;
case MSI_ZONE_ON_BOARD_LED_4:
return &data.on_board_led_4;
case MSI_ZONE_ON_BOARD_LED_5:
return &data.on_board_led_5;
case MSI_ZONE_ON_BOARD_LED_6:
return &data.on_board_led_6;
case MSI_ZONE_ON_BOARD_LED_7:
return &data.on_board_led_7;
case MSI_ZONE_ON_BOARD_LED_8:
return &data.on_board_led_8;
case MSI_ZONE_ON_BOARD_LED_9:
return &data.on_board_led_9;
case MSI_ZONE_J_CORSAIR:
return &data.j_corsair_1;
}
return nullptr;
}
RainbowZoneData *MSIMysticLight162Controller::GetRainbowZoneData
(
MSI_ZONE zone
)
{
switch(zone)
{
case MSI_ZONE_J_RGB_1:
return &data_packet.j_rgb_1;
case MSI_ZONE_J_RGB_2:
return &data_packet.j_rgb_2;
case MSI_ZONE_J_RAINBOW_1:
return &data_packet.j_rainbow_1;
case MSI_ZONE_J_RAINBOW_2:
return &data_packet.on_board_led_10;
case MSI_ZONE_ON_BOARD_LED_0:
return &data_packet.on_board_led;
case MSI_ZONE_ON_BOARD_LED_1:
return &data_packet.on_board_led_1;
case MSI_ZONE_ON_BOARD_LED_2:
return &data_packet.on_board_led_2;
case MSI_ZONE_ON_BOARD_LED_3:
return &data_packet.on_board_led_3;
case MSI_ZONE_ON_BOARD_LED_4:
return &data_packet.on_board_led_4;
case MSI_ZONE_ON_BOARD_LED_5:
return &data_packet.on_board_led_5;
case MSI_ZONE_ON_BOARD_LED_6:
return &data_packet.on_board_led_6;
case MSI_ZONE_ON_BOARD_LED_7:
return &data_packet.on_board_led_7;
case MSI_ZONE_ON_BOARD_LED_8:
return &data_packet.on_board_led_8;
case MSI_ZONE_ON_BOARD_LED_9:
return &data_packet.on_board_led_9;
case MSI_ZONE_ON_BOARD_LED_10:
return &data_packet.on_board_led_10;
case MSI_ZONE_J_CORSAIR:
return &data_packet.j_corsair_1;
default:
break;
case MSI_ZONE_J_RAINBOW_1:
return (RainbowZoneData *)&data.j_rainbow_1;
// case MSI_ZONE_J_RAINBOW_2:
// return &data.j_rainbow_2;
case MSI_ZONE_J_CORSAIR:
default:
return nullptr;
}
return nullptr;
}
bool MSIMysticLight162Controller::ReadFwVersion()
@@ -428,7 +225,7 @@ bool MSIMysticLight162Controller::ReadFwVersion()
/*-----------------------------------------------------*\
| Build firmware string <high>.<low> |
\*-----------------------------------------------------*/
version_APROM = std::to_string((int)highValue).append(".").append(std::to_string((int)lowValue));
version_APROM = std::to_string(static_cast<int>(highValue)).append(".").append(std::to_string(static_cast<int>(lowValue)));
/*-----------------------------------------------------*\
| First read the LDROM |
@@ -457,7 +254,7 @@ bool MSIMysticLight162Controller::ReadFwVersion()
/*-----------------------------------------------------*\
| Build firmware string <high>.<low> |
\*-----------------------------------------------------*/
version_LDROM = std::to_string((int)highValue).append(".").append(std::to_string((int)lowValue));
version_LDROM = std::to_string(static_cast<int>(highValue)).append(".").append(std::to_string(static_cast<int>(lowValue)));
/*-----------------------------------------------------*\
| If return value is zero it means an HID transfer |
@@ -509,30 +306,24 @@ void MSIMysticLight162Controller::ReadName()
name.append(" ").append(std::string(wname.begin(), wname.end()));
}
MSI_MODE MSIMysticLight162Controller::GetMode()
{
return (MSI_MODE)data.on_board_led.effect;
}
void MSIMysticLight162Controller::GetMode
(
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color,
unsigned int &color
)
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color
)
{
/*-----------------------------------------------------*\
| Get data for given zone |
\*-----------------------------------------------------*/
ZoneData *zone_data = GetZoneData(data, zone);
ZoneData *zoneData = GetZoneData(zone);
/*-----------------------------------------------------*\
| Return if zone is invalid |
\*-----------------------------------------------------*/
if(zone_data == nullptr)
if (!zoneData)
{
return;
}
@@ -540,22 +331,18 @@ void MSIMysticLight162Controller::GetMode
/*-----------------------------------------------------*\
| Update pointers with data |
\*-----------------------------------------------------*/
mode = (MSI_MODE)zone_data->effect;
speed = (MSI_SPEED)(zone_data->speedAndBrightnessFlags & 0x03);
brightness = (MSI_BRIGHTNESS)((zone_data->speedAndBrightnessFlags >> 2) & 0x1F);
rainbow_color = (zone_data->colorFlags & 0x80) == 0 ? true : false;
color = ToRGBColor(zone_data->color.R, zone_data->color.G, zone_data->color.B);
mode = (MSI_MODE)(zoneData->effect);
speed = (MSI_SPEED)(zoneData->speedAndBrightnessFlags & 0x03);
brightness = (MSI_BRIGHTNESS)((zoneData->speedAndBrightnessFlags >> 2) & 0x1F);
rainbow_color = (zoneData->colorFlags & 0x80) >> 7;
}
void MSIMysticLight162Controller::SetDirectMode
unsigned char MSIMysticLight162Controller::BitSet
(
bool mode
unsigned char value,
bool bit,
unsigned int position
)
{
direct_mode = mode;
}
size_t MSIMysticLight162Controller::GetMaxOnboardLeds()
{
return numof_onboard_leds;
return static_cast<unsigned char>(std::bitset<8>(value).set(position, bit).to_ulong());
}

65
Controllers/MSIMysticLightController/MSIMysticLight162Controller.h
View File

@@ -19,12 +19,7 @@
class MSIMysticLight162Controller
{
public:
MSIMysticLight162Controller
(
hid_device* handle,
const char *path,
unsigned short pid
);
MSIMysticLight162Controller(hid_device* handle, const char *path);
~MSIMysticLight162Controller();
void SetMode
@@ -36,19 +31,16 @@ public:
bool rainbow_color
);
MSI_MODE GetMode();
void GetMode
(
MSI_ZONE zone,
MSI_MODE &mode,
MSI_SPEED &speed,
MSI_BRIGHTNESS &brightness,
bool &rainbow_color,
unsigned int &color
bool &rainbow_color
);
void SetZoneColor
void SetLEDColor
(
MSI_ZONE zone,
unsigned char red1,
@@ -59,55 +51,30 @@ public:
unsigned char blu2
);
void SetLedColor
(
MSI_ZONE zone,
unsigned char red,
unsigned char grn,
unsigned char blu
);
bool Update
(
bool save
);
bool Update();
std::string GetDeviceName();
std::string GetDeviceLocation();
std::string GetFWVersion();
std::string GetSerial();
void SetDirectMode
(
bool mode
);
bool IsDirectModeActive() { return direct_mode; }
size_t GetMaxOnboardLeds();
const std::vector<MSI_ZONE>*
GetSupportedZones() { return supported_zones; }
private:
bool ReadSettings();
void SaveOnUpdate(bool send);
bool ReadFwVersion();
void ReadSerial();
void ReadName();
ZoneData* GetZoneData
(
FeaturePacket_162& dataPacket,
MSI_ZONE zone
);
ZoneData* GetZoneData(MSI_ZONE zone);
RainbowZoneData*
GetRainbowZoneData(MSI_ZONE zone);
static unsigned char BitSet(unsigned char value, bool bit, unsigned int position);
hid_device* dev;
std::string name;
std::string location;
std::string version_APROM;
std::string version_LDROM;
std::string chip_id;
hid_device* dev;
std::string name;
std::string location;
std::string version_APROM;
std::string version_LDROM;
std::string chip_id;
FeaturePacket_162 data;
FeaturePacket_162 zone_based_per_led_data;
bool direct_mode;
size_t numof_onboard_leds;
const std::vector<MSI_ZONE>* supported_zones;
FeaturePacket_162 data;
};

2
Controllers/MSIMysticLightController/MSIMysticLightControllerDetect.cpp
View File

@@ -54,7 +54,7 @@ void DetectMSIMysticLightControllers
}
else if((packet_length >= sizeof(FeaturePacket_162)) && (packet_length <= (sizeof(FeaturePacket_162) + 1)))
{
MSIMysticLight162Controller* controller = new MSIMysticLight162Controller(dev, info->path, info->product_id);
MSIMysticLight162Controller* controller = new MSIMysticLight162Controller(dev, info->path);
RGBController_MSIMysticLight162* rgb_controller = new RGBController_MSIMysticLight162(controller);
rgb_controller->name = "MSI " + dmi.getMainboard();
ResourceManager::get()->RegisterRGBController(rgb_controller);

372
Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.cpp
View File

@@ -9,45 +9,71 @@
#include "RGBController_MSIMysticLight162.h"
struct ZoneDescription
{
std::string name;
MSI_ZONE zone_type;
std::string name;
const MSI_ZONE* leds;
};
#define NUMOF_ZONES (sizeof(led_zones) / sizeof(ZoneDescription))
const ZoneDescription led_zones[] =
static const MSI_ZONE ZoneList_JRGB1[] =
{
ZoneDescription{ "JRGB1", MSI_ZONE_J_RGB_1 },
ZoneDescription{ "JRGB2", MSI_ZONE_J_RGB_2 },
ZoneDescription{ "JRAINBOW1", MSI_ZONE_J_RAINBOW_1 },
ZoneDescription{ "JRAINBOW2", MSI_ZONE_J_RAINBOW_2 },
ZoneDescription{ "JCORSAIR", MSI_ZONE_J_CORSAIR },
ZoneDescription{ "Onboard LEDs", MSI_ZONE_ON_BOARD_LED_0 }
MSI_ZONE_J_RGB_1,
MSI_ZONE_NONE
};
static const MSI_ZONE ZoneList_JRGB2[] =
{
MSI_ZONE_J_RGB_2,
MSI_ZONE_NONE
};
static std::vector<const ZoneDescription*> zone_description;
static const MSI_ZONE ZoneList_JRainbow1[] =
{
MSI_ZONE_J_RAINBOW_1,
MSI_ZONE_NONE
};
static const MSI_ZONE ZoneList_JRainbow2[] =
{
MSI_ZONE_J_RAINBOW_2,
MSI_ZONE_NONE
};
static const MSI_ZONE ZoneList_JCorsair[] =
{
MSI_ZONE_J_CORSAIR,
MSI_ZONE_NONE
};
/**------------------------------------------------------------------*\
@name MSI Mystic Light (162 Byte)
@category Motherboard
@type USB
@save :robot:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectMSIMysticLightControllers
@comment
\*-------------------------------------------------------------------*/
static const MSI_ZONE ZoneList_Onboard[] =
{
MSI_ZONE_ON_BOARD_LED_0,
MSI_ZONE_ON_BOARD_LED_1,
MSI_ZONE_ON_BOARD_LED_2,
MSI_ZONE_ON_BOARD_LED_3,
MSI_ZONE_ON_BOARD_LED_4,
MSI_ZONE_ON_BOARD_LED_5,
MSI_ZONE_ON_BOARD_LED_6,
MSI_ZONE_ON_BOARD_LED_7,
MSI_ZONE_ON_BOARD_LED_8,
MSI_ZONE_ON_BOARD_LED_9,
MSI_ZONE_ON_BOARD_LED_10,
MSI_ZONE_NONE
};
RGBController_MSIMysticLight162::RGBController_MSIMysticLight162
(
MSIMysticLight162Controller* controller_ptr
)
#define NUM_ZONES (sizeof(led_zones) / sizeof(led_zones[0]))
static const ZoneDescription led_zones[] =
{
ZoneDescription{"JRGB1", ZoneList_JRGB1 },
ZoneDescription{"JRGB2", ZoneList_JRGB2 },
ZoneDescription{"JRAINBOW1", ZoneList_JRainbow1 },
ZoneDescription{"JRAINBOW2", ZoneList_JRainbow2 },
ZoneDescription{"JCORSAIR", ZoneList_JCorsair },
ZoneDescription{"Onboard LEDs", ZoneList_Onboard },
};
RGBController_MSIMysticLight162::RGBController_MSIMysticLight162(MSIMysticLight162Controller* controller_ptr)
{
controller = controller_ptr;
@@ -59,212 +85,139 @@ RGBController_MSIMysticLight162::RGBController_MSIMysticLight162
location = controller->GetDeviceLocation();
serial = controller->GetSerial();
const std::vector<MSI_ZONE>* supported_zones = controller->GetSupportedZones();
for(std::size_t i = 0; i < supported_zones->size(); ++i)
{
for(std::size_t j = 0; j < NUMOF_ZONES; ++j)
{
if(led_zones[j].zone_type == (*supported_zones)[i])
{
zone_description.push_back(&led_zones[j]);
break;
}
}
}
SetupModes();
SetupZones();
SetupColors();
active_mode = GetDeviceMode();
GetDeviceConfig();
}
RGBController_MSIMysticLight162::~RGBController_MSIMysticLight162()
{
zone_description.clear();
delete controller;
}
int RGBController_MSIMysticLight162::GetDeviceMode()
{
MSI_MODE mode = controller->GetMode();
for(unsigned int i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
return i;
}
}
return 0;
}
void RGBController_MSIMysticLight162::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
for(std::size_t zone_idx = 0; zone_idx < NUM_ZONES; zone_idx++)
{
const ZoneDescription* zd = zone_description[zone_idx];
ZoneDescription zd = led_zones[zone_idx];
zone new_zone;
new_zone.name = zd->name;
unsigned int led_count = 0;
/*--------------------------------------------------\
| 162-byte MSI does not have resizable zones, but |
| onboard LED zones have multiple LEDs |
\*-------------------------------------------------*/
if(zd->zone_type == MSI_ZONE_ON_BOARD_LED_0)
while(zd.leds[led_count] != MSI_ZONE_NONE)
{
new_zone.leds_max = (int)controller->GetMaxOnboardLeds();
}
else
{
new_zone.leds_max = 1;
led_count++;
}
new_zone.leds_min = new_zone.leds_max;
new_zone.leds_count = new_zone.leds_max;
/*-------------------------------------------------*\
| Determine zone type based on max number of LEDs |
\*-------------------------------------------------*/
if(new_zone.leds_max == 1)
{
new_zone.type = ZONE_TYPE_SINGLE;
}
else
{
new_zone.type = ZONE_TYPE_LINEAR;
}
new_zone.name = zd.name;
new_zone.type = ZONE_TYPE_LINEAR;
new_zone.leds_min = led_count;
new_zone.leds_max = led_count;
new_zone.leds_count = led_count;
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
}
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for(std::size_t zone_idx = 0; zone_idx < zone_description.size(); ++zone_idx)
{
for(std::size_t led_idx = 0; led_idx < zones[zone_idx].leds_count; ++led_idx)
/*---------------------------------------------------------*\
| Set up LEDs |
\*---------------------------------------------------------*/
for(std::size_t led_idx = 0; led_idx < new_zone.leds_count; led_idx++)
{
led new_led;
new_led.name = zones[zone_idx].name + " LED ";
if(zones[zone_idx].leds_count > 1)
new_led.name = new_zone.name + " LED ";
if(new_zone.leds_count > 1)
{
new_led.name.append(std::to_string(led_idx + 1));
}
new_led.value = (unsigned int)(zone_description[zone_idx]->zone_type + led_idx);
new_led.value = zd.leds[led_idx];
leds.push_back(new_led);
}
}
}
void RGBController_MSIMysticLight162::ResizeZone
(
int /*zone*/,
int /*new_size*/
)
void RGBController_MSIMysticLight162::ResizeZone(int zone, int new_size)
{
}
void RGBController_MSIMysticLight162::SetCustomMode()
{
active_mode = 0;
}
void RGBController_MSIMysticLight162::DeviceUpdateLEDs()
{
for(std::size_t zone_idx = 0; zone_idx < zones.size(); ++zone_idx)
for(size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
for(int led_idx = zones[zone_idx].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed((int)zone_idx, led_idx);
UpdateLed(zone_idx, led_idx);
}
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
controller->Update();
}
void RGBController_MSIMysticLight162::UpdateZoneLEDs
(
int zone
)
void RGBController_MSIMysticLight162::UpdateZoneLEDs(int zone)
{
for(int led_idx = zones[zone].leds_count - 1; led_idx >= 0; led_idx--)
{
UpdateLed(zone, led_idx);
}
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
controller->Update();
}
void RGBController_MSIMysticLight162::UpdateSingleLED
(
int led
)
void RGBController_MSIMysticLight162::UpdateSingleLED(int led)
{
UpdateLed(leds[led].value, led);
controller->Update((modes[active_mode].flags & MODE_FLAG_AUTOMATIC_SAVE) != 0);
controller->Update();
}
void RGBController_MSIMysticLight162::DeviceUpdateMode()
{
if(modes[active_mode].value == MSI_MODE_DIRECT_DUMMY)
{
controller->SetDirectMode(true);
}
else
{
controller->SetDirectMode(false);
DeviceUpdateLEDs();
}
}
void RGBController_MSIMysticLight162::DeviceSaveMode()
{
controller->Update(true);
}
void RGBController_MSIMysticLight162::SetupModes()
{
constexpr unsigned int PER_LED_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
constexpr unsigned int RANDOM_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_MANUAL_SAVE;
constexpr unsigned int RANDOM_ONLY = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_RANDOM_COLOR;
constexpr unsigned int COMMON = RANDOM_ONLY | MODE_FLAG_HAS_PER_LED_COLOR;
SetupMode("Direct", MSI_MODE_DIRECT_DUMMY, MODE_FLAG_HAS_PER_LED_COLOR);
SetupMode("Static", MSI_MODE_STATIC, MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE);
// SetupMode("Off", MSI_MODE_DISABLE, 0);
SetupMode("Breathing", MSI_MODE_BREATHING, PER_LED_ONLY);
SetupMode("Direct", MSI_MODE_STATIC, MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR);
SetupMode("Off", MSI_MODE_DISABLE, 0);
SetupMode("Breathing", MSI_MODE_BREATHING, COMMON);
SetupMode("Flashing", MSI_MODE_FLASHING, COMMON);
SetupMode("Double flashing", MSI_MODE_DOUBLE_FLASHING, COMMON);
SetupMode("Lightning", MSI_MODE_LIGHTNING, PER_LED_ONLY);
SetupMode("Lightning", MSI_MODE_LIGHTNING, COMMON);
// SetupMode("MSI Marquee", MSI_MODE_MSI_MARQUEE, COMMON);
SetupMode("Meteor", MSI_MODE_METEOR, COMMON);
SetupMode("Stack", MSI_MODE_WATER_DROP, COMMON);
// SetupMode("Meteor", MSI_MODE_METEOR, COMMON);
// SetupMode("Water drop", MSI_MODE_WATER_DROP, COMMON);
// SetupMode("MSI Rainbow", MSI_MODE_MSI_RAINBOW, RANDOM_ONLY);
// SetupMode("Pop", MSI_MODE_POP, COMMON);
// SetupMode("Rap", MSI_MODE_RAP, COMMON);
// SetupMode("Jazz", MSI_MODE_JAZZ, COMMON);
// SetupMode("Play", MSI_MODE_PLAY, COMMON);
// SetupMode("Movie", MSI_MODE_MOVIE, COMMON);
SetupMode("Rainbow", MSI_MODE_COLOR_RING, COMMON);
SetupMode("Planetary", MSI_MODE_PLANETARY, RANDOM_ONLY);
SetupMode("Double meteor", MSI_MODE_DOUBLE_METEOR, RANDOM_ONLY);
SetupMode("Energy", MSI_MODE_ENERGY, RANDOM_ONLY);
SetupMode("Blink", MSI_MODE_BLINK, COMMON);
SetupMode("Clock", MSI_MODE_CLOCK, RANDOM_ONLY);
SetupMode("Color pulse", MSI_MODE_COLOR_PULSE, COMMON);
SetupMode("Color shift", MSI_MODE_COLOR_SHIFT, RANDOM_ONLY);
SetupMode("Color wave", MSI_MODE_COLOR_WAVE, COMMON);
SetupMode("Marquee", MSI_MODE_MARQUEE, PER_LED_ONLY);
// SetupMode("Color ring", MSI_MODE_COLOR_RING, COMMON);
// SetupMode("Planetary", MSI_MODE_PLANETARY, COMMON);
// SetupMode("Double meteor", MSI_MODE_DOUBLE_METEOR, COMMON);
// SetupMode("Energy", MSI_MODE_ENERGY, COMMON);
// SetupMode("Blink", MSI_MODE_BLINK, COMMON);
// SetupMode("Clock", MSI_MODE_CLOCK, COMMON);
// SetupMode("Color pulse", MSI_MODE_COLOR_PULSE, COMMON);
// SetupMode("Color shift", MSI_MODE_COLOR_SHIFT, COMMON);
// SetupMode("Color wave", MSI_MODE_COLOR_WAVE, COMMON);
// SetupMode("Marquee", MSI_MODE_MARQUEE, COMMON);
// SetupMode("Rainbow", MSI_MODE_RAINBOW, COMMON);
SetupMode("Rainbow wave", MSI_MODE_RAINBOW_WAVE, RANDOM_ONLY);
SetupMode("Visor", MSI_MODE_VISOR, COMMON);
// SetupMode("Rainbow wave", MSI_MODE_RAINBOW_WAVE, COMMON);
// SetupMode("Visor", MSI_MODE_VISOR, COMMON);
// SetupMode("JRainbow", MSI_MODE_JRAINBOW, COMMON);
SetupMode("Rainbow flashing", MSI_MODE_RAINBOW_FLASHING, RANDOM_ONLY);
SetupMode("Rainbow double flashing", MSI_MODE_RAINBOW_DOUBLE_FLASHING, RANDOM_ONLY);
// SetupMode("Rainbow flashing", MSI_MODE_RAINBOW_FLASHING, COMMON);
// SetupMode("Rainbow double flashing", MSI_MODE_RAINBOW_DOUBLE_FLASHING, COMMON);
// SetupMode("Random", MSI_MODE_RANDOM, COMMON);
// SetupMode("Fan control", MSI_MODE_FAN_CONTROL, COMMON);
// SetupMode("Off 2", MSI_MODE_DISABLE_2, COMMON);
@@ -276,44 +229,25 @@ void RGBController_MSIMysticLight162::SetupModes()
// SetupMode("Lava", MSI_MODE_LAVA, COMMON);
}
void RGBController_MSIMysticLight162::UpdateLed
(
int zone,
int led
)
void RGBController_MSIMysticLight162::UpdateLed(int zone, int led)
{
unsigned char red = RGBGetRValue(zones[zone].colors[led]);
unsigned char grn = RGBGetGValue(zones[zone].colors[led]);
unsigned char blu = RGBGetBValue(zones[zone].colors[led]);
if(controller->IsDirectModeActive())
{
controller->SetLedColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu);
}
else
{
bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
MSI_MODE mode = (MSI_MODE)modes[active_mode].value;
MSI_SPEED speed = (MSI_SPEED)modes[active_mode].speed;
MSI_BRIGHTNESS brightness = (MSI_BRIGHTNESS)modes[active_mode].brightness;
controller->SetMode((MSI_ZONE)zones[zone].leds[led].value, mode, speed, brightness, random);
controller->SetZoneColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu, red, grn, blu);
}
bool random = modes[active_mode].color_mode == MODE_COLORS_RANDOM;
unsigned char red = RGBGetRValue(zones[zone].colors[led]);
unsigned char grn = RGBGetGValue(zones[zone].colors[led]);
unsigned char blu = RGBGetBValue(zones[zone].colors[led]);
MSI_MODE mode = (MSI_MODE)(modes[active_mode].value);
MSI_SPEED speed = (MSI_SPEED)(modes[active_mode].speed);
controller->SetMode((MSI_ZONE)zones[zone].leds[led].value, mode, speed, MSI_BRIGHTNESS_LEVEL_100, random);
controller->SetLEDColor((MSI_ZONE)zones[zone].leds[led].value, red, grn, blu, red, grn, blu);
}
void RGBController_MSIMysticLight162::SetupMode
(
const char *name,
MSI_MODE mod,
unsigned int flags
)
void RGBController_MSIMysticLight162::SetupMode(const char *name, MSI_MODE mod, unsigned int flags)
{
mode Mode;
Mode.name = name;
Mode.value = mod;
Mode.flags = flags;
Mode.name = name;
Mode.value = mod;
Mode.flags = flags;
if(flags & MODE_FLAG_HAS_PER_LED_COLOR)
{
Mode.color_mode = MODE_COLORS_PER_LED;
@@ -341,69 +275,5 @@ void RGBController_MSIMysticLight162::SetupMode
Mode.speed_min = 0;
}
if(flags & MODE_FLAG_HAS_BRIGHTNESS)
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_OFF;
}
else
{
Mode.brightness = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_max = MSI_BRIGHTNESS_LEVEL_100;
Mode.brightness_min = MSI_BRIGHTNESS_LEVEL_100;
}
modes.push_back(Mode);
}
void RGBController_MSIMysticLight162::GetDeviceConfig()
{
MSI_MODE mode;
MSI_SPEED speed;
MSI_BRIGHTNESS brightness;
bool rainbow;
unsigned int color;
for(size_t i = 0; i < zone_description.size(); ++i)
{
controller->GetMode(zone_description[i]->zone_type, mode, speed, brightness, rainbow, color);
for(size_t j = 0; j < zones[i].leds_count; ++j)
{
zones[i].colors[j] = color;
}
}
controller->GetMode(zone_description[0]->zone_type, mode, speed, brightness, rainbow, color);
for(size_t i = 0; i < modes.size(); ++i)
{
if(mode == modes[i].value)
{
if(modes[i].flags & MODE_FLAG_HAS_SPEED)
{
modes[i].speed = speed;
}
if(modes[i].flags & MODE_FLAG_HAS_BRIGHTNESS)
{
modes[i].brightness = brightness;
}
if(rainbow)
{
if(modes[i].flags & (MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_RANDOM_COLOR))
{
if(rainbow)
{
modes[i].color_mode = MODE_COLORS_RANDOM;
}
else
{
modes[i].color_mode = MODE_COLORS_PER_LED;
}
}
}
break;
}
}
}

18
Controllers/MSIMysticLightController/RGBController_MSIMysticLight162.h
View File

@@ -19,30 +19,20 @@ public:
~RGBController_MSIMysticLight162();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void SetCustomMode();
void DeviceUpdateMode();
void DeviceSaveMode();
private:
void SetupModes();
void UpdateLed
(
int zone,
int led
);
void SetupMode
(
const char *name,
MSI_MODE mode,
unsigned int flags
);
int GetDeviceMode();
void GetDeviceConfig();
void UpdateLed(int zone, int led);
void SetupMode(const char *name, MSI_MODE mode, unsigned int flags);
MSIMysticLight162Controller* controller;
};