Add missing classes

.gitignore

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

PKGBUILD

@@ -1,5 +1,5 @@
 pkgname=fantasize
-pkgver=0.1.6
+pkgver=0.1.9
 pkgrel=1
 pkgdesc='C++ fan control for Linux'
 url='https://github.com/Tabascl/fantasize.git'

app/CMakeLists.txt

@@ -1,11 +1,11 @@
 cmake_minimum_required(VERSION 3.0)
 
-project(fantasize VERSION 0.1.6)
+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
@@ -19,10 +19,12 @@ add_executable(${PROJECT_NAME}
   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
 )
 

app/include/App.h

@@ -26,6 +26,8 @@ private:
   FanLabeler mFanLabeler;
   FanGenerator mFanGenerator;
 
+  std::shared_ptr<Settings> mSettings;
+
   std::unique_ptr<Controller> mController;
 
   std::vector<std::shared_ptr<Fan>> mFans;

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>>
-  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>> 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::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/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

@@ -4,8 +4,6 @@
 #include <chrono>
 #include <memory>
 
-#include <boost/json/object.hpp>
-
 #include <fan/Fan.h>
 #include <pwm/PWMControl.h>
 #include <sensor/Sensor.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

@@ -10,7 +10,9 @@ void App::Init() {
   auto fanCurves = mSerializer.DeserializeFanCurves(
       mSensorManager.TemperatureSensors(), mFans);
 
-  mController = make_unique<Controller>(fanCurves);
+  mSettings = mSerializer.DeserializeSettings();
+
+  mController = make_unique<Controller>(mSettings, fanCurves);
 }
 
 void App::InitialSetup() {

app/src/Controller.cxx

@@ -6,10 +6,10 @@
 
 using namespace std;
 
-#define TIMEOUT 500
-
-Controller::Controller(vector<shared_ptr<FanCurve>> curves)
-    : mFanCurves(curves), mRun(false) {}
+Controller::Controller(shared_ptr<Settings> settings,
+                       vector<shared_ptr<FanCurve>> curves)
+    : mTimeout((1 / settings->Frequency()) * 1000), mFanCurves(curves),
+      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,17 +4,25 @@
 #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)
-    : mSteps(steps), mTempSensors(sensors), mFans(fans) {
+                   std::vector<std::shared_ptr<Fan>> 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();
@@ -51,17 +59,15 @@ void FanCurve::DoFanControl() {
   }
 }
 
-// Dummy Implementation using AVG
-int FanCurve::AggregateTemperature() {
-  int sum = 0;
-  for (auto s : mTempSensors) {
-    sum += s->value();
+int
+FanCurve::AggregateTemperature()
+{
+  return mAggregator->aggregate(mTempSensors);
 }
 
-  return sum / mTempSensors.size();
-}
-
-void FanCurve::PrintInfo() {
+void
+FanCurve::PrintInfo()
+{
   BOOST_LOG_FUNCTION()
 
   BOOST_LOG_TRIVIAL(info) << "### Fan curve:";
@@ -90,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/main.cxx

@@ -20,7 +20,7 @@
 
 #include <App.h>
 
-#define PROJECT_VERSION "v0.1.6"
+#define PROJECT_VERSION "v0.1.9"
 
 namespace po = boost::program_options;
 namespace logging = boost::log;
@@ -29,9 +29,15 @@ App app;
 
 static int doInitialSetup = 0;
 
-void signal_handler(int s) { app.Shutdown(); }
+void
+signal_handler(int s)
+{
+  app.Shutdown();
+}
 
-void InitLogging(bool verbose) {
+void
+InitLogging(bool verbose)
+{
   logging::add_console_log(
     std::clog,
     logging::keywords::format =
@@ -60,7 +66,9 @@ void InitLogging(bool verbose) {
   }
 }
 
-int main(int argc, char **argv) {
+int
+main(int argc, char** argv)
+{
   BOOST_LOG_FUNCTION()
   BOOST_LOG_TRIVIAL(info) << "Version: " << PROJECT_VERSION;
 
@@ -69,8 +77,8 @@ int main(int argc, char **argv) {
 
   po::options_description desc("Allowed options");
   desc.add_options()("help,h", "produce help message")(
-      "setup,s", po::bool_switch(),
-      "run initial setup")("verbose,v", po::bool_switch(), "print debug info");
+    "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);

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)
-        << "Updating control value to " << percent << "% (" << pwmValue << ")";
+    BOOST_LOG_TRIVIAL(trace) << "Updating control value of " << toString()
+                             << " 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/unit/fantasize.service

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