mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-01-01 03:37:49 -05:00
Code Issues Packages Projects Releases Wiki Activity
Files
9062be446275cc9ae50f1487de0e508014f01a1d
OpenRGB/Controllers/AlienwareController/AlienwareController.cpp
Gabriel Marcano 9062be4462 New device: Dell G5 SE Alienware LED Keyboard 
- 4 region keyboard LED controller (tried to keep controller generic
   for other setups as well)
 - Support for Static, Flashing, Morph, Spectrum Cycle, Rainbow Wave,
   and Breathing modes
 - Implemented rate limiting for sending reports since the controller
   crashes if too many reports are sent too quickly. Also implemented
   functionality to prevent sending frivolous update requests
 - Implemented support for setting mode, color, tempo, and period
   independently for each zone (not fully exposed in UI). Morph mode
   exposes 2 colors per zone.

Commit amended for code style by Adam Honse <calcprogrammer1@gmail.com>
2021-07-06 01:51:55 -05:00

839 lines
30 KiB
C++
Raw Blame History

/*-----------------------------------------*\
| AlienwareController.cpp |
| |
| Driver for Alienware lighting controller |
| |
| Gabriel Marcano (gemarcano) 4/21/2021 |
\*-----------------------------------------*/
#include "RGBController.h"
#include "AlienwareController.h"
#include <cstring>
#include <cstdint>
#include <map>
#include <thread>
#include <chrono>
#include <algorithm>
#include <sstream>
typedef uint32_t alienware_platform_id;
/*---------------------------------------------------------*\
| Some devices appear to report the wrong number of zones. |
| Record that here. |
\*---------------------------------------------------------*/
static const std::map<alienware_platform_id, uint8_t> zone_quirks_table =
{
{ 0x0C01, 4 } // Dell G5 SE 5505
};
/*---------------------------------------------------------*\
| Add zones for devices here, mapping the platform ID to |
| the zone names |
\*---------------------------------------------------------*/
static const std::map<alienware_platform_id, std::vector<const char*>> zone_names_table =
{
{ 0x0C01, { "Left", "Middle", "Right", "Numpad" } }
};
static void SendHIDReport(hid_device *dev, const unsigned char* usb_buf, size_t usb_buf_size)
{
using namespace std::chrono_literals;
hid_send_feature_report(dev, usb_buf, usb_buf_size);
/*-----------------------------------------------------*\
| The controller really doesn't like really spammed by |
| too many commands at once... the delay may be command |
| dependent also. Delay for longer if the command is |
| changing animation state |
\*-----------------------------------------------------*/
unsigned char command = usb_buf[2];
unsigned char subcommand = usb_buf[3];
if( ( command == ALIENWARE_COMMAND_USER_ANIM )
&& ( ( subcommand == ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY )
|| ( subcommand == ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE ) ) )
{
std::this_thread::sleep_for(1s);
}
else
{
std::this_thread::sleep_for(60ms);
}
}
AlienwareController::AlienwareController(hid_device* dev_handle, const hid_device_info& info, std::string name)
{
HidapiAlienwareReport report;
dev = dev_handle;
device_name = name;
location = info.path;
/*-----------------------------------------------------*\
| Get serial number |
\*-----------------------------------------------------*/
std::wstring tmp_serial_number;
tmp_serial_number = info.serial_number;
serial_number = std::string(tmp_serial_number.begin(), tmp_serial_number.end());
/*-----------------------------------------------------*\
| Get zone information by checking firmware |
| configuration |
\*-----------------------------------------------------*/
report = Report(ALIENWARE_COMMAND_REPORT_CONFIG);
alienware_platform_id platform_id = report.data[4] << 8 | report.data[5];
/*-----------------------------------------------------*\
| Get firmware version |
\*-----------------------------------------------------*/
report = Report(ALIENWARE_COMMAND_REPORT_FIRMWARE);
std::stringstream fw_string;
fw_string << static_cast<unsigned>(report.data[4]) << '.' << static_cast<unsigned>(report.data[5]) << '.' << static_cast<unsigned>(report.data[6]);
version = fw_string.str();
/*-----------------------------------------------------*\
| Check if the device reports the wrong number of zones |
\*-----------------------------------------------------*/
unsigned number_of_zones = zone_quirks_table.count(platform_id) ? zone_quirks_table.at(platform_id) : report.data[6];
/*-----------------------------------------------------*\
| Initialize Alienware zones |
\*-----------------------------------------------------*/
zones.resize(number_of_zones);
if(zone_names_table.count(platform_id))
{
zone_names = zone_names_table.at(platform_id);
}
else
{
/*-------------------------------------------------*\
| If this is an unknown controller, set the name of |
| all regions to "Unknown" |
\*-------------------------------------------------*/
for(size_t i = 0; i < number_of_zones; i++)
{
zone_names.emplace_back("Unknown");
}
}
/*-----------------------------------------------------*\
| Set defaults for all zones |
| It doesn't seem possible to read the controller's |
| current state, hence the default value being set here.|
\*-----------------------------------------------------*/
for(unsigned int zone_idx; zone_idx < zones.size(); zone_idx++)
{
zones[zone_idx].color[0] = 0x000000;
zones[zone_idx].color[1] = 0x000000;
zones[zone_idx].mode = ALIENWARE_MODE_COLOR;
/*-------------------------------------------------*\
| Default period value from ACC |
\*-------------------------------------------------*/
zones[zone_idx].period = 2000;
zones[zone_idx].tempo = ALIENWARE_TEMPO_MAX;
zones[zone_idx].dim = 0;
}
/*-----------------------------------------------------*\
| Initialize dirty flags |
\*-----------------------------------------------------*/
dirty = true;
dirty_dim = true;
}
AlienwareController::~AlienwareController()
{
}
unsigned int AlienwareController::GetZoneCount()
{
return(zones.size());
}
std::vector<const char*> AlienwareController::GetZoneNames()
{
return(zone_names);
}
std::string AlienwareController::GetDeviceLocation()
{
return("HID: " + location);
}
std::string AlienwareController::GetDeviceName()
{
return(device_name);
}
std::string AlienwareController::GetSerialString()
{
return(serial_number);
}
std::string AlienwareController::GetFirmwareVersion()
{
return(version);
}
AlienwareController::HidapiAlienwareReport AlienwareController::GetResponse()
{
/*-----------------------------------------------------*\
| Zero init. This is not updated if there's a problem. |
\*-----------------------------------------------------*/
HidapiAlienwareReport result;
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(result.data, 0x00, sizeof(result.data));
hid_get_feature_report(dev, result.data, HIDAPI_ALIENWARE_REPORT_SIZE);
return(result);
}
AlienwareController::HidapiAlienwareReport AlienwareController::Report(uint8_t subcommand)
{
unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet with leading 00, per hidapi |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x03;
usb_buf[0x02] = ALIENWARE_COMMAND_REPORT;
usb_buf[0x03] = subcommand;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
SendHIDReport(dev, usb_buf, sizeof(usb_buf));
return(GetResponse());
}
AlienwareReport AlienwareController::GetStatus(uint8_t subcommand)
{
HidapiAlienwareReport data = Report(subcommand);
AlienwareReport result = AlienwareReport{};
/*-----------------------------------------------------*\
| Skip first byte, as that's the report number, which |
| should be 0 |
\*-----------------------------------------------------*/
memcpy(result.data, &data.data[1], sizeof(result.data));
return(result);
}
bool AlienwareController::Dim(std::vector<uint8_t> zones, double percent)
{
/*-----------------------------------------------------*\
| Bail out if there are no zones to update |
\*-----------------------------------------------------*/
if(!zones.size())
{
return(true);
}
unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet with leading 00, per hidapi |
\*-----------------------------------------------------*/
uint16_t num_zones = zones.size();
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x03;
usb_buf[0x02] = ALIENWARE_COMMAND_DIM;
usb_buf[0x03] = static_cast<uint8_t>(percent * 0x64);
usb_buf[0x04] = num_zones >> 8;
usb_buf[0x05] = num_zones & 0xFF;
for(size_t i = 0; i < num_zones; i++)
{
usb_buf[0x06+i] = zones[i];
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
SendHIDReport(dev, usb_buf, sizeof(usb_buf));
HidapiAlienwareReport response;
response = GetResponse();
/*-----------------------------------------------------*\
| For this command, error is if the output equals the |
| input |
\*-----------------------------------------------------*/
return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
}
bool AlienwareController::UserAnimation(uint16_t subcommand, uint16_t animation, uint16_t duration)
{
unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet with leading 00 per hidapi |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x03;
usb_buf[0x02] = ALIENWARE_COMMAND_USER_ANIM;
usb_buf[0x03] = subcommand >> 8;
usb_buf[0x04] = subcommand & 0xFF;
usb_buf[0x05] = animation >> 8;
usb_buf[0x06] = animation & 0xFF;
usb_buf[0x07] = duration >> 8;
usb_buf[0x08] = duration & 0xFF;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
SendHIDReport(dev, usb_buf, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Every subcommand appears to report its result on a |
| different byte |
\*-----------------------------------------------------*/
HidapiAlienwareReport response;
response = GetResponse();
/*-----------------------------------------------------*\
| The only time the 0x03 byte is zero is if the |
| controller has crashed |
\*-----------------------------------------------------*/
if(response.data[1] == 0)
{
return(false);
}
switch(subcommand)
{
case ALIENWARE_COMMAND_USER_ANIM_FINISH_SAVE:
return(!response.data[7]);
case ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY:
return(!response.data[5]);
case ALIENWARE_COMMAND_USER_ANIM_PLAY:
return(!response.data[7]);
default:
return(true);
}
}
bool AlienwareController::SelectZones(const std::vector<uint8_t>& zones)
{
/*-----------------------------------------------------*\
| Bail if zones is empty, and return false to indicate |
| nothing has changed |
\*-----------------------------------------------------*/
if(!zones.size())
{
return(false);
}
unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet with leading 00, per hidapi |
\*-----------------------------------------------------*/
uint16_t num_zones = zones.size();
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x03;
usb_buf[0x02] = ALIENWARE_COMMAND_SELECT_ZONES;
usb_buf[0x03] = 1; // loop?
usb_buf[0x04] = num_zones >> 8;
usb_buf[0x05] = num_zones & 0xFF;
for(size_t i = 0; i < num_zones; i++)
{
usb_buf[0x06+i] = zones[i];
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
SendHIDReport(dev, usb_buf, sizeof(usb_buf));
HidapiAlienwareReport response;
response = GetResponse();
/*-----------------------------------------------------*\
| For this command, error is if the output equals the |
| input |
\*-----------------------------------------------------*/
return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
}
bool AlienwareController::ModeAction(uint8_t mode, uint16_t duration, uint16_t tempo, RGBColor color)
{
return(ModeAction(&mode, &duration, &tempo, &color, 1));
}
bool AlienwareController::ModeAction
(
const uint8_t* mode,
const uint16_t* duration,
const uint16_t* tempo,
const RGBColor* color,
unsigned amount
)
{
unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Amount must be 3 or less, as that's how many |
| subcommands can fit into one report |
\*-----------------------------------------------------*/
if(amount > 3)
{
return(false);
}
/*-----------------------------------------------------*\
| Set up message packet with leading 00, per hidapi |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x03;
usb_buf[0x02] = ALIENWARE_COMMAND_ADD_ACTION;
for(unsigned int i = 0; i < amount; i++)
{
usb_buf[0x03 + (8 * i)] = mode[i];
usb_buf[0x04 + (8 * i)] = duration[i] >> 8;
usb_buf[0x05 + (8 * i)] = duration[i] & 0xFF;
usb_buf[0x06 + (8 * i)] = tempo[i] >> 8;
usb_buf[0x07 + (8 * i)] = tempo[i] & 0xFF;
usb_buf[0x08 + (8 * i)] = RGBGetRValue(color[i]);
usb_buf[0x09 + (8 * i)] = RGBGetGValue(color[i]);
usb_buf[0x0A + (8 * i)] = RGBGetBValue(color[i]);
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
SendHIDReport(dev, usb_buf, sizeof(usb_buf));
HidapiAlienwareReport response;
response = GetResponse();
/*-----------------------------------------------------*\
| For this command, error is if the output equals the |
| input |
\*-----------------------------------------------------*/
return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
}
bool AlienwareController::MultiModeAction
(
const uint8_t* mode,
const uint16_t* duration,
const uint16_t* tempo,
const RGBColor* color,
unsigned amount
)
{
bool result = true;
unsigned int left = amount;
while(left && result)
{
unsigned int tmp_amount;
tmp_amount = std::min(left, 3u);
result &= ModeAction(mode, duration, tempo, color, tmp_amount);
mode += tmp_amount;
duration += tmp_amount;
tempo += tmp_amount;
color += tmp_amount;
left -= tmp_amount;
}
return(result);
}
bool AlienwareController::SetColorDirect(RGBColor color, std::vector<uint8_t> zones)
{
/*-----------------------------------------------------*\
| Bail if zones is empty |
\*-----------------------------------------------------*/
if(zones.empty())
{
return(true);
}
unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet with leading 00, per hidapi |
\*-----------------------------------------------------*/
uint16_t num_zones = zones.size();
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x03;
usb_buf[0x02] = ALIENWARE_COMMAND_SET_COLOR;
usb_buf[0x03] = RGBGetRValue(color);
usb_buf[0x04] = RGBGetGValue(color);
usb_buf[0x05] = RGBGetBValue(color);
usb_buf[0x06] = num_zones >> 8;
usb_buf[0x07] = num_zones & 0xFF;
for(size_t i = 0; i < num_zones; i++)
{
usb_buf[0x08 + i] = zones[i];
}
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
SendHIDReport(dev, usb_buf, sizeof(usb_buf));
HidapiAlienwareReport response;
response = GetResponse();
/*-----------------------------------------------------*\
| For this command, error is if the output equals the |
| input |
\*-----------------------------------------------------*/
return((response.data[1] == 0x03) && memcmp(usb_buf, response.data, HIDAPI_ALIENWARE_REPORT_SIZE));
}
bool AlienwareController::Reset()
{
/*-----------------------------------------------------*\
| Bail if zones is empty |
\*-----------------------------------------------------*/
if(zones.empty())
{
return(true);
}
unsigned char usb_buf[HIDAPI_ALIENWARE_REPORT_SIZE];
/*-----------------------------------------------------*\
| Zero out buffer |
\*-----------------------------------------------------*/
memset(usb_buf, 0x00, sizeof(usb_buf));
/*-----------------------------------------------------*\
| Set up message packet with leading 00, per hidapi |
\*-----------------------------------------------------*/
usb_buf[0x00] = 0x00;
usb_buf[0x01] = 0x03;
usb_buf[0x02] = ALIENWARE_COMMAND_RESET;
/*-----------------------------------------------------*\
| Send packet |
\*-----------------------------------------------------*/
SendHIDReport(dev, usb_buf, sizeof(usb_buf));
HidapiAlienwareReport response;
response = GetResponse();
/*-----------------------------------------------------*\
| For this command, error is if the output equals the |
| input |
\*-----------------------------------------------------*/
return(response.data[1] == 0x03);
}
void AlienwareController::SetMode(uint8_t zone, uint8_t mode)
{
if(mode != zones[zone].mode)
{
zones[zone].mode = mode;
dirty = true;
}
}
void AlienwareController::SetColor(uint8_t zone, RGBColor color)
{
SetColor(zone, color, zones[zone].color[1]);
}
void AlienwareController::SetColor(uint8_t zone, RGBColor color1, RGBColor color2)
{
if((color1 != zones[zone].color[0]))
{
zones[zone].color[0] = color1;
dirty = true;
}
if((color2 != zones[zone].color[1]))
{
zones[zone].color[1] = color2;
dirty = true;
}
}
void AlienwareController::SetPeriod(uint8_t zone, uint16_t period)
{
if(period != zones[zone].period)
{
zones[zone].period = period;
dirty = true;
}
}
void AlienwareController::SetTempo(uint8_t zone, uint16_t tempo)
{
if(tempo != zones[zone].tempo)
{
zones[zone].tempo = tempo;
dirty = true;
}
}
void AlienwareController::SetDim(uint8_t zone, uint8_t dim)
{
/*-----------------------------------------------------*\
| Clamp dim to values between 0 and 100 |
\*-----------------------------------------------------*/
if(dim > 100)
{
dim = 100;
}
if(dim != zones[zone].dim)
{
zones[zone].dim = dim;
dirty_dim = true;
}
}
void AlienwareController::UpdateDim()
{
if(!dirty_dim)
{
return;
}
/*-----------------------------------------------------*\
| Collect all zones that share dim settings, and update |
| them together |
\*-----------------------------------------------------*/
std::map<uint8_t, std::vector<uint8_t>> dim_zone_map;
for(size_t i = 0; i < zones.size(); i++)
{
dim_zone_map[zones[i].dim].emplace_back(i);
}
for(std::pair<const uint8_t, std::vector<uint8_t>> &pair : dim_zone_map)
{
/*-------------------------------------------------*\
| Bail on an error... |
\*-------------------------------------------------*/
if(!Dim(pair.second, pair.first))
{
return;
}
}
dirty_dim = false;
}
bool AlienwareController::UpdateDirect()
{
/*-----------------------------------------------------*\
| Collect all zones that share dim settings, and update |
| them together |
\*-----------------------------------------------------*/
std::map<RGBColor, std::vector<uint8_t>> color_zone_map;
for(size_t i = 0; i < zones.size(); i++)
{
color_zone_map[zones[i].color[0]].emplace_back(i);
}
for(std::pair<const RGBColor, std::vector<uint8_t>> &pair : color_zone_map)
{
/*-------------------------------------------------*\
| Bail on an error... |
\*-------------------------------------------------*/
if(!SetColorDirect(pair.first, pair.second))
{
return false;
}
}
return true;
}
static const RGBColor rainbow_colors[4][7] =
{
{ 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF, 0x0000FF, 0x800080 },
{ 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF, 0x0000FF },
{ 0x0000FF, 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000, 0x00BFFF },
{ 0x00BFFF, 0x0000FF, 0x800080, 0xFF0000, 0xFFA500, 0xFFFF00, 0x008000 }
};
void AlienwareController::UpdateMode()
{
/*-----------------------------------------------------*\
| If there are no updates, don't bother running this |
\*-----------------------------------------------------*/
if(!dirty)
{
return;
}
bool result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_NEW, ALIENWARE_COMMAND_USER_ANIM_KEYBOARD, 0);
if(!result)
{
return;
}
for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++)
{
alienware_zone zone = zones[zone_idx];
result = SelectZones({static_cast<uint8_t>(zone_idx)});
if(!result)
{
return;
}
/*-------------------------------------------------*\
| Some modes use 0x07D0 for their duration as sent |
| by AWCC traces, maybe 2000ms? |
\*-------------------------------------------------*/
switch (zone.mode)
{
case ALIENWARE_MODE_COLOR:
result = ModeAction(zone.mode, 2000, ALIENWARE_TEMPO_MAX, zone.color[0]);
break;
case ALIENWARE_MODE_PULSE:
result = ModeAction(zone.mode, zone.period, zone.tempo, zone.color[0]);
break;
case ALIENWARE_MODE_MORPH:
{
uint8_t zones[2] = { zone.mode, zone.mode };
uint16_t periods[2] = { zone.period, zone.period };
uint16_t tempos[2] = { zone.tempo, zone.tempo };
RGBColor colors[2] = { zone.color[0], zone.color[1] };
result = MultiModeAction(zones, periods, tempos, colors, 2);
}
break;
case ALIENWARE_MODE_SPECTRUM:
{
uint8_t zones[7] = { ALIENWARE_MODE_MORPH, ALIENWARE_MODE_MORPH,
ALIENWARE_MODE_MORPH, ALIENWARE_MODE_MORPH,
ALIENWARE_MODE_MORPH, ALIENWARE_MODE_MORPH,
ALIENWARE_MODE_MORPH };
uint16_t periods[7] = { zone.period, zone.period,
zone.period, zone.period,
zone.period, zone.period,
zone.period };
uint16_t tempos[7] = { zone.tempo, zone.tempo,
zone.tempo, zone.tempo,
zone.tempo, zone.tempo,
zone.tempo };
result = MultiModeAction(zones, periods, tempos, rainbow_colors[0], 7);
}
break;
case ALIENWARE_MODE_RAINBOW:
{
uint8_t zones[7] = { ALIENWARE_MODE_MORPH, ALIENWARE_MODE_MORPH,
ALIENWARE_MODE_MORPH, ALIENWARE_MODE_MORPH,
ALIENWARE_MODE_MORPH, ALIENWARE_MODE_MORPH,
ALIENWARE_MODE_MORPH };
uint16_t periods[7] = { zone.period, zone.period,
zone.period, zone.period,
zone.period, zone.period,
zone.period };
uint16_t tempos[7] = { zone.tempo, zone.tempo,
zone.tempo, zone.tempo,
zone.tempo, zone.tempo,
zone.tempo };
result = MultiModeAction(zones, periods, tempos, rainbow_colors[zone_idx], 7);
}
break;
case ALIENWARE_MODE_BREATHING:
{
uint8_t zones[2] = { ALIENWARE_MODE_MORPH, ALIENWARE_MODE_MORPH };
uint16_t periods[2] = { zone.period, zone.period };
uint16_t tempos[2] = { zone.tempo, zone.tempo };
RGBColor colors[2] = { zone.color[0], 0x0 };
result = MultiModeAction(zones, periods, tempos, colors, 2);
}
break;
default:
result = false;
}
if(!result)
{
return;
}
}
result = UserAnimation(ALIENWARE_COMMAND_USER_ANIM_FINISH_PLAY, ALIENWARE_COMMAND_USER_ANIM_KEYBOARD, 0);
/*-------------------------------------------------*\
| Don't update dirty flag if there's an error |
\*-------------------------------------------------*/
if(!result)
{
return;
}
dirty = false;
}
void AlienwareController::UpdateController()
{
UpdateMode();
UpdateDim();
}
Reference in New Issue View Git Blame Copy Permalink