Improve logic to handle fans stopping

Conversion from power percentage to PWM value didn't take into floating
point arithmetic into account
Make log messages more helpful, add handling for fan stopping completely

.gitignore

@@ -1,3 +1,8 @@
 oot/
 compile_commands.json
 .cache/
+pkg/
+rel_oot/
+src/
+*.pkg.tar.zst
+*.tar.gz

PKGBUILD

@@ -1,5 +1,5 @@
 pkgname=fantasize
-pkgver=0.1.0
+pkgver=0.1.6
 pkgrel=1
 pkgdesc='C++ fan control for Linux'
 url='https://github.com/Tabascl/fantasize.git'
@@ -7,7 +7,7 @@ source=("$pkgname-$pkgver.tar.gz::https://github.com/Tabascl/fantasize/archive/r
 arch=('x86_64')
 license=('GPL3')
 makedepends=('git' 'cmake' 'nlohmann-json' 'boost' 'cuda')
-sha256sums=('69d61255edb49b66396f00b7bfadb39ce1220769838929ad74dc9f3301742ce7')
+sha256sums=('SKIP')
 
 build() {
     cmake -S "$pkgname-$pkgver/app" -B build -DCMAKE_BUILD_TYPE=Release

app/CMakeLists.txt

@@ -1,11 +1,11 @@
 cmake_minimum_required(VERSION 3.0)
 
-project(fantasize VERSION 0.1.0)
+project(fantasize VERSION 0.1.6)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 find_package(nlohmann_json 3.11.2 REQUIRED)
-find_package(Boost 1.80 COMPONENTS program_options REQUIRED)
+find_package(Boost 1.80 COMPONENTS program_options log log_setup date_time REQUIRED)
 
 add_executable(${PROJECT_NAME}
   src/main.cxx

app/include/App.h

@@ -27,6 +27,8 @@ private:
   FanGenerator mFanGenerator;
 
   std::unique_ptr<Controller> mController;
+
+  std::vector<std::shared_ptr<Fan>> mFans;
 };
 
 #endif // APP_H_

app/include/fan/Fan.h

@@ -10,11 +10,15 @@ public:
   virtual int RPM() = 0;
 
   virtual void Label(std::string label) = 0;
-  virtual void MinPWM(int value) = 0;
-  virtual void StartPWM(int value) = 0;
 
-  virtual void FindMinPWM() = 0;
-  virtual void FindStartPWM() = 0;
+  virtual void MinPWM(int value) = 0;
+  virtual int MinPWM() = 0;
+
+  virtual void StartPWM(int value) = 0;
+  virtual int StartPWM() = 0;
+
+  virtual void FindPWMLimits() = 0;
+  virtual void AdjustPWMLimits() = 0;
 };
 
 #endif // FAN_H_

app/include/fan/HwmonFan.h

@@ -1,9 +1,11 @@
 #ifndef HWMONFAN_H_
 #define HWMONFAN_H_
 
-#include <boost/json/object.hpp>
+#include <chrono>
 #include <memory>
 
+#include <boost/json/object.hpp>
+
 #include <fan/Fan.h>
 #include <pwm/PWMControl.h>
 #include <sensor/Sensor.h>
@@ -17,11 +19,15 @@ public:
   int RPM() override;
 
   void Label(std::string label) override;
-  void MinPWM(int value) override;
-  void StartPWM(int value) override;
 
-  void FindMinPWM() override;
-  void FindStartPWM() override;
+  void MinPWM(int value) override;
+  int MinPWM() override;
+
+  void StartPWM(int value) override;
+  int StartPWM() override;
+
+  void FindPWMLimits() override;
+  void AdjustPWMLimits() override;
 
   json toJson() const override;
 
@@ -34,6 +40,7 @@ private:
 
   int mMinPWM;
   int mStartPWM;
+  std::chrono::time_point<std::chrono::steady_clock> mLastAdjustmentTime;
 };
 
 #endif // HWMONFAN_H_

app/include/pwm/PWMControl.h

@@ -16,8 +16,8 @@ public:
   PWMControl(std::string controlPath);
   ~PWMControl();
 
-  void pwm(int percent);
-  int pwm();
+  void Power(int percent);
+  int Power();
 
   void EnableManualControl();
   void Reset();
@@ -27,7 +27,7 @@ public:
   json toJson() const override;
 
 private:
-  int readValue(std::string path);
+  int mCurrentValue;
 
   std::string mControlPath;
   std::string mEnablePath;

app/src/App.cxx

@@ -5,10 +5,10 @@
 using namespace std;
 
 void App::Init() {
-  auto fans = mSerializer.DeserializeFans(mSensorManager.RPMSensors());
+  mFans = mSerializer.DeserializeFans(mSensorManager.RPMSensors());
 
   auto fanCurves = mSerializer.DeserializeFanCurves(
-      mSensorManager.TemperatureSensors(), fans);
+      mSensorManager.TemperatureSensors(), mFans);
 
   mController = make_unique<Controller>(fanCurves);
 }
@@ -18,11 +18,13 @@ void App::InitialSetup() {
                                      mPWMControlFacade.PWMControls());
 
   std::for_each(std::execution::par, std::begin(fans), std::end(fans),
-                [](auto &&fan) { fan->FindMinPWM(); });
+                [](auto &&fan) { fan->FindPWMLimits(); });
 
   mFanLabeler.RunFanLabelInteraction(fans);
 
   mSerializer.SerializeFans(fans);
+
+  mFans = fans;
 }
 
 void App::NormalOperation() {
@@ -30,4 +32,8 @@ void App::NormalOperation() {
     mController->StartFanControlLoop();
 }
 
-void App::Shutdown() { mController.reset(); }
+void App::Shutdown() {
+  mSerializer.SerializeFans(mFans);
+  mFans.clear();
+  mController.reset();
+}

app/src/FanGenerator.cxx

@@ -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->pwm(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->pwm(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->pwm(100);
+    c->Power(100);
   }
 
   return mapping;

app/src/Serializer.cxx

@@ -47,10 +47,12 @@ Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors) {
       auto rpmSensor = sensorMap[el.value()["LMSensor"]];
 
       int minPWM = el.value()["MinPWM"];
+      int startPWM = el.value()["StartPWM"];
       string label = el.value()["Label"];
 
       auto fan = make_shared<HwmonFan>(pwmControl, rpmSensor);
       fan->MinPWM(minPWM);
+      fan->StartPWM(startPWM);
       fan->Label(label);
 
       fans.push_back(fan);

app/src/fan/FanCurve.cxx

@@ -1,5 +1,8 @@
+#include <boost/log/attributes/named_scope.hpp>
 #include <iostream>
 
+#include <boost/log/trivial.hpp>
+
 #include <fan/FanCurve.h>
 
 using namespace std;
@@ -8,20 +11,21 @@ FanCurve::FanCurve(std::vector<FanStep> steps,
                    std::vector<std::shared_ptr<Sensor>> sensors,
                    std::vector<std::shared_ptr<Fan>> fans)
     : mSteps(steps), mTempSensors(sensors), mFans(fans) {
-  cout << "Initialized Fan Curve:" << endl;
   PrintInfo();
 }
 
 void FanCurve::DoFanControl() {
+  BOOST_LOG_FUNCTION();
+
   int temp = AggregateTemperature();
 
   int t0, t1, p0, p1;
-  int targetFanSpeed;
+  int targetFanPower;
 
   if (temp <= mSteps[0].Temp) {
-    targetFanSpeed = mSteps[0].Percent;
+    targetFanPower = mSteps[0].Percent;
   } else if (temp > mSteps[mSteps.size() - 1].Temp) {
-    targetFanSpeed = mSteps[mSteps.size() - 1].Percent;
+    targetFanPower = mSteps[mSteps.size() - 1].Percent;
   } else {
     for (int i = 0; i < mSteps.size(); i++) {
       if (temp > mSteps[i].Temp) {
@@ -33,11 +37,17 @@ void FanCurve::DoFanControl() {
       }
     }
 
-    targetFanSpeed = p0 + ((p1 - p0) / (t1 - t0)) * (temp - t0);
+    targetFanPower = p0 + ((p1 - p0) / (t1 - t0)) * (temp - t0);
   }
 
   for (auto f : mFans) {
-    f->PWM(targetFanSpeed);
+    if (f->RPM() <= 0) {
+      BOOST_LOG_TRIVIAL(warning) << "Fan stopped completely!";
+      f->PWM(f->StartPWM());
+      f->AdjustPWMLimits();
+    } else {
+      f->PWM(targetFanPower);
+    }
   }
 }
 
@@ -52,28 +62,32 @@ int FanCurve::AggregateTemperature() {
 }
 
 void FanCurve::PrintInfo() {
+  BOOST_LOG_FUNCTION()
+
+  BOOST_LOG_TRIVIAL(info) << "### Fan curve:";
+
   stringstream sStream;
-  cout << "Steps: ";
+  sStream << "Steps: ";
   for (auto s : mSteps) {
     sStream << "[ " << s.Temp << "C, " << s.Percent << "% ] ";
   }
-  cout << sStream.str() << endl;
+  BOOST_LOG_TRIVIAL(info) << sStream.str();
 
   sStream.str(string());
 
-  cout << "Sensors: ";
+  sStream << "Sensors: ";
   for (auto s : mTempSensors) {
     sStream << s->toString() << ", ";
   }
 
-  cout << sStream.str() << endl;
+  BOOST_LOG_TRIVIAL(info) << sStream.str();
 
   sStream.str(string());
 
-  cout << "Fans: ";
+  sStream << "Fans: ";
   for (auto s : mFans) {
     sStream << s->toString() << ", ";
   }
 
-  cout << sStream.str() << endl;
+  BOOST_LOG_TRIVIAL(info) << sStream.str();
 }

app/src/fan/HwmonFan.cxx

@@ -1,13 +1,15 @@
-#include <chrono>
 #include <iostream>
 #include <ostream>
 #include <thread>
 
-#include "pwm/PWMControl.h"
-#include <boost/json/object.hpp>
-#include <fan/HwmonFan.h>
+#include <boost/log/attributes/named_scope.hpp>
+#include <boost/log/trivial.hpp>
 
-#define TIMEOUT 5
+#include <fan/HwmonFan.h>
+#include <pwm/PWMControl.h>
+
+#define TIMEOUT 10
+#define STEP 2
 
 using namespace std;
 
@@ -19,9 +21,9 @@ HwmonFan::HwmonFan(std::shared_ptr<PWMControl> pwmControl,
 
 void HwmonFan::PWM(int percent) {
   if (percent < mMinPWM) {
-    mPWMControl->pwm(mMinPWM);
+    mPWMControl->Power(mMinPWM);
   } else {
-    mPWMControl->pwm(percent);
+    mPWMControl->Power(percent);
   }
 }
 
@@ -31,41 +33,73 @@ void HwmonFan::Label(std::string label) { mLabel = label; }
 
 void HwmonFan::MinPWM(int value) { mMinPWM = value; }
 
+int HwmonFan::MinPWM() { return mMinPWM; }
+
 void HwmonFan::StartPWM(int value) { mStartPWM = value; }
 
-void HwmonFan::FindMinPWM() {
+int HwmonFan::StartPWM() { return mStartPWM; }
+
+void HwmonFan::FindPWMLimits() {
   cout << "Looking for minimal PWM" << endl;
   int minPWM = 0;
   mMinPWM = 0;
+  mStartPWM = 0;
 
-  for (int curPWM = 100; curPWM > 0; curPWM -= 5) {
+  for (int curPWM = 100; curPWM > 0; curPWM -= STEP) {
     PWM(curPWM);
     this_thread::sleep_for(chrono::seconds(TIMEOUT));
 
-    int curRPM = RPM();
-
-    if (curRPM <= 0) {
-      minPWM = curPWM + 5;
+    if (RPM() <= 0) {
+      minPWM = curPWM + STEP;
       break;
     }
   }
 
+  cout << "Setting minimal PWM: " << minPWM << endl;
+  mMinPWM = minPWM;
+
   if (minPWM == 0) {
     cout << "Fan never stopped. ";
-  }
-  cout << "Setting minimal PWM: " << minPWM << endl;
+  } else {
+    int startPWM = 0;
 
-  mMinPWM = minPWM;
+    cout << "Looking for start PWM!" << endl;
+    for (int curPWM = minPWM - STEP; curPWM < 100; curPWM += STEP) {
+      PWM(curPWM);
+      this_thread::sleep_for(chrono::seconds(TIMEOUT));
+
+      if (RPM() > 0) {
+        cout << "Setting start PWM: " << startPWM << endl;
+        startPWM = curPWM;
+        break;
+      }
     }
 
-void HwmonFan::FindStartPWM() {}
+    mStartPWM = startPWM;
+  }
+}
+
+void HwmonFan::AdjustPWMLimits() {
+  BOOST_LOG_FUNCTION()
+
+  chrono::time_point now = chrono::steady_clock::now();
+
+  if ((now - mLastAdjustmentTime) >
+      chrono::duration(chrono::seconds(TIMEOUT))) {
+    BOOST_LOG_TRIVIAL(info) << "Increasing minimal fan speed";
+
+    mLastAdjustmentTime = now;
+    mMinPWM += 2;
+  }
+}
 
 json HwmonFan::toJson() const {
   json obj;
   obj = {mPWMControl->toJson(),
          mRpmSensor->toJson(),
          {"Label", mLabel},
-         {"MinPWM", mMinPWM}};
+         {"MinPWM", mMinPWM},
+         {"StartPWM", mStartPWM}};
   return obj;
 }
 

app/src/main.cxx

@@ -1,15 +1,29 @@
+#include <csignal>
+#include <iostream>
+
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+#include <boost/log/attributes/named_scope.hpp>
+#include <boost/log/core.hpp>
+#include <boost/log/expressions.hpp>
+#include <boost/log/expressions/formatters/named_scope.hpp>
+#include <boost/log/expressions/message.hpp>
+#include <boost/log/support/date_time.hpp>
+#include <boost/log/trivial.hpp>
+#include <boost/log/utility/setup.hpp>
+#include <boost/log/utility/setup/common_attributes.hpp>
+#include <boost/log/utility/setup/console.hpp>
+#include <boost/program_options.hpp>
 #include <boost/program_options/options_description.hpp>
 #include <boost/program_options/parsers.hpp>
 #include <boost/program_options/value_semantic.hpp>
 #include <boost/program_options/variables_map.hpp>
-#include <csignal>
-#include <iostream>
-
-#include <boost/program_options.hpp>
 
 #include <App.h>
 
+#define PROJECT_VERSION "v0.1.6"
+
 namespace po = boost::program_options;
+namespace logging = boost::log;
 
 App app;
 
@@ -17,18 +31,54 @@ static int doInitialSetup = 0;
 
 void signal_handler(int s) { app.Shutdown(); }
 
+void InitLogging(bool verbose) {
+  logging::add_console_log(
+      std::clog,
+      logging::keywords::format =
+          (logging::expressions::stream
+           << "["
+           << logging::expressions::format_date_time<boost::posix_time::ptime>(
+                  "TimeStamp", "%Y-%m-%d %H:%M:%S")
+           << "]["
+           << logging::expressions::format_named_scope(
+                  "Scope", logging::keywords::format = "%c")
+           << "]"
+           << "[" << logging::trivial::severity << "] "
+           << logging::expressions::smessage));
+
+  logging::add_common_attributes();
+  logging::core::get()->add_global_attribute(
+      "Scope", logging::attributes::named_scope());
+
+  BOOST_LOG_FUNCTION();
+
+  if (!verbose) {
+    logging::core::get()->set_filter(logging::trivial::severity >=
+                                     logging::trivial::info);
+  } else {
+    BOOST_LOG_TRIVIAL(info) << "Verbose logging enabled";
+  }
+}
+
 int main(int argc, char **argv) {
+  BOOST_LOG_FUNCTION()
+  BOOST_LOG_TRIVIAL(info) << "Version: " << PROJECT_VERSION;
+
   signal(SIGINT, signal_handler);
+  signal(SIGTERM, signal_handler);
 
   po::options_description desc("Allowed options");
-  desc.add_options()("help", "produce help message")("setup", po::bool_switch(),
-                                                     "run initial setup");
+  desc.add_options()("help,h", "produce help message")(
+      "setup,s", po::bool_switch(),
+      "run initial setup")("verbose,v", po::bool_switch(), "print debug info");
 
   po::variables_map vm;
   po::store(po::parse_command_line(argc, argv, desc), vm);
   po::notify(vm);
 
   try {
+    InitLogging(vm["verbose"].as<bool>());
+
     if (vm.count("help")) {
       std::cout << desc << "\n";
       return 0;

app/src/pwm/PWMControl.cxx

@@ -1,8 +1,10 @@
-#include <boost/json/object.hpp>
+#include <boost/log/attributes/named_scope.hpp>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
 
+#include <boost/log/trivial.hpp>
+
 #include <pwm/PWMControl.h>
 
 #define PWM_POSTFIX_ENABLE "_enable"
@@ -22,6 +24,8 @@ PWMControl::PWMControl(string controlPath) : mControlPath(controlPath) {
 
   ifstream istrm;
 
+  mCurrentValue = Power();
+
   istrm.open(mEnablePath);
   istrm >> mInitialEnable;
   istrm.close();
@@ -32,26 +36,36 @@ PWMControl::PWMControl(string controlPath) : mControlPath(controlPath) {
 }
 
 PWMControl::~PWMControl() {
-  cout << "Cleanup" << endl;
+  BOOST_LOG_FUNCTION();
+
+  BOOST_LOG_TRIVIAL(trace) << "Cleanup";
   Reset();
 }
 
-void PWMControl::pwm(int percent) {
-  int pwmValue = PWM_MAX_VALUE * percent / 100;
+void PWMControl::Power(int percent) {
+  BOOST_LOG_FUNCTION();
 
+  int pwmValue = (PWM_MAX_VALUE * percent) / 100;
+
+  if (percent != mCurrentValue) {
+    BOOST_LOG_TRIVIAL(trace)
+        << "Updating control value to " << percent << "% (" << pwmValue << ")";
     ofstream ostrm(mControlPath, ios::trunc);
     ostrm << pwmValue;
     ostrm.close();
+
+    mCurrentValue = percent;
+  }
 }
 
-int PWMControl::pwm() {
+int PWMControl::Power() {
   int value;
   ifstream istrm;
 
   istrm.open(mControlPath);
   istrm >> value;
 
-  return value;
+  return (value * 100) / PWM_MAX_VALUE;
 }
 
 void PWMControl::EnableManualControl() {