Remove NVIDIA stuff

.gitignore

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

PKGBUILD

@@ -1,12 +1,12 @@
 pkgname=fantasize
-pkgver=0.1.2
+pkgver=0.2.0
 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' 'cmake' 'nlohmann-json' 'boost' 'cuda')
+makedepends=('git' 'cmake' 'nlohmann-json' 'boost')
 sha256sums=('SKIP')
 
 build() {

app/CMakeLists.txt

@@ -1,35 +1,39 @@
 cmake_minimum_required(VERSION 3.0)
 
-project(fantasize VERSION 0.1.2)
+project(fantasize VERSION 0.1.8)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 find_package(nlohmann_json 3.11.2 REQUIRED)
-find_package(Boost 1.80 COMPONENTS program_options log log_setup date_time REQUIRED)
+find_package(Boost 1.74 COMPONENTS program_options log log_setup date_time REQUIRED)
 
 add_executable(${PROJECT_NAME}
   src/main.cxx
   src/sensor/LMSensorsFacade.cxx
-  src/sensor/GPUSensorsFacade.cxx
+#  src/sensor/GPUSensorsFacade.cxx
   src/sensor/Sensor.cxx
-  src/sensor/NvidiaSensor.cxx
+#  src/sensor/NvidiaSensor.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
 )
 
 set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 20)
 
-target_include_directories(${PROJECT_NAME} PUBLIC include /opt/cuda)
+# target_include_directories(${PROJECT_NAME} PUBLIC include /opt/cuda)
-target_link_libraries(${PROJECT_NAME} PUBLIC sensors nvidia-ml nlohmann_json::nlohmann_json tbb ${Boost_LIBRARIES})
+target_include_directories(${PROJECT_NAME} PUBLIC include)
+# target_link_libraries(${PROJECT_NAME} PUBLIC sensors nvidia-ml nlohmann_json::nlohmann_json tbb ${Boost_LIBRARIES})
+target_link_libraries(${PROJECT_NAME} PUBLIC sensors nlohmann_json::nlohmann_json tbb ${Boost_LIBRARIES})
 
 install(TARGETS ${PROJECT_NAME} DESTINATION usr/local/bin)
 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/unit/fantasize.service DESTINATION usr/lib/systemd/system)

app/include/App.h

@@ -26,7 +26,11 @@ private:
   FanLabeler mFanLabeler;
   FanGenerator mFanGenerator;
 
+  std::shared_ptr<Settings> mSettings;
+
   std::unique_ptr<Controller> mController;
+
+  std::vector<std::shared_ptr<Fan>> mFans;
 };
 
 #endif // APP_H_

app/include/Controller.h

@@ -5,11 +5,13 @@
 #include <thread>
 #include <vector>
 
+#include <Settings.h>
 #include <fan/FanCurve.h>
 
 class Controller {
 public:
-  Controller(std::vector<std::shared_ptr<FanCurve>> curves);
+  Controller(std::shared_ptr<Settings> settings,
+             std::vector<std::shared_ptr<FanCurve>> curves);
   ~Controller();
 
   void StartFanControlLoop();
@@ -18,6 +20,8 @@ public:
 private:
   void Loop();
 
+  int mTimeout;
+
   std::vector<std::shared_ptr<FanCurve>> mFanCurves;
   std::atomic<bool> mRun;
 

app/include/Serializer.h

@@ -1,12 +1,13 @@
 #ifndef SERIALIZER_H_
 #define SERIALIZER_H_
 
-#include "fan/HwmonFan.h"
 #include <memory>
 #include <vector>
 
 #include <nlohmann/json.hpp>
 
+#include <Settings.h>
+#include <fan/Aggregators.h>
 #include <fan/Fan.h>
 #include <fan/FanCurve.h>
 #include <sensor/Sensor.h>
@@ -16,19 +17,22 @@
 
 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>>
+  std::vector<std::shared_ptr<Fan>> DeserializeFans(
-  DeserializeFans(std::vector<std::shared_ptr<Sensor>> availableSensors);
+    std::vector<std::shared_ptr<Sensor>> availableSensors);
-  std::vector<std::shared_ptr<FanCurve>>
+  std::vector<std::shared_ptr<FanCurve>> DeserializeFanCurves(
-  DeserializeFanCurves(std::vector<std::shared_ptr<Sensor>> availableSensors,
+    std::vector<std::shared_ptr<Sensor>> availableSensors,
     std::vector<std::shared_ptr<Fan>> availableFans);
+  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/Settings.h

@@ -0,0 +1,17 @@
+#ifndef SETTINGS_H_
+#define SETTINGS_H_
+
+#define FREQUENCY_DEFAULT 1
+
+class Settings {
+public:
+  Settings(int frequency);
+
+  int Frequency() const;
+
+private:
+  void LogSettings();
+  int mFrequency;
+};
+
+#endif // SETTINGS_H_

app/include/fan/Aggregators.h

@@ -0,0 +1,27 @@
+#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

@@ -18,6 +18,7 @@ public:
   virtual int StartPWM() = 0;
 
   virtual void FindPWMLimits() = 0;
+  virtual void AdjustPWMLimits() = 0;
 };
 
 #endif // FAN_H_

app/include/fan/FanCurve.h

@@ -4,19 +4,23 @@
 #include <memory>
 #include <vector>
 
+#include <fan/Aggregators.h>
 #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::vector<std::shared_ptr<Fan>> fans,
+           std::unique_ptr<Aggregator> aggregator);
 
   void DoFanControl();
 
@@ -27,6 +31,7 @@ private:
   std::vector<FanStep> mSteps;
   std::vector<std::shared_ptr<Sensor>> mTempSensors;
   std::vector<std::shared_ptr<Fan>> mFans;
+  std::unique_ptr<Aggregator> mAggregator;
 };
 
 #endif // FANCURVE_H_

app/include/fan/HwmonFan.h

@@ -1,7 +1,7 @@
 #ifndef HWMONFAN_H_
 #define HWMONFAN_H_
 
-#include <boost/json/object.hpp>
+#include <chrono>
 #include <memory>
 
 #include <fan/Fan.h>
@@ -25,6 +25,7 @@ public:
   int StartPWM() override;
 
   void FindPWMLimits() override;
+  void AdjustPWMLimits() override;
 
   json toJson() const override;
 
@@ -37,6 +38,7 @@ private:
 
   int mMinPWM;
   int mStartPWM;
+  std::chrono::time_point<std::chrono::steady_clock> mLastAdjustmentTime;
 };
 
 #endif // HWMONFAN_H_

app/include/pwm/PWMControl.h

@@ -1,7 +1,6 @@
 #ifndef PWMCONTROL_H_
 #define PWMCONTROL_H_
 
-#include <boost/json/object.hpp>
 #include <string>
 
 #include <Printable.h>

app/src/App.cxx

@@ -5,12 +5,14 @@
 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);
+  mSettings = mSerializer.DeserializeSettings();
+
+  mController = make_unique<Controller>(mSettings, fanCurves);
 }
 
 void App::InitialSetup() {
@@ -23,6 +25,8 @@ void App::InitialSetup() {
   mFanLabeler.RunFanLabelInteraction(fans);
 
   mSerializer.SerializeFans(fans);
+
+  mFans = fans;
 }
 
 void App::NormalOperation() {
@@ -30,4 +34,8 @@ void App::NormalOperation() {
     mController->StartFanControlLoop();
 }
 
-void App::Shutdown() { mController.reset(); }
+void App::Shutdown() {
+  mSerializer.SerializeFans(mFans);
+  mFans.clear();
+  mController.reset();
+}

app/src/Controller.cxx

@@ -6,10 +6,10 @@
 
 using namespace std;
 
-#define TIMEOUT 500
+Controller::Controller(shared_ptr<Settings> settings,
-
+                       vector<shared_ptr<FanCurve>> curves)
-Controller::Controller(vector<shared_ptr<FanCurve>> curves)
+    : mTimeout((1 / settings->Frequency()) * 1000), mFanCurves(curves),
-    : mFanCurves(curves), mRun(false) {}
+      mRun(false) {}
 
 Controller::~Controller() { StopFanControlLoop(); }
 
@@ -32,6 +32,6 @@ void Controller::Loop() {
       c->DoFanControl();
     }
 
-    this_thread::sleep_for(chrono::milliseconds(TIMEOUT));
+    this_thread::sleep_for(chrono::milliseconds(mTimeout));
   }
 }

app/src/Serializer.cxx

@@ -1,5 +1,3 @@
-#include "fan/FanCurve.h"
-#include "sensor/Sensor.h"
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -10,17 +8,21 @@
 #include <fan/HwmonFan.h>
 #include <pwm/PWMControl.h>
 #include <sensor/LMSensor.h>
+#include <string>
 
 using namespace std;
 namespace fs = filesystem;
 
-Serializer::Serializer() {
+Serializer::Serializer()
+{
   if (!fs::exists(SERIALIZATION_DIR)) {
     fs::create_directory(SERIALIZATION_DIR);
   }
 }
 
-void Serializer::SerializeFans(vector<shared_ptr<Fan>> fans) {
+void
+Serializer::SerializeFans(vector<shared_ptr<Fan>> fans)
+{
   json obj;
 
   for (auto f : fans) {
@@ -31,7 +33,8 @@ void Serializer::SerializeFans(vector<shared_ptr<Fan>> fans) {
 }
 
 vector<shared_ptr<Fan>>
-Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors) {
+Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors)
+{
   vector<shared_ptr<Fan>> fans;
 
   // Create a for the sensors first, then searching becomes cheaper
@@ -63,7 +66,9 @@ Serializer::DeserializeFans(vector<shared_ptr<Sensor>> availableSensors) {
   return fans;
 }
 
-void Serializer::WriteJson(json o) {
+void
+Serializer::WriteJson(json o)
+{
   json obj;
 
   if (fs::exists(fs::path(SERIALIZATION_DIR) / FANS_JSON_FILENAME)) {
@@ -78,14 +83,18 @@ void Serializer::WriteJson(json o) {
   ostrm << obj.dump(2) << "\n";
 }
 
-json Serializer::ReadJson() {
+json
+Serializer::ReadJson()
+{
   ifstream istrm(fs::path(SERIALIZATION_DIR) / FANS_JSON_FILENAME);
   return json::parse(istrm);
 }
 
-vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
+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)
+{
   auto data = ReadJson();
 
   map<string, shared_ptr<Sensor>> sensorMap;
@@ -119,8 +128,38 @@ vector<shared_ptr<FanCurve>> Serializer::DeserializeFanCurves(
         fans.push_back(fanMap[fan.value()]);
     }
 
-    curves.push_back(make_shared<FanCurve>(steps, sensors, fans));
+    std::unique_ptr<Aggregator> aggregator =
+      aggregatorFromString(el.value()["AggregateFunction"]);
+
+    curves.push_back(
+      make_shared<FanCurve>(steps, sensors, fans, std::move(aggregator)));
   }
 
   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;
+
+  auto data = ReadJson();
+
+  if (data.contains("settings")) {
+    auto items = data["settings"];
+
+    if (items.contains("frequency"))
+      frequency = items["frequency"];
+  }
+
+  return make_shared<Settings>(frequency);
+}

app/src/Settings.cxx

@@ -0,0 +1,17 @@
+#include <iostream>
+
+#include <boost/log/attributes/named_scope.hpp>
+#include <boost/log/trivial.hpp>
+
+#include <Settings.h>
+
+Settings::Settings(int frequency) : mFrequency(frequency) { LogSettings(); }
+
+int Settings::Frequency() const { return mFrequency; }
+
+void Settings::LogSettings() {
+  BOOST_LOG_FUNCTION();
+
+  BOOST_LOG_TRIVIAL(info) << "### Settings";
+  BOOST_LOG_TRIVIAL(info) << "Frequency: " << mFrequency << "Hz";
+}

app/src/fan/Aggregators.cxx

@@ -0,0 +1,39 @@
+#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

@@ -4,18 +4,27 @@
 #include <boost/log/trivial.hpp>
 
 #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,
-    : mSteps(steps), mTempSensors(sensors), mFans(fans) {
+                   std::unique_ptr<Aggregator> aggregator)
+  : mSteps(steps)
+  , mTempSensors(sensors)
+  , mFans(fans)
+  , mAggregator(std::move(aggregator))
+{
   PrintInfo();
 }
 
-void FanCurve::DoFanControl() {
+void
+FanCurve::DoFanControl()
+{
   BOOST_LOG_FUNCTION();
+
   int temp = AggregateTemperature();
 
   int t0, t1, p0, p1;
@@ -43,22 +52,22 @@ void FanCurve::DoFanControl() {
     if (f->RPM() <= 0) {
       BOOST_LOG_TRIVIAL(warning) << "Fan stopped completely!";
       f->PWM(f->StartPWM());
-    }
+      f->AdjustPWMLimits();
+    } else {
       f->PWM(targetFanPower);
     }
   }
-
-// Dummy Implementation using AVG
-int FanCurve::AggregateTemperature() {
-  int sum = 0;
-  for (auto s : mTempSensors) {
-    sum += s->value();
 }
 
-  return sum / mTempSensors.size();
+int
+FanCurve::AggregateTemperature()
+{
+  return mAggregator->aggregate(mTempSensors);
 }
 
-void FanCurve::PrintInfo() {
+void
+FanCurve::PrintInfo()
+{
   BOOST_LOG_FUNCTION()
 
   BOOST_LOG_TRIVIAL(info) << "### Fan curve:";
@@ -87,4 +96,10 @@ void FanCurve::PrintInfo() {
   }
 
   BOOST_LOG_TRIVIAL(info) << sStream.str();
+
+  sStream.str(string());
+
+  sStream << "Aggregate function: " << mAggregator->toString();
+
+  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/log/attributes/named_scope.hpp>
-#include <boost/json/object.hpp>
+#include <boost/log/trivial.hpp>
+
 #include <fan/HwmonFan.h>
+#include <pwm/PWMControl.h>
 
 #define TIMEOUT 10
+#define STEP 2
 
 using namespace std;
 
@@ -33,24 +35,22 @@ void HwmonFan::MinPWM(int value) { mMinPWM = value; }
 
 int HwmonFan::MinPWM() { return mMinPWM; }
 
-int HwmonFan::StartPWM() { return mStartPWM; }
-
 void HwmonFan::StartPWM(int value) { mStartPWM = value; }
 
+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 (RPM() <= 0) {
-
+      minPWM = curPWM + STEP;
-    if (curRPM <= 0) {
-      minPWM = curPWM + 5;
       break;
     }
   }
@@ -64,13 +64,11 @@ void HwmonFan::FindPWMLimits() {
     int startPWM = 0;
 
     cout << "Looking for start PWM!" << endl;
-    for (int curPWM = minPWM - 5; curPWM < 100; curPWM += 5) {
+    for (int curPWM = minPWM - STEP; curPWM < 100; curPWM += STEP) {
       PWM(curPWM);
       this_thread::sleep_for(chrono::seconds(TIMEOUT));
 
-      int curRPM = RPM();
+      if (RPM() > 0) {
-
-      if (curRPM > 0) {
         cout << "Setting start PWM: " << startPWM << endl;
         startPWM = curPWM;
         break;
@@ -81,6 +79,20 @@ void HwmonFan::FindPWMLimits() {
   }
 }
 
+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(),

app/src/main.cxx

@@ -1,4 +1,3 @@
-#include <boost/log/expressions/formatters/named_scope.hpp>
 #include <csignal>
 #include <iostream>
 
@@ -6,6 +5,7 @@
 #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>
@@ -20,6 +20,8 @@
 
 #include <App.h>
 
+#define PROJECT_VERSION "v0.2.0"
+
 namespace po = boost::program_options;
 namespace logging = boost::log;
 
@@ -59,7 +61,11 @@ void InitLogging(bool verbose) {
 }
 
 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,h", "produce help message")(

app/src/pwm/PWMControl.cxx

@@ -15,7 +15,9 @@
 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);
 
@@ -35,21 +37,24 @@ PWMControl::PWMControl(string controlPath) : mControlPath(controlPath) {
   istrm.close();
 }
 
-PWMControl::~PWMControl() {
+PWMControl::~PWMControl()
+{
   BOOST_LOG_FUNCTION();
 
   BOOST_LOG_TRIVIAL(trace) << "Cleanup";
   Reset();
 }
 
-void PWMControl::Power(int percent) {
+void
+PWMControl::Power(int percent)
+{
   BOOST_LOG_FUNCTION();
 
   int pwmValue = (PWM_MAX_VALUE * percent) / 100;
 
   if (percent != mCurrentValue) {
-    BOOST_LOG_TRIVIAL(trace)
+    BOOST_LOG_TRIVIAL(trace) << "Updating control value of " << toString()
-        << "Updating control value to " << percent << "% (" << pwmValue << ")";
+                             << " to " << percent << "% (" << pwmValue << ")";
     ofstream ostrm(mControlPath, ios::trunc);
     ostrm << pwmValue;
     ostrm.close();
@@ -58,7 +63,9 @@ void PWMControl::Power(int percent) {
   }
 }
 
-int PWMControl::Power() {
+int
+PWMControl::Power()
+{
   int value;
   ifstream istrm;
 
@@ -68,13 +75,17 @@ int PWMControl::Power() {
   return (value * 100) / PWM_MAX_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;
@@ -86,11 +97,15 @@ void PWMControl::Reset() {
   ostrm.close();
 }
 
-const string PWMControl::toString() const {
+const string
+PWMControl::toString() const
+{
   return fs::path(mControlPath).filename();
 }
 
-json PWMControl::toJson() const {
+json
+PWMControl::toJson() const
+{
   json obj = { "PWMControl", mControlPath };
   return obj;
 }

app/src/sensor/NvidiaSensor.cxx

@@ -1,4 +1,3 @@
-#include <boost/json/object.hpp>
 #include <include/nvml.h>
 
 #include <sensor/NvidiaSensor.h>

app/src/sensor/SensorManager.cxx

@@ -11,8 +11,9 @@ vector<shared_ptr<Sensor>> SensorManager::TemperatureSensors() {
 
   tempSensors = mLMSensorsFacade->TemperatureSensors();
 
-  auto gpuSensors = mGPUSensorsFacade->TemperatureSensors();
+  //   auto gpuSensors = mGPUSensorsFacade->TemperatureSensors();
-  tempSensors.insert(tempSensors.end(), gpuSensors.begin(), gpuSensors.end());
+  //  tempSensors.insert(tempSensors.end(), gpuSensors.begin(),
+  //  gpuSensors.end());
 
   return tempSensors;
 }

app/unit/fantasize.service

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