Add handling for missing nvml lib

PKGBUILD

@@ -1,21 +1,19 @@
 pkgname=fantasize
-pkgver=0.3.0
+pkgver=0.1.7
 pkgrel=1
 pkgdesc='C++ fan control for Linux'
 url='https://github.com/Tabascl/fantasize.git'
 source=("$pkgname-$pkgver.tar.gz::https://github.com/Tabascl/fantasize/archive/refs/tags/v$pkgver.tar.gz")
 arch=('x86_64')
 license=('GPL3')
-makedepends=('git' 'meson' 'nlohmann-json' 'boost')
+makedepends=('git' 'cmake' 'nlohmann-json' 'boost' 'cuda')
 sha256sums=('SKIP')
 
 build() {
-    meson setup build "$pkgname-$pkgver/app" -Dbuildtype=Release
+    cmake -S "$pkgname-$pkgver/app" -B build -DCMAKE_BUILD_TYPE=Release
-    cd build
+    cmake --build build
-    meson compile
 }
 
 package() {
-    cd build
+    cmake --install build --prefix "$pkgdir/" --verbose
-    meson install
 }

app/.clang-format

@@ -0,0 +1 @@
+BasedOnStyle: Google

app/CMakeLists.txt

@@ -0,0 +1,51 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(fantasize VERSION 0.1.7)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+find_package(nlohmann_json 3.7 REQUIRED)
+find_package(Boost 1.80 COMPONENTS program_options log log_setup date_time REQUIRED)
+
+find_library(NVML_LIB nvidia-ml)
+
+set(ADDITIONAL_LIBS)
+
+if (NVML_LIB)
+    set(HAVE_NVML)
+
+    add_library(nvidia-sensor-lib STATIC
+      src/sensor/NvidiaSensor.cxx
+      src/sensor/GPUSensorsFacade.cxx)
+
+    target_link_libraries(nvidia-sensor-lib PUBLIC NVML_LIB)
+
+    list(APPEND ADDITIONAL_LIBS nvidia-sensor-lib)
+endif()
+
+add_executable(${PROJECT_NAME}
+  src/main.cxx
+  src/sensor/LMSensorsFacade.cxx
+  src/sensor/Sensor.cxx
+  src/sensor/LMSensor.cxx
+  src/pwm/PWMControl.cxx
+  src/pwm/PWMControlFacade.cxx
+  src/fan/HwmonFan.cxx
+  src/fan/FanCurve.cxx
+  src/fan/FanLabeler.cxx
+  src/FanGenerator.cxx
+  src/Serializer.cxx
+  src/sensor/SensorManager.cxx
+  src/Controller.cxx
+  src/Settings.cxx
+  src/App.cxx
+)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 20)
+
+target_include_directories(${PROJECT_NAME} PUBLIC include /opt/cuda)
+
+target_link_libraries(${PROJECT_NAME} PUBLIC sensors nlohmann_json::nlohmann_json tbb ${Boost_LIBRARIES} ${ADDITIONAL_LIBS})
+
+install(TARGETS ${PROJECT_NAME} DESTINATION usr/local/bin)
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/unit/fantasize.service DESTINATION usr/lib/systemd/system)

app/include/Serializer.h

@@ -7,7 +7,6 @@
 #include <nlohmann/json.hpp>
 
 #include <Settings.h>
-#include <fan/Aggregators.h>
 #include <fan/Fan.h>
 #include <fan/FanCurve.h>
 #include <sensor/Sensor.h>
@@ -25,14 +24,12 @@ public:
   DeserializeFans(std::vector<std::shared_ptr<Sensor>> availableSensors);
   std::vector<std::shared_ptr<FanCurve>>
   DeserializeFanCurves(std::vector<std::shared_ptr<Sensor>> availableSensors,
-                       std::vector<std::shared_ptr<Fan>> availableFans,
+                       std::vector<std::shared_ptr<Fan>> availableFans);
-                       bool &everythingFound);
   std::shared_ptr<Settings> DeserializeSettings();
 
 private:
   void WriteJson(json o);
   json ReadJson();
-  std::unique_ptr<Aggregator> aggregatorFromString(std::string str) const;
 };
 
 #endif // SERIALIZER_H_

app/include/fan/Aggregators.h

@@ -1,27 +0,0 @@
-#ifndef AGGREGATORS_H_
-#define AGGREGATORS_H_
-
-#include <sensor/Sensor.h>
-
-class Aggregator
-{
-public:
-  virtual int aggregate(std::vector<std::shared_ptr<Sensor>> sensors) const = 0;
-  virtual const std::string toString() const = 0;
-};
-
-class AverageAggregator : public Aggregator
-{
-public:
-  int aggregate(std::vector<std::shared_ptr<Sensor>> sensors) const override;
-  const std::string toString() const override;
-};
-
-class MaxAggregator : public Aggregator
-{
-public:
-  int aggregate(std::vector<std::shared_ptr<Sensor>> sensors) const override;
-  const std::string toString() const override;
-};
-
-#endif // AGGERGATORS_H_

app/include/fan/Fan.h

@@ -17,13 +17,8 @@ public:
   virtual void StartPWM(int value) = 0;
   virtual int StartPWM() = 0;
 
-  virtual void ZeroFanModeSupported(bool value) = 0;
-  virtual bool ZeroFanModeSupported() = 0;
-
   virtual void FindPWMLimits() = 0;
   virtual void AdjustPWMLimits() = 0;
-
-  virtual void EnforceSetValue() = 0;
 };
 
 #endif // FAN_H_

app/include/fan/FanCurve.h

@@ -4,7 +4,6 @@
 #include <memory>
 #include <vector>
 
-#include <fan/Aggregators.h>
 #include <fan/HwmonFan.h>
 #include <sensor/Sensor.h>
 
@@ -17,22 +16,17 @@ class FanCurve {
 public:
   FanCurve(std::vector<FanStep> steps,
            std::vector<std::shared_ptr<Sensor>> sensors,
-           std::vector<std::shared_ptr<Fan>> fans,
+           std::vector<std::shared_ptr<Fan>> fans);
-           std::unique_ptr<Aggregator> aggregator, int hysteresis);
 
   void DoFanControl();
 
 private:
+  int AggregateTemperature();
   void PrintInfo();
-  bool ExceedsHysteresis(int temperature);
-  void ApplyFanPower(std::shared_ptr<Fan> fan, int targetFanPower);
 
   std::vector<FanStep> mSteps;
   std::vector<std::shared_ptr<Sensor>> mTempSensors;
   std::vector<std::shared_ptr<Fan>> mFans;
-  std::unique_ptr<Aggregator> mAggregator;
-  int mHystersis;
-  int mLastTemperature;
 };
 
 #endif // FANCURVE_H_

app/include/fan/HwmonFan.h

@@ -4,6 +4,8 @@
 #include <chrono>
 #include <memory>
 
+#include <boost/json/object.hpp>
+
 #include <fan/Fan.h>
 #include <pwm/PWMControl.h>
 #include <sensor/Sensor.h>
@@ -24,33 +26,21 @@ public:
   void StartPWM(int value) override;
   int StartPWM() override;
 
-  void ZeroFanModeSupported(bool value) override;
-  bool ZeroFanModeSupported() override;
-
   void FindPWMLimits() override;
   void AdjustPWMLimits() override;
 
-  void EnforceSetValue() override;
-
   json toJson() const override;
 
   const std::string toString() const override;
 
 private:
-  bool InhibitStopPeriodExpired();
-  void SetPower(int percent);
-
   std::shared_ptr<PWMControl> mPWMControl;
   std::shared_ptr<Sensor> mRpmSensor;
   std::string mLabel;
 
-  int mMinPWM = 0;
+  int mMinPWM;
-  int mStartPWM = 0;
+  int mStartPWM;
-  bool mZeroFanModeSupported = false;
   std::chrono::time_point<std::chrono::steady_clock> mLastAdjustmentTime;
-  std::chrono::time_point<std::chrono::steady_clock> mLastStartTime;
-  int mSetValue = 0;
-  bool mWasStopped = false;
 };
 
 #endif // HWMONFAN_H_

app/include/pwm/PWMControl.h

@@ -1,6 +1,7 @@
 #ifndef PWMCONTROL_H_
 #define PWMCONTROL_H_
 
+#include <boost/json/object.hpp>
 #include <string>
 
 #include <Printable.h>
@@ -12,11 +13,11 @@ enum class PWM_MODE { DC = 0, PWM };
 
 class PWMControl : public Printable, public Serializable {
 public:
-  PWMControl(std::string controlPath, int deviceIndex);
+  PWMControl(std::string controlPath);
   ~PWMControl();
 
-  void SetPower(int percent);
+  void Power(int percent);
-  int CurrentPWM();
+  int Power();
 
   void EnableManualControl();
   void Reset();
@@ -26,11 +27,11 @@ public:
   json toJson() const override;
 
 private:
-  std::string mConfigPath;
+  int mCurrentValue;
+
   std::string mControlPath;
   std::string mEnablePath;
   std::string mModePath;
-  int mDeviceIndex;
 
   std::string mInitialEnable;
   std::string mInitialMode;

app/include/sensor/LMSensorsFacade.h

@@ -16,13 +16,9 @@ public:
   std::vector<std::shared_ptr<Sensor>> TemperatureSensors();
   std::vector<std::shared_ptr<Sensor>> RPMSensors();
 
-  void ReloadSensors();
-
 private:
   template <sensors_subfeature_type T>
   std::vector<std::shared_ptr<Sensor>> Sensors();
-  void InitSensors();
-  void CleanupSensors();
 
 private:
   FILE *mConfigFile;

app/include/sensor/SensorManager.h

@@ -12,8 +12,6 @@ public:
   std::vector<std::shared_ptr<Sensor>> TemperatureSensors();
   std::vector<std::shared_ptr<Sensor>> RPMSensors();
 
-  void ReloadSensors();
-
 private:
   std::unique_ptr<LMSensorsFacade> mLMSensorsFacade;
   std::unique_ptr<GPUSensorsFacade> mGPUSensorsFacade;

app/meson.build

@@ -1,37 +0,0 @@
-project('fantasize', 'cpp', version : '0.3.0', default_options : 'cpp_std=c++20')
-
-src = [
-  'src/main.cxx',
-  'src/sensor/LMSensorsFacade.cxx',
-  'src/sensor/Sensor.cxx',
-  'src/sensor/LMSensor.cxx',
-  'src/pwm/PWMControl.cxx',
-  'src/pwm/PWMControlFacade.cxx',
-  'src/fan/HwmonFan.cxx',
-  'src/fan/FanCurve.cxx',
-  'src/fan/FanLabeler.cxx',
-  'src/fan/Aggregators.cxx',
-  'src/FanGenerator.cxx',
-  'src/Serializer.cxx',
-  'src/sensor/SensorManager.cxx',
-  'src/Controller.cxx',
-  'src/Settings.cxx',
-  'src/App.cxx'
-]
-
-deps = [
-  dependency('nlohmann_json'),
-  dependency('boost', modules : ['program_options', 'log', 'log_setup', 'date_time', 'thread']),
-  dependency('tbb'),
-  meson.get_compiler('cpp').find_library('sensors')
-]
-
-inc = include_directories('include')
-
-exe = executable('fantasize',
-  src,
-  dependencies: deps,
-  install: true,
-  include_directories: inc)
-
-install_data('unit/fantasize.service', install_dir : '/usr/lib/systemd/system')

app/src/App.cxx

@@ -1,35 +1,14 @@
-#include "fan/Fan.h"
-#include "fan/FanCurve.h"
-#include <chrono>
 #include <execution>
 
-#include <boost/log/attributes/named_scope.hpp>
-#include <boost/log/trivial.hpp>
-
 #include <App.h>
-#include <memory>
-#include <thread>
 
 using namespace std;
 
 void App::Init() {
-  BOOST_LOG_FUNCTION();
-
-  bool everythingFound = false;
-
   mFans = mSerializer.DeserializeFans(mSensorManager.RPMSensors());
+
   auto fanCurves = mSerializer.DeserializeFanCurves(
-      mSensorManager.TemperatureSensors(), mFans, everythingFound);
+      mSensorManager.TemperatureSensors(), mFans);
-
-  while (!everythingFound) {
-    BOOST_LOG_TRIVIAL(info) << "Couldn't find every sensor. Retrying in 5s...";
-    this_thread::sleep_for(chrono::seconds(5));
-
-    mSensorManager.ReloadSensors();
-    mFans = mSerializer.DeserializeFans(mSensorManager.RPMSensors());
-    fanCurves = mSerializer.DeserializeFanCurves(
-        mSensorManager.TemperatureSensors(), mFans, everythingFound);
-  }
 
   mSettings = mSerializer.DeserializeSettings();
 

app/src/FanGenerator.cxx

@@ -8,7 +8,7 @@
 #include <fan/HwmonFan.h>
 #include <pwm/PWMControl.h>
 
-#define SETTLE_TIMEOUT 30
+#define SETTLE_TIMEOUT 5
 
 using namespace std;
 
@@ -22,7 +22,7 @@ FanGenerator::FindFans(vector<shared_ptr<Sensor>> rpmSensors,
   cout << "Setting all fans to maximum speed" << endl;
   for (auto c : pwmControls) {
     c->EnableManualControl();
-    c->SetPower(100);
+    c->Power(100);
   }
 
   // Wait for fans to settle
@@ -41,7 +41,7 @@ FanGenerator::FindFans(vector<shared_ptr<Sensor>> rpmSensors,
   for (auto c : pwmControls) {
     cout << "Setting " << c->toString()
          << " to 50% and wait for it to settle..." << endl;
-    c->SetPower(50);
+    c->Power(50);
 
     this_thread::sleep_for(chrono::seconds(SETTLE_TIMEOUT));
 
@@ -53,7 +53,7 @@ FanGenerator::FindFans(vector<shared_ptr<Sensor>> rpmSensors,
     }
 
     cout << "Setting fan back to 100%" << endl;
-    c->SetPower(100);
+    c->Power(100);
   }
 
   return mapping;

app/src/Serializer.cxx

@@ -1,16 +1,14 @@
+#include "Settings.h"
 #include <filesystem>
 #include <fstream>
 #include <iostream>
-#include <memory>
 
-#include <boost/log/attributes/named_scope.hpp>
+#include <memory>
-#include <boost/log/trivial.hpp>
 
 #include <Serializer.h>
 #include <fan/HwmonFan.h>
 #include <pwm/PWMControl.h>
 #include <sensor/LMSensor.h>
-#include <string>
 
 using namespace std;
 namespace fs = filesystem;
@@ -33,11 +31,9 @@ void Serializer::SerializeFans(vector<shared_ptr<Fan>> fans) {
 
 vector<shared_ptr<Fan>>
 Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors) {
-  BOOST_LOG_FUNCTION();
-
   vector<shared_ptr<Fan>> fans;
 
-  // Create a map for the sensors first, then searching becomes cheaper
+  // Create a for the sensors first, then searching becomes cheaper
   map<string, shared_ptr<Sensor>> sensorMap;
   for (auto s : availableSensors) {
     sensorMap[s->toString()] = s;
@@ -46,31 +42,23 @@ Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors) {
   auto data = ReadJson();
   try {
     for (auto &el : data["fans"].items()) {
-      auto pwmControl = make_shared<PWMControl>(el.value()["PWMControl"]["Path"], el.value()["PWMControl"]["Index"]);
+      auto pwmControl = make_shared<PWMControl>(el.value()["PWMControl"]);
       auto rpmSensor = sensorMap[el.value()["LMSensor"]];
 
       int minPWM = el.value()["MinPWM"];
       int startPWM = el.value()["StartPWM"];
       string label = el.value()["Label"];
-      bool zeroFan = el.value()["ZeroFan"];
 
       auto fan = make_shared<HwmonFan>(pwmControl, rpmSensor);
       fan->MinPWM(minPWM);
       fan->StartPWM(startPWM);
       fan->Label(label);
-      fan->ZeroFanModeSupported(zeroFan);
 
       fans.push_back(fan);
     }
   } catch (const std::exception &e) {
     std::cout << "Deserialization error! Message: " << e.what() << std::endl;
   }
-
-  BOOST_LOG_TRIVIAL(trace) << "### Available Fans";
-  for (auto f : fans) {
-    BOOST_LOG_TRIVIAL(trace) << f->toString();
-  }
-
   return fans;
 }
 
@@ -96,10 +84,7 @@ json Serializer::ReadJson() {
 
 vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
     std::vector<std::shared_ptr<Sensor>> availableSensors,
-    std::vector<std::shared_ptr<Fan>> availableFans, bool &everythingFound) {
+    std::vector<std::shared_ptr<Fan>> availableFans) {
-  BOOST_LOG_FUNCTION();
-
-  everythingFound = true;
   auto data = ReadJson();
 
   map<string, shared_ptr<Sensor>> sensorMap;
@@ -126,11 +111,6 @@ vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
     for (auto &sensor : el.value()["Sensors"].items()) {
       if (sensorMap.contains(sensor.value()))
         sensors.push_back(sensorMap[sensor.value()]);
-      else {
-        BOOST_LOG_TRIVIAL(warning)
-            << "Sensor " << sensor.value() << " not found!";
-        everythingFound = false;
-      }
     }
 
     for (auto &fan : el.value()["Fans"].items()) {
@@ -138,26 +118,12 @@ vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
         fans.push_back(fanMap[fan.value()]);
     }
 
-    std::unique_ptr<Aggregator> aggregator =
+    curves.push_back(make_shared<FanCurve>(steps, sensors, fans));
-        aggregatorFromString(el.value()["AggregateFunction"]);
-
-    int hysteresis = el.value()["Hysteresis"];
-
-    curves.push_back(make_shared<FanCurve>(steps, sensors, fans,
-                                           std::move(aggregator), hysteresis));
   }
 
   return curves;
 }
 
-std::unique_ptr<Aggregator>
-Serializer::aggregatorFromString(std::string str) const {
-  if (str == "max")
-    return std::make_unique<MaxAggregator>();
-  else
-    return std::make_unique<AverageAggregator>();
-}
-
 shared_ptr<Settings> Serializer::DeserializeSettings() {
   int frequency = FREQUENCY_DEFAULT;
 

app/src/fan/Aggregators.cxx

@@ -1,39 +0,0 @@
-#include <climits>
-#include <fan/Aggregators.h>
-
-int
-AverageAggregator::aggregate(std::vector<std::shared_ptr<Sensor>> sensors) const
-{
-  int sum = 0;
-
-  for (auto sensor : sensors) {
-    sum += sensor->value();
-  }
-
-  return sum / sensors.size();
-}
-
-const std::string
-AverageAggregator::toString() const
-{
-  return "Average";
-}
-
-int
-MaxAggregator::aggregate(std::vector<std::shared_ptr<Sensor>> sensors) const
-{
-  int max = INT_MIN;
-
-  for (auto sensor : sensors) {
-    if (sensor->value() > max)
-      max = sensor->value();
-  }
-
-  return max;
-}
-
-const std::string
-MaxAggregator::toString() const
-{
-  return "Max";
-}

app/src/fan/FanCurve.cxx

@@ -1,37 +1,24 @@
-#include <iostream>
+#include <fan/FanCurve.h>
 
 #include <boost/log/attributes/named_scope.hpp>
 #include <boost/log/trivial.hpp>
-
+#include <sstream>
-#include <fan/FanCurve.h>
-#include <memory>
 
 using namespace std;
 
 FanCurve::FanCurve(std::vector<FanStep> steps,
                    std::vector<std::shared_ptr<Sensor>> sensors,
-                   std::vector<std::shared_ptr<Fan>> fans,
+                   std::vector<std::shared_ptr<Fan>> fans)
-                   std::unique_ptr<Aggregator> aggregator, int hysteresis)
+    : mSteps(steps), mTempSensors(sensors), mFans(fans) {
-    : mSteps(steps), mTempSensors(sensors), mFans(fans),
-      mAggregator(std::move(aggregator)), mHystersis(hysteresis),
-      mLastTemperature(INT_MIN) {
   PrintInfo();
 }
 
 void FanCurve::DoFanControl() {
-  BOOST_LOG_FUNCTION()
+  BOOST_LOG_FUNCTION();
 
-  BOOST_LOG_TRIVIAL(trace) << "## Fans in curve";
+  int temp = AggregateTemperature();
-  for (auto f : mFans)
-    BOOST_LOG_TRIVIAL(trace) << f->toString();
 
-  BOOST_LOG_TRIVIAL(trace) << "## Sensors in curve";
+  int t0, t1, p0, p1;
-  for (auto s : mTempSensors)
-    BOOST_LOG_TRIVIAL(trace) << s->toString();
-
-  int temp = mAggregator->aggregate(mTempSensors);
-
-  int t0 = 0, t1 = 0, p0 = 0, p1 = 0;
   int targetFanPower;
 
   if (temp <= mSteps[0].Temp) {
@@ -39,7 +26,7 @@ void FanCurve::DoFanControl() {
   } else if (temp > mSteps[mSteps.size() - 1].Temp) {
     targetFanPower = mSteps[mSteps.size() - 1].Percent;
   } else {
-    for (int i = 0; i < (int)mSteps.size(); i++) {
+    for (int i = 0; i < mSteps.size(); i++) {
       if (temp > mSteps[i].Temp) {
         t0 = mSteps[i].Temp;
         p0 = mSteps[i].Percent;
@@ -52,23 +39,25 @@ void FanCurve::DoFanControl() {
     targetFanPower = p0 + ((p1 - p0) / (t1 - t0)) * (temp - t0);
   }
 
-  BOOST_LOG_TRIVIAL(trace) << "Current temp: " << temp;
-  BOOST_LOG_TRIVIAL(trace) << "Last temp: " << mLastTemperature;
-
-  BOOST_LOG_TRIVIAL(trace) << "# Hysteresis check";
-  if (ExceedsHysteresis(temp)) {
-    BOOST_LOG_TRIVIAL(trace) << "passed";
   for (auto f : mFans) {
-      ApplyFanPower(f, targetFanPower);
+    if (f->RPM() <= 0) {
-
+      BOOST_LOG_TRIVIAL(warning) << "Fan stopped completely!";
-      mLastTemperature = temp;
+      f->PWM(f->StartPWM());
-    }
+      f->AdjustPWMLimits();
     } else {
-    for (auto f : mFans)
+      f->PWM(targetFanPower);
-      f->EnforceSetValue();
-
-    BOOST_LOG_TRIVIAL(trace) << "not passed";
     }
+  }
+}
+
+// Dummy Implementation using AVG
+int FanCurve::AggregateTemperature() {
+  int sum = 0;
+  for (auto s : mTempSensors) {
+    sum += s->value();
+  }
+
+  return sum / mTempSensors.size();
 }
 
 void FanCurve::PrintInfo() {
@@ -100,29 +89,4 @@ void FanCurve::PrintInfo() {
   }
 
   BOOST_LOG_TRIVIAL(info) << sStream.str();
-
-  sStream.str(string());
-
-  sStream << "Aggregate function: " << mAggregator->toString();
-
-  BOOST_LOG_TRIVIAL(info) << sStream.str();
-}
-
-bool FanCurve::ExceedsHysteresis(int temperature) {
-  int lowThreshold = mLastTemperature - mHystersis;
-  int highThreshold = mLastTemperature + mHystersis;
-
-  return temperature <= lowThreshold || temperature >= highThreshold;
-}
-
-void FanCurve::ApplyFanPower(std::shared_ptr<Fan> fan, int targetFanPower) {
-  BOOST_LOG_FUNCTION();
-
-  if (!fan->ZeroFanModeSupported() && fan->RPM() <= 0) {
-    BOOST_LOG_TRIVIAL(warning) << "Fan " << fan->toString() << " stopped completely!";
-    fan->PWM(fan->StartPWM());
-    fan->AdjustPWMLimits();
-  } else {
-    fan->PWM(targetFanPower);
-  }
 }

app/src/fan/FanLabeler.cxx

@@ -16,7 +16,7 @@ void FanLabeler::RunFanLabelInteraction(
   cout << endl;
 
   for (auto f : fans) {
-    cout << "Setting fan " << f->toString() << " to max power" << endl;
+    cout << "Setting fan to max power" << endl;
 
     f->PWM(100);
 

app/src/fan/HwmonFan.cxx

@@ -1,4 +1,3 @@
-#include <chrono>
 #include <iostream>
 #include <ostream>
 #include <thread>
@@ -10,7 +9,6 @@
 #include <pwm/PWMControl.h>
 
 #define TIMEOUT 10
-#define INHIBIT_STOP_PERIOD 120
 #define STEP 2
 
 using namespace std;
@@ -23,38 +21,10 @@ HwmonFan::HwmonFan(std::shared_ptr<PWMControl> pwmControl,
 
 void HwmonFan::PWM(int percent) {
   if (percent < mMinPWM) {
-    if (mZeroFanModeSupported && InhibitStopPeriodExpired()) {
+    mPWMControl->Power(mMinPWM);
-      SetPower(percent);
-      mWasStopped = true;
   } else {
-      SetPower(mMinPWM);
+    mPWMControl->Power(percent);
   }
-  } else {
-    if (mWasStopped) {
-      mWasStopped = false;
-      mLastStartTime = chrono::steady_clock::now();
-      SetPower(mStartPWM);
-    } else {
-      SetPower(percent);
-    }
-  }
-}
-
-bool HwmonFan::InhibitStopPeriodExpired() {
-  BOOST_LOG_FUNCTION();
-
-  auto result = chrono::steady_clock::now() - mLastStartTime >
-                chrono::duration(chrono::seconds(INHIBIT_STOP_PERIOD));
-
-  BOOST_LOG_TRIVIAL(trace) << "Inhibit-Stop period expired:"
-                           << (result ? "true" : "false");
-
-  return result;
-}
-
-void HwmonFan::SetPower(int percent) {
-  mPWMControl->SetPower(percent);
-  mSetValue = percent;
 }
 
 int HwmonFan::RPM() { return mRpmSensor->value(); }
@@ -69,12 +39,6 @@ void HwmonFan::StartPWM(int value) { mStartPWM = value; }
 
 int HwmonFan::StartPWM() { return mStartPWM; }
 
-void HwmonFan::ZeroFanModeSupported(bool value) {
-  mZeroFanModeSupported = value;
-}
-
-bool HwmonFan::ZeroFanModeSupported() { return mZeroFanModeSupported; }
-
 void HwmonFan::FindPWMLimits() {
   cout << "Looking for minimal PWM" << endl;
   int minPWM = 0;
@@ -129,13 +93,13 @@ void HwmonFan::AdjustPWMLimits() {
   }
 }
 
-void HwmonFan::EnforceSetValue() { mPWMControl->SetPower(mSetValue); }
-
 json HwmonFan::toJson() const {
   json obj;
-  obj = {mPWMControl->toJson(),   mRpmSensor->toJson(),
+  obj = {mPWMControl->toJson(),
-         {"Label", mLabel},       {"MinPWM", mMinPWM},
+         mRpmSensor->toJson(),
-         {"StartPWM", mStartPWM}, {"ZeroFan", mZeroFanModeSupported}};
+         {"Label", mLabel},
+         {"MinPWM", mMinPWM},
+         {"StartPWM", mStartPWM}};
   return obj;
 }
 
@@ -143,6 +107,6 @@ const string HwmonFan::toString() const {
   if (!mLabel.empty()) {
     return mLabel;
   } else {
-    return mPWMControl->toString();
+    return "fan:" + mPWMControl->toString();
   }
 }

app/src/main.cxx

@@ -20,13 +20,15 @@
 
 #include <App.h>
 
-#define PROJECT_VERSION "v0.3.0"
+#define PROJECT_VERSION "v0.1.6"
 
 namespace po = boost::program_options;
 namespace logging = boost::log;
 
 App app;
 
+static int doInitialSetup = 0;
+
 void signal_handler(int s) { app.Shutdown(); }
 
 void InitLogging(bool verbose) {

app/src/pwm/PWMControl.cxx

@@ -1,8 +1,8 @@
+#include <boost/log/attributes/named_scope.hpp>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
 
-#include <boost/log/attributes/named_scope.hpp>
 #include <boost/log/trivial.hpp>
 
 #include <pwm/PWMControl.h>
@@ -15,27 +15,17 @@
 using namespace std;
 namespace fs = filesystem;
 
-PWMControl::PWMControl(string controlPath, int deviceIndex)
+PWMControl::PWMControl(string controlPath) : mControlPath(controlPath) {
-    : mConfigPath(controlPath), mDeviceIndex(deviceIndex) {
+  fs::path pathEnable(mControlPath + PWM_POSTFIX_ENABLE);
-  auto path = fs::path{controlPath};
+  fs::path pathMode(mControlPath + PWM_POSTFIX_MODE);
 
-  int fileCount =
+  mEnablePath = pathEnable;
-      distance(fs::directory_iterator(path), fs::directory_iterator{});
+  mModePath = pathMode;
-  if (fileCount != 1)
-    throw runtime_error("More than one HWMON device present, unsupported");
-
-  for (auto de : fs::directory_iterator(path)) {
-    auto testPath = de.path();
-    mControlPath =
-        fs::path{de.path() / (string("pwm").append(to_string(deviceIndex)))}
-            .string();
-  }
-
-  mEnablePath = fs::path{mControlPath + PWM_POSTFIX_ENABLE}.string();
-  mModePath = fs::path{mControlPath + PWM_POSTFIX_MODE}.string();
 
   ifstream istrm;
 
+  mCurrentValue = Power();
+
   istrm.open(mEnablePath);
   istrm >> mInitialEnable;
   istrm.close();
@@ -52,28 +42,30 @@ PWMControl::~PWMControl() {
   Reset();
 }
 
-void PWMControl::SetPower(int percent) {
+void PWMControl::Power(int percent) {
   BOOST_LOG_FUNCTION();
 
   int pwmValue = (PWM_MAX_VALUE * percent) / 100;
 
-  if (pwmValue != CurrentPWM()) {
+  if (percent != mCurrentValue) {
-    BOOST_LOG_TRIVIAL(trace) << "Updating control value of " << toString()
+    BOOST_LOG_TRIVIAL(trace)
-                             << " to " << percent << "% (" << pwmValue << ")";
+        << "Updating control value to " << percent << "% (" << pwmValue << ")";
     ofstream ostrm(mControlPath, ios::trunc);
     ostrm << pwmValue;
     ostrm.close();
+
+    mCurrentValue = percent;
   }
 }
 
-int PWMControl::CurrentPWM() {
+int PWMControl::Power() {
   int value;
   ifstream istrm;
 
   istrm.open(mControlPath);
   istrm >> value;
 
-  return value;
+  return (value * 100) / PWM_MAX_VALUE;
 }
 
 void PWMControl::EnableManualControl() {
@@ -94,9 +86,11 @@ void PWMControl::Reset() {
   ostrm.close();
 }
 
-const string PWMControl::toString() const { return fs::path(mControlPath); }
+const string PWMControl::toString() const {
+  return fs::path(mControlPath).filename();
+}
 
 json PWMControl::toJson() const {
-  json obj = {"PWMControl", {{"Path", mConfigPath}, {"Index", mDeviceIndex}}};
+  json obj = {"PWMControl", mControlPath};
   return obj;
 }

app/src/pwm/PWMControlFacade.cxx

@@ -1,7 +1,6 @@
 #include <filesystem>
 #include <iostream>
 #include <regex>
-#include <string>
 
 #include <pwm/PWMControlFacade.h>
 
@@ -21,20 +20,14 @@ vector<shared_ptr<PWMControl>> PWMControlFacade::PWMControls() {
     for (const fs::directory_entry &hwmon_device :
          fs::directory_iterator{HWMON_BASE_PATH}) {
 
-      // Resolve symlink to get device path instead of hwmon path, the latter of
-      // which can change
-      fs::path actual_path =
-          fs::canonical(HWMON_BASE_PATH / fs::read_symlink(hwmon_device));
-
       for (const fs::directory_entry &control :
-           fs::directory_iterator{actual_path}) {
+           fs::directory_iterator{hwmon_device}) {
         auto filename = control.path().filename().string();
 
         if (regex_match(filename, re_ctrl)) {
-          auto controlIndex = filename.back() - '0';
+          auto controlPath = control.path().string();
-          auto controlPath = actual_path.parent_path();
 
-          controls.push_back(make_shared<PWMControl>(controlPath, controlIndex));
+          controls.push_back(make_shared<PWMControl>(controlPath));
         }
       }
     }

app/src/sensor/LMSensor.cxx

@@ -1,5 +1,3 @@
-#include <iostream>
-
 #include <boost/json/kind.hpp>
 #include <sensor/LMSensor.h>
 #include <sensors/sensors.h>
@@ -19,9 +17,7 @@ int LMSensor::value() {
 }
 
 const string LMSensor::toString() const {
-  ostringstream os;
+  return sensors_get_label(mChipName, mFeature);
-  os << mChipName->prefix << "." << sensors_get_label(mChipName, mFeature);
-  return os.str();
 }
 
 json LMSensor::toJson() const {

app/src/sensor/LMSensorsFacade.cxx

@@ -12,10 +12,12 @@ using namespace std;
 #define CONFIG_FILE "/etc/conf.d/sensors"
 
 LMSensorsFacade::LMSensorsFacade() : mConfigFile(fopen(CONFIG_FILE, "r")) {
-  InitSensors();
+  if (sensors_init(mConfigFile) != 0) {
+    throw runtime_error("Config file doesn't exist");
+  }
 }
 
-LMSensorsFacade::~LMSensorsFacade() { CleanupSensors(); }
+LMSensorsFacade::~LMSensorsFacade() { sensors_cleanup(); }
 
 std::vector<std::shared_ptr<Sensor>> LMSensorsFacade::TemperatureSensors() {
   return Sensors<SENSORS_SUBFEATURE_TEMP_INPUT>();
@@ -46,16 +48,3 @@ std::vector<std::shared_ptr<Sensor>> LMSensorsFacade::Sensors() {
 
   return sensors;
 }
-
-void LMSensorsFacade::ReloadSensors() {
-  CleanupSensors();
-  InitSensors();
-}
-
-void LMSensorsFacade::InitSensors() {
-  if (sensors_init(mConfigFile) != 0) {
-    throw runtime_error("Config file doesn't exist");
-  }
-}
-
-void LMSensorsFacade::CleanupSensors() { sensors_cleanup(); }

app/src/sensor/NvidiaSensor.cxx

@@ -1,7 +1,10 @@
-#include <include/nvml.h>
+#ifdef HAVE_NVML
 
+#include <include/nvml.h>
 #include <sensor/NvidiaSensor.h>
 
+#include <boost/json/object.hpp>
+
 using namespace std;
 
 NvidiaSensor::NvidiaSensor() { nvmlInit_v2(); }
@@ -24,3 +27,5 @@ json NvidiaSensor::toJson() const {
   json obj = {"NvidiaSensor", toString()};
   return obj;
 }
+
+#endif

app/src/sensor/SensorManager.cxx

@@ -1,35 +1,28 @@
 #include <sensor/SensorManager.h>
 
-#include <boost/log/attributes/named_scope.hpp>
-#include <boost/log/trivial.hpp>
-
 using namespace std;
 
 SensorManager::SensorManager()
-    : mLMSensorsFacade(make_unique<LMSensorsFacade>()),
+    : mLMSensorsFacade(make_unique<LMSensorsFacade>())
-      mGPUSensorsFacade(make_unique<GPUSensorsFacade>()) {}
+    , mGPUSensorsFacade(make_unique<GPUSensorsFacade>())
-
+{
-vector<shared_ptr<Sensor>> SensorManager::TemperatureSensors() {
+}
-  BOOST_LOG_FUNCTION();
 
+vector<shared_ptr<Sensor>> SensorManager::TemperatureSensors()
+{
     vector<shared_ptr<Sensor>> tempSensors;
 
     tempSensors = mLMSensorsFacade->TemperatureSensors();
 
-  BOOST_LOG_TRIVIAL(trace) << "### Temperature sensors:";
+#ifdef HAVE_NVML
-  for (auto s : tempSensors) {
+    auto gpuSensors = mGPUSensorsFacade->TemperatureSensors();
-    BOOST_LOG_TRIVIAL(trace) << s->toString();
+    tempSensors.insert(tempSensors.end(), gpuSensors.begin(), gpuSensors.end());
-  }
+#endif
-
-  //   auto gpuSensors = mGPUSensorsFacade->TemperatureSensors();
-  //  tempSensors.insert(tempSensors.end(), gpuSensors.begin(),
-  //  gpuSensors.end());
 
     return tempSensors;
 }
 
-vector<shared_ptr<Sensor>> SensorManager::RPMSensors() {
+vector<shared_ptr<Sensor>> SensorManager::RPMSensors()
+{
     return mLMSensorsFacade->RPMSensors();
 }
-
-void SensorManager::ReloadSensors() { mLMSensorsFacade->ReloadSensors(); }

app/unit/fantasize.service

@@ -7,4 +7,4 @@ ExecStart=/usr/local/bin/fantasize
 Restart=always
 
 [Install]
-WantedBy=graphical.target
+WantedBy=multi-user.target