Fix severe bug, improve logging, handle fan stops

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

app/src/App.cxx

@@ -18,7 +18,7 @@ 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);
 

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

@@ -15,15 +15,16 @@ FanCurve::FanCurve(std::vector<FanStep> steps,
 }
 
 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) {
@@ -35,11 +36,15 @@ 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->PWM(targetFanPower);
   }
 }
 

app/src/fan/HwmonFan.cxx

@@ -7,7 +7,7 @@
 #include <boost/json/object.hpp>
 #include <fan/HwmonFan.h>
 
-#define TIMEOUT 5
+#define TIMEOUT 10
 
 using namespace std;
 
@@ -31,12 +31,17 @@ 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) {
     PWM(curPWM);
@@ -50,22 +55,39 @@ void HwmonFan::FindMinPWM() {
     }
   }
 
+  cout << "Setting minimal PWM: " << minPWM << endl;
+  mMinPWM = minPWM;
+
   if (minPWM == 0) {
     cout << "Fan never stopped. ";
+  } else {
+    int startPWM = 0;
+
+    cout << "Looking for start PWM!" << endl;
+    for (int curPWM = minPWM - 5; curPWM < 100; curPWM += 5) {
+      PWM(curPWM);
+      this_thread::sleep_for(chrono::seconds(TIMEOUT));
+
+      int curRPM = RPM();
+
+      if (curRPM > 0) {
+        cout << "Setting start PWM: " << startPWM << endl;
+        startPWM = curPWM;
+        break;
+      }
+    }
+
+    mStartPWM = startPWM;
   }
-  cout << "Setting minimal PWM: " << minPWM << endl;
-
-  mMinPWM = minPWM;
 }
 
-void HwmonFan::FindStartPWM() {}
-
 json HwmonFan::toJson() const {
   json obj;
   obj = {mPWMControl->toJson(),
          mRpmSensor->toJson(),
          {"Label", mLabel},
-         {"MinPWM", mMinPWM}};
+         {"MinPWM", mMinPWM},
+         {"StartPWM", mStartPWM}};
   return obj;
 }
 

app/src/pwm/PWMControl.cxx

@@ -36,6 +36,8 @@ PWMControl::PWMControl(string controlPath) : mControlPath(controlPath) {
 }
 
 PWMControl::~PWMControl() {
+  BOOST_LOG_FUNCTION();
+
   BOOST_LOG_TRIVIAL(trace) << "Cleanup";
   Reset();
 }
@@ -43,17 +45,16 @@ PWMControl::~PWMControl() {
 void PWMControl::Power(int percent) {
   BOOST_LOG_FUNCTION();
 
-  int pwmValue = PWM_MAX_VALUE * (percent / 100);
+  int pwmValue = (PWM_MAX_VALUE * percent) / 100;
 
   if (percent != mCurrentValue) {
-    BOOST_LOG_TRIVIAL(trace) << "Updating control value to " << percent;
+    BOOST_LOG_TRIVIAL(trace)
+        << "Updating control value to " << percent << "% (" << pwmValue << ")";
     ofstream ostrm(mControlPath, ios::trunc);
     ostrm << pwmValue;
     ostrm.close();
 
     mCurrentValue = percent;
-  } else {
-    BOOST_LOG_TRIVIAL(trace) << "Value unchanged, do nothing";
   }
 }
 
@@ -64,7 +65,7 @@ int PWMControl::Power() {
   istrm.open(mControlPath);
   istrm >> value;
 
-  return (value / PWM_MAX_VALUE) * 100;
+  return (value * 100) / PWM_MAX_VALUE;
 }
 
 void PWMControl::EnableManualControl() {