Adapt version

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.5
 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.5)
 
 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,14 @@ 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 MinPWM(int value) = 0;
-  virtual void FindStartPWM() = 0;
+  virtual int MinPWM() = 0;
+
+  virtual void StartPWM(int value) = 0;
+  virtual int StartPWM() = 0;
+
+  virtual void FindPWMLimits() = 0;
 };
 
 #endif // FAN_H_

app/include/fan/HwmonFan.h

@@ -17,11 +17,14 @@ public:
   int RPM() override;
 
   void Label(std::string label) override;
-  void MinPWM(int value) override;
-  void StartPWM(int value) override;
 
-  void FindMinPWM() override;
+  void MinPWM(int value) override;
-  void FindStartPWM() override;
+  int MinPWM() override;
+
+  void StartPWM(int value) override;
+  int StartPWM() override;
+
+  void FindPWMLimits() override;
 
   json toJson() const override;
 

app/include/pwm/PWMControl.h

@@ -16,8 +16,8 @@ public:
   PWMControl(std::string controlPath);
   ~PWMControl();
 
-  void pwm(int percent);
+  void Power(int percent);
-  int pwm();
+  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,19 @@ 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());
+
+      BOOST_LOG_TRIVIAL(info) << "Adjusting minPWM of fan " << f->toString();
+      f->MinPWM(f->MinPWM() + 2);
+    } else {
+      f->PWM(targetFanPower);
+    }
   }
 }
 
@@ -52,28 +64,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

@@ -7,7 +7,8 @@
 #include <boost/json/object.hpp>
 #include <fan/HwmonFan.h>
 
-#define TIMEOUT 5
+#define TIMEOUT 10
+#define STEP 2
 
 using namespace std;
 
@@ -19,9 +20,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 +32,59 @@ void HwmonFan::Label(std::string label) { mLabel = label; }
 
 void HwmonFan::MinPWM(int value) { mMinPWM = value; }
 
+int HwmonFan::MinPWM() { return mMinPWM; }
+
+int HwmonFan::StartPWM() { return mStartPWM; }
+
 void HwmonFan::StartPWM(int value) { mStartPWM = value; }
 
-void HwmonFan::FindMinPWM() {
+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 (RPM() <= 0) {
-
+      minPWM = curPWM + STEP;
-    if (curRPM <= 0) {
-      minPWM = curPWM + 5;
       break;
     }
   }
 
+  cout << "Setting minimal PWM: " << minPWM << endl;
+  mMinPWM = minPWM;
+
   if (minPWM == 0) {
     cout << "Fan never stopped. ";
-  }
+  } else {
-  cout << "Setting minimal PWM: " << minPWM << endl;
+    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;
+  }
+}
 
 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.5"
+
 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(),
+  desc.add_options()("help,h", "produce help message")(
-                                                     "run initial setup");
+      "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) {
+void PWMControl::Power(int percent) {
-  int pwmValue = PWM_MAX_VALUE * percent / 100;
+  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() {