Fix: start/stop thresholds not being set because of initial values (#900)

* fix: (WIP) start/stop thresholds not being set because of initial values

* refactor: rewrite battery scripts more cleanly + fix bug where start/stop charge thres settings don't apply

* fix: battery start/stop pr: small typos, pr comments..

* fix: actually validate start/stop, and enforce both to be present

* fix: start/stop threshold value check + add more docs + add override check_thresholds=false for exceptional cases

* add: debug prints for testers

* fix: type errors in battery config, prefer charge_control_{start,end}_threshold values over charge_{start,stop}_threshold

* fix: do not change charge thresholds with --monitor flag

* fix: reference ideapad_laptop kernel module in Readme

* Regularly apply battery thresholds, add note in README about conflicting software, remove debug statements

* Apply copilot suggestions. Remove misleading section about fixed thresholds from README

* Update auto_cpufreq/battery_scripts/shared.py

Fix grammatical error

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Remove unnecessary shell option from run call

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Do not change Ideapad conservation mode if not explicitly set in config, fix config not being overridden in IdeapadBatteryDevice class

* Suggest setting start threshold to 0 in README

---------

Co-authored-by: Benedikt Westreicher <benedikt.westreicher@hotmail.com>
Co-authored-by: Adnan Hodzic <adnan@hodzic.org>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Benedikt Westreicher <48734011+be-west@users.noreply.github.com>

Author: 4 people

README.md

@@ -608,53 +608,59 @@ As of [v2.2.0](https://github.com/AdnanHodzic/auto-cpufreq/releases/tag/v2.2.0),
 
 - **Lenovo ThinkPad** (thinkpad_acpi)*
 - **Lenovo IdeaPad** (ideapad_acpi)*
+- **Lenovo Laptop** (ideapad_laptop)*
 - **ASUS :Laptops** (asus_wmi)*
 
-***Please note, your laptop must have an installed ACPI kernel driver specific to the manufacturer.** To check if you have the correct module installed and loaded run `lsmod [module]`
+**Please note, your laptop must have an installed ACPI kernel driver specific to the manufacturer.** To check if you have the correct module installed and loaded run `lsmod [module]`
+
+Additionally, **you should make sure that you have no other software running that may conflict with auto-cpufreq's battery threshold management** (e.g., GNOME's *Preserve Battery Health* option). Using both at the same time will lead to conflicts and to your battery potentially never charging.
 
 **To request that your device be supported, please open an [issue](https://github.com/AdnanHodzic/auto-cpufreq/issues/new). In your issue, make us aware of the driver that works with your laptop**
 
 ### Battery config
+
 Edit the config at `/etc/auto-cpufreq.conf`
 
 Example config for battery ([already part of example config file](https://github.com/AdnanHodzic/auto-cpufreq/#example-config-file-contents))
-```
+
+```ini
 [battery]
 enable_thresholds = true
 start_threshold = 20
 stop_threshold = 80
 ```
 
-### Lenovo_laptop conservation mode
-
-this works only with `lenovo_laptop` kernel module compatable laptops.  
+You will need to specify both `start_threshold` AND `stop_threshold` in most cases.
+For these changes to have an effect, you will need to restart the daemon:
 
-add `ideapad_laptop_conservation_mode = true` to your `auto-cpufreq.conf` file
+```shell
+systemctl restart auto-cpufreq.service
+```
 
-### Special cases of Lenovo_ideapad (or some other models with fixed threshold)
+See more here on the kernel doc pages: [docs.kernel.org](https://docs.kernel.org/admin-guide/laptops/thinkpad-acpi.html#battery-charge-control)
 
-As you may know, for some laptop models you can only decide to limit battery charging but can not set the limit value. The limit value is set by the manufacturer in the system (generally 60% and sometimes 80%). Also, you can not set the value of start charging.
+### A few notes about these battery config options
 
-This limit value is not always accessible for users to avoid changing it, but you can try looking in some of these paths : 
+When you remove/uninstall the auto-cpufreq daemon, the last applied settings for battery thresholds will still apply. You might need to manually set these yourself to whatever default they were before. E.g. (as sudo):
 
-```
-cat /sys/bus/platform/drivers/ideapad_acpi/VPC2004:00/charge_control_end_threshold
-cat /sys/class/power_supply/BAT0/charge_control_end_threshold
-cat /sys/class/power_supply/BAT0/charge_control_start_threshold
+```shell
+echo 0 > /sys/class/power_supply/BAT0/charge_start_threshold
+echo 100 > /sys/class/power_supply/BAT0/charge_stop_threshold
 ```
 
-This is the config to apply at /etc/auto-cpufreq.conf in order to stop battery charging at 60% or 80% depending on the value set in the system by the manufacturer.
+### Ideapad conservation mode
 
-```
-[battery]
-enable_thresholds = true
-start_threshold = 20
-stop_threshold = 1
+This works only with laptops that have the `ideapad_laptop` kernel module.  
 
+add `ideapad_laptop_conservation_mode = true` to your `auto-cpufreq.conf` file
+
+```ini
+[battery]
+ideapad_laptop_conservation_mode = true
 ```
-start_threshold = 20 (should be present with a valid number but it's ignored)
 
-stop_threshold = 1 (to stop charging the battery at the limit value 60% or 80%)
+This is a special mode which limits the maximum charge level of the battery to around 60-80% depending on the model.
+
 
 ### Ignoring power supplies
 
@@ -663,7 +669,7 @@ to limit preformence to ignore them add to you config file the name of the power
 
 the name of the power supply can be found with  `ls /sys/class/power_supply/`
 
-```
+```ini
 [power_supply_ignore_list]
 
 name1 = this
@@ -688,7 +694,7 @@ xboxctrl = {the xbox controler power supply name}
 
 This can be done by editing the `GRUB_CMDLINE_LINUX_DEFAULT` params in `/etc/default/grub`. For instance:
 
-```
+```shell
     sudo nano /etc/default/grub
     # make sure you have nano installed, or you can use your favorite text editor
 ```
@@ -707,35 +713,35 @@ GRUB_CMDLINE_LINUX_DEFAULT="quiet splash initcall_blacklist=amd_pstate_init amd_
 
 Once you have made the necessary changes to the GRUB configuration file, you can update GRUB by running `sudo update-grub` on Debian/Ubuntu, `sudo grub-mkconfig -o /boot/grub/grub.cfg` on Arch Linux, or one of the following on Fedora:
 
-```
+```shell
     sudo grub2-mkconfig -o /etc/grub2.cfg
 ```
 
-```
+```shell
     sudo grub2-mkconfig -o /etc/grub2-efi.cfg
 ```
 
-```
+```shell
     sudo grub2-mkconfig -o /boot/grub2/grub.cfg
     # legacy boot method
 ```
 
 For systemd-boot users:
 
-```
+```shell
     sudo nano /etc/kernel/cmdline
     # make sure you have nano installed, or you can use your favorite text editor
 ```
 
 For Intel users:
 
-```
+```shell
 quiet splash intel_pstate=disable
 ```
 
 For AMD users:
 
-```
+```shell
 quiet splash initcall_blacklist=amd_pstate_init amd_pstate.enable=0
 ```
 

auto_cpufreq/battery_scripts/asus.py

@@ -1,50 +1,8 @@
 #!/usr/bin/env python3
-import os
-from subprocess import check_output
 
-from auto_cpufreq.config.config import config
-from auto_cpufreq.globals import POWER_SUPPLY_DIR
+from auto_cpufreq.battery_scripts.shared import BatteryDevice
 
-def set_battery(value, mode, bat):
-    path = f"{POWER_SUPPLY_DIR}{bat}/charge_{mode}_threshold"
-    fallback_mode = "start" if mode == "start" else "end"
-    fallback_path = f"{POWER_SUPPLY_DIR}{bat}/charge_control_{fallback_mode}_threshold"
-    if os.path.isfile(path): check_output(f"echo {value} | tee {path}", shell=True, text=True)
-    elif os.path.isfile(fallback_path): check_output(f"echo {value} | tee {fallback_path}", shell=True, text=True)
-    else: print(f"WARNING: {path} does NOT exist")
 
-def get_threshold_value(mode):
-    conf = config.get_config()
-    return conf["battery"][f"{mode}_threshold"] if conf.has_option("battery", f"{mode}_threshold") else (0 if mode == "start" else 100)
-
-def asus_setup():
-    conf = config.get_config()
-
-    if not (conf.has_option("battery", "enable_thresholds") and conf["battery"]["enable_thresholds"] == "true"): return
-
-    if os.path.exists(POWER_SUPPLY_DIR):
-        batteries = [name for name in os.listdir(POWER_SUPPLY_DIR) if name.startswith('BAT')]
-
-        for bat in batteries:
-            set_battery(get_threshold_value("start"), "start", bat)
-            set_battery(get_threshold_value("stop"), "stop", bat)
-    else: print(f"WARNING {POWER_SUPPLY_DIR} does NOT esixt")
-
-
-def asus_print_thresholds():
-    batteries = [name for name in os.listdir(POWER_SUPPLY_DIR) if name.startswith('BAT')]
-    print("\n-------------------------------- Battery Info ---------------------------------\n")
-    print(f"battery count = {len(batteries)}")
-    for bat in batteries:
-        try:
-            primary_start = f"{POWER_SUPPLY_DIR}{bat}/charge_start_threshold"
-            primary_stop = f"{POWER_SUPPLY_DIR}{bat}/charge_stop_threshold"
-            fallback_start = f"{POWER_SUPPLY_DIR}{bat}/charge_control_start_threshold"
-            fallback_stop = f"{POWER_SUPPLY_DIR}{bat}/charge_control_end_threshold"
-            if os.path.isfile(primary_start): print(bat, "start threshold =", check_output(["cat", primary_start]))
-            elif os.path.isfile(fallback_start): print(bat, "start threshold =", check_output(["cat", fallback_start]))
-            else: print(f"{bat} start threshold: file not found")
-            if os.path.isfile(primary_stop): print(bat, "stop threshold =", check_output(["cat", primary_stop]))
-            elif os.path.isfile(fallback_stop): print(bat, "stop threshold =", check_output(["cat", fallback_stop]))
-            else: print(f"{bat} stop threshold: file not found")
-        except Exception as e: print(f"ERROR: failed to read battery {bat} thresholds:", repr(e))
+class AsusBatteryDevice(BatteryDevice):
+    def __init__(self):
+        super().__init__()

auto_cpufreq/battery_scripts/battery.py

@@ -1,23 +1,57 @@
 #!/usr/bin/env python3
 from subprocess import PIPE, run
+from threading import Thread
+from time import sleep
 
-from auto_cpufreq.battery_scripts.ideapad_acpi import ideapad_acpi_print_thresholds, ideapad_acpi_setup
-from auto_cpufreq.battery_scripts.ideapad_laptop import ideapad_laptop_print_thresholds, ideapad_laptop_setup
-from auto_cpufreq.battery_scripts.thinkpad import thinkpad_print_thresholds, thinkpad_setup
-from auto_cpufreq.battery_scripts.asus import asus_print_thresholds, asus_setup
+from auto_cpufreq.battery_scripts.asus import AsusBatteryDevice
+from auto_cpufreq.battery_scripts.ideapad_laptop import IdeapadBatteryDevice
+from auto_cpufreq.battery_scripts.shared import BatteryDevice
+
+BATTERY_APPLY_INTERVAL = 3600  # 1 hour
+
+
+def lsmod(module):
+    return (
+        module in run(["lsmod"], stdout=PIPE, stderr=PIPE, text=True).stdout
+    )
 
-def lsmod(module): return module in run(['lsmod'], stdout=PIPE, stderr=PIPE, text=True, shell=True).stdout
 
 def battery_get_thresholds():
-    if lsmod("ideapad_acpi"): ideapad_acpi_print_thresholds()
-    elif lsmod("ideapad_laptop"): ideapad_laptop_print_thresholds()
-    elif lsmod("thinkpad_acpi"): thinkpad_print_thresholds()
-    elif lsmod("asus_wmi"): asus_print_thresholds()
-    else: return
-
-def battery_setup():
-    if lsmod("ideapad_acpi"): ideapad_acpi_setup()
-    elif lsmod("ideapad_laptop"): ideapad_laptop_setup()
-    elif lsmod("thinkpad_acpi"): thinkpad_setup()
-    elif lsmod("asus_wmi"): asus_setup()
-    else: return
+    dev = get_battery_device()
+    if dev is not None:
+        return dev.print_thresholds()
+
+
+def start_battery_daemon():
+    """Battery daemon that applies battery charge thresholds at regular intervals."""
+    dev = get_battery_device()
+    if dev is None:
+        print(
+            "WARNING: No supported battery device found, battery thresholds will not be applied."
+        )
+        return
+
+    def battery_daemon():
+        while True:
+            try:
+                dev.apply_threshold_settings()
+            except Exception as e:
+                print(
+                    f"ERROR: An error occurred while applying battery thresholds: {e}"
+                )
+            sleep(BATTERY_APPLY_INTERVAL)
+
+    Thread(target=battery_daemon, daemon=True).start()
+
+
+def get_battery_device():
+    if lsmod("ideapad_acpi"):
+        return BatteryDevice()
+    elif lsmod("ideapad_laptop"):
+        return IdeapadBatteryDevice()
+    elif lsmod("thinkpad_acpi"):
+        return BatteryDevice()
+    elif lsmod("asus_wmi"):
+        return AsusBatteryDevice()
+    else:
+        return None