Upload 3 files

.gitattributes

@@ -37,3 +37,5 @@ SmartDiskTool.exe filter=lfs diff=lfs merge=lfs -text
 SmartTaskTool_v1_alpha.exe filter=lfs diff=lfs merge=lfs -text
 SmartTaskTool_by_Sevenof9_v2_alpha.exe filter=lfs diff=lfs merge=lfs -text
 hardwarecheck.exe filter=lfs diff=lfs merge=lfs -text
+hardwarecheck_AMD.exe filter=lfs diff=lfs merge=lfs -text
+LibreHardwareMonitorLib.dll filter=lfs diff=lfs merge=lfs -text

LibreHardwareMonitorLib.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0f2728f1734c236a9d02d9e25a88bc4f8cb7bd1faff1770726beb7af06bf8dc
+size 712192

hardwarecheck_AMD.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:593a3ad3fee96b6bf58675c6a0a22ad8ebe611a9bc521ba7d4f253859fa770ac
+size 10726169

hardwarecheck_AMD.py

@@ -0,0 +1,229 @@
+import os
+import clr
+import time
+#from difflib import get_close_matches
+
+# DLL laden (Pfad ggf. anpassen)
+dll_path = os.path.abspath("LibreHardwareMonitorLib.dll")
+clr.AddReference(dll_path)
+
+from LibreHardwareMonitor import Hardware
+#from difflib import SequenceMatcher
+# ----------------------------------------
+# Hilfsfunktion: unscharfer Vergleich
+# ----------------------------------------
+#from rapidfuzz import fuzz
+from rapidfuzz.fuzz import partial_ratio
+
+def best_match_optional(filter_str, target_str, min_token_score=80):
+    """
+    Für jedes Token im Filter suchen wir das bestpassende Token im Ziel (mit partial_ratio).
+    Der finale Score ist der Durchschnitt dieser besten Matches.
+    """
+    if not filter_str:
+        return 1.0
+
+    filter_tokens = filter_str.lower().split()
+    target_tokens = target_str.lower().split()
+
+    if not target_tokens:
+        return 0.0
+
+    match_scores = []
+    for ftoken in filter_tokens:
+        best_score = max(
+            partial_ratio(ftoken, ttoken)
+            for ttoken in target_tokens
+        )
+        if best_score < min_token_score:
+            return 0.0  # Ein Filter-Token ist zu unähnlich → kein Match
+        match_scores.append(best_score)
+
+    return sum(match_scores) / (100 * len(match_scores))  # Normiert auf [0.0, 1.0]
+
+
+
+
+# ----------------------------------------
+# Einmalige GPU-Auslesung (alle Sensorwerte)
+# ----------------------------------------
+def lese_gpu_sensorwerte():
+    hw = Hardware.Computer()
+    hw.IsGpuEnabled = True
+    hw.IsCpuEnabled = False
+    hw.IsMemoryEnabled = False
+    hw.IsMotherboardEnabled = False
+    hw.IsStorageEnabled = False
+    hw.IsNetworkEnabled = False
+    hw.IsControllerEnabled = False
+    hw.Open()
+
+    daten = []
+    hardware_counter = 0
+
+    for hardware in hw.Hardware:
+        hardware.Update()
+
+        #if hardware.HardwareType.ToString().lower() != "gpu":
+        #    continue
+
+        hardware_type = hardware.HardwareType.ToString()
+        hardware_name = hardware.Name
+        hardware_id = f"ID{hardware_counter}"
+        hardware_counter += 1
+
+        for sensor in hardware.Sensors:
+            eintrag = {
+                "ID": hardware_id,
+                "HardwareName": hardware_name,
+                "HardwareType": hardware_type,
+                "SensorName": sensor.Name,
+                "SensorType": sensor.SensorType.ToString(),
+                "Value": sensor.Value
+            }
+            daten.append(eintrag)
+
+
+    hw.Close()
+    return daten
+
+# ----------------------------------------
+# Filterfunktion mit flexiblen Feldern
+# ----------------------------------------
+def filter_sensordaten(daten, filterkriterien):
+    treffer = []
+    for eintrag in daten:
+        if all([
+            best_match_optional(filterkriterien.get("ID"), eintrag["ID"]),
+            best_match_optional(filterkriterien.get("HardwareName"), eintrag["HardwareName"]),
+            best_match_optional(filterkriterien.get("HardwareType"), eintrag["HardwareType"]),
+            best_match_optional(filterkriterien.get("SensorName"), eintrag["SensorName"]),
+            best_match_optional(filterkriterien.get("SensorType"), eintrag["SensorType"]),
+            (filterkriterien.get("Value") is None or eintrag["Value"] == filterkriterien["Value"])
+        ]):
+            treffer.append(eintrag)
+    return treffer
+
+# ----------------------------------------
+# Hauptprogramm
+# ----------------------------------------
+if __name__ == "__main__":
+    # Alle GPU-Daten einmalig auslesen
+    alle_sensoren = lese_gpu_sensorwerte()
+
+    print("\n--- Alle ausgelesenen GPU-Sensorwerte ---")
+    for sensor in alle_sensoren:
+        val = sensor["Value"]
+        val_str = f"{round(val, 1)}" if isinstance(val, (float, int)) else str(val)
+        print(f"ID: {sensor['ID']} | HwType: <{sensor['HardwareType']}> | "
+              f"HwName: <{sensor['HardwareName']}> | Sensor: <{sensor['SensorName']}> | "
+              f"Typ: <{sensor['SensorType']}> = {val_str}")
+    print(f"\nInsgesamt {len(alle_sensoren)} Sensoren gefunden.")
+
+
+    # -------------------------------
+    # 10 definierbare Suchabfragen
+    # -------------------------------
+    suchabfragen = [
+        {
+            "aktiv": True,
+            "filter": {
+                "HardwareType": "GpuAmd",
+                "HardwareName": "AMD",
+                "SensorName": "Core",
+                "SensorType": "Temperature",
+                "ID": "",
+                "Value": None
+            }
+        },
+        
+        {
+            "aktiv": True,
+            "filter": {
+                "HardwareType": "GpuAmd",
+                "HardwareName": "AMD",
+                "SensorName": "Core",
+                "SensorType": "Load",
+                "ID": "",
+                "Value": None
+            }
+        },
+
+        {
+            "aktiv": True,
+            "filter": {
+                "HardwareType": "GpuAmd",
+                "HardwareName": "AMD",
+                "SensorName": "GPU Memory Used",
+                "SensorType": "",
+                "ID": "",
+                "Value": None
+            }
+        },
+        
+        {
+            "aktiv": True,
+            "filter": {
+                "HardwareType": "GpuAmd",
+                "HardwareName": "AMD",
+                "SensorName": "GPU Memory Free",
+                "SensorType": "",
+                "ID": "",
+                "Value": None
+            }
+        },
+    
+        {
+            "aktiv": True,
+            "filter": {
+                "HardwareType": "GpuAmd",
+                "HardwareName": "AMD",
+                "SensorName": "GPU Memory Total",
+                "SensorType": "",
+                "ID": "",
+                "Value": None
+            }
+        },
+
+        {
+            "aktiv": False,
+            "filter": {
+                "HardwareType": "Check",
+                "HardwareName": "",
+                "SensorName": "",
+                "SensorType": "",
+                "ID": "",
+                "Value": None
+            }
+        },
+        # ... weitere Suchabfragen:
+        *[
+            {"aktiv": False, "filter": {}}  # Platzhalter
+            for _ in range(10)
+        ]
+    ]
+
+    # -------------------------------
+    # Suchabfragen ausführen
+    # -------------------------------
+    for idx, suchanfrage in enumerate(suchabfragen):
+        if not suchanfrage["aktiv"]:
+            continue
+
+        print(f"\n--- Suche #{idx + 1} ---")
+        resultate = filter_sensordaten(alle_sensoren, suchanfrage["filter"])
+
+        if not resultate:
+            print("Keine passenden Sensorwerte gefunden.")
+        else:
+            for r in resultate:
+                val = r["Value"]
+                val_str = f"{round(val, 1)}" if isinstance(val, (float, int)) else str(val)
+                print(f"ID: {r['ID']} | HwType: <{r['HardwareType']}> | "
+                      f"HwName: <{r['HardwareName']}> | Sensor: <{r['SensorName']}> | "
+                      f"Typ: <{r['SensorType']}> = {val_str}")
+                time.sleep(0.01)
+
+    input("\nDrücke eine Taste zum Beenden...")
+
+