Fixed screen dimming when changing power profiles & new config with legal values for fan lower limits + tests

Author: aredden

.gitignore

@@ -228,3 +228,5 @@ fabric.properties
 random/
 starto.ps1
 .vscode/launch.json
+config.DAT
+testing files/brightnesstest.py

G14Control.pyw

@@ -51,3 +51,7 @@ def kill(self):
         if res > 1:
             ctypes.pythonapi.PyThreadState_SetAsyncExc(self.ident, 0)
             print('Exception raise failure')
+
+
+fans = psutil.sensors_fans()
+print(fans.values())

G14ControlThreads.py

@@ -22,7 +22,6 @@ def __init__(self, config, G14dir, app_GUID, dpp_GUID, notify, windows_plans, ac
     def set_windows_and_active_plans(self, winplns, activeplns):
         self.active_plan_map = activeplns
         self.windows_plans = winplns
-
         # noinspection PyBroadException
 
     # Small utility to convert windows HEX format to a boolean.
@@ -70,25 +69,16 @@ def do_boost(self, state):
                          creationflags=subprocess.CREATE_NO_WINDOW)
         subprocess.Popen(SET_DC_VAL, shell=True,
                          creationflags=subprocess.CREATE_NO_WINDOW)
-        print(SET_AC_VAL)
-        print(SET_DC_VAL)
+        self.finalize_powercfg_chg(pwr_guid)
+        if self.config['debug']:
+            print(SET_AC_VAL)
+            print(SET_DC_VAL)
 
     def set_boost(self, state, notification=True):
-        current_boost_mode = state
-        win_plans = self.windows_plans
-        active_plans = self.active_plan_map
-        windows_plan_map = self.windows_plan_map
         CURRENT_SCHEME = os.popen("powercfg /GETACTIVESCHEME")
         pwr_guid = CURRENT_SCHEME.readlines()[0].rsplit(": ")[1].rsplit(
             " (")[0].lstrip("\n").replace(" ", "")  # Parse the GUID
-        switch_to = list(
-            {val for key, val in windows_plan_map.items() if val != pwr_guid})[0]
-        print(switch_to, "switch to guid")
         print(pwr_guid, "power guid")
-        print(self.active_plan_map)
-        self.set_power_plan(switch_to)
-        time.sleep(.25)
-        self.set_power_plan(pwr_guid)
         if state is True:  # Activate boost
             self.do_boost(state)
             if notification is True:
@@ -104,15 +94,11 @@ def set_boost(self, state, notification=True):
         elif state == 4:
             self.do_boost(state)
             if notification is True:
-                # Inform the user
-                self.notify("Boost set to Efficient Aggressive")
+                self.notify("Boost: Efficient Aggressive")  # Inform the user
         elif state == 2:
             self.do_boost(state)
             if notification is True:
-                self.notify("Boost set to Aggressive")  # Inform the user
-        self.set_power_plan(switch_to)
-        time.sleep(0.25)
-        self.set_power_plan(pwr_guid)
+                self.notify("Boost: Aggressive")  # Inform the user
 
     def get_dgpu(self):
         # I know, it's ugly, but no other way to do that from py.
@@ -132,7 +118,6 @@ def get_dgpu(self):
             return True
 
     def set_dgpu(self, state, notification=True):
-        config = self.config
         G14dir = self.G14dir
         # Just to be safe, let's get the current power scheme
         current_pwr = os.popen("powercfg /GETACTIVESCHEME")
@@ -235,6 +220,11 @@ def set_power_plan(self, GUID):
         if self.config['debug']:
             print('Set power result (good if nothing): ', result)
 
+    def finalize_powercfg_chg(self, GUID):
+        time.sleep(.25)
+        subprocess.Popen(['powercfg', '-setactive', GUID], shell=True,
+                         creationflags=subprocess.CREATE_NO_WINDOW, stderr=STDOUT)
+
     def apply_plan(self, plan):
         current_plan = plan['name']
         self.set_atrofac(plan['plan'], plan['cpu_curve'], plan['gpu_curve'])

G14RunCommands.py

@@ -33,8 +33,8 @@ plans:
     screen_hz: 120
   - name: Silent (low-speed fan)
     plan: windows
-    cpu_curve: "30c:0%,40c:5%,50c:5%,60c:10%,70c:31%,80c:49%,90c:56%,100c:56%"
-    gpu_curve: "30c:0%,40c:5%,50c:5%,60c:10%,70c:34%,80c:51%,90c:61%,100c:61%"
+    cpu_curve: "30c:0%,40c:0%,50c:20%,60c:20%,70c:31%,80c:49%,90c:56%,100c:56%"
+    gpu_curve: "30c:0%,40c:0%,50c:20%,60c:20%,70c:34%,80c:51%,90c:61%,100c:61%"
     cpu_tdp: 35000
     boost: 0
     dgpu_enabled: true
@@ -49,16 +49,16 @@ plans:
     screen_hz: 120
   - name: Performance
     plan: performance
-    cpu_curve: "30c:0%,40c:5%,50c:8%,60c:10%,70c:31%,80c:49%,90c:56%,100c:56%"
-    gpu_curve: "30c:0%,40c:5%,50c:8%,60c:10%,70c:34%,80c:51%,90c:61%,100c:61%"
+    cpu_curve: "30c:0%,40c:20%,50c:20%,60c:20%,70c:31%,80c:49%,90c:56%,100c:56%"
+    gpu_curve: "30c:0%,40c:20%,50c:20%,60c:20%,70c:34%,80c:51%,90c:61%,100c:61%"
     cpu_tdp: 38000
     boost: 4
     dgpu_enabled: true
     screen_hz: 120
   - name: Performance Plus
     plan: performance
-    cpu_curve: "30c:0%,40c:5%,50c:15%,60c:24%,70c:31%,80c:49%,90c:56%,100c:56%"
-    gpu_curve: "30c:0%,40c:5%,50c:15%,60c:24%,70c:34%,80c:51%,90c:61%,100c:61%"
+    cpu_curve: "30c:0%,40c:20%,50c:20%,60c:24%,70c:31%,80c:49%,90c:56%,100c:56%"
+    gpu_curve: "30c:0%,40c:20%,50c:20%,60c:24%,70c:34%,80c:51%,90c:61%,100c:61%"
     cpu_tdp: 40000
     boost: 4
     dgpu_enabled: true

data/config.yml

@@ -4,8 +4,6 @@
 import ctypes
 
 
-
-
 class PowerThreadTest(threading.Thread):
     def __init__(self):
         threading.Thread.__init__(self)
@@ -15,25 +13,23 @@ def run(self):
             print('running')
             time.sleep(1)
 
-    def murder(self): 
+    def kill(self):
         print('trying to kill')
-        res = ctypes.pythonapi.PyThreadState_SetAsyncExc(self.ident, 
-              ctypes.py_object(SystemExit)) 
-        if res > 1: 
-            ctypes.pythonapi.PyThreadState_SetAsyncExc(self.ident, 0) 
-            print('Exception raise failure') 
-
-
+        res = ctypes.pythonapi.PyThreadState_SetAsyncExc(self.ident,
+                                                         ctypes.py_object(SystemExit))
+        if res > 1:
+            ctypes.pythonapi.PyThreadState_SetAsyncExc(self.ident, 0)
+            print('Exception raise failure')
 
 
 def starto():
     thd = PowerThreadTest()
     thd.start()
     time.sleep(6)
-    thd.murder()
+    thd.kill()
     thd.join()
     print("ded")
-    print(thd,thd.is_alive())
+    print(thd, thd.is_alive())
 
 
 starto()

testing files/threadtest.py

@@ -0,0 +1,116 @@
+import unittest
+import os
+import re
+from G14RunCommands import RunCommands
+import yaml
+import pathlib
+import subprocess as sp
+import subprocess
+import sys
+
+config = {}
+windows_plans = []
+current_windows_plan = ""
+app_GUID = ""
+dpp_GUID = ""
+active_plan_map = dict()
+G14dir = ""
+
+
+def get_power_plans():
+    global dpp_GUID, app_GUID
+    all_plans = subprocess.check_output(["powercfg", "/l"])
+    for i in str(all_plans).split('\\n'):
+        print(i)
+        if i.find(config['default_power_plan']) != -1:
+            dpp_GUID = i.split(' ')[3]
+        if i.find(config['alt_power_plan']) != -1:
+            app_GUID = i.split(' ')[3]
+
+
+def get_windows_plans():
+    global config, active_plan_map, current_windows_plan
+    windows_power_options = re.findall(
+        r"([0-9a-f\-]{36}) *\((.*)\) *\*?\n", os.popen("powercfg /l").read())
+    active_plan_map = {x[1]: False for x in windows_power_options}
+    active_plan_map[current_windows_plan] = True
+    return windows_power_options
+
+
+"""
+Cannot be run before @get_windows_plans()
+"""
+
+
+def get_active_plan_map():
+    global windows_plans, active_plan_map
+    try:
+        active_plan_map["Balanced"]
+        return active_plan_map
+    except Exception:
+        active_plan_map = {x[1]: False for x in windows_plans}
+        active_plan_map[current_windows_plan] = True
+        return active_plan_map
+
+
+def get_app_path():
+    global G14dir
+    G14Dir = ""
+    # Sets the path accordingly whether it is a python script or a frozen .exe
+    if getattr(sys, 'frozen', False):
+        G14dir = os.path.dirname(os.path.realpath(sys.executable))
+    elif __file__:
+        G14dir = os.path.dirname(os.path.realpath(__file__))
+
+
+def loadConfig():
+    config = {}
+    with open('data/config.yml') as file:
+        config = yaml.load(file.read())
+    return config
+
+
+class RunCommandsTests(unittest.TestCase):
+
+    def setUp(self):
+        global config, windows_plans, active_plan_map, config, dpp_GUID, app_GUID, G14dir
+        self.config = loadConfig()
+        config = self.config
+        get_power_plans()
+        get_app_path()
+        get_windows_plans()
+        get_active_plan_map()
+        self.main_cmds = RunCommands(self.config,
+                                     G14dir=G14dir,
+                                     app_GUID=app_GUID,
+                                     dpp_GUID=dpp_GUID,
+                                     notify=lambda x: print(x),
+                                     windows_plans=windows_plans,
+                                     active_plan_map=active_plan_map)
+
+    def boost_test(self):
+        startboost = self.main_cmds.get_boost()
+        self.main_cmds.do_boost(2)
+        boost = self.main_cmds.get_boost()
+        self.assertEqual(
+            2, int(boost, 16), "Boost not equal to boost that was set (2)")
+        self.main_cmds.do_boost(4)
+        boost = self.main_cmds.get_boost()
+        self.assertEqual(4, int(boost, 16))
+
+        self.main_cmds.do_boost(0)
+        boost = self.main_cmds.get_boost()
+        self.assertEqual(0, int(boost, 16))
+
+        self.main_cmds.do_boost(int(startboost, 16))
+
+
+def suite():
+    suite = unittest.TestSuite()
+    suite.addTest(RunCommandsTests('boost_test'))
+    return suite
+
+
+if __name__ == '__main__':
+    runner = unittest.TextTestRunner()
+    runner.run(suite())