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

Adds support for ANSI Lenovo Legion 7 Gen 7

Browse source
This commit is contained in:
Peter Vazny 2023-08-16 15:35:58 +00:00 • committed by Adam Honse
parent e4c0979951
commit 839701fcf8
8 changed files with 1333 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

242
Controllers/LenovoControllers/LenovoDevices.h
View file

@ -24,6 +24,7 @@
#define LEGION_Y750S 0xC957
#define LEGION_Y760 0xC968
#define LEGION_Y760S 0xC967
#define LEGION_7GEN7 0xC978
enum LENOVO_KEYBOARD
{
@ -268,7 +269,7 @@ const lenovo_led legion_Y760_ansi_leds[]
{0x75, "Key: >"},//107
{0x76, "Key: ?"},//108
{0x8D, KEY_EN_RIGHT_SHIFT},//109
{0xa2, KEY_EN_RIGHT_SHIFT},//110
{0xA2, KEY_EN_RIGHT_SHIFT},//110
{0x79, KEY_EN_NUMPAD_4},//111
{0x7A, "Key: Number Pad Right Arrow"},//112
{0x7B, KEY_EN_NUMPAD_5},//113
@ -285,7 +286,7 @@ const lenovo_led legion_Y760_ansi_leds[]
{0x91, "Key: Number Pad Down Arrow"},//122
{0x92, KEY_EN_NUMPAD_3},//123
{0x93, "Key: Number Pad Page Down"},//124
{0xa7, KEY_EN_NUMPAD_ENTER},//125
{0xA7, KEY_EN_NUMPAD_ENTER},//125
//row 8
{0x7F, KEY_EN_LEFT_CONTROL},//126
@ -434,7 +435,7 @@ const lenovo_led legion_Y760_iso_leds[]
{0x75, "Key: >"},//105
{0x76, "Key: ?"},//106
{0x8D, KEY_EN_RIGHT_SHIFT},//107
{0xa2, KEY_EN_RIGHT_SHIFT},//108
{0xA2, KEY_EN_RIGHT_SHIFT},//108
{0x79, KEY_EN_NUMPAD_4},//109
{0x7A, "Key: Number Pad Right Arrow"},//110
{0x7B, KEY_EN_NUMPAD_5},//111
@ -451,7 +452,7 @@ const lenovo_led legion_Y760_iso_leds[]
{0x91, "Key: Number Pad Down Arrow"},//120
{0x92, KEY_EN_NUMPAD_3},//121
{0x93, "Key: Number Pad Page Down"},//122
{0xa7, KEY_EN_NUMPAD_ENTER},//123
{0xA7, KEY_EN_NUMPAD_ENTER},//123
//row 8
{0x7F, KEY_EN_LEFT_CONTROL},//124
@ -607,7 +608,7 @@ const lenovo_led legion_Y760_jp_leds[]
{0x8B, KEY_EN_FORWARD_SLASH}, //112
{0x8C, KEY_JP_RO}, //113
{0x8D, KEY_EN_RIGHT_SHIFT}, //114
{0xa2, KEY_EN_RIGHT_SHIFT}, //115
{0xA2, KEY_EN_RIGHT_SHIFT}, //115
{0x79, KEY_EN_NUMPAD_4}, //116
{0x7A, "Key: Number Pad Right Arrow"}, //117
{0x7B, KEY_EN_NUMPAD_5}, //118
@ -621,7 +622,7 @@ const lenovo_led legion_Y760_jp_leds[]
{0x91, "Key: Number Pad Down Arrow"}, //124
{0x92, KEY_EN_NUMPAD_3}, //125
{0x93, "Key: Number Pad Page Down"}, //126
{0xa7, KEY_EN_NUMPAD_ENTER}, //127
{0xA7, KEY_EN_NUMPAD_ENTER}, //127
//row 8
{0x7F, KEY_EN_LEFT_CONTROL}, //128
@ -1705,4 +1706,233 @@ static lenovo_zone lenovo_legion_Y740_15_kbd_iso
88,
};
/*--------------------------------------------------------*\
| Legion 7 gen7: 4 zones |
\*--------------------------------------------------------*/
static const unsigned int legion_7gen7_ansi_leds_map[] =
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, NA, 30, 31, 32, 33, NA, 34, 35, 36, 37,
38, 39, 40, 41, NA, 42, 43, 44, 45, 46, 47, 48, 49, 50, NA, 51, 52, 53, 54, NA,
55, 56, NA, 57, 58, 59, 60, 61, 62, 63, 64, 65, NA, 66, 67, NA, 68, 69, 70, 71,
72, NA, 73, 74, 75, NA, 76, 77, 78, 79, 80, 81, 82, NA, 83, NA, 84, 85, 86, NA,
87, 88, 89, 90, 91, NA, NA, NA, NA, NA, 92, 93, NA, 94, NA, NA, 95, NA, 96, 97,
NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 98, 99, NA, 100, NA, NA, NA, NA};
/*---------------------*\
| zone 1, keyboard ANSI |
\*---------------------*/
const lenovo_led legion_7gen7_ansi_leds[]
{
//row 1
{0x01, KEY_EN_ESCAPE},//0
{0x02, KEY_EN_F1},//1
{0x03, KEY_EN_F2},//2
{0x04, KEY_EN_F3},//3
{0x05, KEY_EN_F4},//4
{0x06, KEY_EN_F5},//5
{0x07, KEY_EN_F6},//6
{0x08, KEY_EN_F7},//7
{0x09, KEY_EN_F8},//8
{0x0A, KEY_EN_F9},//9
{0x0B, KEY_EN_F10},//10
{0x0C, KEY_EN_F11},//11
{0x0D, KEY_EN_F12},//12
{0x0E, KEY_EN_INSERT},//13
{0x0F, KEY_EN_PRINT_SCREEN},//14
{0x10, KEY_EN_DELETE},//15
{0x11, KEY_EN_HOME},//16
{0x12, KEY_EN_END},//17
{0x13, KEY_EN_PAGE_UP},//18
{0x14, KEY_EN_PAGE_DOWN},//19
//row 2
{0x16, KEY_EN_BACK_TICK},//20
{0x17, KEY_EN_1},//21
{0x18, KEY_EN_2},//22
{0x19, KEY_EN_3},//23
{0x1A, KEY_EN_4},//24
{0x1B, KEY_EN_5},//25
{0x1C, KEY_EN_6},//26
{0x1D, KEY_EN_7},//27
{0x1E, KEY_EN_8},//28
{0x1F, KEY_EN_9},//29
{0x20, KEY_EN_0},//30
{0x21, KEY_EN_MINUS},//31
{0x22, KEY_EN_EQUALS},//32
{0x38, KEY_EN_BACKSPACE},//33
{0x26, KEY_EN_NUMPAD_LOCK},//34
{0x27, KEY_EN_NUMPAD_DIVIDE},//35
{0x28, KEY_EN_NUMPAD_TIMES},//36
{0x29, KEY_EN_NUMPAD_MINUS},//37
//row 3
{0x40, KEY_EN_TAB},//38
{0x42, KEY_EN_Q},//39
{0x43, KEY_EN_W},//40
{0x44, KEY_EN_E},//41
{0x45, KEY_EN_R},//42
{0x46, KEY_EN_T},//43
{0x47, KEY_EN_Y},//44
{0x48, KEY_EN_U},//45
{0x49, KEY_EN_I},//46
{0x4A, KEY_EN_O},//47
{0x4B, KEY_EN_P},//48
{0x4C, KEY_EN_LEFT_BRACKET},//49
{0x4D, KEY_EN_RIGHT_BRACKET},//50
{0x4E, KEY_EN_ANSI_BACK_SLASH},//51
{0x4F, KEY_EN_NUMPAD_7},//52
{0x50, KEY_EN_NUMPAD_8},//53
{0x51, KEY_EN_NUMPAD_9},//54
//row 4
{0x55, KEY_EN_CAPS_LOCK},//55
{0x6D, KEY_EN_A},//56
{0x6E, KEY_EN_S},//57
{0x58, KEY_EN_D},//58
{0x59, KEY_EN_F},//59
{0x5A, KEY_EN_G},//60
{0x71, KEY_EN_H},//61
{0x72, KEY_EN_J},//62
{0x5B, KEY_EN_K},//63
{0x5C, KEY_EN_L},//64
{0x5D, KEY_EN_SEMICOLON},//65
{0x5F, KEY_EN_QUOTE},//66
{0x77, KEY_EN_ANSI_ENTER},//67
{0x79, KEY_EN_NUMPAD_4},//68
{0x7B, KEY_EN_NUMPAD_5},//69
{0x7C, KEY_EN_NUMPAD_6},//70
{0x68, KEY_EN_NUMPAD_PLUS},//71
//row 5
{0x6A, KEY_EN_LEFT_SHIFT},//72
{0x82, KEY_EN_Z},//73
{0x83, KEY_EN_X},//74
{0x6F, KEY_EN_C},//75
{0x70, KEY_EN_V},//76
{0x87, KEY_EN_B},//77
{0x88, KEY_EN_N},//78
{0x73, KEY_EN_M},//79
{0x74, KEY_EN_COMMA},//80
{0x75, KEY_EN_PERIOD},//81
{0x76, KEY_EN_FORWARD_SLASH},//82
{0x8D, KEY_EN_RIGHT_SHIFT},//83
{0x8E, KEY_EN_NUMPAD_1},//84
{0x90, KEY_EN_NUMPAD_2},//85
{0x92, KEY_EN_NUMPAD_3},//86
//row 6
{0x7F, KEY_EN_LEFT_CONTROL},//87
{0x80, KEY_EN_LEFT_FUNCTION},//88
{0x96, KEY_EN_LEFT_WINDOWS},//89
{0x97, KEY_EN_LEFT_ALT},//90
{0x98, KEY_EN_SPACE},//91
{0x9A, KEY_EN_RIGHT_ALT},//92
{0x9B, KEY_EN_RIGHT_CONTROL},//93
{0x9D, KEY_EN_UP_ARROW},//94
{0xA3, KEY_EN_NUMPAD_0},//95
{0xA5, KEY_EN_NUMPAD_PERIOD},//96
{0xA7, KEY_EN_NUMPAD_ENTER},//97
//row 7
{0x9C, KEY_EN_LEFT_ARROW},//98
{0x9F, KEY_EN_DOWN_ARROW},//99
{0xA1, KEY_EN_RIGHT_ARROW},//100
};
const lenovo_led legion_7gen7_neon_leds[]
{
{0xF5, "Neon group 1"},//0
{0xF6, "Neon group 2"},//1
{0xF7, "Neon group 3"},//2
{0xF8, "Neon group 4"},//3
{0xF9, "Neon group 5"},//4
{0xFA, "Neon group 6"},//5
{0xFB, "Neon group 7"},//6
{0xFC, "Neon group 8"},//7
{0xFD, "Neon group 9"},//8
{0xFE, "Neon group 10"},//9
};
const lenovo_led legion_7gen7_vents_leds[]
{
{0xE9, "Vent group 1"},//0
{0xEA, "Vent group 2"},//1
{0xEB, "Vent group 3"},//2
{0xEC, "Vent group 4"},//3
{0xED, "Vent group 5"},//4
{0xEE, "Vent group 6"},//5
{0xEF, "Vent group 7"},//6
{0xF0, "Vent group 8"},//7
};
const lenovo_led legion_7gen7_logo_leds[]
{
{0xDD, "Logo"},//0
};
/*------*\
|keyboard|
\*------*/
static lenovo_zone lenovo_legion_7gen7_kbd_ansi
{
"Keyboard",
ZONE_TYPE_MATRIX,
0,
7,
20,
legion_7gen7_ansi_leds_map,
legion_7gen7_ansi_leds,
0,
100,
};
/*------*\
|logo |
\*------*/
static lenovo_zone lenovo_legion_7gen7_logo
{
"Logo",
ZONE_TYPE_LINEAR,
5,
1,
1,
NULL,
legion_7gen7_logo_leds,
0,
0,
};
/*------*\
|vents |
\*------*/
static lenovo_zone lenovo_legion_7gen7_vents
{
"Vents",
ZONE_TYPE_LINEAR,
3,
1,
8,
NULL,
legion_7gen7_vents_leds,
0,
7,
};
/*------*\
|neon |
\*------*/
static lenovo_zone lenovo_legion_7gen7_neon
{
"Neon",
ZONE_TYPE_LINEAR,
1,
1,
10,
NULL,
legion_7gen7_neon_leds,
0,
9,
};
#endif

300
Controllers/LenovoControllers/LenovoGen7USBController.cpp Normal file
View file

@ -0,0 +1,300 @@
#include "LenovoGen7USBController.h"
#include <sstream>
#include <iomanip>
using namespace std;
LenovoGen7USBController::LenovoGen7USBController(hid_device* dev_handle, const char* path, uint16_t in_pid)
{
const uint8_t sz = HID_MAX_STR;
wchar_t tmp[sz];
dev = dev_handle;
location = path;
pid = in_pid;
hid_get_manufacturer_string(dev, tmp, sz);
std::wstring w_tmp = wstring(tmp);
name = string(w_tmp.begin(), w_tmp.end());
hid_get_product_string(dev, tmp, sz);
w_tmp = wstring(tmp);
name.append(" ").append(string(w_tmp.begin(), w_tmp.end()));
}
LenovoGen7USBController::~LenovoGen7USBController()
{
hid_close(dev);
}
uint16_t LenovoGen7USBController::getPid()
{
return pid;
}
string LenovoGen7USBController::getName()
{
return name;
}
string LenovoGen7USBController::getLocation()
{
return location;
}
void LenovoGen7USBController::setLedsByGroup(uint8_t profile_id, vector<led_group> led_groups)
{
uint8_t buffer[PACKET_SIZE];
memset(buffer, 0x00, PACKET_SIZE);
size_t i = 0;
buffer[i++] = REPORT_ID;
buffer[i++] = SAVE_PROFILE;
buffer[i++] = 0xC0;
buffer[i++] = 0x03;
buffer[i++] = profile_id;
buffer[i++] = 0x01;
buffer[i++] = 0x01;
for(size_t group = 0; group < led_groups.size() && i < PACKET_SIZE - 21; group++)
{
buffer[i++] = group + 1; //Group index
buffer[i++] = 0x06;
buffer[i++] = 0x01;
buffer[i++] = led_groups[group].mode;
buffer[i++] = 0x02;
buffer[i++] = led_groups[group].speed;
buffer[i++] = 0x03;
buffer[i++] = led_groups[group].spin;
buffer[i++] = 0x04;
buffer[i++] = led_groups[group].direction;
buffer[i++] = 0x05;
buffer[i++] = led_groups[group].color_mode;
buffer[i++] = 0x06;
buffer[i++] = 0x00;
buffer[i++] = led_groups[group].colors.size();
for(RGBColor c : led_groups[group].colors)
{
buffer[i++] = RGBGetRValue(c);
buffer[i++] = RGBGetGValue(c);
buffer[i++] = RGBGetBValue(c);
}
vector<uint16_t> leds = led_groups[group].leds;
size_t led_count = min(leds.size(), (PACKET_SIZE - i)/2);
buffer[i++] = led_count;
uint8_t* byte_ptr = reinterpret_cast<uint8_t*>(leds.data());
std::copy(byte_ptr, byte_ptr + led_count * sizeof(uint16_t), buffer + i);
i+= led_count * sizeof(uint16_t);
}
buffer[2] = i;
sendFeatureReport(buffer, PACKET_SIZE);
}
void LenovoGen7USBController::setLedsDirectOn(uint8_t profile_id)
{
uint8_t buffer[PACKET_SIZE];
memset(buffer, 0x00, PACKET_SIZE);
size_t i = 0;
buffer[i++] = REPORT_ID;
buffer[i++] = SET_DIRECT_MODE;
buffer[i++] = 0xC0;
buffer[i++] = 0x03;
buffer[i++] = 0x01;
buffer[i++] = profile_id;
sendFeatureReport(buffer, PACKET_SIZE);
}
void LenovoGen7USBController::setLedsDirectOff(uint8_t profile_id)
{
uint8_t buffer[PACKET_SIZE];
memset(buffer, 0x00, PACKET_SIZE);
size_t i = 0;
buffer[i++] = REPORT_ID;
buffer[i++] = SET_DIRECT_MODE;
buffer[i++] = 0xC0;
buffer[i++] = 0x03;
buffer[i++] = 0x02;
buffer[i++] = profile_id;
sendFeatureReport(buffer, PACKET_SIZE);
}
void LenovoGen7USBController::setLedsDirect(std::vector<led> &leds, std::vector<RGBColor> &colors)
{
uint8_t buffer[PACKET_SIZE];
memset(buffer, 0x00, PACKET_SIZE);
size_t i = 0;
buffer[i++] = REPORT_ID;
buffer[i++] = DIRECT_MODE;
buffer[i++] = 0xC0;
buffer[i++] = 0x03;
for(size_t index = 0; index < leds.size() && i < PACKET_SIZE; index++)
{
buffer[i++] = leds[index].value & 0xFF;
buffer[i++] = leds[index].value >> 8 & 0xFF;
buffer[i++] = RGBGetRValue(colors[index]);
buffer[i++] = RGBGetGValue(colors[index]);
buffer[i++] = RGBGetBValue(colors[index]);
}
sendFeatureReport(buffer, PACKET_SIZE);
}
void LenovoGen7USBController::setLedsAllOff(uint8_t profile_id)
{
uint8_t buffer[PACKET_SIZE] = {REPORT_ID, SAVE_PROFILE, 0xC0, 0x03, profile_id, 0x01, 0x01};
sendFeatureReport(buffer, PACKET_SIZE);
}
uint8_t LenovoGen7USBController::getCurrentProfileId()
{
uint8_t buffer[PACKET_SIZE] = {REPORT_ID, GET_ACTIVE_PROFILE, 0xC0, 0x03};
vector<uint8_t> response = getFeatureReport(buffer, PACKET_SIZE);
return response.size()>4?response[4]:0x01;
}
uint8_t LenovoGen7USBController::getCurrentBrightness()
{
uint8_t buffer[PACKET_SIZE] = {REPORT_ID, GET_BRIGHTNESS, 0xC0, 0x03};
vector<uint8_t> response = getFeatureReport(buffer, PACKET_SIZE);
return response.size()>4?response[4]:0x00;
}
void LenovoGen7USBController::setBrightness(uint8_t brightness)
{
uint8_t buffer[PACKET_SIZE] = {REPORT_ID, SET_BRIGHTNESS, 0xC0, 0x03, brightness};
sendFeatureReport(buffer, PACKET_SIZE);
}
void LenovoGen7USBController::switchProfileTo(uint8_t profile_id)
{
uint8_t buffer[PACKET_SIZE] = {REPORT_ID, SWITCH_PROFILE, 0xC0, 0x03, profile_id};
sendFeatureReport(buffer, PACKET_SIZE);
}
std::vector<led_group> LenovoGen7USBController::getProfileSettings(uint8_t profile_id)
{
uint8_t buffer[PACKET_SIZE] = {REPORT_ID, GET_PROFILE, 0xC0, 0x03, profile_id};
vector<uint8_t> response = getFeatureReport(buffer, PACKET_SIZE);
vector<led_group> groups;
size_t i = 7;
while(i < response.size() && response[i] != 0x00){
i++;
led_group group;
/*-----------------*\
|read group settings|
\*-----------------*/
size_t cnt = response[i++];
for(size_t j = 0; j < cnt && i < response.size(); j++, i+=2)
{
switch(response[i])
{
case 0x01:
group.mode = response[i+1];
break;
case 0x02:
group.speed = response[i+1];
break;
case 0x03:
group.spin = response[i+1];
break;
case 0x04:
group.direction = response[i+1];
break;
case 0x05:
group.color_mode = response[i+1];
break;
case 0x06:
//group.mode = response[i+1];
break;
}
}
/*-----------------*\
|read group colors |
\*-----------------*/
cnt = response[i++];
for(size_t j = 0; j < cnt && i < response.size(); j++, i+=3)
{
group.colors.push_back(ToRGBColor(response[i],response[i+1],response[i+2]));
}
/*-----------------*\
|read group LEDs |
\*-----------------*/
cnt = response[i++];
for(size_t j = 0; j < cnt && i < response.size(); j++, i+=2)
{
group.leds.push_back(response[i] | response[i+1] << 8);
}
groups.push_back(group);
}
return groups;
}
void LenovoGen7USBController::sendFeatureReport(uint8_t packet[], size_t packet_size)
{
hid_send_feature_report(dev, packet, packet_size);
LOG_TRACE("[Lenovo Gen 7 Controller] Buffer: %s", ConvertBytesToHex(packet, packet_size).c_str());
}
std::vector<uint8_t> LenovoGen7USBController::getFeatureReport(uint8_t packet[], size_t packet_size)
{
sendFeatureReport(packet, packet_size);
uint8_t read_buffer[PACKET_SIZE] = {REPORT_ID};
int num_bytes = 0;
num_bytes = hid_get_feature_report(dev, read_buffer, sizeof(read_buffer));
vector<uint8_t> response = {};
if(num_bytes > 0)
{
response.insert(response.begin(), read_buffer, read_buffer + num_bytes);
}
LOG_TRACE("[Lenovo Gen 7 Controller] Read Buffer: %s", ConvertBytesToHex(response).c_str());
return response;
}
std::string LenovoGen7USBController::ConvertBytesToHex(uint8_t packet[], size_t packet_size)
{
return ConvertBytesToHex(std::vector<uint8_t>(packet, packet + packet_size));
}
std::string LenovoGen7USBController::ConvertBytesToHex(const std::vector<uint8_t> &input)
{
std::ostringstream temp_stream;
for(const uint8_t &oneInputByte : input)
{
temp_stream << (temp_stream.tellp()==0 ? "" : " ") << std::setw(2) << std::setfill('0') << std::hex << (int)oneInputByte;
}
return temp_stream.str();
}

97
Controllers/LenovoControllers/LenovoGen7USBController.h Normal file
View file

@ -0,0 +1,97 @@
/*-------------------------------------------------------------------*\
| LenovoGen7USBController.h |
| |
| Driver for Lenovo Legion 7 Gen 7 |
| |
| Peter Vazny 15 Nov 2022 |
| |
\*-------------------------------------------------------------------*/
#include "RGBController.h"
#include "LogManager.h"
#include <string>
#include <array>
#include <vector>
#include <utility>
#include <hidapi/hidapi.h>
#ifndef HID_MAX_STR
#define HID_MAX_STR 255
#endif
#ifndef LENOVOGEN7USBCONTROLLER_H
#define LENOVOGEN7USBCONTROLLER_H
#define PACKET_SIZE 960
#define REPORT_ID 0x07
#define DIRECT_MODE 0xA1
#define SWITCH_PROFILE 0xC8
#define GET_ACTIVE_PROFILE 0xCA
#define SAVE_PROFILE 0xCB
#define GET_PROFILE 0xCC
#define GET_BRIGHTNESS 0xCD
#define SET_BRIGHTNESS 0xCE
#define SET_DIRECT_MODE 0xD0
#define GET_DIRECT_MODE_PROFILE 0xD1
struct led_group
{
uint8_t mode;
uint8_t speed;
uint8_t spin;
uint8_t direction;
uint8_t color_mode;
std::vector<RGBColor> colors;
std::vector<uint16_t> leds;
};
class LenovoGen7USBController
{
public:
/*--------------*\
|ctor(s) and dtor|
\*--------------*/
LenovoGen7USBController(hid_device* dev_handle, const char* path, uint16_t in_pid);
LenovoGen7USBController();
~LenovoGen7USBController();
/*--------------*\
|device functions|
\*--------------*/
void setLedsByGroup(uint8_t profile_id, std::vector<led_group> led_groups);
void setLedsDirect(std::vector<led> &leds, std::vector<RGBColor> &colors);
void setLedsAllOff(uint8_t profile_id);
void setLedsDirectOn(uint8_t profile_id);
void setLedsDirectOff(uint8_t profile_id);
uint16_t getPid();
std::string getName();
std::string getLocation();
uint8_t getCurrentProfileId();
uint8_t getCurrentBrightness();
void setBrightness(uint8_t brightness);
uint8_t getKeyboardId();
void switchProfileTo(uint8_t profile_id);
std::vector<led_group> getProfileSettings(uint8_t profile_id);
private:
/*--------------*\
|data members |
\*--------------*/
std::string name;
hid_device *dev;
std::string location;
uint16_t pid;
/*--------------*\
|device functions|
\*--------------*/
void sendFeatureReport(uint8_t packet[], size_t packet_size);
std::vector<uint8_t> getFeatureReport(uint8_t packet[], size_t packet_size);
std::string ConvertBytesToHex(uint8_t packet[], size_t packet_size);
std::string ConvertBytesToHex(const std::vector<uint8_t> &input);
};
#endif // LENOVOGEN7USBCONTROLLER_H

27
Controllers/LenovoControllers/LenovoUSBDetect.cpp
View file

@ -10,9 +10,11 @@
#include "Detector.h"
#include "LogManager.h"
#include "RGBController.h"
#include "LenovoGen7USBController.h"
#include "LenovoUSBController.h"
#include "LenovoDevices.h"
#include "RGBController_LenovoUSB.h"
#include "RGBController_Lenovo_Gen7USB.h"
#include <hidapi/hidapi.h>
/*-----------------------------------------------------*\
@ -43,8 +45,23 @@ void DetectLenovoLegionUSBControllers(hid_device_info* info, const std::string&
}
}
REGISTER_HID_DETECTOR_PU("Lenovo Legion Y740", DetectLenovoLegionUSBControllers, ITE_VID, LEGION_Y740, LENOVO_PAGE, LENOVO_USEAGE);
REGISTER_HID_DETECTOR_PU("Lenovo Legion 7 gen 5", DetectLenovoLegionUSBControllers, ITE_VID, LEGION_Y750, LENOVO_PAGE, LENOVO_USEAGE);
REGISTER_HID_DETECTOR_PU("Lenovo Legion 7S gen 5", DetectLenovoLegionUSBControllers, ITE_VID, LEGION_Y750S, LENOVO_PAGE, LENOVO_USEAGE);
REGISTER_HID_DETECTOR_PU("Lenovo Legion 7 gen 6", DetectLenovoLegionUSBControllers, ITE_VID, LEGION_Y760, LENOVO_PAGE, LENOVO_USEAGE);
REGISTER_HID_DETECTOR_PU("Lenovo Legion 7S gen 6", DetectLenovoLegionUSBControllers, ITE_VID, LEGION_Y760S, LENOVO_PAGE, LENOVO_USEAGE);
void DetectLenovoLegionUSBControllersGen7(hid_device_info* info, const std::string& name)
{
hid_device* dev = hid_open_path(info->path);
if(dev)
{
LenovoGen7USBController* controller = new LenovoGen7USBController(dev, info->path, info->product_id);
RGBController_Lenovo_Gen7USB* rgb_controller = new RGBController_Lenovo_Gen7USB(controller);
rgb_controller->name = name;
ResourceManager::get()->RegisterRGBController(rgb_controller);
}
}
REGISTER_HID_DETECTOR_PU("Lenovo Legion Y740", DetectLenovoLegionUSBControllers, ITE_VID, LEGION_Y740, LENOVO_PAGE, LENOVO_USEAGE);
REGISTER_HID_DETECTOR_PU("Lenovo Legion 7 gen 5", DetectLenovoLegionUSBControllers, ITE_VID, LEGION_Y750, LENOVO_PAGE, LENOVO_USEAGE);
REGISTER_HID_DETECTOR_PU("Lenovo Legion 7S gen 5", DetectLenovoLegionUSBControllers, ITE_VID, LEGION_Y750S, LENOVO_PAGE, LENOVO_USEAGE);
REGISTER_HID_DETECTOR_PU("Lenovo Legion 7 gen 6", DetectLenovoLegionUSBControllers, ITE_VID, LEGION_Y760, LENOVO_PAGE, LENOVO_USEAGE);
REGISTER_HID_DETECTOR_PU("Lenovo Legion 7S gen 6", DetectLenovoLegionUSBControllers, ITE_VID, LEGION_Y760S, LENOVO_PAGE, LENOVO_USEAGE);
REGISTER_HID_DETECTOR_PU("Lenovo Legion 7 gen 7", DetectLenovoLegionUSBControllersGen7, ITE_VID, LEGION_7GEN7, LENOVO_PAGE, LENOVO_USEAGE);

6
Controllers/LenovoControllers/RGBController_LenovoUSB.cpp
View file

@ -288,6 +288,12 @@ void RGBController_LenovoUSB::SetupZones()
lenovo_zones.push_back(lenovo_legion_Y760_vent_back_left);
lenovo_zones.push_back(lenovo_legion_Y760_neon);
break;
case LEGION_7GEN7:
lenovo_zones.push_back(lenovo_legion_7gen7_kbd_ansi);
lenovo_zones.push_back(lenovo_legion_7gen7_logo);
lenovo_zones.push_back(lenovo_legion_7gen7_vents);
lenovo_zones.push_back(lenovo_legion_7gen7_neon);
break;
}
for(unsigned int i = 0; i < lenovo_zones.size(); i++)

611
Controllers/LenovoControllers/RGBController_Lenovo_Gen7USB.cpp Normal file
View file

@ -0,0 +1,611 @@
#include "RGBController_Lenovo_Gen7USB.h"
#include "LenovoDevices.h"
#include <vector>
using namespace std;
RGBController_Lenovo_Gen7USB::RGBController_Lenovo_Gen7USB(LenovoGen7USBController* controller_ptr)
{
controller = controller_ptr;
name = "Legion 7 Gen 7";
vendor = "Lenovo";
type = DEVICE_TYPE_KEYBOARD;
description = "Legion 7 Gen 7";
brightness = controller->getCurrentBrightness();
profile_id = controller->getCurrentProfileId();
mode Screw;
Screw.name = "Screw Rainbow";
Screw.value = LENOVO_LEGION_GEN7_MODE_SCREW_RAINBOW;
Screw.flags = MODE_FLAG_HAS_SPEED |
MODE_FLAG_HAS_DIRECTION_LR |
MODE_FLAG_HAS_BRIGHTNESS |
MODE_FLAG_AUTOMATIC_SAVE;
Screw.speed_min = 0x01;
Screw.speed_max = 0x03;
Screw.speed = 2;
Screw.color_mode = MODE_COLORS_NONE;
Screw.brightness_min = 0;
Screw.brightness_max = 9;
Screw.brightness = brightness;
Screw.direction = MODE_DIRECTION_RIGHT;
modes.push_back(Screw);
mode Rainbow;
Rainbow.name = "Rainbow Wave";
Rainbow.value = LENOVO_LEGION_GEN7_MODE_RAINBOW_WAVE;
Rainbow.flags = MODE_FLAG_HAS_SPEED |
MODE_FLAG_HAS_DIRECTION_LR |
MODE_FLAG_HAS_DIRECTION_UD |
MODE_FLAG_HAS_BRIGHTNESS |
MODE_FLAG_AUTOMATIC_SAVE;
Rainbow.speed_min = 0x01;
Rainbow.speed_max = 0x03;
Rainbow.speed = 2;
Rainbow.color_mode = MODE_COLORS_NONE;
Rainbow.brightness_min = 0;
Rainbow.brightness_max = 9;
Rainbow.brightness = brightness;
Rainbow.direction = MODE_DIRECTION_RIGHT;
modes.push_back(Rainbow);
mode ColorChange;
ColorChange.name = "Color Change";
ColorChange.value = LENOVO_LEGION_GEN7_MODE_COLOR_CHANGE;
ColorChange.flags = MODE_FLAG_HAS_SPEED |
MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
MODE_FLAG_HAS_RANDOM_COLOR |
MODE_FLAG_HAS_BRIGHTNESS |
MODE_FLAG_AUTOMATIC_SAVE;
ColorChange.speed_min = 0x01;
ColorChange.speed_max = 0x03;
ColorChange.speed = 2;
ColorChange.colors_min = 1;
ColorChange.colors_max = 4;
ColorChange.colors.resize(4);
ColorChange.colors[0] = 0xFFF500;
ColorChange.color_mode = MODE_COLORS_RANDOM;
ColorChange.brightness_min = 0;
ColorChange.brightness_max = 9;
ColorChange.brightness = brightness;
modes.push_back(ColorChange);
mode ColorPulse;
ColorPulse.name = "Color Pulse";
ColorPulse.value = LENOVO_LEGION_GEN7_MODE_COLOR_PULSE;
ColorPulse.flags = MODE_FLAG_HAS_SPEED |
MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
MODE_FLAG_HAS_RANDOM_COLOR |
MODE_FLAG_HAS_BRIGHTNESS |
MODE_FLAG_AUTOMATIC_SAVE;
ColorPulse.speed_min = 0x01;
ColorPulse.speed_max = 0x03;
ColorPulse.speed = 2;
ColorPulse.colors_min = 1;
ColorPulse.colors_max = 4;
ColorPulse.colors.resize(4);
ColorPulse.colors[0] = 0xFFF500;
ColorPulse.color_mode = MODE_COLORS_RANDOM;
ColorPulse.brightness_min = 0;
ColorPulse.brightness_max = 9;
ColorPulse.brightness = brightness;
modes.push_back(ColorPulse);
mode ColorWave;
ColorWave.name = "Color Wave";
ColorWave.value = LENOVO_LEGION_GEN7_MODE_COLOR_WAVE;
ColorWave.flags = MODE_FLAG_HAS_SPEED |
MODE_FLAG_HAS_DIRECTION_LR |
MODE_FLAG_HAS_DIRECTION_UD |
MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
MODE_FLAG_HAS_RANDOM_COLOR |
MODE_FLAG_HAS_BRIGHTNESS |
MODE_FLAG_AUTOMATIC_SAVE;
ColorWave.speed_min = 0x01;
ColorWave.speed_max = 0x03;
ColorWave.speed = 2;
ColorWave.colors_min = 1;
ColorWave.colors_max = 4;
ColorWave.colors.resize(4);
ColorWave.colors[0] = 0xFFF500;
ColorWave.color_mode = MODE_COLORS_RANDOM;
ColorWave.brightness_min = 0;
ColorWave.brightness_max = 9;
ColorWave.brightness = brightness;
ColorWave.direction = MODE_DIRECTION_RIGHT;
modes.push_back(ColorWave);
mode Smooth;
Smooth.name = "Smooth";
Smooth.value = LENOVO_LEGION_GEN7_MODE_SMOOTH;
Smooth.flags = MODE_FLAG_HAS_SPEED |
MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
MODE_FLAG_HAS_RANDOM_COLOR |
MODE_FLAG_HAS_BRIGHTNESS |
MODE_FLAG_AUTOMATIC_SAVE;
Smooth.speed_min = 0x01;
Smooth.speed_max = 0x03;
Smooth.speed = 2;
Smooth.colors_min = 1;
Smooth.colors_max = 4;
Smooth.colors.resize(4);
Smooth.colors[0] = 0xFFF500;
Smooth.color_mode = MODE_COLORS_RANDOM;
Smooth.brightness_min = 0;
Smooth.brightness_max = 9;
Smooth.brightness = brightness;
modes.push_back(Smooth);
mode Rain;
Rain.name = "Rain";
Rain.value = LENOVO_LEGION_GEN7_MODE_RAIN;
Rain.flags = MODE_FLAG_HAS_SPEED |
MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
MODE_FLAG_HAS_RANDOM_COLOR |
MODE_FLAG_HAS_BRIGHTNESS |
MODE_FLAG_AUTOMATIC_SAVE;
Rain.speed_min = 0x01;
Rain.speed_max = 0x03;
Rain.speed = 2;
Rain.colors_min = 1;
Rain.colors_max = 4;
Rain.colors.resize(4);
Rain.colors[0] = 0xFFF500;
Rain.color_mode = MODE_COLORS_RANDOM;
Rain.brightness_min = 0;
Rain.brightness_max = 9;
Rain.brightness = brightness;
modes.push_back(Rain);
mode Ripple;
Ripple.name = "Ripple";
Ripple.value = LENOVO_LEGION_GEN7_MODE_RIPPLE;
Ripple.flags = MODE_FLAG_HAS_SPEED |
MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
MODE_FLAG_HAS_RANDOM_COLOR |
MODE_FLAG_HAS_BRIGHTNESS |
MODE_FLAG_AUTOMATIC_SAVE;
Ripple.speed_min = 0x01;
Ripple.speed_max = 0x03;
Ripple.speed = 2;
Ripple.colors_min = 1;
Ripple.colors_max = 4;
Ripple.colors.resize(4);
Ripple.colors[0] = 0xFFF500;
Ripple.color_mode = MODE_COLORS_RANDOM;
Ripple.brightness_min = 0;
Ripple.brightness_max = 9;
Ripple.brightness = brightness;
modes.push_back(Ripple);
mode AudioBounce;
AudioBounce.name = "Audio Bounce Lighting";
AudioBounce.value = LENOVO_LEGION_GEN7_MODE_AUDIO_BOUNCE;
AudioBounce.flags = MODE_FLAG_HAS_BRIGHTNESS;
AudioBounce.color_mode = MODE_COLORS_NONE;
AudioBounce.brightness_min = 0;
AudioBounce.brightness_max = 9;
AudioBounce.brightness = brightness;
modes.push_back(AudioBounce);
mode AudioRipple;
AudioRipple.name = "Audio Ripple Lighting";
AudioRipple.value = LENOVO_LEGION_GEN7_MODE_AUDIO_RIPPLE;
AudioRipple.flags = MODE_FLAG_HAS_BRIGHTNESS;
AudioRipple.color_mode = MODE_COLORS_NONE;
AudioRipple.brightness_min = 0;
AudioRipple.brightness_max = 9;
AudioRipple.brightness = brightness;
modes.push_back(AudioRipple);
mode Static;
Static.name = "Static";
Static.value = LENOVO_LEGION_GEN7_MODE_STATIC;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR |
MODE_FLAG_HAS_BRIGHTNESS |
MODE_FLAG_AUTOMATIC_SAVE;
Static.color_mode = MODE_COLORS_PER_LED;
Static.brightness_min = 0;
Static.brightness_max = 9;
Static.brightness = brightness;
modes.push_back(Static);
mode Type;
Type.name = "Type Lighting";
Type.value = LENOVO_LEGION_GEN7_MODE_TYPE;
Type.flags = MODE_FLAG_HAS_SPEED |
MODE_FLAG_HAS_MODE_SPECIFIC_COLOR |
MODE_FLAG_HAS_RANDOM_COLOR |
MODE_FLAG_HAS_BRIGHTNESS |
MODE_FLAG_AUTOMATIC_SAVE;
Type.speed_min = 0x01;
Type.speed_max = 0x03;
Type.speed = 2;
Type.colors_min = 1;
Type.colors_max = 4;
Type.colors.resize(4);
Type.colors[0] = 0xFFF500;
Type.color_mode = MODE_COLORS_RANDOM;
Type.brightness_min = 0;
Type.brightness_max = 9;
Type.brightness = brightness;
modes.push_back(Type);
mode Direct;
Direct.name = "Direct";
Direct.value = LENOVO_LEGION_GEN7_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR |
MODE_FLAG_HAS_BRIGHTNESS;
Direct.color_mode = MODE_COLORS_PER_LED;
Direct.brightness_min = 0;
Direct.brightness_max = 9;
Direct.brightness = brightness;
modes.push_back(Direct);
SetupZones();
/*-------------------------*\
| Initialize active mode |
\*-------------------------*/
active_mode = 10;
ReadDeviceSettings();
last_mode = active_mode;
}
RGBController_Lenovo_Gen7USB::~RGBController_Lenovo_Gen7USB()
{
delete controller;
}
void RGBController_Lenovo_Gen7USB::SetupZones()
{
vector<lenovo_zone> lenovo_zones;
lenovo_zones.push_back(lenovo_legion_7gen7_kbd_ansi);
lenovo_zones.push_back(lenovo_legion_7gen7_logo);
lenovo_zones.push_back(lenovo_legion_7gen7_vents);
lenovo_zones.push_back(lenovo_legion_7gen7_neon);
for(unsigned int i = 0; i < lenovo_zones.size(); i++)
{
zone new_zone;
new_zone.name = lenovo_zones[i].name;
new_zone.type = lenovo_zones[i].type;
new_zone.leds_count = lenovo_zones[i].end - lenovo_zones[i].start + 1;
new_zone.leds_max = new_zone.leds_count;
new_zone.leds_min = new_zone.leds_count;
LOG_DEBUG("[Lenovo Gen7 Controller] adding zone: %s with %u LEDs", new_zone.name.c_str(), new_zone.leds_count);
if(lenovo_zones[i].type == ZONE_TYPE_MATRIX)
{
new_zone.matrix_map = new matrix_map_type;
new_zone.matrix_map->height = lenovo_zones[i].height;
new_zone.matrix_map->width = lenovo_zones[i].width;
new_zone.matrix_map->map = new unsigned int[new_zone.matrix_map->height * new_zone.matrix_map->width];
if(lenovo_zones[i].matrix_map != NULL)
{
new_zone.matrix_map->map = (unsigned int *) lenovo_zones[i].matrix_map;
}
}
else
{
new_zone.matrix_map = NULL;
}
zones.push_back(new_zone);
for(unsigned int led_idx = lenovo_zones[i].start; led_idx <= lenovo_zones[i].end; led_idx++ )
{
led new_led;
new_led.name = lenovo_zones[i].leds[led_idx].name;
new_led.value = lenovo_zones[i].id << 8 | lenovo_zones[i].leds[led_idx].led_num ;
leds.push_back(new_led);
/*---------------------------------------------------------*\
| create led id to index map for fast look up |
\*---------------------------------------------------------*/
led_id_to_index[new_led.value]=leds.size() - 1;
}
}
SetupColors();
}
void RGBController_Lenovo_Gen7USB::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_Lenovo_Gen7USB::UpdateSingleLED(int led)
{
DeviceUpdateLEDs();
}
void RGBController_Lenovo_Gen7USB::UpdateZoneLEDs(int led)
{
DeviceUpdateLEDs();
}
void RGBController_Lenovo_Gen7USB::DeviceUpdateMode()
{
uint8_t hw_profile_id = controller->getCurrentProfileId();
if(hw_profile_id != profile_id) {
profile_id = hw_profile_id;
ReadDeviceSettings();
last_mode = active_mode;
}
if(brightness != modes[active_mode].brightness)
{
brightness = modes[active_mode].brightness;
controller->setBrightness(brightness);
for(mode &m : modes)
{
m.brightness = brightness;
}
}
if(last_mode != active_mode){
if(modes[last_mode].value == LENOVO_LEGION_GEN7_MODE_DIRECT)
{
controller->setLedsDirectOff(profile_id);
}
if(modes[active_mode].value == LENOVO_LEGION_GEN7_MODE_DIRECT)
{
controller->setLedsDirectOn(profile_id);
controller->setLedsByGroup(profile_id, GetLedGroups());
}
last_mode = active_mode;
}
if(modes[active_mode].value != LENOVO_LEGION_GEN7_MODE_DIRECT)
{
DeviceUpdateLEDs();
}
}
void RGBController_Lenovo_Gen7USB::DeviceUpdateLEDs()
{
if(modes[active_mode].value == LENOVO_LEGION_GEN7_MODE_DIRECT)
{
controller->setLedsDirect(leds, colors);
}
else
{
controller->setLedsByGroup(profile_id, GetLedGroups());
}
}
void RGBController_Lenovo_Gen7USB::ReadDeviceSettings()
{
vector<led_group> current_settings = controller->getProfileSettings(profile_id);
if(current_settings.size()>0)
{
for(int i = 0; i<modes.size(); i++){
if(modes[i].value == current_settings[0].mode)
{
switch(current_settings[0].color_mode)
{
case 0x02:
if(modes[i].flags & MODE_FLAG_HAS_PER_LED_COLOR)
{
modes[i].color_mode = MODE_COLORS_PER_LED;
}
else
{
modes[i].color_mode = MODE_COLORS_MODE_SPECIFIC;
}
break;
case 0x01:
modes[i].color_mode = MODE_COLORS_RANDOM;
break;
default:
modes[i].color_mode = MODE_COLORS_NONE;
}
switch(modes[i].color_mode)
{
case MODE_COLORS_PER_LED:
for(size_t j=0; j< colors.size(); j++) colors[j]=0x00;
for(const led_group &lg : current_settings)
{
if(lg.colors.size()>0)
{
for(uint16_t led_id : lg.leds)
{
if(auto search = led_id_to_index.find(led_id); search != led_id_to_index.end())
{
colors[search->second] = lg.colors[0];
}
}
}
}
break;
case MODE_COLORS_MODE_SPECIFIC:
for(size_t j=0; j<modes[i].colors.size(); j++)
{
if(j<current_settings[0].colors.size())
{
modes[i].colors[j] = current_settings[0].colors[j];
}
else
{
modes[i].colors[j] = 0x00;
}
}
}
switch(current_settings[0].direction)
{
case 0x01:
modes[i].direction = MODE_DIRECTION_UP;
break;
case 0x02:
modes[i].direction = MODE_DIRECTION_DOWN;
break;
case 0x03:
modes[i].direction = MODE_DIRECTION_LEFT;
break;
case 0x04:
modes[i].direction = MODE_DIRECTION_RIGHT;
break;
}
switch(current_settings[0].spin)
{
case 0x01:
modes[i].direction = MODE_DIRECTION_RIGHT;
break;
case 0x02:
modes[i].direction = MODE_DIRECTION_LEFT;
break;
}
active_mode = i;
break; //stop for loop
}
}
}
}
std::vector<led_group> RGBController_Lenovo_Gen7USB::GetLedGroups()
{
std::unordered_map<RGBColor, vector<uint16_t>> led_map;
if(modes[active_mode].color_mode == MODE_COLORS_PER_LED &&
modes[active_mode].value != LENOVO_LEGION_GEN7_MODE_DIRECT)
{
for(size_t i = 0; i < leds.size(); i++)
{
led_map[colors[i]].push_back(leds[i].value);
}
}
else
{
size_t start = 0;
size_t end = leds.size();
/*---------------------------------------------------------*\
| Riplle and Type only apply to keyboard |
\*---------------------------------------------------------*/
if(modes[active_mode].value == LENOVO_LEGION_GEN7_MODE_RIPPLE ||
modes[active_mode].value == LENOVO_LEGION_GEN7_MODE_TYPE)
{
for(const zone &z : zones)
{
if(z.name == "Keyboard")
{
start = z.start_idx;
end = start + z.leds_count;
}
}
}
for(size_t i = start; i < end; i++)
{
led_map[0x00].push_back(leds[i].value);
}
}
vector<led_group> led_groups;
for(const auto &pair : led_map)
{
if(pair.first == 0x00 && led_map.size() != 1)
{
continue;
}
led_group group;
group.mode = modes[active_mode].value;
group.speed = modes[active_mode].speed;
group.spin = 0x00;
group.direction = 0x00;
switch(modes[active_mode].direction)
{
case MODE_DIRECTION_UP:
group.direction = 0x01;
break;
case MODE_DIRECTION_DOWN:
group.direction = 0x02;
break;
case MODE_DIRECTION_LEFT:
if(modes[active_mode].value == LENOVO_LEGION_GEN7_MODE_SCREW_RAINBOW)
{
group.spin = 0x02;
}
else
{
group.direction = 0x03;
}
break;
case MODE_DIRECTION_RIGHT:
if(modes[active_mode].value == LENOVO_LEGION_GEN7_MODE_SCREW_RAINBOW)
{
group.spin = 0x01;
}
else
{
group.direction = 0x04;
}
break;
}
switch(modes[active_mode].color_mode)
{
default:
case MODE_COLORS_NONE:
group.color_mode = 0x00;
break;
case MODE_COLORS_RANDOM:
group.color_mode = 0x01;
break;
case MODE_COLORS_MODE_SPECIFIC:
group.color_mode = 0x02;
for(RGBColor c : modes[active_mode].colors)
{
if(c)
{
group.colors.push_back(c);
}
}
if(group.colors.size() == 0)
{
group.colors.push_back(0xFFF500);
}
break;
case MODE_COLORS_PER_LED:
group.color_mode = 0x02;
group.colors.push_back(pair.first);
break;
}
group.leds = pair.second;
led_groups.push_back(group);
}
return led_groups;
}

52
Controllers/LenovoControllers/RGBController_Lenovo_Gen7USB.h Normal file
View file

@ -0,0 +1,52 @@
#ifndef RGBCONTROLLER_LENOVO_GEN7USB_H
#define RGBCONTROLLER_LENOVO_GEN7USB_H
#pragma once
#include "RGBController.h"
#include "LenovoGen7USBController.h"
enum
{
LENOVO_LEGION_GEN7_MODE_SCREW_RAINBOW = 0x01,
LENOVO_LEGION_GEN7_MODE_RAINBOW_WAVE = 0x02,
LENOVO_LEGION_GEN7_MODE_COLOR_CHANGE = 0x03,
LENOVO_LEGION_GEN7_MODE_COLOR_PULSE = 0x04,
LENOVO_LEGION_GEN7_MODE_COLOR_WAVE = 0x05,
LENOVO_LEGION_GEN7_MODE_SMOOTH = 0x06,
LENOVO_LEGION_GEN7_MODE_RAIN = 0x07,
LENOVO_LEGION_GEN7_MODE_RIPPLE = 0x08,
LENOVO_LEGION_GEN7_MODE_AUDIO_BOUNCE = 0x09,
LENOVO_LEGION_GEN7_MODE_AUDIO_RIPPLE = 0x0A,
LENOVO_LEGION_GEN7_MODE_STATIC = 0x0B,
LENOVO_LEGION_GEN7_MODE_TYPE = 0x0C,
LENOVO_LEGION_GEN7_MODE_DIRECT = 0x0D,
};
class RGBController_Lenovo_Gen7USB : public RGBController
{
public:
RGBController_Lenovo_Gen7USB(LenovoGen7USBController* controller_ptr);
~RGBController_Lenovo_Gen7USB();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
LenovoGen7USBController* controller;
std::vector<led_group> GetLedGroups();
void ReadDeviceSettings();
std::unordered_map<unsigned int, size_t> led_id_to_index;
int last_mode = 0;
uint8_t brightness = 0x00;
uint8_t profile_id = 0x01;
};
#endif // RGBCONTROLLER_LENOVO_GEN7USB_H

14
OpenRGB.pro
View file

@ -551,12 +551,14 @@ HEADERS +=
Controllers/LEDStripController/RGBController_LEDStrip.h \
Controllers/LegoDimensionsToypadBaseController/LegoDimensionsToypadBaseController.h \
Controllers/LegoDimensionsToypadBaseController/RGBController_LegoDimensionsToypadBase.h \
Controllers/LenovoControllers/Lenovo4ZoneUSBController.h \
Controllers/LenovoControllers/LenovoDevices.h \
Controllers/LenovoControllers/LenovoDevices4Zone.h \
Controllers/LenovoControllers/LenovoGen7USBController.h \
Controllers/LenovoControllers/LenovoUSBController.h \
Controllers/LenovoControllers/Lenovo4ZoneUSBController.h \
Controllers/LenovoControllers/RGBController_LenovoUSB.h \
Controllers/LenovoControllers/RGBController_Lenovo4ZoneUSB.h \
Controllers/LenovoControllers/RGBController_LenovoUSB.h \
Controllers/LenovoControllers/RGBController_Lenovo_Gen7USB.h \
Controllers/LenovoMotherboardController/LenovoMotherboardController.h \
Controllers/LenovoMotherboardController/RGBController_LenovoMotherboard.h \
Controllers/LexipMouseController/LexipMouseController.h \
@ -1210,12 +1212,14 @@ SOURCES +=
Controllers/LegoDimensionsToypadBaseController/LegoDimensionsToypadBaseController.cpp \
Controllers/LegoDimensionsToypadBaseController/LegoDimensionsToypadBaseControllerDetect.cpp \
Controllers/LegoDimensionsToypadBaseController/RGBController_LegoDimensionsToypadBase.cpp \
Controllers/LenovoControllers/LenovoUSBController.cpp \
Controllers/LenovoControllers/Lenovo4ZoneUSBController.cpp \
Controllers/LenovoControllers/LenovoUSBDetect.cpp \
Controllers/LenovoControllers/Lenovo4ZoneUSBDetect.cpp \
Controllers/LenovoControllers/RGBController_LenovoUSB.cpp \
Controllers/LenovoControllers/LenovoGen7USBController.cpp \
Controllers/LenovoControllers/LenovoUSBController.cpp \
Controllers/LenovoControllers/LenovoUSBDetect.cpp \
Controllers/LenovoControllers/RGBController_Lenovo4ZoneUSB.cpp \
Controllers/LenovoControllers/RGBController_LenovoUSB.cpp \
Controllers/LenovoControllers/RGBController_Lenovo_Gen7USB.cpp \
Controllers/LenovoMotherboardController/LenovoMotherboardController.cpp \
Controllers/LenovoMotherboardController/LenovoMotherboardControllerDetect.cpp \
Controllers/LenovoMotherboardController/RGBController_LenovoMotherboard.cpp \