Various fixes

- Change unit path
- Rename method
- Make CurrentPWM method return its value in PWM instead of percent

app/include/Serializer.h

@@ -17,16 +17,16 @@
 
 using json = nlohmann::json;
 
-class Serializer
-{
+class Serializer {
 public:
   Serializer();
   void SerializeFans(std::vector<std::shared_ptr<Fan>> fans);
-  std::vector<std::shared_ptr<Fan>> 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>>
+  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,
+                       bool &everythingFound);
   std::shared_ptr<Settings> DeserializeSettings();
 
 private:

app/include/fan/Fan.h

@@ -22,6 +22,8 @@ public:
 
   virtual void FindPWMLimits() = 0;
   virtual void AdjustPWMLimits() = 0;
+
+  virtual void EnforceSetValue() = 0;
 };
 
 #endif // FAN_H_

app/include/fan/FanCurve.h

@@ -8,30 +8,32 @@
 #include <fan/HwmonFan.h>
 #include <sensor/Sensor.h>
 
-struct FanStep
-{
+struct FanStep {
   int Temp;
   int Percent;
 };
 
-class FanCurve
-{
+class FanCurve {
 public:
   FanCurve(std::vector<FanStep> steps,
            std::vector<std::shared_ptr<Sensor>> sensors,
            std::vector<std::shared_ptr<Fan>> fans,
-           std::unique_ptr<Aggregator> aggregator);
+           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

@@ -30,11 +30,16 @@ public:
   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;
@@ -43,6 +48,9 @@ private:
   int mStartPWM = 0;
   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

@@ -15,8 +15,8 @@ public:
   PWMControl(std::string controlPath);
   ~PWMControl();
 
-  void Power(int percent);
-  int Power();
+  void SetPower(int percent);
+  int CurrentPWM();
 
   void EnableManualControl();
   void Reset();
@@ -26,8 +26,6 @@ public:
   json toJson() const override;
 
 private:
-  int mCurrentValue;
-
   std::string mControlPath;
   std::string mEnablePath;
   std::string mModePath;

app/include/sensor/LMSensorsFacade.h

@@ -16,9 +16,13 @@ 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,6 +12,8 @@ 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

@@ -34,4 +34,4 @@ exe = executable('fantasize',
   install: true,
   include_directories: inc)
 
-install_data('unit/fantasize.service', install_dir : 'usr/lib/systemd/system')
+install_data('unit/fantasize.service', install_dir : '/usr/lib/systemd/system')

app/src/App.cxx

@@ -1,14 +1,35 @@
+#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() {
-  mFans = mSerializer.DeserializeFans(mSensorManager.RPMSensors());
+  BOOST_LOG_FUNCTION();
 
+  bool everythingFound = false;
+
+  mFans = mSerializer.DeserializeFans(mSensorManager.RPMSensors());
   auto fanCurves = mSerializer.DeserializeFanCurves(
-      mSensorManager.TemperatureSensors(), mFans);
+      mSensorManager.TemperatureSensors(), mFans, everythingFound);
+
+  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 5
+#define SETTLE_TIMEOUT 10
 
 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->Power(100);
+    c->SetPower(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->Power(50);
+    c->SetPower(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->Power(100);
+    c->SetPower(100);
   }
 
   return mapping;

app/src/Serializer.cxx

@@ -1,9 +1,11 @@
 #include <filesystem>
 #include <fstream>
 #include <iostream>
-
 #include <memory>
 
+#include <boost/log/attributes/named_scope.hpp>
+#include <boost/log/trivial.hpp>
+
 #include <Serializer.h>
 #include <fan/HwmonFan.h>
 #include <pwm/PWMControl.h>
@@ -31,6 +33,8 @@ 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 for the sensors first, then searching becomes cheaper
@@ -61,6 +65,12 @@ Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors) {
   } 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;
 }
 
@@ -86,7 +96,10 @@ json Serializer::ReadJson() {
 
 vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
     std::vector<std::shared_ptr<Sensor>> availableSensors,
-    std::vector<std::shared_ptr<Fan>> availableFans) {
+    std::vector<std::shared_ptr<Fan>> availableFans, bool &everythingFound) {
+  BOOST_LOG_FUNCTION();
+
+  everythingFound = true;
   auto data = ReadJson();
 
   map<string, shared_ptr<Sensor>> sensorMap;
@@ -113,6 +126,11 @@ 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()) {
@@ -123,8 +141,10 @@ vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
     std::unique_ptr<Aggregator> aggregator =
         aggregatorFromString(el.value()["AggregateFunction"]);
 
-    curves.push_back(
-        make_shared<FanCurve>(steps, sensors, fans, std::move(aggregator)));
+    int hysteresis = el.value()["Hysteresis"];
+
+    curves.push_back(make_shared<FanCurve>(steps, sensors, fans,
+                                           std::move(aggregator), hysteresis));
   }
 
   return curves;

app/src/fan/FanCurve.cxx

@@ -1,6 +1,6 @@
-#include <boost/log/attributes/named_scope.hpp>
 #include <iostream>
 
+#include <boost/log/attributes/named_scope.hpp>
 #include <boost/log/trivial.hpp>
 
 #include <fan/FanCurve.h>
@@ -11,14 +11,23 @@ using namespace std;
 FanCurve::FanCurve(std::vector<FanStep> steps,
                    std::vector<std::shared_ptr<Sensor>> sensors,
                    std::vector<std::shared_ptr<Fan>> fans,
-                   std::unique_ptr<Aggregator> aggregator)
+                   std::unique_ptr<Aggregator> aggregator, int hysteresis)
     : mSteps(steps), mTempSensors(sensors), mFans(fans),
-      mAggregator(std::move(aggregator)) {
+      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";
+  for (auto f : mFans)
+    BOOST_LOG_TRIVIAL(trace) << f->toString();
+
+  BOOST_LOG_TRIVIAL(trace) << "## Sensors in curve";
+  for (auto s : mTempSensors)
+    BOOST_LOG_TRIVIAL(trace) << s->toString();
 
   int temp = AggregateTemperature();
 
@@ -43,14 +52,22 @@ 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) {
-    if (!f->ZeroFanModeSupported() && f->RPM() <= 0) {
-      BOOST_LOG_TRIVIAL(warning) << "Fan stopped completely!";
-      f->PWM(f->StartPWM());
-      f->AdjustPWMLimits();
-    } else {
-      f->PWM(targetFanPower);
+      ApplyFanPower(f, targetFanPower);
+
+      mLastTemperature = temp;
     }
+  } else {
+    for (auto f : mFans)
+      f->EnforceSetValue();
+
+    BOOST_LOG_TRIVIAL(trace) << "not passed";
   }
 }
 
@@ -94,3 +111,22 @@ void FanCurve::PrintInfo() {
 
   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 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 to max power" << endl;
+    cout << "Setting fan " << f->toString() << " to max power" << endl;
 
     f->PWM(100);
 

app/src/fan/HwmonFan.cxx

@@ -1,3 +1,4 @@
+#include <chrono>
 #include <iostream>
 #include <ostream>
 #include <thread>
@@ -9,6 +10,7 @@
 #include <pwm/PWMControl.h>
 
 #define TIMEOUT 10
+#define INHIBIT_STOP_PERIOD 120
 #define STEP 2
 
 using namespace std;
@@ -21,10 +23,38 @@ HwmonFan::HwmonFan(std::shared_ptr<PWMControl> pwmControl,
 
 void HwmonFan::PWM(int percent) {
   if (percent < mMinPWM) {
-    mPWMControl->Power(mMinPWM);
+    if (mZeroFanModeSupported && InhibitStopPeriodExpired()) {
+      SetPower(percent);
+      mWasStopped = true;
     } else {
-    mPWMControl->Power(percent);
+      SetPower(mMinPWM);
     }
+  } 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(); }
@@ -99,6 +129,8 @@ void HwmonFan::AdjustPWMLimits() {
   }
 }
 
+void HwmonFan::EnforceSetValue() { mPWMControl->SetPower(mSetValue); }
+
 json HwmonFan::toJson() const {
   json obj;
   obj = {mPWMControl->toJson(),   mRpmSensor->toJson(),
@@ -111,6 +143,6 @@ const string HwmonFan::toString() const {
   if (!mLabel.empty()) {
     return mLabel;
   } else {
-    return "fan:" + mPWMControl->toString();
+    return mPWMControl->toString();
   }
 }

app/src/main.cxx

@@ -27,8 +27,6 @@ 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

@@ -15,9 +15,7 @@
 using namespace std;
 namespace fs = filesystem;
 
-PWMControl::PWMControl(string controlPath)
-  : mControlPath(controlPath)
-{
+PWMControl::PWMControl(string controlPath) : mControlPath(controlPath) {
   fs::path pathEnable(mControlPath + PWM_POSTFIX_ENABLE);
   fs::path pathMode(mControlPath + PWM_POSTFIX_MODE);
 
@@ -26,8 +24,6 @@ PWMControl::PWMControl(string controlPath)
 
   ifstream istrm;
 
-  mCurrentValue = Power();
-
   istrm.open(mEnablePath);
   istrm >> mInitialEnable;
   istrm.close();
@@ -37,55 +33,44 @@ PWMControl::PWMControl(string controlPath)
   istrm.close();
 }
 
-PWMControl::~PWMControl()
-{
+PWMControl::~PWMControl() {
   BOOST_LOG_FUNCTION();
 
   BOOST_LOG_TRIVIAL(trace) << "Cleanup";
   Reset();
 }
 
-void
-PWMControl::Power(int percent)
-{
+void PWMControl::SetPower(int percent) {
   BOOST_LOG_FUNCTION();
 
   int pwmValue = (PWM_MAX_VALUE * percent) / 100;
 
-  if (percent != mCurrentValue) {
+  if (pwmValue != CurrentPWM()) {
     BOOST_LOG_TRIVIAL(trace) << "Updating control value of " << toString()
                              << " to " << percent << "% (" << pwmValue << ")";
     ofstream ostrm(mControlPath, ios::trunc);
     ostrm << pwmValue;
     ostrm.close();
-
-    mCurrentValue = percent;
   }
 }
 
-int
-PWMControl::Power()
-{
+int PWMControl::CurrentPWM() {
   int value;
   ifstream istrm;
 
   istrm.open(mControlPath);
   istrm >> value;
 
-  return (value * 100) / PWM_MAX_VALUE;
+  return value;
 }
 
-void
-PWMControl::EnableManualControl()
-{
+void PWMControl::EnableManualControl() {
   ofstream ostrm(mEnablePath, ios::trunc);
   ostrm << static_cast<int>(PWM_ENABLE::MANUAL_CONTROL);
   ostrm.close();
 }
 
-void
-PWMControl::Reset()
-{
+void PWMControl::Reset() {
   ofstream ostrm(mEnablePath, ios::trunc);
 
   ostrm << mInitialEnable;
@@ -97,15 +82,9 @@ PWMControl::Reset()
   ostrm.close();
 }
 
-const string
-PWMControl::toString() const
-{
-  return fs::path(mControlPath).filename();
-}
+const string PWMControl::toString() const { return fs::path(mControlPath); }
 
-json
-PWMControl::toJson() const
-{
+json PWMControl::toJson() const {
   json obj = {"PWMControl", mControlPath};
   return obj;
 }

app/src/sensor/LMSensorsFacade.cxx

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

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