Add brightness and manual saving to EVGA v2 controller

TheRogueZeta · TheRogueZeta · commit ec1624a0b00b · 2021-10-07T20:46:07.000-07:00
diff --git a/Controllers/EVGAGPUController/EVGAGPUv2Controller.cpp b/Controllers/EVGAGPUController/EVGAGPUv2Controller.cpp
@@ -71,10 +71,9 @@ unsigned char EVGAGPUv2Controller::GetMode()
             }
             break;
         
-        case EVGA_GPU_V2_MODE_DIRECT:
+        case EVGA_GPU_V2_MODE_STATIC:
             {
-                //No way to detect static so just return direct.
-                return_mode = EVGA_GPU_V2_RGB_MODE_DIRECT;
+                return_mode = EVGA_GPU_V2_RGB_MODE_STATIC;
             }
             break;
 
@@ -121,40 +120,31 @@ unsigned char EVGAGPUv2Controller::GetSpeed()
     return (unsigned char) speed_16.u16;
 }
 
-void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor color2, unsigned int speed)
+void EVGAGPUv2Controller::SetMode(uint8_t mode, RGBColor color1, RGBColor color2, uint16_t speed, uint8_t brightness)
 {
-    bool boolSave = false;
 
     EnableWrite(true);
     switch (mode)
     {
     case EVGA_GPU_V2_RGB_MODE_OFF:
         {
             SendMode(EVGA_GPU_V2_MODE_OFF);
-            boolSave = true;
         }
         break;
 
-    case EVGA_GPU_V2_RGB_MODE_DIRECT:
     case EVGA_GPU_V2_RGB_MODE_STATIC:
         {
-            SendMode(EVGA_GPU_V2_MODE_DIRECT);
-            //Static is mode 0x01 but with SaveSettings()
-            boolSave = (mode == EVGA_GPU_V2_RGB_MODE_STATIC);
-
-            SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1));
+            SendMode(EVGA_GPU_V2_MODE_STATIC);
+            SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1), brightness);
         }
         break;
 
     case EVGA_GPU_V2_RGB_MODE_RAINBOW:
         {
             SendMode(EVGA_GPU_V2_MODE_RAINBOW);
-            //OpenRGB does not do brightness yet
-            SendBrightness(0x64); //Default = 0x64
+            SendBrightness(brightness); //Default = 0x64
             // Set Rainbow speed? No control in the GUI but this register is only set in Ranbow mode.
-            bus->i2c_smbus_write_byte_data(dev, 0x19, 0x11);
-
-            boolSave = true;
+            bus->i2c_smbus_write_byte_data(dev, 0x19, 0x11);;
         }
         break;
 
@@ -169,8 +159,8 @@ void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor
             | inspection is required.                                   |
             \*---------------------------------------------------------*/
 
-            SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1));
-            SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(color2), RGBGetGValue(color2), RGBGetBValue(color2));
+            SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1), brightness);
+            SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(color2), RGBGetGValue(color2), RGBGetBValue(color2), brightness);
 
             /*-----------------------------------------------------------------*\
             | Breathing mode speeds are consistent for B_TO_A and A_TO_B        |
@@ -185,22 +175,15 @@ void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor
             // 0x6A and 0x6B = 0x00
             bus->i2c_smbus_write_byte_data(dev, 0x6A,   0x00);
             bus->i2c_smbus_write_byte_data(dev, 0x6B,   0x00);
-
-            boolSave = true;
         }
         break;
 
     default:
         break;
     }
 
-    //Disable writes and Save (if applicable)
+    //Disable writes
     EnableWrite(false);
-
-    if(boolSave)
-    {
-        SaveSettings();
-    }
 }
 
 void EVGAGPUv2Controller::EnableWrite(bool boolEnable)
@@ -232,20 +215,20 @@ void EVGAGPUv2Controller::SaveSettings()
     bus->i2c_smbus_write_byte_data(dev, 0x0E,   0xE0);
 }
 
-void EVGAGPUv2Controller::SendBrightness(unsigned char brightness)
+void EVGAGPUv2Controller::SendBrightness(uint8_t brightness)
 {
     bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BRIGHTNESS, brightness);
 }
 
-void EVGAGPUv2Controller::SendColor(unsigned char start_register, unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness)
+void EVGAGPUv2Controller::SendColor(uint8_t start_register, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness)
 {
     bus->i2c_smbus_write_byte_data(dev, start_register,         red);
     bus->i2c_smbus_write_byte_data(dev, (start_register + 1),   green);
     bus->i2c_smbus_write_byte_data(dev, (start_register + 2),   blue);
     bus->i2c_smbus_write_byte_data(dev, (start_register + 3),   brightness);
 }
 
-void EVGAGPUv2Controller::SendMode(unsigned char mode)
+void EVGAGPUv2Controller::SendMode(uint8_t mode)
 {
     bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_MODE, mode);
 }
@@ -264,15 +247,10 @@ void EVGAGPUv2Controller::SendSpeed(u16_to_u8 aOnTime, u16_to_u8 bOnTime, u16_to
     bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_MSB, (unsigned char) aOnTime.MSB );
 }
 
-void EVGAGPUv2Controller::SetColor(RGBColor colorA, RGBColor colorB, bool boolSave)
+void EVGAGPUv2Controller::SetColor(RGBColor colorA, RGBColor colorB, uint8_t brightness)
 {
     EnableWrite(true);
-    SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(colorA), RGBGetGValue(colorA), RGBGetBValue(colorA), 0x64);
-    SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(colorB), RGBGetGValue(colorB), RGBGetBValue(colorB), 0x64);
+    SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(colorA), RGBGetGValue(colorA), RGBGetBValue(colorA), brightness);
+    SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(colorB), RGBGetGValue(colorB), RGBGetBValue(colorB), brightness);
     EnableWrite(false);
-
-    if(boolSave)
-    {
-        SaveSettings();
-    }
 }
diff --git a/Controllers/EVGAGPUController/EVGAGPUv2Controller.h b/Controllers/EVGAGPUController/EVGAGPUv2Controller.h
@@ -15,7 +15,10 @@
 
 typedef unsigned char	evga_dev_id;
 
-#define SPEED_MULTIPLIER 10
+#define SPEED_MULTIPLIER                10
+#define EVGA_GPU_V2_BRIGHTNESS_MIN      0x01
+#define EVGA_GPU_V2_BRIGHTNESS_DEFAULT  0x64
+#define EVGA_GPU_V2_BRIGHTNESS_MAX      0x64
 
 enum
 {
@@ -43,17 +46,16 @@ enum
 enum
 {
     EVGA_GPU_V2_RGB_MODE_OFF                = 0x00,
-    EVGA_GPU_V2_RGB_MODE_DIRECT             = 0x01, 
-    EVGA_GPU_V2_RGB_MODE_STATIC             = 0x02,
-    EVGA_GPU_V2_RGB_MODE_RAINBOW            = 0x03,
-    EVGA_GPU_V2_RGB_MODE_BREATHING          = 0x04,
-    EVGA_GPU_V2_RGB_MODE_PULSE              = 0x05,
+    EVGA_GPU_V2_RGB_MODE_STATIC             = 0x01,
+    EVGA_GPU_V2_RGB_MODE_RAINBOW            = 0x02,
+    EVGA_GPU_V2_RGB_MODE_BREATHING          = 0x03,
+    EVGA_GPU_V2_RGB_MODE_PULSE              = 0x04,
 };
 
 enum
 {
     EVGA_GPU_V2_MODE_OFF                    = 0x00,
-    EVGA_GPU_V2_MODE_DIRECT                 = 0x01, 
+    EVGA_GPU_V2_MODE_STATIC                 = 0x01, 
     EVGA_GPU_V2_MODE_RAINBOW                = 0x0F,
     EVGA_GPU_V2_MODE_BREATHING              = 0x22,
 };
@@ -92,15 +94,15 @@ class EVGAGPUv2Controller
     unsigned char   GetMode();
     unsigned char   GetSpeed();
 
-    void            SetColor(RGBColor colorA, RGBColor colorB, bool boolSave);
-    void            SetMode(unsigned char mode, RGBColor color1, RGBColor color2, unsigned int speed);
+    void            SetColor(RGBColor colorA, RGBColor colorB, uint8_t brightness);
+    void            SetMode(uint8_t mode, RGBColor color1, RGBColor color2, uint16_t speed, uint8_t brightness);
+    void            SaveSettings();
 
 private:
     void            EnableWrite(bool enable);
-    void            SaveSettings();
-    void            SendBrightness(unsigned char brightness = 0x64);
-    void            SendColor(unsigned char start_register, unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness = 0x64);
-    void            SendMode(unsigned char mode);
+    void            SendBrightness(uint8_t brightness);
+    void            SendColor(uint8_t start_register, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness);
+    void            SendMode(uint8_t mode);
     void            SendSpeed(u16_to_u8 aOnTime, u16_to_u8 bOnTime, u16_to_u8 b2a, u16_to_u8 a2b, u16_to_u8 speed_un);
 
     i2c_smbus_interface*    bus;
diff --git a/Controllers/EVGAGPUController/RGBController_EVGAGPUv2.cpp b/Controllers/EVGAGPUController/RGBController_EVGAGPUv2.cpp
@@ -21,60 +21,64 @@ RGBController_EVGAGPUv2::RGBController_EVGAGPUv2(EVGAGPUv2Controller* evga_ptr)
     type = DEVICE_TYPE_GPU;
 
     mode Off;
-    Off.name                = "Off";
-    Off.value               = EVGA_GPU_V2_RGB_MODE_OFF;
-    Off.flags               = 0;  //pretty sure not needed
-    Off.color_mode          = MODE_COLORS_NONE;
+    Off.name                    = "Off";
+    Off.value                   = EVGA_GPU_V2_RGB_MODE_OFF;
+    Off.flags                   = 0;  //pretty sure not needed
+    Off.color_mode              = MODE_COLORS_NONE;
     modes.push_back(Off);
 
-    mode Direct;
-    Direct.name             = "Direct";
-    Direct.value            = EVGA_GPU_V2_RGB_MODE_DIRECT;
-    Direct.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Direct.color_mode       = MODE_COLORS_PER_LED;
-    Direct.colors_min       = 1;
-    Direct.colors_max       = 1;
-    modes.push_back(Direct);
-
     mode Static;
-    Static.name             = "Static";
-    Static.value            = EVGA_GPU_V2_RGB_MODE_STATIC;
-    Static.flags            = MODE_FLAG_HAS_PER_LED_COLOR;
-    Static.color_mode       = MODE_COLORS_PER_LED;
-    Static.colors_min       = 1;
-    Static.colors_max       = 1;
+    Static.name                 = "Direct";
+    Static.value                = EVGA_GPU_V2_RGB_MODE_STATIC;
+    Static.flags                = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Static.color_mode           = MODE_COLORS_PER_LED;
+    Static.colors_min           = 1;
+    Static.colors_max           = 1;
+    Static.brightness_min       = EVGA_GPU_V2_BRIGHTNESS_MIN;
+    Static.brightness           = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
+    Static.brightness_max       = EVGA_GPU_V2_BRIGHTNESS_MAX;
+
     modes.push_back(Static);
 
     mode Rainbow;
-    Rainbow.name            = "Spectrum Cycle";
-    Rainbow.value           = EVGA_GPU_V2_RGB_MODE_RAINBOW;
-    Rainbow.flags           = MODE_FLAG_HAS_BRIGHTNESS;
-    Rainbow.color_mode      = MODE_COLORS_NONE;
+    Rainbow.name                = "Spectrum Cycle";
+    Rainbow.value               = EVGA_GPU_V2_RGB_MODE_RAINBOW;
+    Rainbow.flags               = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_MANUAL_SAVE;
+    Rainbow.color_mode          = MODE_COLORS_NONE;
+    Rainbow.brightness_min      = EVGA_GPU_V2_BRIGHTNESS_MIN;
+    Rainbow.brightness          = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
+    Rainbow.brightness_max      = EVGA_GPU_V2_BRIGHTNESS_MAX;
     modes.push_back(Rainbow);
 
     mode Breathing;
-    Breathing.name          = "Breathing";
-    Breathing.value         = EVGA_GPU_V2_RGB_MODE_BREATHING;
-    Breathing.flags         = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Breathing.speed_min     = EVGA_GPU_V2_SPEED_BREATHING_SLOWEST;
-    Breathing.speed         = EVGA_GPU_V2_SPEED_BREATHING_NORMAL;
-    Breathing.speed_max     = EVGA_GPU_V2_SPEED_BREATHING_FASTEST;
-    Breathing.color_mode    = MODE_COLORS_MODE_SPECIFIC;
-    Breathing.colors_min    = 1;
-    Breathing.colors_max    = 2;
+    Breathing.name              = "Breathing";
+    Breathing.value             = EVGA_GPU_V2_RGB_MODE_BREATHING;
+    Breathing.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Breathing.speed_min         = EVGA_GPU_V2_SPEED_BREATHING_SLOWEST;
+    Breathing.speed             = EVGA_GPU_V2_SPEED_BREATHING_NORMAL;
+    Breathing.speed_max         = EVGA_GPU_V2_SPEED_BREATHING_FASTEST;
+    Breathing.color_mode        = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.brightness_min    = EVGA_GPU_V2_BRIGHTNESS_MIN;
+    Breathing.brightness        = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
+    Breathing.brightness_max    = EVGA_GPU_V2_BRIGHTNESS_MAX;
+    Breathing.colors_min        = 1;
+    Breathing.colors_max        = 2;
     Breathing.colors.resize(1);
     modes.push_back(Breathing);
 
     mode Pulse;
-    Pulse.name              = "Flashing";
-    Pulse.value             = EVGA_GPU_V2_RGB_MODE_PULSE;
-    Pulse.flags             = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
-    Pulse.speed_min         = EVGA_GPU_V2_SPEED_PULSE_SLOWEST;
-    Pulse.speed             = EVGA_GPU_V2_SPEED_PULSE_NORMAL;
-    Pulse.speed_max         = EVGA_GPU_V2_SPEED_PULSE_FASTEST;
-    Pulse.color_mode        = MODE_COLORS_MODE_SPECIFIC;
-    Pulse.colors_min        = 1;
-    Pulse.colors_max        = 2;
+    Pulse.name                  = "Flashing";
+    Pulse.value                 = EVGA_GPU_V2_RGB_MODE_PULSE;
+    Pulse.flags                 = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_MANUAL_SAVE;
+    Pulse.speed_min             = EVGA_GPU_V2_SPEED_PULSE_SLOWEST;
+    Pulse.speed                 = EVGA_GPU_V2_SPEED_PULSE_NORMAL;
+    Pulse.speed_max             = EVGA_GPU_V2_SPEED_PULSE_FASTEST;
+    Pulse.color_mode            = MODE_COLORS_MODE_SPECIFIC;
+    Pulse.colors_min            = 1;
+    Pulse.colors_max            = 2;
+    Pulse.brightness_min        = EVGA_GPU_V2_BRIGHTNESS_MIN;
+    Pulse.brightness            = EVGA_GPU_V2_BRIGHTNESS_DEFAULT;
+    Pulse.brightness_max        = EVGA_GPU_V2_BRIGHTNESS_MAX;
     Pulse.colors.resize(1);
     modes.push_back(Pulse);
 
@@ -108,6 +112,7 @@ RGBController_EVGAGPUv2::RGBController_EVGAGPUv2(EVGAGPUv2Controller* evga_ptr)
 
     // Load speed settings from the card:
     modes[active_mode].speed = evga->GetSpeed();
+    modes[active_mode].brightness = evga->GetBrightnessA();
 }
 
 RGBController_EVGAGPUv2::~RGBController_EVGAGPUv2()
@@ -169,7 +174,7 @@ void RGBController_EVGAGPUv2::DeviceUpdateLEDs()
     | modes and as such colorB will always be black (0x000000)  |
     \*---------------------------------------------------------*/
 
-    evga->SetColor(colors[0], 0, (modes[active_mode].value != EVGA_GPU_V2_RGB_MODE_DIRECT) );
+    evga->SetColor(colors[0], /* colorB*/ 0, modes[active_mode].brightness);
 }
 
 void RGBController_EVGAGPUv2::UpdateZoneLEDs(int /*zone*/)
@@ -184,7 +189,7 @@ void RGBController_EVGAGPUv2::UpdateSingleLED(int /*led*/)
 
 void RGBController_EVGAGPUv2::SetCustomMode()
 {
-    active_mode = getModeIndex(EVGA_GPU_V2_RGB_MODE_DIRECT);
+    active_mode = getModeIndex(EVGA_GPU_V2_RGB_MODE_STATIC);
 }
 
 void RGBController_EVGAGPUv2::DeviceUpdateMode()
@@ -204,5 +209,10 @@ void RGBController_EVGAGPUv2::DeviceUpdateMode()
         colorB = (modes[active_mode].colors.size() == 2) ? modes[active_mode].colors[1] : 0 ;
     }
     
-    evga->SetMode( modes[active_mode].value, colorA, colorB, modes[active_mode].speed);
+    evga->SetMode( modes[active_mode].value, colorA, colorB, modes[active_mode].speed, modes[active_mode].brightness);
+}
+
+void RGBController_EVGAGPUv2::DeviceSaveMode()
+{
+    evga->SaveSettings();
 }
diff --git a/Controllers/EVGAGPUController/RGBController_EVGAGPUv2.h b/Controllers/EVGAGPUController/RGBController_EVGAGPUv2.h
@@ -28,6 +28,7 @@ class RGBController_EVGAGPUv2 : public RGBController
 
     void        SetCustomMode();
     void        DeviceUpdateMode();
+    void        DeviceSaveMode();
 
 private:
     int         getModeIndex(unsigned char mode_value);

Original file line number	Diff line number	Diff line change
`@@ -71,10 +71,9 @@ unsigned char EVGAGPUv2Controller::GetMode()`
`71`	`71`	`}`
`72`	`72`	`break;`
`73`	`73`
`74`		`- case EVGA_GPU_V2_MODE_DIRECT:`
	`74`	`+ case EVGA_GPU_V2_MODE_STATIC:`
`75`	`75`	`{`
`76`		`- //No way to detect static so just return direct.`
`77`		`- return_mode = EVGA_GPU_V2_RGB_MODE_DIRECT;`
	`76`	`+ return_mode = EVGA_GPU_V2_RGB_MODE_STATIC;`
`78`	`77`	`}`
`79`	`78`	`break;`
`80`	`79`
`@@ -121,40 +120,31 @@ unsigned char EVGAGPUv2Controller::GetSpeed()`
`121`	`120`	`return (unsigned char) speed_16.u16;`
`122`	`121`	`}`
`123`	`122`
`124`		`-void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor color2, unsigned int speed)`
	`123`	`+void EVGAGPUv2Controller::SetMode(uint8_t mode, RGBColor color1, RGBColor color2, uint16_t speed, uint8_t brightness)`
`125`	`124`	`{`
`126`		`- bool boolSave = false;`
`127`	`125`
`128`	`126`	`EnableWrite(true);`
`129`	`127`	`switch (mode)`
`130`	`128`	`{`
`131`	`129`	`case EVGA_GPU_V2_RGB_MODE_OFF:`
`132`	`130`	`{`
`133`	`131`	`SendMode(EVGA_GPU_V2_MODE_OFF);`
`134`		`- boolSave = true;`
`135`	`132`	`}`
`136`	`133`	`break;`
`137`	`134`
`138`		`- case EVGA_GPU_V2_RGB_MODE_DIRECT:`
`139`	`135`	`case EVGA_GPU_V2_RGB_MODE_STATIC:`
`140`	`136`	`{`
`141`		`- SendMode(EVGA_GPU_V2_MODE_DIRECT);`
`142`		`- //Static is mode 0x01 but with SaveSettings()`
`143`		`- boolSave = (mode == EVGA_GPU_V2_RGB_MODE_STATIC);`
`144`		`-`
`145`		`- SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1));`
	`137`	`+ SendMode(EVGA_GPU_V2_MODE_STATIC);`
	`138`	`+ SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1), brightness);`
`146`	`139`	`}`
`147`	`140`	`break;`
`148`	`141`
`149`	`142`	`case EVGA_GPU_V2_RGB_MODE_RAINBOW:`
`150`	`143`	`{`
`151`	`144`	`SendMode(EVGA_GPU_V2_MODE_RAINBOW);`
`152`		`- //OpenRGB does not do brightness yet`
`153`		`- SendBrightness(0x64); //Default = 0x64`
	`145`	`+ SendBrightness(brightness); //Default = 0x64`
`154`	`146`	`// Set Rainbow speed? No control in the GUI but this register is only set in Ranbow mode.`
`155`		`- bus->i2c_smbus_write_byte_data(dev, 0x19, 0x11);`
`156`		`-`
`157`		`- boolSave = true;`
	`147`	`+ bus->i2c_smbus_write_byte_data(dev, 0x19, 0x11);;`
`158`	`148`	`}`
`159`	`149`	`break;`
`160`	`150`
`@@ -169,8 +159,8 @@ void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor`
`169`	`159`	`\| inspection is required. \|`
`170`	`160`	`\---------------------------------------------------------/`
`171`	`161`
`172`		`- SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1));`
`173`		`- SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(color2), RGBGetGValue(color2), RGBGetBValue(color2));`
	`162`	`+ SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(color1), RGBGetGValue(color1), RGBGetBValue(color1), brightness);`
	`163`	`+ SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(color2), RGBGetGValue(color2), RGBGetBValue(color2), brightness);`
`174`	`164`
`175`	`165`	`/-----------------------------------------------------------------\`
`176`	`166`	`\| Breathing mode speeds are consistent for B_TO_A and A_TO_B \|`
`@@ -185,22 +175,15 @@ void EVGAGPUv2Controller::SetMode(unsigned char mode, RGBColor color1, RGBColor`
`185`	`175`	`// 0x6A and 0x6B = 0x00`
`186`	`176`	`bus->i2c_smbus_write_byte_data(dev, 0x6A, 0x00);`
`187`	`177`	`bus->i2c_smbus_write_byte_data(dev, 0x6B, 0x00);`
`188`		`-`
`189`		`- boolSave = true;`
`190`	`178`	`}`
`191`	`179`	`break;`
`192`	`180`
`193`	`181`	`default:`
`194`	`182`	`break;`
`195`	`183`	`}`
`196`	`184`
`197`		`- //Disable writes and Save (if applicable)`
	`185`	`+ //Disable writes`
`198`	`186`	`EnableWrite(false);`
`199`		`-`
`200`		`- if(boolSave)`
`201`		`- {`
`202`		`- SaveSettings();`
`203`		`- }`
`204`	`187`	`}`
`205`	`188`
`206`	`189`	`void EVGAGPUv2Controller::EnableWrite(bool boolEnable)`
`@@ -232,20 +215,20 @@ void EVGAGPUv2Controller::SaveSettings()`
`232`	`215`	`bus->i2c_smbus_write_byte_data(dev, 0x0E, 0xE0);`
`233`	`216`	`}`
`234`	`217`
`235`		`-void EVGAGPUv2Controller::SendBrightness(unsigned char brightness)`
	`218`	`+void EVGAGPUv2Controller::SendBrightness(uint8_t brightness)`
`236`	`219`	`{`
`237`	`220`	`bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_BRIGHTNESS, brightness);`
`238`	`221`	`}`
`239`	`222`
`240`		`-void EVGAGPUv2Controller::SendColor(unsigned char start_register, unsigned char red, unsigned char green, unsigned char blue, unsigned char brightness)`
	`223`	`+void EVGAGPUv2Controller::SendColor(uint8_t start_register, uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness)`
`241`	`224`	`{`
`242`	`225`	`bus->i2c_smbus_write_byte_data(dev, start_register, red);`
`243`	`226`	`bus->i2c_smbus_write_byte_data(dev, (start_register + 1), green);`
`244`	`227`	`bus->i2c_smbus_write_byte_data(dev, (start_register + 2), blue);`
`245`	`228`	`bus->i2c_smbus_write_byte_data(dev, (start_register + 3), brightness);`
`246`	`229`	`}`
`247`	`230`
`248`		`-void EVGAGPUv2Controller::SendMode(unsigned char mode)`
	`231`	`+void EVGAGPUv2Controller::SendMode(uint8_t mode)`
`249`	`232`	`{`
`250`	`233`	`bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_MODE, mode);`
`251`	`234`	`}`
`@@ -264,15 +247,10 @@ void EVGAGPUv2Controller::SendSpeed(u16_to_u8 aOnTime, u16_to_u8 bOnTime, u16_to`
`264`	`247`	`bus->i2c_smbus_write_byte_data(dev, EVGA_GPU_V2_REG_COLOR_A_ONTIME_MSB, (unsigned char) aOnTime.MSB );`
`265`	`248`	`}`
`266`	`249`
`267`		`-void EVGAGPUv2Controller::SetColor(RGBColor colorA, RGBColor colorB, bool boolSave)`
	`250`	`+void EVGAGPUv2Controller::SetColor(RGBColor colorA, RGBColor colorB, uint8_t brightness)`
`268`	`251`	`{`
`269`	`252`	`EnableWrite(true);`
`270`		`- SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(colorA), RGBGetGValue(colorA), RGBGetBValue(colorA), 0x64);`
`271`		`- SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(colorB), RGBGetGValue(colorB), RGBGetBValue(colorB), 0x64);`
	`253`	`+ SendColor(EVGA_GPU_V2_REG_COLOR_A_RED, RGBGetRValue(colorA), RGBGetGValue(colorA), RGBGetBValue(colorA), brightness);`
	`254`	`+ SendColor(EVGA_GPU_V2_REG_COLOR_B_RED, RGBGetRValue(colorB), RGBGetGValue(colorB), RGBGetBValue(colorB), brightness);`
`272`	`255`	`EnableWrite(false);`
`273`		`-`
`274`		`- if(boolSave)`
`275`		`- {`
`276`		`- SaveSettings();`
`277`		`- }`
`278`	`256`	`}`