Update 'README.md'

added missing alias in config

.idea/.gitignore

@@ -0,0 +1,2 @@
+# Default ignored files
+/workspace.xml

README.md

@@ -1,12 +1,14 @@
 ## PyFAN
 
-This python script utilizes hwmon and PID as base for fan controlling.
+This python script utilizes linux's hwmon interface and a PID controller for fan controlling. No external dependencies besides simple_pid are needed.
 
 # Usage
 
-Put your config in /etc/pyfan (reference example config) and enable pyfan as a service (service file also available here).
+Put your config in /etc/pyfan (see example config) and enable pyfan as a service (see example service file).
+
+# Finding your fans
+> It is recommended to use pwmconfig from lm_sensors to detect your fans.
 
-# Config
 
 To know which hwmon is what device and what pwm controls what fan, the following commands can help you:
 

config-example.yaml

@@ -1,26 +1,26 @@
 loglevel: DEBUG
 
 thermalzones:
-    -
-        name: GPU+SYSTEM
-        source: hwmon3/temp1_input
-        factor: 1000
-        fan:
-            - hwmon2/pwm2
-            - hwmon3/pwm1: 170
-        target: 60
-        pid:
-            p: 1
-            i: 1.5
-            d: 2
-    -
-        name: CPU
-        source: hwmon1/temp1_input
-        factor: 1000
-        fan:
-            - hwmon2/pwm1
-        target: 50
-        pid:
-            p: 1
-            i: 1.5
-            d: 2
+  - name: GPU+SYSTEM
+    hwmon: amdgpu
+    source: amdgpu/temp1_input
+    factor: 1000
+    fan:
+      - it8686/pwm2
+      - amdgpu/pwm1: 170
+    target: 60
+    pid:
+      p: 1
+      i: 1
+      d: 1.5
+  - name: CPU
+    hwmon: it8686
+    source: coretemp/temp1_input
+    factor: 1000
+    fan:
+      - it8686/pwm1
+    target: 50
+    pid:
+      p: 1
+      i: 1
+      d: 1.5

pyfan.py

@@ -1,94 +1,111 @@
 #!/usr/bin/env python
-
-import sys
+import glob
 import logging
+import re
+import sys
 from time import sleep
+
 import yaml
 from simple_pid import PID
 
 SYSFS_HWMON_BASE = "/sys/class/hwmon/"
 
 
-def build_pwm_path(specific):
-    return SYSFS_HWMON_BASE + specific
-
-
-def write_sysfs(path, value):
-    try:
-        with open(build_pwm_path(path), 'w') as sysfs_f:
-            sysfs_f.write(str(value))
-    except OSError as err:
-        print("WARN:", err.strerror)
-
-
-def read_sysfs(path):
-    with open(build_pwm_path(path)) as sysfs_f:
-        return sysfs_f.readline()
-
-
-def set_pwm_mode(path, value=1):
-    write_sysfs(path + "_enable", value)
-
-
 class ThermalZone:
-    def __init__(self, temp_source, fans, p, i, d, target, factor, name) -> None:
-        self.fans = fans
-        self.temp_source = temp_source
-        self.pid = PID(p, i, d, setpoint=0)
+    def __init__(self, config, hwmon_map) -> None:
+        self.fans = config["fan"]
+        self.temp_source = config["source"]
+        self.pid = PID(config["pid"]["p"], config["pid"]["i"], config["pid"]["d"], setpoint=0)
         self.pid.output_limits = (0, 255)
-        self.factor = 1 / factor
-        self.name = name
-        self.target = target
+        self.factor = 1 / config["factor"]
+        self.name = config["name"]
+        self.target = config["target"]
+        self.hwname = config["hwmon"]
+        self.hwmap = hwmon_map
+        self.alias_replace = re.compile('|'.join(self.hwmap.keys()))
         self.setup_pwm()
 
-        logging.info("[{zone}] Source={source} Fans={fans} Factor={factor} PID={pid}".format(zone=name,
-                                                                                             source=temp_source,
-                                                                                             fans=fans,
-                                                                                             factor=factor,
-                                                                                             pid=(
-                                                                                                 p, i, d)))
+        logging.getLogger("pyfan").info(
+            "[{zone}] Source={source} Fans={fans} Factor={factor} PID={pid}".format(zone=self.name,
+                                                                                    source=self.temp_source,
+                                                                                    fans=self.fans,
+                                                                                    factor=self.factor,
+                                                                                    pid=(
+                                                                                        self.pid.Kp, self.pid.Ki,
+                                                                                        self.pid.Kd)))
 
     def eval(self):
         diff = self.target - self.get_temp()
         val = self.pid(diff)
 
-        for target_fan in self.fans:
-            if type(target_fan) is dict:
-                write_sysfs(list(target_fan.keys())[0], min(int(val), list(target_fan.values())[0]))
-            else:
-                write_sysfs(target_fan, int(val))
+        try:
+            for target_fan in self.fans:
+                if type(target_fan) is dict:
+                    self.write_sysfs(list(target_fan.keys())[0], min(int(val), list(target_fan.values())[0]))
+                else:
+                    self.write_sysfs(target_fan, int(val))
+        except OSError as err:
+            logging.getLogger("pyfan").warning(
+                "[%s] Failed to set pwm, trying to reset it. (%s)" % (self.name, err.strerror))
+            self.setup_pwm(1)
 
-        logging.debug(
-            "[{name}] {val}% ({diff}C/{temp}C)".format(name=self.name, val=int(val / 255 * 100), diff=diff,
-                                                       temp=self.get_temp()))
+        p, i, d = self.pid.components
+
+        logging.getLogger("pyfan").debug(
+            "[{name}] {val}% ({diff}C/{temp}C) ({p}|{i}|{d})".format(name=self.name, val=int(val / 255 * 100),
+                                                                     diff=diff,
+                                                                     temp=self.get_temp(), p=int(p), i=int(i),
+                                                                     d=int(d)))
 
     def get_temp(self):
-        return float(read_sysfs(self.temp_source)) * self.factor
+        return float(self.read_sysfs(self.temp_source)) * self.factor
 
     def restore(self):
         self.setup_pwm(2)
 
     def setup_pwm(self, value=1):
         for target_fan in self.fans:
-            if type(target_fan) is dict:
-                set_pwm_mode(list(target_fan.keys())[0], value)
-            else:
-                set_pwm_mode(target_fan, value)
+            try:
+                if type(target_fan) is dict:
+                    self.set_pwm_mode(list(target_fan.keys())[0], value)
+                else:
+                    self.set_pwm_mode(target_fan, value)
+            except FileNotFoundError as err:
+                logging.getLogger("pyfan").warning("[%s] pwm not found. Not ready yet or wrong path? (%s)" % (self.name,
+                                                                                                              err.strerror))
+
+    def replace_alias(self, path):
+        replaced = self.alias_replace.sub(lambda x: self.hwmap[x.group()], path)
+        logging.getLogger("pyfan").debug("[ALIAS] %s -> %s" % (path, replaced))
+        return replaced
+
+    def build_pwm_path(self, specific):
+        return self.replace_alias(SYSFS_HWMON_BASE + specific)
+
+    def write_sysfs(self, path, value):
+        with open(self.build_pwm_path(path), 'w') as sysfs_f:
+            sysfs_f.write(str(value))
+
+    def read_sysfs(self, path):
+        with open(self.build_pwm_path(path)) as sysfs_f:
+            return sysfs_f.readline()
+
+    def set_pwm_mode(self, path, value=1):
+        self.write_sysfs(path + "_enable", value)
 
 
 class PyFan:
     def __init__(self, config="/etc/pyfan") -> None:
         self.config = self.__load_config(config)
-        logging.basicConfig(level=logging.getLevelName(self.config["loglevel"]), style='{')
+        logging.basicConfig(level=logging.getLevelName(self.config["loglevel"]))
         self.zones = []
+        self.hwmon_map = {}
+        self.gen_hwmon_map()
 
         for zone in self.config["thermalzones"]:
-            self.zones.append(
-                ThermalZone(zone["source"], zone["fan"], zone["pid"]["p"], zone["pid"]["i"], zone["pid"]["d"],
-                            zone["target"],
-                            zone["factor"], zone["name"]))
+            self.zones.append(ThermalZone(zone, self.hwmon_map))
 
-        logging.info("Finished creating %d thermal zones." % len(self.zones))
+        logging.getLogger("pyfan").info("Finished creating %d thermal zones." % len(self.zones))
 
     def __enter__(self):
         return self
@@ -106,6 +123,15 @@ class PyFan:
         with open(path) as cfg_file:
             return yaml.safe_load(cfg_file)
 
+    def gen_hwmon_map(self):
+        names = glob.glob(SYSFS_HWMON_BASE + "hwmon*/name")
+
+        for name in names:
+            hwmon = name.split("/")[-2]
+            with open(name) as file:
+                hwname = file.read().strip()
+            self.hwmon_map[hwname] = hwmon
+
 
 if __name__ == "__main__":
     with PyFan() as pyfan: